icuSources/test/perf/ustrperf/stringperf.h

   1 /*
   2 **********************************************************************
   3 * Copyright (c) 2002-2004, International Business Machines
   4 * Corporation and others.  All Rights Reserved.
   5 **********************************************************************
   6 **********************************************************************
   7 */
   8 #ifndef _STRINGPERF_H
   9 #define _STRINGPERF_H
  10
  11 #include <string>
  12
  13 #include "uperf.h"
  14 #include "unicode/utypes.h"
  15 #include "unicode/unistr.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
  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
  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
 123         virtual long getOperationsPerIteration()
 124         {
 125         if(line_mode_==TRUE){
 126             return numLines_;
 127         }else{
 128             return 1;
 129         }
 130         }
 131
 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
 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
 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
 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
 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:
 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
 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
 384 inline void ctor(const UChar* src,int32_t srcLen, UnicodeString s0)
 385 {
 386         UnicodeString a;
 387 }
 388
 389 inline void ctor1(const UChar* src,int32_t srcLen, UnicodeString s0)
 390 {
 391         UnicodeString b(uTESTCHAR1);
 392 }
 393
 394 inline void ctor2(const UChar* src,int32_t srcLen, UnicodeString s0)
 395 {
 396         UnicodeString c(uEMPTY);
 397 }
 398
 399 inline void ctor3(const UChar* src,int32_t srcLen, UnicodeString s0)
 400 {
 401         UnicodeString d(src,srcLen);
 402 }
 403
 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
 410 inline void assign(const UChar* src,int32_t srcLen, UnicodeString s0)
 411 {
 412         unistr = icu_assign_helper(src,srcLen);
 413 }
 414
 415 inline void assign1(const UChar* src,int32_t srcLen, UnicodeString s0)
 416 {
 417         unistr.setTo(src, srcLen);
 418 }
 419
 420 inline void assign2(const UChar* src,int32_t srcLen, UnicodeString s0)
 421 {
 422         unistr = s0;
 423 }
 424
 425 inline void getch(const UChar* src,int32_t srcLen, UnicodeString s0)
 426 {
 427         s0.charAt(0);
 428 }
 429
 430
 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
 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
 454 inline void scan1(const UChar* src,int32_t srcLen, UnicodeString s0)
 455 {
 456         scan_idx = uScan_STRING.indexOf(SCAN1,3);
 457 }
 458
 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
 468 inline void StdLibCtor(const wchar_t* src,int32_t srcLen, stlstring s0)
 469 {
 470         stlstring a;
 471 }
 472
 473 inline void StdLibCtor1(const wchar_t* src,int32_t srcLen, stlstring s0)
 474 {
 475
 476         stlstring b(simulate);
 477 }
 478
 479 inline void StdLibCtor2(const wchar_t* src,int32_t srcLen, stlstring s0)
 480 {
 481         stlstring c(sEMPTY);
 482 }
 483
 484 inline void StdLibCtor3(const wchar_t* src,int32_t srcLen, stlstring s0)
 485 {
 486         if (srcLen==-1) {
 487                 stlstring d(src);
 488         }else {
 489                 stlstring d(src, srcLen);
 490         }
 491 }
 492
 493 inline stlstring stl_assign_helper(const wchar_t* src,int32_t srcLen)
 494 {
 495         if (srcLen==-1) { return src;}
 496         else { return stlstring(src, srcLen);}
 497 }
 498
 499 inline void StdLibAssign(const wchar_t* src,int32_t srcLen, stlstring s0)
 500 {
 501         stlstr = stl_assign_helper(src,srcLen);
 502 }
 503
 504 inline void StdLibAssign1(const wchar_t* src,int32_t srcLen, stlstring s0)
 505 {
 506         if (srcLen==-1) { stlstr=src;}
 507         else { stlstr.assign(src, srcLen);}
 508 }
 509
 510 inline void StdLibAssign2(const wchar_t* src,int32_t srcLen, stlstring s0)
 511 {
 512         stlstr=s0;
 513 }
 514
 515 inline void StdLibGetch(const wchar_t* src,int32_t srcLen, stlstring s0)
 516 {
 517         s0.at(0);
 518 }
 519
 520 inline void StdLibCatenate(const wchar_t* src,int32_t srcLen, stlstring s0)
 521 {
 522         UTimer mystart, mystop;
 523         utimer_getTime(&mystart);
 524
 525     *catStd += s0;
 526         *catStd += sCatenate_STR;
 527
 528         utimer_getTime(&mystop);
 529     double mytime = utimer_getDeltaSeconds(&mystart,&mystop);
 530         printf("\nmytime=%f \n", mytime);
 531
 532 }
 533
 534 inline void StdLibScan(const wchar_t* src,int32_t srcLen, stlstring s0)
 535 {
 536         scan_idx = (int) sScan_STRING.find('.');
 537 }
 538
 539 inline void StdLibScan1(const wchar_t* src,int32_t srcLen, stlstring s0)
 540 {
 541         scan_idx = (int) sScan_STRING.find(L"123");
 542 }
 543
 544 inline void StdLibScan2(const wchar_t* src,int32_t srcLen, stlstring s0)
 545 {
 546         scan_idx = (int) sScan_STRING.find_first_of(L"sm");
 547 }
 548
 549 #endif // STRINGPERF_H