icuSources/test/perf/ustrperf/stringperf.cpp

   1 /***********************************************************************
   2  * © 2016 and later: Unicode, Inc. and others.
   3  * License & terms of use: http://www.unicode.org/copyright.html#License
   4  *
   5  ***********************************************************************
   6  ***********************************************************************
   7  * COPYRIGHT:
   8  * Copyright (C) 2002-2006 International Business Machines Corporation
   9  * and others. All Rights Reserved.
  10  *
  11  ***********************************************************************/
  12 /*****************************************************************************
  13 * File stringperf.cpp
  14 *
  15 * Modification History:
  16 * Name                     Description
  17 * Doug Wang                Second version
  18 * Doug Wang                First Version
  19 ******************************************************************************
  20 */
  21
  22 /**
  23  * This program tests UnicodeString performance.
  24  * APIs tested: UnicodeString
  25  * ICU4C
  26  * Windows 2000/XP, Linux
  27  */
  28
  29 #include "stringperf.h"
  30
  31
  32 int main(int argc, const char *argv[])
  33 {
  34     UErrorCode status = U_ZERO_ERROR;
  35
  36     bCatenatePrealloc=TRUE;
  37
  38     StringPerformanceTest test(argc, argv, status);
  39     if (U_FAILURE(status)){
  40         return status;
  41     }
  42
  43     int loops = LOOPS;
  44     if (bCatenatePrealloc) {
  45         int to_alloc = loops * MAXNUMLINES * (MAXSRCLEN + catenate_STRLEN);
  46         catICU = new UnicodeString(to_alloc,'a',0);
  47         //catICU = new UnicodeString();
  48
  49         catStd = new stlstring();
  50         catStd -> reserve(loops * MAXNUMLINES * (MAXSRCLEN + catenate_STRLEN));
  51         //catStd -> reserve(110000000);
  52     } else {
  53         catICU = new UnicodeString();
  54         catStd = new stlstring();
  55     }
  56
  57     if (test.run() == FALSE){
  58         fprintf(stderr, "FAILED: Tests could not be run please check the "
  59             "arguments.\n");
  60         return -1;
  61     }
  62
  63     delete catICU;
  64     delete catStd;
  65     return 0;
  66 }
  67
  68 StringPerformanceTest::StringPerformanceTest(int32_t argc, const char *argv[],
  69                                              UErrorCode &status)
  70                                              : UPerfTest(argc, argv, status)
  71 {
  72     filelines_=NULL;
  73     StrBuffer=NULL;
  74     StrBufferLen=0;
  75
  76     int32_t len =0;
  77
  78     if (status== U_ILLEGAL_ARGUMENT_ERROR){
  79         //fprintf(stderr,gUsageString, "stringperf");
  80         return;
  81     }
  82     if (U_FAILURE(status)){
  83         fprintf(stderr, "FAILED to create UPerfTest object. Error: %s\n",
  84             u_errorName(status));
  85         return;
  86     }
  87
  88
  89     if(line_mode){
  90         ULine* filelines = getLines(status);
  91         if(U_FAILURE(status)){
  92             fprintf(stderr, "FAILED to read lines from file and create UPerfTest object. Error: %s\n", u_errorName(status));
  93             return;
  94         }
  95
  96         filelines_ = new ULine[numLines];
  97         for (int i =0; i < numLines; i++) {
  98             len = filelines[i].len;
  99             filelines_[i].name  = new UChar[len];
 100             filelines_[i].len   = len;
 101             memcpy(filelines_[i].name, filelines[i].name, len * U_SIZEOF_UCHAR);
 102         }
 103
 104     }else if(bulk_mode){
 105         int32_t srcLen = 0;
 106         const UChar* src = getBuffer(srcLen,status);
 107         if(U_FAILURE(status)){
 108             fprintf(stderr, "FAILED to read buffer from file and create UPerfTest object. Error: %s\n", u_errorName(status));
 109             return;
 110         }
 111
 112         StrBuffer = new UChar[srcLen];
 113         StrBufferLen = srcLen;
 114         memcpy(StrBuffer, src, srcLen * U_SIZEOF_UCHAR);
 115
 116     }
 117 }
 118
 119 StringPerformanceTest::~StringPerformanceTest()
 120 {
 121     delete[] filelines_;
 122     delete[] StrBuffer;
 123 }
 124
 125 UPerfFunction* StringPerformanceTest::runIndexedTest(int32_t index, UBool exec,
 126                                                    const char *&name,
 127                                                    char* par)
 128 {
 129     switch (index) {
 130         TESTCASE(0, TestCtor);
 131         TESTCASE(1, TestCtor1);
 132         TESTCASE(2, TestCtor2);
 133         TESTCASE(3, TestCtor3);
 134         TESTCASE(4, TestAssign);
 135         TESTCASE(5, TestAssign1);
 136         TESTCASE(6, TestAssign2);
 137         TESTCASE(7, TestGetch);
 138         TESTCASE(8, TestCatenate);
 139         TESTCASE(9, TestScan);
 140         TESTCASE(10, TestScan1);
 141         TESTCASE(11, TestScan2);
 142
 143         TESTCASE(12, TestStdLibCtor);
 144         TESTCASE(13, TestStdLibCtor1);
 145         TESTCASE(14, TestStdLibCtor2);
 146         TESTCASE(15, TestStdLibCtor3);
 147         TESTCASE(16, TestStdLibAssign);
 148         TESTCASE(17, TestStdLibAssign1);
 149         TESTCASE(18, TestStdLibAssign2);
 150         TESTCASE(19, TestStdLibGetch);
 151         TESTCASE(20, TestStdLibCatenate);
 152         TESTCASE(21, TestStdLibScan);
 153         TESTCASE(22, TestStdLibScan1);
 154         TESTCASE(23, TestStdLibScan2);
 155
 156         default:
 157             name = "";
 158             return NULL;
 159     }
 160     return NULL;
 161 }
 162
 163 UPerfFunction* StringPerformanceTest::TestCtor()
 164 {
 165     if (line_mode) {
 166         return new StringPerfFunction(ctor, filelines_, numLines, uselen);
 167     } else {
 168         return new StringPerfFunction(ctor, StrBuffer, StrBufferLen, uselen);
 169     }
 170 }
 171
 172 UPerfFunction* StringPerformanceTest::TestCtor1()
 173 {
 174     if (line_mode) {
 175         return new StringPerfFunction(ctor1, filelines_, numLines, uselen);
 176     } else {
 177         return new StringPerfFunction(ctor1, StrBuffer, StrBufferLen, uselen);
 178     }
 179 }
 180
 181 UPerfFunction* StringPerformanceTest::TestCtor2()
 182 {
 183     if (line_mode) {
 184         return new StringPerfFunction(ctor2, filelines_, numLines, uselen);
 185     } else {
 186         return new StringPerfFunction(ctor2, StrBuffer, StrBufferLen, uselen);
 187     }
 188 }
 189
 190 UPerfFunction* StringPerformanceTest::TestCtor3()
 191 {
 192     if (line_mode) {
 193         return new StringPerfFunction(ctor3, filelines_, numLines, uselen);
 194     } else {
 195         return new StringPerfFunction(ctor3, StrBuffer, StrBufferLen, uselen);
 196     }
 197 }
 198
 199 UPerfFunction* StringPerformanceTest::TestAssign()
 200 {
 201     if (line_mode) {
 202         return new StringPerfFunction(assign, filelines_, numLines, uselen);
 203     } else {
 204         return new StringPerfFunction(assign, StrBuffer, StrBufferLen, uselen);
 205     }
 206 }
 207
 208 UPerfFunction* StringPerformanceTest::TestAssign1()
 209 {
 210     if (line_mode) {
 211         return new StringPerfFunction(assign1, filelines_, numLines, uselen);
 212     } else {
 213         return new StringPerfFunction(assign1, StrBuffer, StrBufferLen, uselen);
 214     }
 215 }
 216
 217 UPerfFunction* StringPerformanceTest::TestAssign2()
 218 {
 219     if (line_mode) {
 220         return new StringPerfFunction(assign2, filelines_, numLines, uselen);
 221     } else {
 222         return new StringPerfFunction(assign2, StrBuffer, StrBufferLen, uselen);
 223     }
 224 }
 225
 226
 227 UPerfFunction* StringPerformanceTest::TestGetch()
 228 {
 229     if (line_mode) {
 230         return new StringPerfFunction(getch, filelines_, numLines, uselen);
 231     } else {
 232         return new StringPerfFunction(getch, StrBuffer, StrBufferLen, uselen);
 233     }
 234 }
 235
 236 UPerfFunction* StringPerformanceTest::TestCatenate()
 237 {
 238     if (line_mode) {
 239         return new StringPerfFunction(catenate, filelines_, numLines, uselen);
 240     } else {
 241         //return new StringPerfFunction(catenate, buffer, bufferLen, uselen);
 242         return new StringPerfFunction(catenate, StrBuffer, StrBufferLen, uselen);
 243     }
 244 }
 245
 246 UPerfFunction* StringPerformanceTest::TestScan()
 247 {
 248     if (line_mode) {
 249         return new StringPerfFunction(scan, filelines_, numLines, uselen);
 250     } else {
 251         return new StringPerfFunction(scan, StrBuffer, StrBufferLen, uselen);
 252     }
 253 }
 254
 255 UPerfFunction* StringPerformanceTest::TestScan1()
 256 {
 257     if (line_mode) {
 258         return new StringPerfFunction(scan1, filelines_, numLines, uselen);
 259     } else {
 260         return new StringPerfFunction(scan1, StrBuffer, StrBufferLen, uselen);
 261     }
 262 }
 263
 264 UPerfFunction* StringPerformanceTest::TestScan2()
 265 {
 266     if (line_mode) {
 267         return new StringPerfFunction(scan2, filelines_, numLines, uselen);
 268     } else {
 269         return new StringPerfFunction(scan2, StrBuffer, StrBufferLen, uselen);
 270     }
 271 }
 272
 273 UPerfFunction* StringPerformanceTest::TestStdLibCtor()
 274 {
 275     if (line_mode) {
 276         return new StringPerfFunction(StdLibCtor, filelines_, numLines, uselen);
 277     } else {
 278         return new StringPerfFunction(StdLibCtor, StrBuffer, StrBufferLen, uselen);
 279     }
 280 }
 281
 282 UPerfFunction* StringPerformanceTest::TestStdLibCtor1()
 283 {
 284     if (line_mode) {
 285         return new StringPerfFunction(StdLibCtor1, filelines_, numLines, uselen);
 286     } else {
 287         return new StringPerfFunction(StdLibCtor1, StrBuffer, StrBufferLen, uselen);
 288     }
 289 }
 290
 291 UPerfFunction* StringPerformanceTest::TestStdLibCtor2()
 292 {
 293     if (line_mode) {
 294         return new StringPerfFunction(StdLibCtor2, filelines_, numLines, uselen);
 295     } else {
 296         return new StringPerfFunction(StdLibCtor2, StrBuffer, StrBufferLen, uselen);
 297     }
 298 }
 299
 300 UPerfFunction* StringPerformanceTest::TestStdLibCtor3()
 301 {
 302     if (line_mode) {
 303         return new StringPerfFunction(StdLibCtor3, filelines_, numLines, uselen);
 304     } else {
 305         return new StringPerfFunction(StdLibCtor3, StrBuffer, StrBufferLen, uselen);
 306     }
 307 }
 308
 309 UPerfFunction* StringPerformanceTest::TestStdLibAssign()
 310 {
 311     if (line_mode) {
 312         return new StringPerfFunction(StdLibAssign, filelines_, numLines, uselen);
 313     } else {
 314         return new StringPerfFunction(StdLibAssign, StrBuffer, StrBufferLen, uselen);
 315     }
 316 }
 317
 318 UPerfFunction* StringPerformanceTest::TestStdLibAssign1()
 319 {
 320     if (line_mode) {
 321         return new StringPerfFunction(StdLibAssign1, filelines_, numLines, uselen);
 322     } else {
 323         return new StringPerfFunction(StdLibAssign1, StrBuffer, StrBufferLen, uselen);
 324     }
 325 }
 326
 327 UPerfFunction* StringPerformanceTest::TestStdLibAssign2()
 328 {
 329     if (line_mode) {
 330         return new StringPerfFunction(StdLibAssign2, filelines_, numLines, uselen);
 331     } else {
 332         return new StringPerfFunction(StdLibAssign2, StrBuffer, StrBufferLen, uselen);
 333     }
 334 }
 335
 336 UPerfFunction* StringPerformanceTest::TestStdLibGetch()
 337 {
 338     if (line_mode) {
 339         return new StringPerfFunction(StdLibGetch, filelines_, numLines, uselen);
 340     } else {
 341         return new StringPerfFunction(StdLibGetch, StrBuffer, StrBufferLen, uselen);
 342     }
 343 }
 344
 345 UPerfFunction* StringPerformanceTest::TestStdLibCatenate()
 346 {
 347     if (line_mode) {
 348         return new StringPerfFunction(StdLibCatenate, filelines_, numLines, uselen);
 349     } else {
 350         //return new StringPerfFunction(StdLibCatenate, buffer, bufferLen, uselen);
 351         return new StringPerfFunction(StdLibCatenate, StrBuffer, StrBufferLen, uselen);
 352     }
 353 }
 354
 355 UPerfFunction* StringPerformanceTest::TestStdLibScan()
 356 {
 357     if (line_mode) {
 358         return new StringPerfFunction(StdLibScan, filelines_, numLines, uselen);
 359     } else {
 360         return new StringPerfFunction(StdLibScan, StrBuffer, StrBufferLen, uselen);
 361     }
 362 }
 363
 364 UPerfFunction* StringPerformanceTest::TestStdLibScan1()
 365 {
 366     if (line_mode) {
 367         return new StringPerfFunction(StdLibScan1, filelines_, numLines, uselen);
 368     } else {
 369         return new StringPerfFunction(StdLibScan1, StrBuffer, StrBufferLen, uselen);
 370     }
 371 }
 372
 373 UPerfFunction* StringPerformanceTest::TestStdLibScan2()
 374 {
 375     if (line_mode) {
 376         return new StringPerfFunction(StdLibScan2, filelines_, numLines, uselen);
 377     } else {
 378         return new StringPerfFunction(StdLibScan2, StrBuffer, StrBufferLen, uselen);
 379     }
 380 }
 381
 382