icuSources/test/perf/ustrperf/stringperf.h

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