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