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 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 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 125 virtual long getOperationsPerIteration() 126 { 127 if(line_mode_==TRUE){ 128 return numLines_; 129 }else{ 130 return 1; 131 } 132 } 133 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 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 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 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 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: 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 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 386 inline void ctor(const UChar* src,int32_t srcLen, UnicodeString s0) 387 { 388 UnicodeString a; 389 } 390 391 inline void ctor1(const UChar* src,int32_t srcLen, UnicodeString s0) 392 { 393 UnicodeString b(uTESTCHAR1); 394 } 395 396 inline void ctor2(const UChar* src,int32_t srcLen, UnicodeString s0) 397 { 398 UnicodeString c(uEMPTY); 399 } 400 401 inline void ctor3(const UChar* src,int32_t srcLen, UnicodeString s0) 402 { 403 UnicodeString d(src,srcLen); 404 } 405 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 412 inline void assign(const UChar* src,int32_t srcLen, UnicodeString s0) 413 { 414 unistr = icu_assign_helper(src,srcLen); 415 } 416 417 inline void assign1(const UChar* src,int32_t srcLen, UnicodeString s0) 418 { 419 unistr.setTo(src, srcLen); 420 } 421 422 inline void assign2(const UChar* src,int32_t srcLen, UnicodeString s0) 423 { 424 unistr = s0; 425 } 426 427 inline void getch(const UChar* src,int32_t srcLen, UnicodeString s0) 428 { 429 s0.charAt(0); 430 } 431 432 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 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 456 inline void scan1(const UChar* src,int32_t srcLen, UnicodeString s0) 457 { 458 scan_idx = uScan_STRING.indexOf(SCAN1,3); 459 } 460 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 470 inline void StdLibCtor(const wchar_t* src,int32_t srcLen, stlstring s0) 471 { 472 stlstring a; 473 } 474 475 inline void StdLibCtor1(const wchar_t* src,int32_t srcLen, stlstring s0) 476 { 477 stlstring b(simulate); 478 } 479 480 inline void StdLibCtor2(const wchar_t* src,int32_t srcLen, stlstring s0) 481 { 482 stlstring c(sEMPTY); 483 } 484 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 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 500 inline void StdLibAssign(const wchar_t* src,int32_t srcLen, stlstring s0) 501 { 502 stlstr = stl_assign_helper(src,srcLen); 503 } 504 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 511 inline void StdLibAssign2(const wchar_t* src,int32_t srcLen, stlstring s0) 512 { 513 stlstr=s0; 514 } 515 516 inline void StdLibGetch(const wchar_t* src,int32_t srcLen, stlstring s0) 517 { 518 s0.at(0); 519 } 520 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 535 inline void StdLibScan(const wchar_t* src,int32_t srcLen, stlstring s0) 536 { 537 scan_idx = (int) sScan_STRING.find('.'); 538 } 539 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 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
