X-Git-Url: https://git.saurik.com/apple/icu.git/blobdiff_plain/b75a7d8f3b4adbae880cab104ce2c6a50eee4db2..374ca955a76ecab1204ca8bfa63ff9238d998416:/icuSources/test/perf/ustrperf/stringperf.h

diff --git a/icuSources/test/perf/ustrperf/stringperf.h b/icuSources/test/perf/ustrperf/stringperf.h
new file mode 100644
index 00000000..f3b83ad0
--- /dev/null
+++ b/icuSources/test/perf/ustrperf/stringperf.h
@@ -0,0 +1,549 @@
+/*
+**********************************************************************
+* Copyright (c) 2002-2004, International Business Machines
+* Corporation and others.  All Rights Reserved.
+**********************************************************************
+**********************************************************************
+*/
+#ifndef _STRINGPERF_H
+#define _STRINGPERF_H
+
+#include <string>
+
+#include "uperf.h"
+#include "unicode/utypes.h"
+#include "unicode/unistr.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
\ No newline at end of file