icuSources/test/perf/unisetperf/unisetperf.cpp

   1 /*
   2 **********************************************************************
   3 *   Copyright (C) 2007, International Business Machines
   4 *   Corporation and others.  All Rights Reserved.
   5 **********************************************************************
   6 *   file name:  unisetperf.cpp
   7 *   encoding:   US-ASCII
   8 *   tab size:   8 (not used)
   9 *   indentation:4
  10 *
  11 *   created on: 2007jan31
  12 *   created by: Markus Scherer
  13 */
  14
  15 #include <stdio.h>
  16 #include <stdlib.h>
  17 #include <string.h>
  18 #include "unicode/uperf.h"
  19 #include "unicode/uniset.h"
  20 #include "unicode/unistr.h"
  21 #include "uoptions.h"
  22
  23 #define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
  24
  25 // Command-line options specific to unisetperf.
  26 // Options do not have abbreviations: Force readable command lines.
  27 // (Using U+0001 for abbreviation characters.)
  28 enum {
  29     SET_PATTERN,
  30     FAST_TYPE,
  31     UNISETPERF_OPTIONS_COUNT
  32 };
  33
  34 static UOption options[UNISETPERF_OPTIONS_COUNT]={
  35     UOPTION_DEF("pattern", '\x01', UOPT_REQUIRES_ARG),
  36     UOPTION_DEF("type",    '\x01', UOPT_REQUIRES_ARG)
  37 };
  38
  39 static const char *const unisetperf_usage =
  40     "\t--pattern   UnicodeSet pattern for instantiation.\n"
  41     "\t            Default: [:ID_Continue:]\n"
  42     "\t--type      Type of UnicodeSet: slow fast\n"
  43     "\t            Default: slow\n";
  44
  45 // Test object with setup data.
  46 class UnicodeSetPerformanceTest : public UPerfTest {
  47 public:
  48     UnicodeSetPerformanceTest(int32_t argc, const char *argv[], UErrorCode &status)
  49             : UPerfTest(argc, argv, options, LENGTHOF(options), unisetperf_usage, status),
  50               utf8(NULL), utf8Length(0), countInputCodePoints(0), spanCount(0) {
  51         if (U_SUCCESS(status)) {
  52             UnicodeString pattern=UnicodeString(options[SET_PATTERN].value, -1, US_INV).unescape();
  53             set.applyPattern(pattern, status);
  54             prefrozen=set;
  55             if(0==strcmp(options[FAST_TYPE].value, "fast")) {
  56                 set.freeze();
  57             }
  58
  59             int32_t inputLength;
  60             UPerfTest::getBuffer(inputLength, status);
  61             if(U_SUCCESS(status) && inputLength>0) {
  62                 countInputCodePoints = u_countChar32(buffer, bufferLen);
  63
  64                 countSpans();
  65
  66                 // Preflight the UTF-8 length and allocate utf8.
  67                 u_strToUTF8(NULL, 0, &utf8Length, buffer, bufferLen, &status);
  68                 if(status==U_BUFFER_OVERFLOW_ERROR) {
  69                     utf8=(char *)malloc(utf8Length);
  70                     if(utf8!=NULL) {
  71                         status=U_ZERO_ERROR;
  72                         u_strToUTF8(utf8, utf8Length, NULL, buffer, bufferLen, &status);
  73                     } else {
  74                         status=U_MEMORY_ALLOCATION_ERROR;
  75                     }
  76                 }
  77
  78                 if(verbose) {
  79                     printf("code points:%ld  len16:%ld  len8:%ld  spans:%ld  "
  80                            "cp/span:%.3g  UChar/span:%.3g  B/span:%.3g  B/cp:%.3g\n",
  81                            (long)countInputCodePoints, (long)bufferLen, (long)utf8Length, (long)spanCount,
  82                            (double)countInputCodePoints/spanCount, (double)bufferLen/spanCount, (double)utf8Length/spanCount,
  83                            (double)utf8Length/countInputCodePoints);
  84                 }
  85             }
  86         }
  87     }
  88
  89     virtual UPerfFunction* runIndexedTest(int32_t index, UBool exec, const char* &name, char* par = NULL);
  90
  91     // Count spans of characters that are in the set,
  92     // and spans of characters that are not in the set.
  93     // If the very first character is in the set, then one additional
  94     // not-span is counted.
  95     void countSpans() {
  96         const UChar *s=getBuffer();
  97         int32_t length=getBufferLen();
  98         int32_t i=0;
  99         UBool tf=FALSE;
 100         while(i<length) {
 101             i=span(s, length, i, tf);
 102             tf=(UBool)(!tf);
 103             ++spanCount;
 104         }
 105     }
 106     int32_t span(const UChar *s, int32_t length, int32_t start, UBool tf) const {
 107         UChar32 c;
 108         int32_t prev;
 109         while((prev=start)<length) {
 110             U16_NEXT(s, start, length, c);
 111             if(tf!=set.contains(c)) {
 112                 break;
 113             }
 114         }
 115         return prev;
 116     }
 117
 118     const UChar *getBuffer() const { return buffer; }
 119     int32_t getBufferLen() const { return bufferLen; }
 120
 121     char *utf8;
 122     int32_t utf8Length;
 123
 124     // Number of code points in the input text.
 125     int32_t countInputCodePoints;
 126     int32_t spanCount;
 127
 128     UnicodeSet set;
 129     UnicodeSet prefrozen;
 130 };
 131
 132 // Performance test function object.
 133 class Command : public UPerfFunction {
 134 protected:
 135     Command(const UnicodeSetPerformanceTest &testcase) : testcase(testcase) {}
 136
 137 public:
 138     virtual ~Command() {}
 139
 140     // virtual void call(UErrorCode* pErrorCode) { ... }
 141
 142     virtual long getOperationsPerIteration() {
 143         // Number of code points tested:
 144         // Input code points, plus one for the end of each span except the last span.
 145         return testcase.countInputCodePoints+testcase.spanCount-1;
 146     }
 147
 148     virtual long getEventsPerIteration() {
 149         return testcase.spanCount;
 150     }
 151
 152     const UnicodeSetPerformanceTest &testcase;
 153 };
 154
 155 class Contains : public Command {
 156 protected:
 157     Contains(const UnicodeSetPerformanceTest &testcase) : Command(testcase) {
 158         // Verify that the frozen set is equal to the unfrozen one.
 159         UnicodeSet set;
 160         UChar32 c;
 161
 162         for(c=0; c<=0x10ffff; ++c) {
 163             if(testcase.set.contains(c)) {
 164                 set.add(c);
 165             }
 166         }
 167         if(set!=testcase.set) {
 168             fprintf(stderr, "error: frozen set != original!\n");
 169         }
 170     }
 171 public:
 172     static UPerfFunction* get(const UnicodeSetPerformanceTest &testcase) {
 173         return new Contains(testcase);
 174     }
 175     virtual void call(UErrorCode* pErrorCode) {
 176         const UnicodeSet &set=testcase.set;
 177         const UChar *s=testcase.getBuffer();
 178         int32_t length=testcase.getBufferLen();
 179         int32_t count=0;
 180         int32_t i=0;
 181         UBool tf=FALSE;
 182         while(i<length) {
 183             i+=span(set, s+i, length-i, tf);
 184             tf=(UBool)(!tf);
 185             ++count;
 186         }
 187         if(count!=testcase.spanCount) {
 188             fprintf(stderr, "error: Contains() count=%ld != %ld=UnicodeSetPerformanceTest.spanCount\n",
 189                     (long)count, (long)testcase.spanCount);
 190         }
 191     }
 192     static int32_t span(const UnicodeSet &set, const UChar *s, int32_t length, UBool tf) {
 193         UChar32 c;
 194         int32_t start=0, prev;
 195         while((prev=start)<length) {
 196             U16_NEXT(s, start, length, c);
 197             if(tf!=set.contains(c)) {
 198                 break;
 199             }
 200         }
 201         return prev;
 202     }
 203 };
 204
 205 class SpanUTF16 : public Command {
 206 protected:
 207     SpanUTF16(const UnicodeSetPerformanceTest &testcase) : Command(testcase) {
 208         // Verify that the frozen set is equal to the unfrozen one.
 209         UnicodeSet set;
 210         UChar utf16[2];
 211         UChar32 c, c2;
 212
 213         for(c=0; c<=0xffff; ++c) {
 214             utf16[0]=(UChar)c;
 215             if(testcase.set.span(utf16, 1, USET_SPAN_CONTAINED)>0) {
 216                 set.add(c);
 217             }
 218         }
 219         for(c=0xd800; c<=0xdbff; ++c) {
 220             utf16[0]=(UChar)c;
 221             for(c2=0xdc00; c2<=0xdfff; ++c2) {
 222                 utf16[1]=(UChar)c2;
 223                 if(testcase.set.span(utf16, 2, USET_SPAN_CONTAINED)>0) {
 224                     set.add(U16_GET_SUPPLEMENTARY(c, c2));
 225                 }
 226             }
 227         }
 228
 229         if(set!=testcase.set) {
 230             fprintf(stderr, "error: frozen set != original!\n");
 231         }
 232     }
 233 public:
 234     static UPerfFunction* get(const UnicodeSetPerformanceTest &testcase) {
 235         return new SpanUTF16(testcase);
 236     }
 237     virtual void call(UErrorCode* pErrorCode) {
 238         const UnicodeSet &set=testcase.set;
 239         const UChar *s=testcase.getBuffer();
 240         int32_t length=testcase.getBufferLen();
 241         int32_t count=0;
 242         int32_t i=0;
 243         UBool tf=FALSE;
 244         while(i<length) {
 245             i+=set.span(s+i, length-i, (USetSpanCondition)tf);
 246             tf=(UBool)(!tf);
 247             ++count;
 248         }
 249         if(count!=testcase.spanCount) {
 250             fprintf(stderr, "error: SpanUTF16() count=%ld != %ld=UnicodeSetPerformanceTest.spanCount\n",
 251                     (long)count, (long)testcase.spanCount);
 252         }
 253     }
 254 };
 255
 256 class SpanBackUTF16 : public Command {
 257 protected:
 258     SpanBackUTF16(const UnicodeSetPerformanceTest &testcase) : Command(testcase) {
 259         // Verify that the frozen set is equal to the unfrozen one.
 260         UnicodeSet set;
 261         UChar utf16[2];
 262         UChar32 c, c2;
 263
 264         for(c=0; c<=0xffff; ++c) {
 265             utf16[0]=(UChar)c;
 266             if(testcase.set.spanBack(utf16, 1, USET_SPAN_CONTAINED)==0) {
 267                 set.add(c);
 268             }
 269         }
 270         for(c=0xd800; c<=0xdbff; ++c) {
 271             utf16[0]=(UChar)c;
 272             for(c2=0xdc00; c2<=0xdfff; ++c2) {
 273                 utf16[1]=(UChar)c2;
 274                 if(testcase.set.spanBack(utf16, 2, USET_SPAN_CONTAINED)==0) {
 275                     set.add(U16_GET_SUPPLEMENTARY(c, c2));
 276                 }
 277             }
 278         }
 279
 280         if(set!=testcase.set) {
 281             fprintf(stderr, "error: frozen set != original!\n");
 282         }
 283     }
 284 public:
 285     static UPerfFunction* get(const UnicodeSetPerformanceTest &testcase) {
 286         return new SpanBackUTF16(testcase);
 287     }
 288     virtual void call(UErrorCode* pErrorCode) {
 289         const UnicodeSet &set=testcase.set;
 290         const UChar *s=testcase.getBuffer();
 291         int32_t length=testcase.getBufferLen();
 292         int32_t count=0;
 293         /*
 294          * Get the same spans as with span() where we always start with a not-contained span.
 295          * If testcase.spanCount is an odd number, then the last span() was not-contained.
 296          * The last spanBack() must be not-contained to match the first span().
 297          */
 298         UBool tf=(UBool)((testcase.spanCount&1)==0);
 299         while(length>0 || !tf) {
 300             length=set.spanBack(s, length, (USetSpanCondition)tf);
 301             tf=(UBool)(!tf);
 302             ++count;
 303         }
 304         if(count!=testcase.spanCount) {
 305             fprintf(stderr, "error: SpanBackUTF16() count=%ld != %ld=UnicodeSetPerformanceTest.spanCount\n",
 306                     (long)count, (long)testcase.spanCount);
 307         }
 308     }
 309 };
 310
 311 class SpanUTF8 : public Command {
 312 protected:
 313     SpanUTF8(const UnicodeSetPerformanceTest &testcase) : Command(testcase) {
 314         // Verify that the frozen set is equal to the unfrozen one.
 315         UnicodeSet set;
 316         char utf8[4];
 317         UChar32 c;
 318         int32_t length;
 319
 320         for(c=0; c<=0x10ffff; ++c) {
 321             if(c==0xd800) {
 322                 c=0xe000;
 323             }
 324             length=0;
 325             U8_APPEND_UNSAFE(utf8, length, c);
 326             if(testcase.set.spanUTF8(utf8, length, USET_SPAN_CONTAINED)>0) {
 327                 set.add(c);
 328             }
 329         }
 330         if(set!=testcase.set) {
 331             fprintf(stderr, "error: frozen set != original!\n");
 332         }
 333     }
 334 public:
 335     static UPerfFunction* get(const UnicodeSetPerformanceTest &testcase) {
 336         return new SpanUTF8(testcase);
 337     }
 338     virtual void call(UErrorCode* pErrorCode) {
 339         const UnicodeSet &set=testcase.set;
 340         const char *s=testcase.utf8;
 341         int32_t length=testcase.utf8Length;
 342         int32_t count=0;
 343         int32_t i=0;
 344         UBool tf=FALSE;
 345         while(i<length) {
 346             i+=set.spanUTF8(s+i, length-i, (USetSpanCondition)tf);
 347             tf=(UBool)(!tf);
 348             ++count;
 349         }
 350         if(count!=testcase.spanCount) {
 351             fprintf(stderr, "error: SpanUTF8() count=%ld != %ld=UnicodeSetPerformanceTest.spanCount\n",
 352                     (long)count, (long)testcase.spanCount);
 353         }
 354     }
 355 };
 356
 357 class SpanBackUTF8 : public Command {
 358 protected:
 359     SpanBackUTF8(const UnicodeSetPerformanceTest &testcase) : Command(testcase) {
 360         // Verify that the frozen set is equal to the unfrozen one.
 361         UnicodeSet set;
 362         char utf8[4];
 363         UChar32 c;
 364         int32_t length;
 365
 366         for(c=0; c<=0x10ffff; ++c) {
 367             if(c==0xd800) {
 368                 c=0xe000;
 369             }
 370             length=0;
 371             U8_APPEND_UNSAFE(utf8, length, c);
 372             if(testcase.set.spanBackUTF8(utf8, length, USET_SPAN_CONTAINED)==0) {
 373                 set.add(c);
 374             }
 375         }
 376         if(set!=testcase.set) {
 377             fprintf(stderr, "error: frozen set != original!\n");
 378         }
 379     }
 380 public:
 381     static UPerfFunction* get(const UnicodeSetPerformanceTest &testcase) {
 382         return new SpanBackUTF8(testcase);
 383     }
 384     virtual void call(UErrorCode* pErrorCode) {
 385         const UnicodeSet &set=testcase.set;
 386         const char *s=testcase.utf8;
 387         int32_t length=testcase.utf8Length;
 388         int32_t count=0;
 389         /*
 390          * Get the same spans as with span() where we always start with a not-contained span.
 391          * If testcase.spanCount is an odd number, then the last span() was not-contained.
 392          * The last spanBack() must be not-contained to match the first span().
 393          */
 394         UBool tf=(UBool)((testcase.spanCount&1)==0);
 395         while(length>0 || !tf) {
 396             length=set.spanBackUTF8(s, length, (USetSpanCondition)tf);
 397             tf=(UBool)(!tf);
 398             ++count;
 399         }
 400         if(count!=testcase.spanCount) {
 401             fprintf(stderr, "error: SpanBackUTF8() count=%ld != %ld=UnicodeSetPerformanceTest.spanCount\n",
 402                     (long)count, (long)testcase.spanCount);
 403         }
 404     }
 405 };
 406
 407 UPerfFunction* UnicodeSetPerformanceTest::runIndexedTest(int32_t index, UBool exec, const char* &name, char* par) {
 408     switch (index) {
 409         case 0: name = "Contains";     if (exec) return Contains::get(*this); break;
 410         case 1: name = "SpanUTF16";    if (exec) return SpanUTF16::get(*this); break;
 411         case 2: name = "SpanBackUTF16";if (exec) return SpanBackUTF16::get(*this); break;
 412         case 3: name = "SpanUTF8";     if (exec) return SpanUTF8::get(*this); break;
 413         case 4: name = "SpanBackUTF8"; if (exec) return SpanBackUTF8::get(*this); break;
 414         default: name = ""; break;
 415     }
 416     return NULL;
 417 }
 418
 419 int main(int argc, const char *argv[])
 420 {
 421     // Default values for command-line options.
 422     options[SET_PATTERN].value = "[:ID_Continue:]";
 423     options[FAST_TYPE].value = "slow";
 424
 425     UErrorCode status = U_ZERO_ERROR;
 426     UnicodeSetPerformanceTest test(argc, argv, status);
 427
 428         if (U_FAILURE(status)){
 429         printf("The error is %s\n", u_errorName(status));
 430         test.usage();
 431         return status;
 432     }
 433
 434     if (test.run() == FALSE){
 435         fprintf(stderr, "FAILED: Tests could not be run, please check the "
 436                                     "arguments.\n");
 437         return 1;
 438     }
 439
 440     return 0;
 441 }