diff options
Diffstat (limited to 'Build/source/libs/icu/icu-xetex/test/perf/ustrperf')
6 files changed, 1395 insertions, 0 deletions
diff --git a/Build/source/libs/icu/icu-xetex/test/perf/ustrperf/Makefile.in b/Build/source/libs/icu/icu-xetex/test/perf/ustrperf/Makefile.in new file mode 100644 index 00000000000..08bf330d82d --- /dev/null +++ b/Build/source/libs/icu/icu-xetex/test/perf/ustrperf/Makefile.in @@ -0,0 +1,79 @@ +## Makefile.in for ICU - test/perf/ustrperf +## Copyright (c) 2001-2006, International Business Machines Corporation and +## others. All Rights Reserved. + +## Source directory information +srcdir = @srcdir@ +top_srcdir = @top_srcdir@ + +top_builddir = ../../.. + +include $(top_builddir)/icudefs.mk + +## Build directory information +subdir = test/perf/ustrperf + +## Extra files to remove for 'make clean' +CLEANFILES = *~ $(DEPS) + +## Target information +TARGET = ustrperf + +CPPFLAGS += -I$(top_builddir)/common -I$(top_srcdir)/common -I$(top_srcdir)/tools/toolutil -I$(top_srcdir)/tools/ctestfw +LIBS = $(LIBCTESTFW) $(LIBICUI18N) $(LIBICUUC) $(LIBICUTOOLUTIL) $(DEFAULT_LIBS) $(LIB_M) + +OBJECTS = stringperf.o + +DEPS = $(OBJECTS:.o=.d) + +## List of phony targets +.PHONY : all all-local install install-local clean clean-local \ +distclean distclean-local dist dist-local check check-local + +## Clear suffix list +.SUFFIXES : + +## List of standard targets +all: all-local +install: install-local +clean: clean-local +distclean : distclean-local +dist: dist-local +check: all check-local + +all-local: $(TARGET) + +install-local: + +dist-local: + +clean-local: + test -z "$(CLEANFILES)" || $(RMV) $(CLEANFILES) + $(RMV) $(OBJECTS) $(TARGET) + +distclean-local: clean-local + $(RMV) Makefile + +check-local: all-local + +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + cd $(top_builddir) \ + && CONFIG_FILES=$(subdir)/$@ CONFIG_HEADERS= $(SHELL) ./config.status + +$(TARGET) : $(OBJECTS) + $(LINK.cc) -o $@ $^ $(LIBS) + $(POST_BUILD_STEP) + +invoke: + ICU_DATA=$${ICU_DATA:-$(top_builddir)/data/} TZ=PST8PDT $(INVOKE) $(INVOCATION) + +ifeq (,$(MAKECMDGOALS)) +-include $(DEPS) +else +ifneq ($(patsubst %clean,,$(MAKECMDGOALS)),) +ifneq ($(patsubst %install,,$(MAKECMDGOALS)),) +-include $(DEPS) +endif +endif +endif + diff --git a/Build/source/libs/icu/icu-xetex/test/perf/ustrperf/StringPerf.pl b/Build/source/libs/icu/icu-xetex/test/perf/ustrperf/StringPerf.pl new file mode 100755 index 00000000000..02cde457e0f --- /dev/null +++ b/Build/source/libs/icu/icu-xetex/test/perf/ustrperf/StringPerf.pl @@ -0,0 +1,68 @@ +#!/usr/bin/perl -w +# ******************************************************************** +# * COPYRIGHT: +# * Copyright (c) 2003-2004, International Business Machines Corporation and +# * others. All Rights Reserved. +# ******************************************************************** + + +use strict; + +use lib '../perldriver'; + +use PerfFramework; + +my $options = { + "title"=>"Unicode String performance: ICU vs. STDLib", + "headers"=>"StdLib ICU", + "operationIs"=>"Unicode String", + "timePerOperationIs"=>"Time per Unicode String", + "passes"=>"5", + "time"=>"2", + #"outputType"=>"HTML", + "dataDir"=>"c:/src/perf/data", + "outputDir"=>"../results" + }; + + +# programs +# tests will be done for all the programs. Results will be stored and connected +my $p = "stringperf.exe -l -u"; + +my $tests = { +"Object Construction(empty string)", ["$p TestStdLibCtor" , "$p TestCtor" ], +"Object Construction(single char)", ["$p TestStdLibCtor1" , "$p TestCtor1" ], +"Object Construction(another string)", ["$p TestStdLibCtor2" , "$p TestCtor2" ], +"Object Construction(string literal)", ["$p TestStdLibCtor3" , "$p TestCtor3" ], +"String Assignment(helper)", ["$p TestStdLibAssign" , "$p TestAssign" ], +"String Assignment(string literal)", ["$p TestStdLibAssign1" , "$p TestAssign1" ], +"String Assignment(another string)", ["$p TestStdLibAssign2" , "$p TestAssign2" ], +"Get String or Character", ["$p TestStdLibGetch" , "$p TestGetch" ], +"Concatenation", ["$p TestStdLibCatenate" , "$p TestCatenate" ], +"String Scanning(char)", ["$p TestStdLibScan" , "$p TestScan" ], +"String Scanning(string)", ["$p TestStdLibScan1" , "$p TestScan1" ], +"String Scanning(char set)", ["$p TestStdLibScan2" , "$p TestScan2" ], +}; + +my $dataFiles = { + "", + [ + "TestNames_Asian.txt", + "TestNames_Chinese.txt", + "TestNames_Simplified_Chinese.txt", + "TestNames_Japanese_h.txt", + "TestNames_Japanese_k.txt", + "TestNames_Korean.txt", + "TestNames_Latin.txt", + "TestNames_SerbianSH.txt", + "TestNames_SerbianSR.txt", + "TestNames_Thai.txt", + "Testnames_Russian.txt", + "th18057.txt", + ] + }; + +runTests($options, $tests, $dataFiles); + +# The whole command line would be something like: +# stringperf.exe -p 5 -t 2 -f c:/src/data/perf/TestNames_Asian.txt -l -u TestStdLibCatenate
\ No newline at end of file diff --git a/Build/source/libs/icu/icu-xetex/test/perf/ustrperf/StringPerf_r.pl b/Build/source/libs/icu/icu-xetex/test/perf/ustrperf/StringPerf_r.pl new file mode 100644 index 00000000000..4a1ffa86420 --- /dev/null +++ b/Build/source/libs/icu/icu-xetex/test/perf/ustrperf/StringPerf_r.pl @@ -0,0 +1,70 @@ +#!/usr/bin/perl +# ******************************************************************** +# * COPYRIGHT: +# * Copyright (c) 2002-2007, International Business Machines +# * Corporation and others. All Rights Reserved. +# ******************************************************************** + +use strict; + +#Assume we are running outside of the ICU source +use lib './ICU-3.0/ICU/source/test/perf/perldriver'; + +use PerfFramework; + +my $options = { + "title"=>"Unicode String performance regression (ICU 2.8 and 3.0)", + "headers"=>"ICU28 ICU30", + "operationIs"=>"Unicode String", + "passes"=>"10", + "time"=>"5", + #"outputType"=>"HTML", + "dataDir"=>"c:/src/perf/data", + "outputDir"=>"results_ICU4C" + }; + +# programs + +my $p1 = "icu-2.8/icu/bin/stringperf28.exe -b -u"; +my $p2 = "icu-3.0/icu/bin/stringperf30.exe -b -u"; + +my $dataFiles = { + "", + [ + "TestNames_Asian.txt", + "TestNames_Chinese.txt", + "TestNames_Japanese.txt", + "TestNames_Japanese_h.txt", + "TestNames_Japanese_k.txt", + "TestNames_Korean.txt", + "TestNames_Latin.txt", + "TestNames_SerbianSH.txt", + "TestNames_SerbianSR.txt", + "TestNames_Thai.txt", + "Testnames_Russian.txt", +# "th18057.txt", +# "thesis.txt", +# "vfear11a.txt", + ] + }; + + +my $tests = { +"Object Construction(empty string)", ["$p1 TestCtor" , "$p2 TestCtor" ], +"Object Construction(single char)", ["$p1 TestCtor1" , "$p2 TestCtor1" ], +"Object Construction(another string)", ["$p1 TestCtor2" , "$p2 TestCtor2" ], +"Object Construction(string literal)", ["$p1 TestCtor3" , "$p2 TestCtor3" ], +"String Assignment(helper)", ["$p1 TestAssign" , "$p2 TestAssign" ], +"String Assignment(string literal)", ["$p1 TestAssign1" , "$p2 TestAssign1" ], +"String Assignment(another string)", ["$p1 TestAssign2" , "$p2 TestAssign2" ], +"Get String or Character", ["$p1 TestGetch" , "$p2 TestGetch" ], +"Concatenation", ["$p1 TestCatenate" , "$p2 TestCatenate" ], +"String Scanning(char)", ["$p1 TestScan" , "$p2 TestScan" ], +"String Scanning(string)", ["$p1 TestScan1" , "$p2 TestScan1" ], +"String Scanning(char set)", ["$p1 TestScan2" , "$p2 TestScan2" ], +}; + + +runTests($options, $tests, $dataFiles); + + diff --git a/Build/source/libs/icu/icu-xetex/test/perf/ustrperf/stringperf.cpp b/Build/source/libs/icu/icu-xetex/test/perf/ustrperf/stringperf.cpp new file mode 100644 index 00000000000..342e060aa8c --- /dev/null +++ b/Build/source/libs/icu/icu-xetex/test/perf/ustrperf/stringperf.cpp @@ -0,0 +1,377 @@ +/******************************************************************** + * COPYRIGHT: + * Copyright (C) 2002-2006 International Business Machines Corporation + * and others. All Rights Reserved. + * + ********************************************************************/ +/***************************************************************************** +* File stringperf.cpp +* +* Modification History: +* Name Description +* Doug Wang Second version +* Doug Wang First Version +****************************************************************************** +*/ + +/** + * This program tests UnicodeString performance. + * APIs tested: UnicodeString + * ICU4C + * Windows 2000/XP, Linux + */ + +#include "stringperf.h" + + +int main(int argc, const char *argv[]) +{ + UErrorCode status = U_ZERO_ERROR; + + bCatenatePrealloc=TRUE; + + StringPerformanceTest test(argc, argv, status); + if (U_FAILURE(status)){ + return status; + } + + int loops = LOOPS; + if (bCatenatePrealloc) { + int to_alloc = loops * MAXNUMLINES * (MAXSRCLEN + catenate_STRLEN); + catICU = new UnicodeString(to_alloc,'a',0); + //catICU = new UnicodeString(); + + catStd = new stlstring(); + catStd -> reserve(loops * MAXNUMLINES * (MAXSRCLEN + catenate_STRLEN)); + //catStd -> reserve(110000000); + } else { + catICU = new UnicodeString(); + catStd = new stlstring(); + } + + if (test.run() == FALSE){ + fprintf(stderr, "FAILED: Tests could not be run please check the " + "arguments.\n"); + return -1; + } + + delete catICU; + delete catStd; + return 0; +} + +StringPerformanceTest::StringPerformanceTest(int32_t argc, const char *argv[], + UErrorCode &status) + : UPerfTest(argc, argv, status) +{ + filelines_=NULL; + StrBuffer=NULL; + StrBufferLen=0; + + int32_t len =0; + + if (status== U_ILLEGAL_ARGUMENT_ERROR){ + //fprintf(stderr,gUsageString, "stringperf"); + return; + } + if (U_FAILURE(status)){ + fprintf(stderr, "FAILED to create UPerfTest object. Error: %s\n", + u_errorName(status)); + return; + } + + + if(line_mode){ + ULine* filelines = getLines(status); + if(U_FAILURE(status)){ + fprintf(stderr, "FAILED to read lines from file and create UPerfTest object. Error: %s\n", u_errorName(status)); + return; + } + + filelines_ = new ULine[numLines]; + for (int i =0; i < numLines; i++) { + len = filelines[i].len; + filelines_[i].name = new UChar[len]; + filelines_[i].len = len; + memcpy(filelines_[i].name, filelines[i].name, len * U_SIZEOF_UCHAR); + } + + }else if(bulk_mode){ + int32_t srcLen = 0; + const UChar* src = getBuffer(srcLen,status); + if(U_FAILURE(status)){ + fprintf(stderr, "FAILED to read buffer from file and create UPerfTest object. Error: %s\n", u_errorName(status)); + return; + } + + StrBuffer = new UChar[srcLen]; + StrBufferLen = srcLen; + memcpy(StrBuffer, src, srcLen * U_SIZEOF_UCHAR); + + } +} + +StringPerformanceTest::~StringPerformanceTest() +{ + delete[] filelines_; + delete[] StrBuffer; +} + +UPerfFunction* StringPerformanceTest::runIndexedTest(int32_t index, UBool exec, + const char *&name, + char* par) +{ + switch (index) { + TESTCASE(0, TestCtor); + TESTCASE(1, TestCtor1); + TESTCASE(2, TestCtor2); + TESTCASE(3, TestCtor3); + TESTCASE(4, TestAssign); + TESTCASE(5, TestAssign1); + TESTCASE(6, TestAssign2); + TESTCASE(7, TestGetch); + TESTCASE(8, TestCatenate); + TESTCASE(9, TestScan); + TESTCASE(10, TestScan1); + TESTCASE(11, TestScan2); + + TESTCASE(12, TestStdLibCtor); + TESTCASE(13, TestStdLibCtor1); + TESTCASE(14, TestStdLibCtor2); + TESTCASE(15, TestStdLibCtor3); + TESTCASE(16, TestStdLibAssign); + TESTCASE(17, TestStdLibAssign1); + TESTCASE(18, TestStdLibAssign2); + TESTCASE(19, TestStdLibGetch); + TESTCASE(20, TestStdLibCatenate); + TESTCASE(21, TestStdLibScan); + TESTCASE(22, TestStdLibScan1); + TESTCASE(23, TestStdLibScan2); + + default: + name = ""; + return NULL; + } + return NULL; +} + +UPerfFunction* StringPerformanceTest::TestCtor() +{ + if (line_mode) { + return new StringPerfFunction(ctor, filelines_, numLines, uselen); + } else { + return new StringPerfFunction(ctor, StrBuffer, StrBufferLen, uselen); + } +} + +UPerfFunction* StringPerformanceTest::TestCtor1() +{ + if (line_mode) { + return new StringPerfFunction(ctor1, filelines_, numLines, uselen); + } else { + return new StringPerfFunction(ctor1, StrBuffer, StrBufferLen, uselen); + } +} + +UPerfFunction* StringPerformanceTest::TestCtor2() +{ + if (line_mode) { + return new StringPerfFunction(ctor2, filelines_, numLines, uselen); + } else { + return new StringPerfFunction(ctor2, StrBuffer, StrBufferLen, uselen); + } +} + +UPerfFunction* StringPerformanceTest::TestCtor3() +{ + if (line_mode) { + return new StringPerfFunction(ctor3, filelines_, numLines, uselen); + } else { + return new StringPerfFunction(ctor3, StrBuffer, StrBufferLen, uselen); + } +} + +UPerfFunction* StringPerformanceTest::TestAssign() +{ + if (line_mode) { + return new StringPerfFunction(assign, filelines_, numLines, uselen); + } else { + return new StringPerfFunction(assign, StrBuffer, StrBufferLen, uselen); + } +} + +UPerfFunction* StringPerformanceTest::TestAssign1() +{ + if (line_mode) { + return new StringPerfFunction(assign1, filelines_, numLines, uselen); + } else { + return new StringPerfFunction(assign1, StrBuffer, StrBufferLen, uselen); + } +} + +UPerfFunction* StringPerformanceTest::TestAssign2() +{ + if (line_mode) { + return new StringPerfFunction(assign2, filelines_, numLines, uselen); + } else { + return new StringPerfFunction(assign2, StrBuffer, StrBufferLen, uselen); + } +} + + +UPerfFunction* StringPerformanceTest::TestGetch() +{ + if (line_mode) { + return new StringPerfFunction(getch, filelines_, numLines, uselen); + } else { + return new StringPerfFunction(getch, StrBuffer, StrBufferLen, uselen); + } +} + +UPerfFunction* StringPerformanceTest::TestCatenate() +{ + if (line_mode) { + return new StringPerfFunction(catenate, filelines_, numLines, uselen); + } else { + //return new StringPerfFunction(catenate, buffer, bufferLen, uselen); + return new StringPerfFunction(catenate, StrBuffer, StrBufferLen, uselen); + } +} + +UPerfFunction* StringPerformanceTest::TestScan() +{ + if (line_mode) { + return new StringPerfFunction(scan, filelines_, numLines, uselen); + } else { + return new StringPerfFunction(scan, StrBuffer, StrBufferLen, uselen); + } +} + +UPerfFunction* StringPerformanceTest::TestScan1() +{ + if (line_mode) { + return new StringPerfFunction(scan1, filelines_, numLines, uselen); + } else { + return new StringPerfFunction(scan1, StrBuffer, StrBufferLen, uselen); + } +} + +UPerfFunction* StringPerformanceTest::TestScan2() +{ + if (line_mode) { + return new StringPerfFunction(scan2, filelines_, numLines, uselen); + } else { + return new StringPerfFunction(scan2, StrBuffer, StrBufferLen, uselen); + } +} + +UPerfFunction* StringPerformanceTest::TestStdLibCtor() +{ + if (line_mode) { + return new StringPerfFunction(StdLibCtor, filelines_, numLines, uselen); + } else { + return new StringPerfFunction(StdLibCtor, StrBuffer, StrBufferLen, uselen); + } +} + +UPerfFunction* StringPerformanceTest::TestStdLibCtor1() +{ + if (line_mode) { + return new StringPerfFunction(StdLibCtor1, filelines_, numLines, uselen); + } else { + return new StringPerfFunction(StdLibCtor1, StrBuffer, StrBufferLen, uselen); + } +} + +UPerfFunction* StringPerformanceTest::TestStdLibCtor2() +{ + if (line_mode) { + return new StringPerfFunction(StdLibCtor2, filelines_, numLines, uselen); + } else { + return new StringPerfFunction(StdLibCtor2, StrBuffer, StrBufferLen, uselen); + } +} + +UPerfFunction* StringPerformanceTest::TestStdLibCtor3() +{ + if (line_mode) { + return new StringPerfFunction(StdLibCtor3, filelines_, numLines, uselen); + } else { + return new StringPerfFunction(StdLibCtor3, StrBuffer, StrBufferLen, uselen); + } +} + +UPerfFunction* StringPerformanceTest::TestStdLibAssign() +{ + if (line_mode) { + return new StringPerfFunction(StdLibAssign, filelines_, numLines, uselen); + } else { + return new StringPerfFunction(StdLibAssign, StrBuffer, StrBufferLen, uselen); + } +} + +UPerfFunction* StringPerformanceTest::TestStdLibAssign1() +{ + if (line_mode) { + return new StringPerfFunction(StdLibAssign1, filelines_, numLines, uselen); + } else { + return new StringPerfFunction(StdLibAssign1, StrBuffer, StrBufferLen, uselen); + } +} + +UPerfFunction* StringPerformanceTest::TestStdLibAssign2() +{ + if (line_mode) { + return new StringPerfFunction(StdLibAssign2, filelines_, numLines, uselen); + } else { + return new StringPerfFunction(StdLibAssign2, StrBuffer, StrBufferLen, uselen); + } +} + +UPerfFunction* StringPerformanceTest::TestStdLibGetch() +{ + if (line_mode) { + return new StringPerfFunction(StdLibGetch, filelines_, numLines, uselen); + } else { + return new StringPerfFunction(StdLibGetch, StrBuffer, StrBufferLen, uselen); + } +} + +UPerfFunction* StringPerformanceTest::TestStdLibCatenate() +{ + if (line_mode) { + return new StringPerfFunction(StdLibCatenate, filelines_, numLines, uselen); + } else { + //return new StringPerfFunction(StdLibCatenate, buffer, bufferLen, uselen); + return new StringPerfFunction(StdLibCatenate, StrBuffer, StrBufferLen, uselen); + } +} + +UPerfFunction* StringPerformanceTest::TestStdLibScan() +{ + if (line_mode) { + return new StringPerfFunction(StdLibScan, filelines_, numLines, uselen); + } else { + return new StringPerfFunction(StdLibScan, StrBuffer, StrBufferLen, uselen); + } +} + +UPerfFunction* StringPerformanceTest::TestStdLibScan1() +{ + if (line_mode) { + return new StringPerfFunction(StdLibScan1, filelines_, numLines, uselen); + } else { + return new StringPerfFunction(StdLibScan1, StrBuffer, StrBufferLen, uselen); + } +} + +UPerfFunction* StringPerformanceTest::TestStdLibScan2() +{ + if (line_mode) { + return new StringPerfFunction(StdLibScan2, filelines_, numLines, uselen); + } else { + return new StringPerfFunction(StdLibScan2, StrBuffer, StrBufferLen, uselen); + } +} + + diff --git a/Build/source/libs/icu/icu-xetex/test/perf/ustrperf/stringperf.h b/Build/source/libs/icu/icu-xetex/test/perf/ustrperf/stringperf.h new file mode 100644 index 00000000000..84d6493a405 --- /dev/null +++ b/Build/source/libs/icu/icu-xetex/test/perf/ustrperf/stringperf.h @@ -0,0 +1,549 @@ +/* +********************************************************************** +* Copyright (c) 2002-2006, International Business Machines +* Corporation and others. All Rights Reserved. +********************************************************************** +*/ +#ifndef _STRINGPERF_H +#define _STRINGPERF_H + +#include <string> + +#include "unicode/utypes.h" +#include "unicode/unistr.h" + +#include "unicode/uperf.h" + +typedef std::wstring stlstring; + +/* Define all constants for test case operations */ +#define MAXNUMLINES 40000 //Max number of lines in a test data file +#define MAXSRCLEN 20 //Max length of one line. maybe a larger number, but it need more mem +#define LOOPS 100 //Iterations +//#define LOOPS 10 +#define catenate_STRLEN 2 + +const UChar uTESTCHAR1 = 'a'; +const wchar_t wTESTCHAR1 = 'a'; +const UnicodeString uEMPTY; +const stlstring sEMPTY; +UnicodeString unistr; +stlstring stlstr; +// Simulate construction with a single-char string for basic_string +wchar_t simulate[2]={wTESTCHAR1, 0}; + +/* Constants for scan operation */ +U_STRING_DECL(scan_STRING, "Dot. 123. Some more data.", 25); +const UnicodeString uScan_STRING=UnicodeString(scan_STRING); +const stlstring sScan_STRING=stlstring(L"Dot. 123. Some more data."); + +/* global variables or constants for concatenation operation */ +U_STRING_DECL(uCatenate_STR, "!!", 2); +const stlstring sCatenate_STR=stlstring(L"!!"); +static UnicodeString* catICU; +static stlstring* catStd; +UBool bCatenatePrealloc; + +/* type defines */ +typedef struct WLine WLine; +struct WLine { + wchar_t name[100]; + int32_t len; +}; //struct to store one line of wchar_t string + +enum FnType { Fn_ICU, Fn_STD }; +typedef FnType FnType; +typedef void (*ICUStringPerfFn)(const UChar* src,int32_t srcLen, UnicodeString s0); +typedef void (*StdStringPerfFn)(const wchar_t* src,int32_t srcLen, stlstring s0); + + +class StringPerfFunction : public UPerfFunction +{ +public: + + virtual long getEventsPerIteration(){ + int loops = LOOPS; + if (catICU) { delete catICU;} + if (catStd) { delete catStd;} + + if (bCatenatePrealloc) { + + int to_alloc = loops * MAXNUMLINES * (MAXSRCLEN + catenate_STRLEN); + catICU = new UnicodeString(to_alloc,'a',0); + //catICU = new UnicodeString(); + + catStd = new stlstring(); + //catStd -> reserve(loops * MAXNUMLINES * (MAXSRCLEN + catenate_STRLEN)); + catStd -> reserve(110000000); + } else { + catICU = new UnicodeString(); + catStd = new stlstring(); + } + + return -1; + } + + virtual void call(UErrorCode* status) + { + if(line_mode_==TRUE){ + if(uselen_){ + for(int32_t i = 0; i< numLines_; i++){ + if (fnType_==Fn_ICU) { + (*fn1_)(lines_[i].name,lines_[i].len,uS0_[i]); + } else { + (*fn2_)(wlines_[i].name,wlines_[i].len,sS0_[i]); + } + } + }else{ + for(int32_t i = 0; i< numLines_; i++){ + if (fnType_==Fn_ICU) { + (*fn1_)(lines_[i].name,-1,uS0_[i]); + } else { + (*fn2_)(wlines_[i].name,-1,sS0_[i]); + } + } + } + }else{ + if(uselen_){ + if (fnType_==Fn_ICU) { + (*fn1_)(src_,srcLen_,*ubulk_); + } else { + (*fn2_)(wsrc_,wsrcLen_,*sbulk_); + } + }else{ + if (fnType_==Fn_ICU) { + (*fn1_)(src_,-1,*ubulk_); + } else { + (*fn2_)(wsrc_,-1,*sbulk_); + } + } + } + } + + virtual long getOperationsPerIteration() + { + if(line_mode_==TRUE){ + return numLines_; + }else{ + return 1; + } + } + + StringPerfFunction(ICUStringPerfFn func, ULine* srcLines, int32_t srcNumLines, UBool uselen) + { + + fn1_ = func; + lines_=srcLines; + wlines_=NULL; + numLines_=srcNumLines; + uselen_=uselen; + line_mode_=TRUE; + src_ = NULL; + srcLen_ = 0; + wsrc_ = NULL; + wsrcLen_ = 0; + fnType_ = Fn_ICU; + + uS0_=new UnicodeString[numLines_]; + for(int32_t i=0; i<numLines_; i++) { + uS0_[i]=UnicodeString(lines_[i].name, lines_[i].len); + } + sS0_=NULL; + ubulk_=NULL; + sbulk_=NULL; + } + + StringPerfFunction(StdStringPerfFn func, ULine* srcLines, int32_t srcNumLines, UBool uselen) + { + + fn2_ = func; + lines_=srcLines; + wlines_=NULL; + numLines_=srcNumLines; + uselen_=uselen; + line_mode_=TRUE; + src_ = NULL; + srcLen_ = 0; + wsrc_ = NULL; + wsrcLen_ = 0; + fnType_ = Fn_STD; + + uS0_=NULL; + ubulk_=NULL; + sbulk_=NULL; + + //fillin wlines_[], sS0_[] + prepareLinesForStd(); + } + + StringPerfFunction(ICUStringPerfFn func, UChar* source, int32_t sourceLen, UBool uselen) + { + + fn1_ = func; + lines_=NULL; + wlines_=NULL; + numLines_=0; + uselen_=uselen; + line_mode_=FALSE; + src_ = new UChar[sourceLen]; + memcpy(src_, source, sourceLen * U_SIZEOF_UCHAR); + srcLen_ = sourceLen; + wsrc_ = NULL; + wsrcLen_ = 0; + fnType_ = Fn_ICU; + + uS0_=NULL; + sS0_=NULL; + ubulk_=new UnicodeString(src_,srcLen_); + sbulk_=NULL; + } + + StringPerfFunction(StdStringPerfFn func, UChar* source, int32_t sourceLen, UBool uselen) + { + + fn2_ = func; + lines_=NULL; + wlines_=NULL; + numLines_=0; + uselen_=uselen; + line_mode_=FALSE; + src_ = new UChar[sourceLen]; + memcpy(src_, source, sourceLen * U_SIZEOF_UCHAR); + srcLen_ = sourceLen; + fnType_ = Fn_STD; + + uS0_=NULL; + sS0_=NULL; + ubulk_=NULL; + + //fillin wsrc_, sbulk_ + prepareBulkForStd(); + + } + + ~StringPerfFunction() + { + //free(src_); + free(wsrc_); + delete[] src_; + delete ubulk_; + delete sbulk_; + delete[] uS0_; + delete[] sS0_; + delete[] wlines_; + } + +private: + void prepareLinesForStd(void) + { + UErrorCode err=U_ZERO_ERROR; + + wlines_=new WLine[numLines_]; + wchar_t ws[100]; + int32_t wcap = sizeof(ws) / sizeof(*ws); + int32_t wl; + wchar_t* wcs; + + sS0_=new stlstring[numLines_]; + for(int32_t i=0; i<numLines_; i++) { + if(uselen_) { + wcs = u_strToWCS(ws, wcap, &wl, lines_[i].name, lines_[i].len, &err); + memcpy(wlines_[i].name, wcs, wl * sizeof(wchar_t)); + wlines_[i].len = wl; + sS0_[i]=stlstring(wlines_[i].name, wlines_[i].len); + } else { + wcs = u_strToWCS(ws, wcap, &wl, lines_[i].name, lines_[i].len-1, &err); + memcpy(wlines_[i].name, wcs, wl*sizeof(wchar_t)); + wlines_[i].len = wl; + sS0_[i]=stlstring(wlines_[i].name, wlines_[i].len+1); + } + + if (U_FAILURE(err)) { + return; + } + } + + } + + void prepareBulkForStd(void) + { + UErrorCode err=U_ZERO_ERROR; + + const UChar* uSrc = src_; + int32_t uSrcLen = srcLen_; + wchar_t* wDest = NULL; + int32_t wDestLen = 0; + int32_t reqLen= 0 ; + + if(uselen_) { + /* pre-flight*/ + u_strToWCS(wDest,wDestLen,&reqLen,uSrc,uSrcLen,&err); + + if(err == U_BUFFER_OVERFLOW_ERROR){ + err=U_ZERO_ERROR; + wDest =(wchar_t*) malloc(sizeof(wchar_t) * (reqLen)); + wDestLen = reqLen; + u_strToWCS(wDest,wDestLen,&reqLen,uSrc,uSrcLen,&err); + } + + if (U_SUCCESS(err)) { + wsrc_ = wDest; + wsrcLen_ = wDestLen; + sbulk_=new stlstring(wsrc_,wsrcLen_); + } + + } else { + /* pre-flight*/ + u_strToWCS(wDest,wDestLen,&reqLen,uSrc,uSrcLen-1,&err); + + if(err == U_BUFFER_OVERFLOW_ERROR){ + err=U_ZERO_ERROR; + wDest =(wchar_t*) malloc(sizeof(wchar_t) * (reqLen+1)); + wDestLen = reqLen+1; + u_strToWCS(wDest,wDestLen,&reqLen,uSrc,uSrcLen-1,&err); + } + + if (U_SUCCESS(err)) { + wsrc_ = wDest; + wsrcLen_ = wDestLen; + sbulk_=new stlstring(wsrc_); + } + } + + //free(wDest); + } + + +private: + ICUStringPerfFn fn1_; + StdStringPerfFn fn2_; + + ULine* lines_; + WLine* wlines_; + int32_t numLines_; + + UBool uselen_; + UChar* src_; + int32_t srcLen_; + wchar_t* wsrc_; + int32_t wsrcLen_; + UBool line_mode_; + + //added for preparing testing data + UnicodeString* uS0_; + stlstring* sS0_; + UnicodeString* ubulk_; + stlstring* sbulk_; + FnType fnType_; +}; + + +class StringPerformanceTest : public UPerfTest +{ +public: + StringPerformanceTest(int32_t argc, const char *argv[], UErrorCode &status); + ~StringPerformanceTest(); + virtual UPerfFunction* runIndexedTest(int32_t index, UBool exec, + const char *&name, + char *par = NULL); + UPerfFunction* TestCtor(); + UPerfFunction* TestCtor1(); + UPerfFunction* TestCtor2(); + UPerfFunction* TestCtor3(); + UPerfFunction* TestAssign(); + UPerfFunction* TestAssign1(); + UPerfFunction* TestAssign2(); + UPerfFunction* TestGetch(); + UPerfFunction* TestCatenate(); + UPerfFunction* TestScan(); + UPerfFunction* TestScan1(); + UPerfFunction* TestScan2(); + + UPerfFunction* TestStdLibCtor(); + UPerfFunction* TestStdLibCtor1(); + UPerfFunction* TestStdLibCtor2(); + UPerfFunction* TestStdLibCtor3(); + UPerfFunction* TestStdLibAssign(); + UPerfFunction* TestStdLibAssign1(); + UPerfFunction* TestStdLibAssign2(); + UPerfFunction* TestStdLibGetch(); + UPerfFunction* TestStdLibCatenate(); + UPerfFunction* TestStdLibScan(); + UPerfFunction* TestStdLibScan1(); + UPerfFunction* TestStdLibScan2(); + +private: + long COUNT_; + ULine* filelines_; + UChar* StrBuffer; + int32_t StrBufferLen; + +}; + + +inline void ctor(const UChar* src,int32_t srcLen, UnicodeString s0) +{ + UnicodeString a; +} + +inline void ctor1(const UChar* src,int32_t srcLen, UnicodeString s0) +{ + UnicodeString b(uTESTCHAR1); +} + +inline void ctor2(const UChar* src,int32_t srcLen, UnicodeString s0) +{ + UnicodeString c(uEMPTY); +} + +inline void ctor3(const UChar* src,int32_t srcLen, UnicodeString s0) +{ + UnicodeString d(src,srcLen); +} + +inline UnicodeString icu_assign_helper(const UChar* src,int32_t srcLen) +{ + if (srcLen==-1) { return src;} + else { return UnicodeString(src, srcLen);} +} + +inline void assign(const UChar* src,int32_t srcLen, UnicodeString s0) +{ + unistr = icu_assign_helper(src,srcLen); +} + +inline void assign1(const UChar* src,int32_t srcLen, UnicodeString s0) +{ + unistr.setTo(src, srcLen); +} + +inline void assign2(const UChar* src,int32_t srcLen, UnicodeString s0) +{ + unistr = s0; +} + +inline void getch(const UChar* src,int32_t srcLen, UnicodeString s0) +{ + s0.charAt(0); +} + + +inline void catenate(const UChar* src,int32_t srcLen, UnicodeString s0) +{ + UTimer mystart, mystop; + utimer_getTime(&mystart); + + *catICU += s0; + + utimer_getTime(&mystop); + double mytime = utimer_getDeltaSeconds(&mystart,&mystop); + printf("\nmytime=%f \n", mytime); + + *catICU += uCatenate_STR; +} + +volatile int scan_idx; +U_STRING_DECL(SCAN1, "123", 3); + +inline void scan(const UChar* src,int32_t srcLen, UnicodeString s0) +{ + UChar c='.'; + scan_idx = uScan_STRING.indexOf(c); +} + +inline void scan1(const UChar* src,int32_t srcLen, UnicodeString s0) +{ + scan_idx = uScan_STRING.indexOf(SCAN1,3); +} + +inline void scan2(const UChar* src,int32_t srcLen, UnicodeString s0) +{ + UChar c1='s'; + UChar c2='m'; + scan_idx = uScan_STRING.indexOf(c1); + scan_idx = uScan_STRING.indexOf(c2); +} + + +inline void StdLibCtor(const wchar_t* src,int32_t srcLen, stlstring s0) +{ + stlstring a; +} + +inline void StdLibCtor1(const wchar_t* src,int32_t srcLen, stlstring s0) +{ + stlstring b(simulate); +} + +inline void StdLibCtor2(const wchar_t* src,int32_t srcLen, stlstring s0) +{ + stlstring c(sEMPTY); +} + +inline void StdLibCtor3(const wchar_t* src,int32_t srcLen, stlstring s0) +{ + if (srcLen==-1) { + stlstring d(src); + }else { + stlstring d(src, srcLen); + } +} + +inline stlstring stl_assign_helper(const wchar_t* src,int32_t srcLen) +{ + if (srcLen==-1) { return src;} + else { return stlstring(src, srcLen);} +} + +inline void StdLibAssign(const wchar_t* src,int32_t srcLen, stlstring s0) +{ + stlstr = stl_assign_helper(src,srcLen); +} + +inline void StdLibAssign1(const wchar_t* src,int32_t srcLen, stlstring s0) +{ + if (srcLen==-1) { stlstr=src;} + else { stlstr.assign(src, srcLen);} +} + +inline void StdLibAssign2(const wchar_t* src,int32_t srcLen, stlstring s0) +{ + stlstr=s0; +} + +inline void StdLibGetch(const wchar_t* src,int32_t srcLen, stlstring s0) +{ + s0.at(0); +} + +inline void StdLibCatenate(const wchar_t* src,int32_t srcLen, stlstring s0) +{ + UTimer mystart, mystop; + utimer_getTime(&mystart); + + *catStd += s0; + *catStd += sCatenate_STR; + + utimer_getTime(&mystop); + double mytime = utimer_getDeltaSeconds(&mystart,&mystop); + printf("\nmytime=%f \n", mytime); + +} + +inline void StdLibScan(const wchar_t* src,int32_t srcLen, stlstring s0) +{ + scan_idx = (int) sScan_STRING.find('.'); +} + +inline void StdLibScan1(const wchar_t* src,int32_t srcLen, stlstring s0) +{ + scan_idx = (int) sScan_STRING.find(L"123"); +} + +inline void StdLibScan2(const wchar_t* src,int32_t srcLen, stlstring s0) +{ + scan_idx = (int) sScan_STRING.find_first_of(L"sm"); +} + +#endif // STRINGPERF_H + diff --git a/Build/source/libs/icu/icu-xetex/test/perf/ustrperf/stringperf.vcproj b/Build/source/libs/icu/icu-xetex/test/perf/ustrperf/stringperf.vcproj new file mode 100644 index 00000000000..1c1f32309e6 --- /dev/null +++ b/Build/source/libs/icu/icu-xetex/test/perf/ustrperf/stringperf.vcproj @@ -0,0 +1,252 @@ +<?xml version="1.0" encoding="Windows-1252"?> +<VisualStudioProject + ProjectType="Visual C++" + Version="8.00" + Name="stringperf" + ProjectGUID="{523710EA-349D-45BF-8B39-289CC86E7D91}" + > + <Platforms> + <Platform + Name="Win32" + /> + </Platforms> + <ToolFiles> + </ToolFiles> + <Configurations> + <Configuration + Name="Release|Win32" + OutputDirectory=".\Release" + IntermediateDirectory=".\Release" + ConfigurationType="1" + InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops" + UseOfMFC="0" + ATLMinimizesCRunTimeLibraryUsage="false" + CharacterSet="2" + > + <Tool + Name="VCPreBuildEventTool" + /> + <Tool + Name="VCCustomBuildTool" + /> + <Tool + Name="VCXMLDataGeneratorTool" + /> + <Tool + Name="VCWebServiceProxyGeneratorTool" + /> + <Tool + Name="VCMIDLTool" + TypeLibraryName=".\Release/stringperf.tlb" + HeaderFileName="" + /> + <Tool + Name="VCCLCompilerTool" + Optimization="2" + InlineFunctionExpansion="1" + AdditionalIncludeDirectories="..\..\..\..\include;..\..\..\tools\toolutil;..\..\..\common;..\..\..\tools\ctestfw" + PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE" + StringPooling="true" + RuntimeLibrary="2" + EnableFunctionLevelLinking="true" + UsePrecompiledHeader="0" + PrecompiledHeaderFile=".\Release/stringperf.pch" + AssemblerListingLocation=".\Release/" + ObjectFile=".\Release/" + ProgramDataBaseFileName=".\Release/" + WarningLevel="3" + SuppressStartupBanner="true" + CompileAs="0" + /> + <Tool + Name="VCManagedResourceCompilerTool" + /> + <Tool + Name="VCResourceCompilerTool" + PreprocessorDefinitions="NDEBUG" + Culture="1033" + /> + <Tool + Name="VCPreLinkEventTool" + /> + <Tool + Name="VCLinkerTool" + AdditionalDependencies="icuuc.lib icutu.lib icutest.lib winmm.lib" + OutputFile=".\Release/stringperf.exe" + LinkIncremental="1" + SuppressStartupBanner="true" + AdditionalLibraryDirectories="..\..\..\..\lib\" + ProgramDatabaseFile=".\Release/stringperf.pdb" + SubSystem="1" + TargetMachine="1" + /> + <Tool + Name="VCALinkTool" + /> + <Tool + Name="VCManifestTool" + /> + <Tool + Name="VCXDCMakeTool" + /> + <Tool + Name="VCBscMakeTool" + /> + <Tool + Name="VCFxCopTool" + /> + <Tool + Name="VCAppVerifierTool" + /> + <Tool + Name="VCWebDeploymentTool" + /> + <Tool + Name="VCPostBuildEventTool" + /> + </Configuration> + <Configuration + Name="Debug|Win32" + OutputDirectory=".\Debug" + IntermediateDirectory=".\Debug" + ConfigurationType="1" + InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops" + UseOfMFC="0" + ATLMinimizesCRunTimeLibraryUsage="false" + CharacterSet="2" + > + <Tool + Name="VCPreBuildEventTool" + /> + <Tool + Name="VCCustomBuildTool" + /> + <Tool + Name="VCXMLDataGeneratorTool" + /> + <Tool + Name="VCWebServiceProxyGeneratorTool" + /> + <Tool + Name="VCMIDLTool" + TypeLibraryName=".\Debug/stringperf.tlb" + HeaderFileName="" + /> + <Tool + Name="VCCLCompilerTool" + Optimization="0" + AdditionalIncludeDirectories="..\..\..\..\include;..\..\..\tools\toolutil;..\..\..\common;..\..\..\tools\ctestfw" + PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE" + BasicRuntimeChecks="3" + RuntimeLibrary="3" + UsePrecompiledHeader="0" + PrecompiledHeaderFile=".\Debug/stringperf.pch" + AssemblerListingLocation=".\Debug/" + ObjectFile=".\Debug/" + ProgramDataBaseFileName=".\Debug/" + BrowseInformation="1" + WarningLevel="3" + SuppressStartupBanner="true" + DebugInformationFormat="3" + CompileAs="0" + /> + <Tool + Name="VCManagedResourceCompilerTool" + /> + <Tool + Name="VCResourceCompilerTool" + PreprocessorDefinitions="_DEBUG" + Culture="1047" + /> + <Tool + Name="VCPreLinkEventTool" + /> + <Tool + Name="VCLinkerTool" + AdditionalDependencies="icuucd.lib icutud.lib icutestd.lib winmm.lib" + OutputFile=".\Debug/stringperf.exe" + LinkIncremental="1" + SuppressStartupBanner="true" + AdditionalLibraryDirectories="..\..\..\..\lib\" + GenerateDebugInformation="true" + ProgramDatabaseFile=".\Debug/stringperf.pdb" + SubSystem="1" + /> + <Tool + Name="VCALinkTool" + /> + <Tool + Name="VCManifestTool" + /> + <Tool + Name="VCXDCMakeTool" + /> + <Tool + Name="VCBscMakeTool" + /> + <Tool + Name="VCFxCopTool" + /> + <Tool + Name="VCAppVerifierTool" + /> + <Tool + Name="VCWebDeploymentTool" + /> + <Tool + Name="VCPostBuildEventTool" + /> + </Configuration> + </Configurations> + <References> + </References> + <Files> + <Filter + Name="Source Files" + Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" + > + <File + RelativePath="stringperf.cpp" + > + <FileConfiguration + Name="Release|Win32" + > + <Tool + Name="VCCLCompilerTool" + Optimization="2" + AdditionalIncludeDirectories="" + PreprocessorDefinitions="" + /> + </FileConfiguration> + <FileConfiguration + Name="Debug|Win32" + > + <Tool + Name="VCCLCompilerTool" + Optimization="0" + AdditionalIncludeDirectories="" + PreprocessorDefinitions="" + BasicRuntimeChecks="3" + BrowseInformation="1" + /> + </FileConfiguration> + </File> + </Filter> + <Filter + Name="Header Files" + Filter="h;hpp;hxx;hm;inl" + > + <File + RelativePath="stringperf.h" + > + </File> + </Filter> + <Filter + Name="Resource Files" + Filter="ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe" + > + </Filter> + </Files> + <Globals> + </Globals> +</VisualStudioProject> |