1 /*
2 **********************************************************************
3 * Copyright (c) 2002-2006, International Business Machines
4 * Corporation and others. All Rights Reserved.
5 **********************************************************************
6 */
7 #ifndef _STRINGPERF_H
8 #define _STRINGPERF_H
9
10 #include <string>
11
12 #include "unicode/utypes.h"
13 #include "unicode/unistr.h"
14
15 #include "unicode/uperf.h"
16
17 typedef std::wstring stlstring;
18
19 /* Define all constants for test case operations */
20 #define MAXNUMLINES 40000 //Max number of lines in a test data file
21 #define MAXSRCLEN 20 //Max length of one line. maybe a larger number, but it need more mem
22 #define LOOPS 100 //Iterations
23 //#define LOOPS 10
24 #define catenate_STRLEN 2
25
26 const UChar uTESTCHAR1 = 'a';
27 const wchar_t wTESTCHAR1 = 'a';
28 const UnicodeString uEMPTY;
29 const stlstring sEMPTY;
30 UnicodeString unistr;
31 stlstring stlstr;
32 // Simulate construction with a single-char string for basic_string
33 wchar_t simulate[2]={wTESTCHAR1, 0};
34
35 /* Constants for scan operation */
36 U_STRING_DECL(scan_STRING, "Dot. 123. Some more data.", 25);
37 const UnicodeString uScan_STRING=UnicodeString(scan_STRING);
38 const stlstring sScan_STRING=stlstring(L"Dot. 123. Some more data.");
39
40 /* global variables or constants for concatenation operation */
41 U_STRING_DECL(uCatenate_STR, "!!", 2);
42 const stlstring sCatenate_STR=stlstring(L"!!");
43 static UnicodeString* catICU;
44 static stlstring* catStd;
45 UBool bCatenatePrealloc;
46
47 /* type defines */
48 typedef struct WLine WLine;
49 struct WLine {
50 wchar_t name[100];
51 int32_t len;
52 }; //struct to store one line of wchar_t string
53
54 enum FnType { Fn_ICU, Fn_STD };
55 typedef FnType FnType;
56 typedef void (*ICUStringPerfFn)(const UChar* src,int32_t srcLen, UnicodeString s0);
57 typedef void (*StdStringPerfFn)(const wchar_t* src,int32_t srcLen, stlstring s0);
58
59
60 class StringPerfFunction : public UPerfFunction
61 {
62 public:
63
getEventsPerIteration()64 virtual long getEventsPerIteration(){
65 int loops = LOOPS;
66 if (catICU) { delete catICU;}
67 if (catStd) { delete catStd;}
68
69 if (bCatenatePrealloc) {
70
71 int to_alloc = loops * MAXNUMLINES * (MAXSRCLEN + catenate_STRLEN);
72 catICU = new UnicodeString(to_alloc,'a',0);
73 //catICU = new UnicodeString();
74
75 catStd = new stlstring();
76 //catStd -> reserve(loops * MAXNUMLINES * (MAXSRCLEN + catenate_STRLEN));
77 catStd -> reserve(110000000);
78 } else {
79 catICU = new UnicodeString();
80 catStd = new stlstring();
81 }
82
83 return -1;
84 }
85
call(UErrorCode * status)86 virtual void call(UErrorCode* status)
87 {
88 if(line_mode_==TRUE){
89 if(uselen_){
90 for(int32_t i = 0; i< numLines_; i++){
91 if (fnType_==Fn_ICU) {
92 (*fn1_)(lines_[i].name,lines_[i].len,uS0_[i]);
93 } else {
94 (*fn2_)(wlines_[i].name,wlines_[i].len,sS0_[i]);
95 }
96 }
97 }else{
98 for(int32_t i = 0; i< numLines_; i++){
99 if (fnType_==Fn_ICU) {
100 (*fn1_)(lines_[i].name,-1,uS0_[i]);
101 } else {
102 (*fn2_)(wlines_[i].name,-1,sS0_[i]);
103 }
104 }
105 }
106 }else{
107 if(uselen_){
108 if (fnType_==Fn_ICU) {
109 (*fn1_)(src_,srcLen_,*ubulk_);
110 } else {
111 (*fn2_)(wsrc_,wsrcLen_,*sbulk_);
112 }
113 }else{
114 if (fnType_==Fn_ICU) {
115 (*fn1_)(src_,-1,*ubulk_);
116 } else {
117 (*fn2_)(wsrc_,-1,*sbulk_);
118 }
119 }
120 }
121 }
122
getOperationsPerIteration()123 virtual long getOperationsPerIteration()
124 {
125 if(line_mode_==TRUE){
126 return numLines_;
127 }else{
128 return 1;
129 }
130 }
131
StringPerfFunction(ICUStringPerfFn func,ULine * srcLines,int32_t srcNumLines,UBool uselen)132 StringPerfFunction(ICUStringPerfFn func, ULine* srcLines, int32_t srcNumLines, UBool uselen)
133 {
134
135 fn1_ = func;
136 lines_=srcLines;
137 wlines_=NULL;
138 numLines_=srcNumLines;
139 uselen_=uselen;
140 line_mode_=TRUE;
141 src_ = NULL;
142 srcLen_ = 0;
143 wsrc_ = NULL;
144 wsrcLen_ = 0;
145 fnType_ = Fn_ICU;
146
147 uS0_=new UnicodeString[numLines_];
148 for(int32_t i=0; i<numLines_; i++) {
149 uS0_[i]=UnicodeString(lines_[i].name, lines_[i].len);
150 }
151 sS0_=NULL;
152 ubulk_=NULL;
153 sbulk_=NULL;
154 }
155
StringPerfFunction(StdStringPerfFn func,ULine * srcLines,int32_t srcNumLines,UBool uselen)156 StringPerfFunction(StdStringPerfFn func, ULine* srcLines, int32_t srcNumLines, UBool uselen)
157 {
158
159 fn2_ = func;
160 lines_=srcLines;
161 wlines_=NULL;
162 numLines_=srcNumLines;
163 uselen_=uselen;
164 line_mode_=TRUE;
165 src_ = NULL;
166 srcLen_ = 0;
167 wsrc_ = NULL;
168 wsrcLen_ = 0;
169 fnType_ = Fn_STD;
170
171 uS0_=NULL;
172 ubulk_=NULL;
173 sbulk_=NULL;
174
175 //fillin wlines_[], sS0_[]
176 prepareLinesForStd();
177 }
178
StringPerfFunction(ICUStringPerfFn func,UChar * source,int32_t sourceLen,UBool uselen)179 StringPerfFunction(ICUStringPerfFn func, UChar* source, int32_t sourceLen, UBool uselen)
180 {
181
182 fn1_ = func;
183 lines_=NULL;
184 wlines_=NULL;
185 numLines_=0;
186 uselen_=uselen;
187 line_mode_=FALSE;
188 src_ = new UChar[sourceLen];
189 memcpy(src_, source, sourceLen * U_SIZEOF_UCHAR);
190 srcLen_ = sourceLen;
191 wsrc_ = NULL;
192 wsrcLen_ = 0;
193 fnType_ = Fn_ICU;
194
195 uS0_=NULL;
196 sS0_=NULL;
197 ubulk_=new UnicodeString(src_,srcLen_);
198 sbulk_=NULL;
199 }
200
StringPerfFunction(StdStringPerfFn func,UChar * source,int32_t sourceLen,UBool uselen)201 StringPerfFunction(StdStringPerfFn func, UChar* source, int32_t sourceLen, UBool uselen)
202 {
203
204 fn2_ = func;
205 lines_=NULL;
206 wlines_=NULL;
207 numLines_=0;
208 uselen_=uselen;
209 line_mode_=FALSE;
210 src_ = new UChar[sourceLen];
211 memcpy(src_, source, sourceLen * U_SIZEOF_UCHAR);
212 srcLen_ = sourceLen;
213 fnType_ = Fn_STD;
214
215 uS0_=NULL;
216 sS0_=NULL;
217 ubulk_=NULL;
218
219 //fillin wsrc_, sbulk_
220 prepareBulkForStd();
221
222 }
223
~StringPerfFunction()224 ~StringPerfFunction()
225 {
226 //free(src_);
227 free(wsrc_);
228 delete[] src_;
229 delete ubulk_;
230 delete sbulk_;
231 delete[] uS0_;
232 delete[] sS0_;
233 delete[] wlines_;
234 }
235
236 private:
prepareLinesForStd(void)237 void prepareLinesForStd(void)
238 {
239 UErrorCode err=U_ZERO_ERROR;
240
241 wlines_=new WLine[numLines_];
242 wchar_t ws[100];
243 int32_t wcap = sizeof(ws) / sizeof(*ws);
244 int32_t wl;
245 wchar_t* wcs;
246
247 sS0_=new stlstring[numLines_];
248 for(int32_t i=0; i<numLines_; i++) {
249 if(uselen_) {
250 wcs = u_strToWCS(ws, wcap, &wl, lines_[i].name, lines_[i].len, &err);
251 memcpy(wlines_[i].name, wcs, wl * sizeof(wchar_t));
252 wlines_[i].len = wl;
253 sS0_[i]=stlstring(wlines_[i].name, wlines_[i].len);
254 } else {
255 wcs = u_strToWCS(ws, wcap, &wl, lines_[i].name, lines_[i].len-1, &err);
256 memcpy(wlines_[i].name, wcs, wl*sizeof(wchar_t));
257 wlines_[i].len = wl;
258 sS0_[i]=stlstring(wlines_[i].name, wlines_[i].len+1);
259 }
260
261 if (U_FAILURE(err)) {
262 return;
263 }
264 }
265
266 }
267
prepareBulkForStd(void)268 void prepareBulkForStd(void)
269 {
270 UErrorCode err=U_ZERO_ERROR;
271
272 const UChar* uSrc = src_;
273 int32_t uSrcLen = srcLen_;
274 wchar_t* wDest = NULL;
275 int32_t wDestLen = 0;
276 int32_t reqLen= 0 ;
277
278 if(uselen_) {
279 /* pre-flight*/
280 u_strToWCS(wDest,wDestLen,&reqLen,uSrc,uSrcLen,&err);
281
282 if(err == U_BUFFER_OVERFLOW_ERROR){
283 err=U_ZERO_ERROR;
284 wDest =(wchar_t*) malloc(sizeof(wchar_t) * (reqLen));
285 wDestLen = reqLen;
286 u_strToWCS(wDest,wDestLen,&reqLen,uSrc,uSrcLen,&err);
287 }
288
289 if (U_SUCCESS(err)) {
290 wsrc_ = wDest;
291 wsrcLen_ = wDestLen;
292 sbulk_=new stlstring(wsrc_,wsrcLen_);
293 }
294
295 } else {
296 /* pre-flight*/
297 u_strToWCS(wDest,wDestLen,&reqLen,uSrc,uSrcLen-1,&err);
298
299 if(err == U_BUFFER_OVERFLOW_ERROR){
300 err=U_ZERO_ERROR;
301 wDest =(wchar_t*) malloc(sizeof(wchar_t) * (reqLen+1));
302 wDestLen = reqLen+1;
303 u_strToWCS(wDest,wDestLen,&reqLen,uSrc,uSrcLen-1,&err);
304 }
305
306 if (U_SUCCESS(err)) {
307 wsrc_ = wDest;
308 wsrcLen_ = wDestLen;
309 sbulk_=new stlstring(wsrc_);
310 }
311 }
312
313 //free(wDest);
314 }
315
316
317 private:
318 ICUStringPerfFn fn1_;
319 StdStringPerfFn fn2_;
320
321 ULine* lines_;
322 WLine* wlines_;
323 int32_t numLines_;
324
325 UBool uselen_;
326 UChar* src_;
327 int32_t srcLen_;
328 wchar_t* wsrc_;
329 int32_t wsrcLen_;
330 UBool line_mode_;
331
332 //added for preparing testing data
333 UnicodeString* uS0_;
334 stlstring* sS0_;
335 UnicodeString* ubulk_;
336 stlstring* sbulk_;
337 FnType fnType_;
338 };
339
340
341 class StringPerformanceTest : public UPerfTest
342 {
343 public:
344 StringPerformanceTest(int32_t argc, const char *argv[], UErrorCode &status);
345 ~StringPerformanceTest();
346 virtual UPerfFunction* runIndexedTest(int32_t index, UBool exec,
347 const char *&name,
348 char *par = NULL);
349 UPerfFunction* TestCtor();
350 UPerfFunction* TestCtor1();
351 UPerfFunction* TestCtor2();
352 UPerfFunction* TestCtor3();
353 UPerfFunction* TestAssign();
354 UPerfFunction* TestAssign1();
355 UPerfFunction* TestAssign2();
356 UPerfFunction* TestGetch();
357 UPerfFunction* TestCatenate();
358 UPerfFunction* TestScan();
359 UPerfFunction* TestScan1();
360 UPerfFunction* TestScan2();
361
362 UPerfFunction* TestStdLibCtor();
363 UPerfFunction* TestStdLibCtor1();
364 UPerfFunction* TestStdLibCtor2();
365 UPerfFunction* TestStdLibCtor3();
366 UPerfFunction* TestStdLibAssign();
367 UPerfFunction* TestStdLibAssign1();
368 UPerfFunction* TestStdLibAssign2();
369 UPerfFunction* TestStdLibGetch();
370 UPerfFunction* TestStdLibCatenate();
371 UPerfFunction* TestStdLibScan();
372 UPerfFunction* TestStdLibScan1();
373 UPerfFunction* TestStdLibScan2();
374
375 private:
376 long COUNT_;
377 ULine* filelines_;
378 UChar* StrBuffer;
379 int32_t StrBufferLen;
380
381 };
382
383
ctor(const UChar * src,int32_t srcLen,UnicodeString s0)384 inline void ctor(const UChar* src,int32_t srcLen, UnicodeString s0)
385 {
386 UnicodeString a;
387 }
388
ctor1(const UChar * src,int32_t srcLen,UnicodeString s0)389 inline void ctor1(const UChar* src,int32_t srcLen, UnicodeString s0)
390 {
391 UnicodeString b(uTESTCHAR1);
392 }
393
ctor2(const UChar * src,int32_t srcLen,UnicodeString s0)394 inline void ctor2(const UChar* src,int32_t srcLen, UnicodeString s0)
395 {
396 UnicodeString c(uEMPTY);
397 }
398
ctor3(const UChar * src,int32_t srcLen,UnicodeString s0)399 inline void ctor3(const UChar* src,int32_t srcLen, UnicodeString s0)
400 {
401 UnicodeString d(src,srcLen);
402 }
403
icu_assign_helper(const UChar * src,int32_t srcLen)404 inline UnicodeString icu_assign_helper(const UChar* src,int32_t srcLen)
405 {
406 if (srcLen==-1) { return src;}
407 else { return UnicodeString(src, srcLen);}
408 }
409
assign(const UChar * src,int32_t srcLen,UnicodeString s0)410 inline void assign(const UChar* src,int32_t srcLen, UnicodeString s0)
411 {
412 unistr = icu_assign_helper(src,srcLen);
413 }
414
assign1(const UChar * src,int32_t srcLen,UnicodeString s0)415 inline void assign1(const UChar* src,int32_t srcLen, UnicodeString s0)
416 {
417 unistr.setTo(src, srcLen);
418 }
419
assign2(const UChar * src,int32_t srcLen,UnicodeString s0)420 inline void assign2(const UChar* src,int32_t srcLen, UnicodeString s0)
421 {
422 unistr = s0;
423 }
424
getch(const UChar * src,int32_t srcLen,UnicodeString s0)425 inline void getch(const UChar* src,int32_t srcLen, UnicodeString s0)
426 {
427 s0.charAt(0);
428 }
429
430
catenate(const UChar * src,int32_t srcLen,UnicodeString s0)431 inline void catenate(const UChar* src,int32_t srcLen, UnicodeString s0)
432 {
433 UTimer mystart, mystop;
434 utimer_getTime(&mystart);
435
436 *catICU += s0;
437
438 utimer_getTime(&mystop);
439 double mytime = utimer_getDeltaSeconds(&mystart,&mystop);
440 printf("\nmytime=%f \n", mytime);
441
442 *catICU += uCatenate_STR;
443 }
444
445 volatile int scan_idx;
446 U_STRING_DECL(SCAN1, "123", 3);
447
scan(const UChar * src,int32_t srcLen,UnicodeString s0)448 inline void scan(const UChar* src,int32_t srcLen, UnicodeString s0)
449 {
450 UChar c='.';
451 scan_idx = uScan_STRING.indexOf(c);
452 }
453
scan1(const UChar * src,int32_t srcLen,UnicodeString s0)454 inline void scan1(const UChar* src,int32_t srcLen, UnicodeString s0)
455 {
456 scan_idx = uScan_STRING.indexOf(SCAN1,3);
457 }
458
scan2(const UChar * src,int32_t srcLen,UnicodeString s0)459 inline void scan2(const UChar* src,int32_t srcLen, UnicodeString s0)
460 {
461 UChar c1='s';
462 UChar c2='m';
463 scan_idx = uScan_STRING.indexOf(c1);
464 scan_idx = uScan_STRING.indexOf(c2);
465 }
466
467
StdLibCtor(const wchar_t * src,int32_t srcLen,stlstring s0)468 inline void StdLibCtor(const wchar_t* src,int32_t srcLen, stlstring s0)
469 {
470 stlstring a;
471 }
472
StdLibCtor1(const wchar_t * src,int32_t srcLen,stlstring s0)473 inline void StdLibCtor1(const wchar_t* src,int32_t srcLen, stlstring s0)
474 {
475 stlstring b(simulate);
476 }
477
StdLibCtor2(const wchar_t * src,int32_t srcLen,stlstring s0)478 inline void StdLibCtor2(const wchar_t* src,int32_t srcLen, stlstring s0)
479 {
480 stlstring c(sEMPTY);
481 }
482
StdLibCtor3(const wchar_t * src,int32_t srcLen,stlstring s0)483 inline void StdLibCtor3(const wchar_t* src,int32_t srcLen, stlstring s0)
484 {
485 if (srcLen==-1) {
486 stlstring d(src);
487 }else {
488 stlstring d(src, srcLen);
489 }
490 }
491
stl_assign_helper(const wchar_t * src,int32_t srcLen)492 inline stlstring stl_assign_helper(const wchar_t* src,int32_t srcLen)
493 {
494 if (srcLen==-1) { return src;}
495 else { return stlstring(src, srcLen);}
496 }
497
StdLibAssign(const wchar_t * src,int32_t srcLen,stlstring s0)498 inline void StdLibAssign(const wchar_t* src,int32_t srcLen, stlstring s0)
499 {
500 stlstr = stl_assign_helper(src,srcLen);
501 }
502
StdLibAssign1(const wchar_t * src,int32_t srcLen,stlstring s0)503 inline void StdLibAssign1(const wchar_t* src,int32_t srcLen, stlstring s0)
504 {
505 if (srcLen==-1) { stlstr=src;}
506 else { stlstr.assign(src, srcLen);}
507 }
508
StdLibAssign2(const wchar_t * src,int32_t srcLen,stlstring s0)509 inline void StdLibAssign2(const wchar_t* src,int32_t srcLen, stlstring s0)
510 {
511 stlstr=s0;
512 }
513
StdLibGetch(const wchar_t * src,int32_t srcLen,stlstring s0)514 inline void StdLibGetch(const wchar_t* src,int32_t srcLen, stlstring s0)
515 {
516 s0.at(0);
517 }
518
StdLibCatenate(const wchar_t * src,int32_t srcLen,stlstring s0)519 inline void StdLibCatenate(const wchar_t* src,int32_t srcLen, stlstring s0)
520 {
521 UTimer mystart, mystop;
522 utimer_getTime(&mystart);
523
524 *catStd += s0;
525 *catStd += sCatenate_STR;
526
527 utimer_getTime(&mystop);
528 double mytime = utimer_getDeltaSeconds(&mystart,&mystop);
529 printf("\nmytime=%f \n", mytime);
530
531 }
532
StdLibScan(const wchar_t * src,int32_t srcLen,stlstring s0)533 inline void StdLibScan(const wchar_t* src,int32_t srcLen, stlstring s0)
534 {
535 scan_idx = (int) sScan_STRING.find('.');
536 }
537
StdLibScan1(const wchar_t * src,int32_t srcLen,stlstring s0)538 inline void StdLibScan1(const wchar_t* src,int32_t srcLen, stlstring s0)
539 {
540 scan_idx = (int) sScan_STRING.find(L"123");
541 }
542
StdLibScan2(const wchar_t * src,int32_t srcLen,stlstring s0)543 inline void StdLibScan2(const wchar_t* src,int32_t srcLen, stlstring s0)
544 {
545 scan_idx = (int) sScan_STRING.find_first_of(L"sm");
546 }
547
548 #endif // STRINGPERF_H
549
550