Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(2)

Unified Diff: icu46/source/test/perf/ustrperf/stringperf.h

Issue 5516007: Check in the pristine copy of ICU 4.6... (Closed) Base URL: svn://chrome-svn/chrome/trunk/deps/third_party/
Patch Set: Created 10 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « icu46/source/test/perf/ustrperf/StringPerf_r.pl ('k') | icu46/source/test/perf/ustrperf/stringperf.cpp » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: icu46/source/test/perf/ustrperf/stringperf.h
===================================================================
--- icu46/source/test/perf/ustrperf/stringperf.h (revision 0)
+++ icu46/source/test/perf/ustrperf/stringperf.h (revision 0)
@@ -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
+
Property changes on: icu46/source/test/perf/ustrperf/stringperf.h
___________________________________________________________________
Added: svn:eol-style
+ LF
« no previous file with comments | « icu46/source/test/perf/ustrperf/StringPerf_r.pl ('k') | icu46/source/test/perf/ustrperf/stringperf.cpp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698