icuSources/test/perf/ustrperf/stringperf.cpp

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