src/third_party/icu/source/test/perf/normperf/normperf.h

   1 /*
   2 **********************************************************************
   3 * Copyright (c) 2002-2011, International Business Machines
   4 * Corporation and others.  All Rights Reserved.
   5 **********************************************************************
   6 **********************************************************************
   7 */
   8 #ifndef _NORMPERF_H
   9 #define _NORMPERF_H
  10
  11 #include "unicode/unorm.h"
  12 #include "unicode/ustring.h"
  13
  14 #include "unicode/uperf.h"
  15 #include <stdlib.h>
  16
  17 //  Stubs for Windows API functions when building on UNIXes.
  18 //
  19 #if U_PLATFORM_USES_ONLY_WIN32_API
  20 // do nothing
  21 #else
  22 #define _UNICODE
  23 typedef int DWORD;
  24 inline int FoldStringW(DWORD dwMapFlags, const UChar* lpSrcStr,int cchSrc, UChar* lpDestStr,int cchDest);
  25 #endif
  26
  27 #define DEST_BUFFER_CAPACITY 6000
  28 typedef int32_t (*NormFn)(const UChar* src,int32_t srcLen, UChar* dest,int32_t dstLen, int32_t options, UErrorCode* status);
  29 typedef int32_t (*QuickCheckFn)(const UChar* src,int32_t srcLen, UNormalizationMode mode, int32_t options, UErrorCode* status);
  30
  31 class QuickCheckPerfFunction : public UPerfFunction{
  32 private:
  33     ULine* lines;
  34     int32_t numLines;
  35     QuickCheckFn fn;
  36     UNormalizationMode mode;
  37     int32_t retVal;
  38     UBool uselen;
  39     const UChar* src;
  40     int32_t srcLen;
  41     UBool line_mode;
  42     int32_t options;
  43
  44 public:
  45     virtual void call(UErrorCode* status){
  46         if(line_mode==TRUE){
  47             if(uselen){
  48                 for(int32_t i = 0; i< numLines; i++){
  49                     retVal =  (*fn)(lines[i].name,lines[i].len,mode, options, status);
  50                 }
  51             }else{
  52                 for(int32_t i = 0; i< numLines; i++){
  53                     retVal =  (*fn)(lines[i].name,-1,mode, options, status);
  54                 }
  55             }
  56         }else{
  57             if(uselen){
  58
  59                 retVal =  (*fn)(src,srcLen,mode, options, status);
  60             }else{
  61                 retVal =  (*fn)(src,-1,mode, options, status);
  62             }
  63         }
  64
  65     }
  66     virtual long getOperationsPerIteration(){
  67         if(line_mode==TRUE){
  68             int32_t totalChars=0;
  69             for(int32_t i =0; i< numLines; i++){
  70                 totalChars+= lines[i].len;
  71             }
  72             return totalChars;
  73         }else{
  74             return srcLen;
  75         }
  76     }
  77     QuickCheckPerfFunction(QuickCheckFn func, ULine* srcLines,int32_t srcNumLines, UNormalizationMode _mode, int32_t opts, UBool _uselen) : options(opts) {
  78         fn = func;
  79         lines = srcLines;
  80         numLines = srcNumLines;
  81         uselen = _uselen;
  82         mode = _mode;
  83         src = NULL;
  84         srcLen = 0;
  85         line_mode = TRUE;
  86     }
  87     QuickCheckPerfFunction(QuickCheckFn func, const UChar* source,int32_t sourceLen, UNormalizationMode _mode, int32_t opts, UBool _uselen) : options(opts) {
  88         fn = func;
  89         lines = NULL;
  90         numLines = 0;
  91         uselen = _uselen;
  92         mode = _mode;
  93         src = source;
  94         srcLen = sourceLen;
  95         line_mode = FALSE;
  96     }
  97 };
  98
  99
 100 class NormPerfFunction : public UPerfFunction{
 101 private:
 102     ULine* lines;
 103     int32_t numLines;
 104     UChar dest[DEST_BUFFER_CAPACITY];
 105     UChar* pDest;
 106     int32_t destLen;
 107     NormFn fn;
 108     int32_t retVal;
 109     UBool uselen;
 110     const UChar* src;
 111     int32_t srcLen;
 112     UBool line_mode;
 113     int32_t options;
 114
 115 public:
 116     virtual void call(UErrorCode* status){
 117         if(line_mode==TRUE){
 118             if(uselen){
 119                 for(int32_t i = 0; i< numLines; i++){
 120                     retVal =  (*fn)(lines[i].name,lines[i].len,pDest,destLen, options, status);
 121                 }
 122             }else{
 123                 for(int32_t i = 0; i< numLines; i++){
 124                     retVal =  (*fn)(lines[i].name,-1,pDest,destLen, options, status);
 125                 }
 126             }
 127         }else{
 128             if(uselen){
 129                 retVal =  (*fn)(src,srcLen,pDest,destLen, options, status);
 130             }else{
 131                 retVal =  (*fn)(src,-1,pDest,destLen, options, status);
 132             }
 133         }
 134     }
 135     virtual long getOperationsPerIteration(){
 136         if(line_mode ==TRUE){
 137             int32_t totalChars=0;
 138             for(int32_t i =0; i< numLines; i++){
 139                 totalChars+= lines[i].len;
 140             }
 141             return totalChars;
 142         }else{
 143             return srcLen;
 144         }
 145     }
 146     NormPerfFunction(NormFn func, int32_t opts, ULine* srcLines,int32_t srcNumLines,UBool _uselen) : options(opts) {
 147         fn = func;
 148         lines = srcLines;
 149         numLines = srcNumLines;
 150         uselen = _uselen;
 151         destLen = DEST_BUFFER_CAPACITY;
 152         pDest = dest;
 153         src = NULL;
 154         srcLen = 0;
 155         line_mode = TRUE;
 156     }
 157     NormPerfFunction(NormFn func, int32_t opts, const UChar* source,int32_t sourceLen,UBool _uselen) : options(opts) {
 158         fn = func;
 159         lines = NULL;
 160         numLines = 0;
 161         uselen = _uselen;
 162         destLen = sourceLen*3;
 163         pDest = (UChar*) malloc(destLen * U_SIZEOF_UCHAR);
 164         src = source;
 165         srcLen = sourceLen;
 166         line_mode = FALSE;
 167     }
 168     ~NormPerfFunction(){
 169         if(dest != pDest){
 170             free(pDest);
 171         }
 172     }
 173 };
 174
 175
 176
 177 class  NormalizerPerformanceTest : public UPerfTest{
 178 private:
 179     ULine* NFDFileLines;
 180     ULine* NFCFileLines;
 181     UChar* NFDBuffer;
 182     UChar* NFCBuffer;
 183     UChar* origBuffer;
 184     int32_t origBufferLen;
 185     int32_t NFDBufferLen;
 186     int32_t NFCBufferLen;
 187     int32_t options;
 188
 189     void normalizeInput(ULine* dest,const UChar* src ,int32_t srcLen,UNormalizationMode mode, int32_t options);
 190     UChar* normalizeInput(int32_t& len, const UChar* src ,int32_t srcLen,UNormalizationMode mode, int32_t options);
 191
 192 public:
 193
 194     NormalizerPerformanceTest(int32_t argc, const char* argv[], UErrorCode& status);
 195     ~NormalizerPerformanceTest();
 196     virtual UPerfFunction* runIndexedTest(int32_t index, UBool exec,const char* &name, char* par = NULL);
 197     /* NFC performance */
 198     UPerfFunction* TestICU_NFC_NFD_Text();
 199     UPerfFunction* TestICU_NFC_NFC_Text();
 200     UPerfFunction* TestICU_NFC_Orig_Text();
 201
 202     /* NFD performance */
 203     UPerfFunction* TestICU_NFD_NFD_Text();
 204     UPerfFunction* TestICU_NFD_NFC_Text();
 205     UPerfFunction* TestICU_NFD_Orig_Text();
 206
 207     /* FCD performance */
 208     UPerfFunction* TestICU_FCD_NFD_Text();
 209     UPerfFunction* TestICU_FCD_NFC_Text();
 210     UPerfFunction* TestICU_FCD_Orig_Text();
 211
 212     /*Win NFC performance */
 213     UPerfFunction* TestWin_NFC_NFD_Text();
 214     UPerfFunction* TestWin_NFC_NFC_Text();
 215     UPerfFunction* TestWin_NFC_Orig_Text();
 216
 217     /* Win NFD performance */
 218     UPerfFunction* TestWin_NFD_NFD_Text();
 219     UPerfFunction* TestWin_NFD_NFC_Text();
 220     UPerfFunction* TestWin_NFD_Orig_Text();
 221
 222     /* Quick check performance */
 223     UPerfFunction* TestQC_NFC_NFD_Text();
 224     UPerfFunction* TestQC_NFC_NFC_Text();
 225     UPerfFunction* TestQC_NFC_Orig_Text();
 226
 227     UPerfFunction* TestQC_NFD_NFD_Text();
 228     UPerfFunction* TestQC_NFD_NFC_Text();
 229     UPerfFunction* TestQC_NFD_Orig_Text();
 230
 231     UPerfFunction* TestQC_FCD_NFD_Text();
 232     UPerfFunction* TestQC_FCD_NFC_Text();
 233     UPerfFunction* TestQC_FCD_Orig_Text();
 234
 235     /* IsNormalized performnace */
 236     UPerfFunction* TestIsNormalized_NFC_NFD_Text();
 237     UPerfFunction* TestIsNormalized_NFC_NFC_Text();
 238     UPerfFunction* TestIsNormalized_NFC_Orig_Text();
 239
 240     UPerfFunction* TestIsNormalized_NFD_NFD_Text();
 241     UPerfFunction* TestIsNormalized_NFD_NFC_Text();
 242     UPerfFunction* TestIsNormalized_NFD_Orig_Text();
 243
 244     UPerfFunction* TestIsNormalized_FCD_NFD_Text();
 245     UPerfFunction* TestIsNormalized_FCD_NFC_Text();
 246     UPerfFunction* TestIsNormalized_FCD_Orig_Text();
 247
 248 };
 249
 250 //---------------------------------------------------------------------------------------
 251 // Platform / ICU version specific proto-types
 252 //---------------------------------------------------------------------------------------
 253
 254
 255 #if (U_ICU_VERSION_MAJOR_NUM > 1 ) || ((U_ICU_VERSION_MAJOR_NUM == 1 )&&(U_ICU_VERSION_MINOR_NUM > 8) && (U_ICU_VERSION_PATCHLEVEL_NUM >=1))
 256
 257 int32_t ICUNormNFD(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
 258     return unorm_normalize(src,srcLen,UNORM_NFD, options,dest,dstLen,status);
 259 }
 260
 261 int32_t ICUNormNFC(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
 262     return unorm_normalize(src,srcLen,UNORM_NFC, options,dest,dstLen,status);
 263 }
 264
 265 int32_t ICUNormNFKD(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
 266     return unorm_normalize(src,srcLen,UNORM_NFKD, options,dest,dstLen,status);
 267 }
 268 int32_t ICUNormNFKC(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
 269     return unorm_normalize(src,srcLen,UNORM_NFKC, options,dest,dstLen,status);
 270 }
 271
 272 int32_t ICUNormFCD(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
 273     return unorm_normalize(src,srcLen,UNORM_FCD, options,dest,dstLen,status);
 274 }
 275
 276 int32_t ICUQuickCheck(const UChar* src,int32_t srcLen, UNormalizationMode mode, int32_t options, UErrorCode* status){
 277 #if (U_ICU_VERSION_MAJOR_NUM > 2 ) || ((U_ICU_VERSION_MAJOR_NUM == 2 )&&(U_ICU_VERSION_MINOR_NUM >= 6))
 278     return unorm_quickCheckWithOptions(src,srcLen,mode, options, status);
 279 #else
 280     return unorm_quickCheck(src,srcLen,mode,status);
 281 #endif
 282 }
 283 int32_t ICUIsNormalized(const UChar* src,int32_t srcLen, UNormalizationMode mode, int32_t options, UErrorCode* status){
 284     return unorm_isNormalized(src,srcLen,mode,status);
 285 }
 286
 287
 288 #else
 289
 290 int32_t ICUNormNFD(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
 291     return unorm_normalize(src,srcLen,UCOL_DECOMP_CAN, options,dest,dstLen,status);
 292 }
 293
 294 int32_t ICUNormNFC(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
 295     return unorm_normalize(src,srcLen,UCOL_COMPOSE_CAN, options,dest,dstLen,status);
 296 }
 297
 298 int32_t ICUNormNFKD(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
 299     return unorm_normalize(src,srcLen,UCOL_DECOMP_COMPAT, options,dest,dstLen,status);
 300 }
 301 int32_t ICUNormNFKC(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
 302     return unorm_normalize(src,srcLen,UCOL_COMPOSE_COMPAT, options,dest,dstLen,status);
 303 }
 304
 305 int32_t ICUNormFCD(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
 306     return unorm_normalize(src,srcLen,UNORM_FCD, options,dest,dstLen,status);
 307 }
 308
 309 int32_t ICUQuickCheck(const UChar* src,int32_t srcLen, UNormalizationMode mode, int32_t options, UErrorCode* status){
 310     return unorm_quickCheck(src,srcLen,mode,status);
 311 }
 312
 313 int32_t ICUIsNormalized(const UChar* src,int32_t srcLen, UNormalizationMode mode, int32_t options, UErrorCode* status){
 314     return 0;
 315 }
 316 #endif
 317
 318 #if U_PLATFORM_HAS_WIN32_API
 319
 320 int32_t WinNormNFD(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
 321     return FoldStringW(MAP_COMPOSITE,src,srcLen,dest,dstLen);
 322 }
 323
 324 int32_t WinNormNFC(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
 325     return FoldStringW(MAP_PRECOMPOSED,src,srcLen,dest,dstLen);
 326 }
 327
 328 int32_t WinNormNFKD(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
 329     return FoldStringW(MAP_COMPOSITE+MAP_FOLDCZONE,src,srcLen,dest,dstLen);
 330 }
 331 int32_t WinNormNFKC(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
 332     return FoldStringW(MAP_FOLDCZONE,src,srcLen,dest,dstLen);
 333 }
 334 #else
 335 int32_t WinNormNFD(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
 336     return 0 ;
 337 }
 338
 339 int32_t WinNormNFC(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
 340     return 0;
 341 }
 342
 343 int32_t WinNormNFKD(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
 344     return 0;
 345 }
 346 int32_t WinNormNFKC(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
 347     return 0;
 348 }
 349 #endif
 350
 351
 352 #endif // NORMPERF_H
 353