| OLD | NEW |
|---|
| (Empty) |
| 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 s
0); | |
| 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_STRL
EN)); | |
| 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 srcNumLine
s, 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 srcNumLine
s, 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, U
Bool 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, U
Bool 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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2435373002:
Delete source/test (Closed)
