icuSources/test/perf/utrie2perf/utrie2perf.cpp

   1 /*
   2  **********************************************************************
   3  *   Copyright (C) 2002-2008, International Business Machines
   4  *   Corporation and others.  All Rights Reserved.
   5  **********************************************************************
   6  *  file name:  utrie2perf.cpp
   7  *  encoding:   US-ASCII
   8  *  tab size:   8 (not used)
   9  *  indentation:4
  10  *
  11  *  created on: 2008sep07
  12  *  created by: Markus W. Scherer
  13  *
  14  *  Performance test program for UTrie2.
  15  */
  16
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include "unicode/uchar.h"
  20 #include "unicode/unorm.h"
  21 #include "unicode/uperf.h"
  22 #include "uoptions.h"
  23
  24 #define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
  25
  26 #if 0
  27 // Left over from when icu/branches/markus/utf8 could use both old UTrie
  28 // and new UTrie2, switched with #if in unorm.cpp and ubidi_props.c.
  29 // Comparative benchmarks were done in that branch on revision r24630
  30 // and earlier.
  31 U_CAPI void U_EXPORT2
  32 unorm_initUTrie2(UErrorCode *pErrorCode);
  33
  34 U_CAPI void U_EXPORT2
  35 ubidi_initUTrie2(UErrorCode *pErrorCode);
  36 #endif
  37
  38 U_NAMESPACE_BEGIN
  39
  40 class UnicodeSet;
  41
  42 U_NAMESPACE_END
  43
  44 // Test object.
  45 class UTrie2PerfTest : public UPerfTest {
  46 public:
  47     UTrie2PerfTest(int32_t argc, const char *argv[], UErrorCode &status)
  48             : UPerfTest(argc, argv, NULL, 0, "", status),
  49               utf8(NULL), utf8Length(0), countInputCodePoints(0) {
  50         if (U_SUCCESS(status)) {
  51 #if 0       // See comment at unorm_initUTrie2() forward declaration.
  52             unorm_initUTrie2(&status);
  53             ubidi_initUTrie2(&status);
  54 #endif
  55             int32_t inputLength;
  56             UPerfTest::getBuffer(inputLength, status);
  57             if(U_SUCCESS(status) && inputLength>0) {
  58                 countInputCodePoints = u_countChar32(buffer, bufferLen);
  59
  60                 // Preflight the UTF-8 length and allocate utf8.
  61                 u_strToUTF8(NULL, 0, &utf8Length, buffer, bufferLen, &status);
  62                 if(status==U_BUFFER_OVERFLOW_ERROR) {
  63                     utf8=(char *)malloc(utf8Length);
  64                     if(utf8!=NULL) {
  65                         status=U_ZERO_ERROR;
  66                         u_strToUTF8(utf8, utf8Length, NULL, buffer, bufferLen, &status);
  67                     } else {
  68                         status=U_MEMORY_ALLOCATION_ERROR;
  69                     }
  70                 }
  71
  72                 if(verbose) {
  73                     printf("code points:%ld  len16:%ld  len8:%ld  "
  74                            "B/cp:%.3g\n",
  75                            (long)countInputCodePoints, (long)bufferLen, (long)utf8Length,
  76                            (double)utf8Length/countInputCodePoints);
  77                 }
  78             }
  79         }
  80     }
  81
  82     virtual UPerfFunction* runIndexedTest(int32_t index, UBool exec, const char* &name, char* par = NULL);
  83
  84     const UChar *getBuffer() const { return buffer; }
  85     int32_t getBufferLen() const { return bufferLen; }
  86
  87     char *utf8;
  88     int32_t utf8Length;
  89
  90     // Number of code points in the input text.
  91     int32_t countInputCodePoints;
  92 };
  93
  94 // Performance test function object.
  95 class Command : public UPerfFunction {
  96 protected:
  97     Command(const UTrie2PerfTest &testcase) : testcase(testcase) {}
  98
  99 public:
 100     virtual ~Command() {}
 101
 102     // virtual void call(UErrorCode* pErrorCode) { ... }
 103
 104     virtual long getOperationsPerIteration() {
 105         // Number of code points tested.
 106         return testcase.countInputCodePoints;
 107     }
 108
 109     // virtual long getEventsPerIteration();
 110
 111     const UTrie2PerfTest &testcase;
 112     UNormalizationCheckResult qcResult;
 113 };
 114
 115 class CheckFCD : public Command {
 116 protected:
 117     CheckFCD(const UTrie2PerfTest &testcase) : Command(testcase) {}
 118 public:
 119     static UPerfFunction* get(const UTrie2PerfTest &testcase) {
 120         return new CheckFCD(testcase);
 121     }
 122     virtual void call(UErrorCode* pErrorCode) {
 123         UErrorCode errorCode=U_ZERO_ERROR;
 124         qcResult=unorm_quickCheck(testcase.getBuffer(), testcase.getBufferLen(),
 125                                   UNORM_FCD, &errorCode);
 126         if(U_FAILURE(errorCode)) {
 127             fprintf(stderr, "error: unorm_quickCheck(UNORM_FCD) failed: %s\n",
 128                     u_errorName(errorCode));
 129         }
 130     }
 131 };
 132
 133 #if 0  // See comment at unorm_initUTrie2() forward declaration.
 134
 135 class CheckFCDAlwaysGet : public Command {
 136 protected:
 137     CheckFCDAlwaysGet(const UTrie2PerfTest &testcase) : Command(testcase) {}
 138 public:
 139     static UPerfFunction* get(const UTrie2PerfTest &testcase) {
 140         return new CheckFCDAlwaysGet(testcase);
 141     }
 142     virtual void call(UErrorCode* pErrorCode) {
 143         UErrorCode errorCode=U_ZERO_ERROR;
 144         qcResult=unorm_quickCheck(testcase.getBuffer(), testcase.getBufferLen(),
 145                                   UNORM_FCD_ALWAYS_GET, &errorCode);
 146         if(U_FAILURE(errorCode)) {
 147             fprintf(stderr, "error: unorm_quickCheck(UNORM_FCD) failed: %s\n",
 148                     u_errorName(errorCode));
 149         }
 150     }
 151 };
 152
 153 U_CAPI UBool U_EXPORT2
 154 unorm_checkFCDUTF8(const uint8_t *src, int32_t srcLength, const UnicodeSet *nx);
 155
 156 class CheckFCDUTF8 : public Command {
 157 protected:
 158     CheckFCDUTF8(const UTrie2PerfTest &testcase) : Command(testcase) {}
 159 public:
 160     static UPerfFunction* get(const UTrie2PerfTest &testcase) {
 161         return new CheckFCDUTF8(testcase);
 162     }
 163     virtual void call(UErrorCode* pErrorCode) {
 164         UBool isFCD=unorm_checkFCDUTF8((const uint8_t *)testcase.utf8, testcase.utf8Length, NULL);
 165         if(isFCD>1) {
 166             fprintf(stderr, "error: bogus result from unorm_checkFCDUTF8()\n");
 167         }
 168     }
 169 };
 170
 171 #endif
 172
 173 class ToNFC : public Command {
 174 protected:
 175     ToNFC(const UTrie2PerfTest &testcase) : Command(testcase) {
 176         UErrorCode errorCode=U_ZERO_ERROR;
 177         destCapacity=unorm_normalize(testcase.getBuffer(), testcase.getBufferLen(),
 178                                      UNORM_NFC, 0,
 179                                      NULL, 0,
 180                                      &errorCode);
 181         dest=new UChar[destCapacity];
 182     }
 183     ~ToNFC() {
 184         delete [] dest;
 185     }
 186 public:
 187     static UPerfFunction* get(const UTrie2PerfTest &testcase) {
 188         return new ToNFC(testcase);
 189     }
 190     virtual void call(UErrorCode* pErrorCode) {
 191         UErrorCode errorCode=U_ZERO_ERROR;
 192         int32_t destLength=unorm_normalize(testcase.getBuffer(), testcase.getBufferLen(),
 193                                            UNORM_NFC, 0,
 194                                            dest, destCapacity,
 195                                            &errorCode);
 196         if(U_FAILURE(errorCode) || destLength!=destCapacity) {
 197             fprintf(stderr, "error: unorm_normalize(UNORM_NFC) failed: %s\n",
 198                     u_errorName(errorCode));
 199         }
 200     }
 201
 202 private:
 203     UChar *dest;
 204     int32_t destCapacity;
 205 };
 206
 207 class GetBiDiClass : public Command {
 208 protected:
 209     GetBiDiClass(const UTrie2PerfTest &testcase) : Command(testcase) {}
 210 public:
 211     static UPerfFunction* get(const UTrie2PerfTest &testcase) {
 212         return new GetBiDiClass(testcase);
 213     }
 214     virtual void call(UErrorCode* pErrorCode) {
 215         const UChar *buffer=testcase.getBuffer();
 216         int32_t length=testcase.getBufferLen();
 217         UChar32 c;
 218         int32_t i;
 219         uint32_t bitSet=0;
 220         for(i=0; i<length;) {
 221             U16_NEXT(buffer, i, length, c);
 222             bitSet|=(uint32_t)1<<u_charDirection(c);
 223         }
 224         if(length>0 && bitSet==0) {
 225             fprintf(stderr, "error: GetBiDiClass() did not collect bits\n");
 226         }
 227     }
 228 };
 229
 230 UPerfFunction* UTrie2PerfTest::runIndexedTest(int32_t index, UBool exec, const char* &name, char* par) {
 231     switch (index) {
 232         case 0: name = "CheckFCD";              if (exec) return CheckFCD::get(*this); break;
 233         case 1: name = "ToNFC";                 if (exec) return ToNFC::get(*this); break;
 234         case 2: name = "GetBiDiClass";          if (exec) return GetBiDiClass::get(*this); break;
 235 #if 0  // See comment at unorm_initUTrie2() forward declaration.
 236         case 3: name = "CheckFCDAlwaysGet";     if (exec) return CheckFCDAlwaysGet::get(*this); break;
 237         case 4: name = "CheckFCDUTF8";          if (exec) return CheckFCDUTF8::get(*this); break;
 238 #endif
 239         default: name = ""; break;
 240     }
 241     return NULL;
 242 }
 243
 244 int main(int argc, const char *argv[]) {
 245     UErrorCode status = U_ZERO_ERROR;
 246     UTrie2PerfTest test(argc, argv, status);
 247
 248         if (U_FAILURE(status)){
 249         printf("The error is %s\n", u_errorName(status));
 250         test.usage();
 251         return status;
 252     }
 253
 254     if (test.run() == FALSE){
 255         fprintf(stderr, "FAILED: Tests could not be run please check the "
 256                                     "arguments.\n");
 257         return -1;
 258     }
 259
 260     return 0;
 261 }