icuSources/test/perf/DateFmtPerf/DateFmtPerf.h

   1 /*
   2 **********************************************************************
   3 * Copyright (c) 2002-2011,International Business Machines
   4 * Corporation and others.  All Rights Reserved.
   5 **********************************************************************
   6 **********************************************************************
   7 */
   8
   9 #ifndef _DATEFMTPERF_H
  10 #define _DATEFMTPERF_H
  11
  12
  13 #include "unicode/stringpiece.h"
  14 #include "unicode/unistr.h"
  15 #include "unicode/uperf.h"
  16
  17 #include "unicode/utypes.h"
  18 #include "unicode/datefmt.h"
  19 #include "unicode/calendar.h"
  20 #include "unicode/uclean.h"
  21 #include "unicode/brkiter.h"
  22 #include "unicode/numfmt.h"
  23 #include "unicode/coll.h"
  24 #include "util.h"
  25
  26 #include "datedata.h"
  27 #include "breakdata.h"
  28 #include "collationdata.h"
  29
  30 #include <stdlib.h>
  31 #include <string.h>
  32
  33 #include <fstream>
  34
  35 #include <iostream>
  36 using namespace std;
  37
  38 //  Stubs for Windows API functions when building on UNIXes.
  39 //
  40 #if U_PLATFORM_USES_ONLY_WIN32_API
  41 // do nothing
  42 #else
  43 #define _UNICODE
  44 typedef int DWORD;
  45 inline int FoldStringW(DWORD dwMapFlags, const UChar* lpSrcStr,int cchSrc, UChar* lpDestStr,int cchDest);
  46 #endif
  47
  48 class BreakItFunction : public UPerfFunction
  49 {
  50 private:
  51         int num;
  52         bool wordIteration;
  53
  54 public:
  55
  56         BreakItFunction(){num = -1;}
  57         BreakItFunction(int a, bool b){num = a; wordIteration = b;}
  58
  59         virtual void call(UErrorCode *status)
  60         {
  61                 BreakIterator* boundary;
  62
  63                 if(wordIteration)
  64                 {
  65                         for(int i = 0; i < num; i++)
  66                         {
  67                                 boundary = BreakIterator::createWordInstance("en", *status);
  68                                 boundary->setText(str);
  69
  70                                 int32_t start = boundary->first();
  71                                 for (int32_t end = boundary->next();
  72                                          end != BreakIterator::DONE;
  73                                          start = end, end = boundary->next())
  74                                 {
  75                                         printTextRange( *boundary, start, end );
  76                                 }
  77                         }
  78                 }
  79
  80                 else // character iteration
  81                 {
  82                         for(int i = 0; i < num; i++)
  83             {
  84                                 boundary = BreakIterator::createCharacterInstance(Locale::getUS(), *status);
  85                                 boundary->setText(str);
  86
  87                                 int32_t start = boundary->first();
  88                                 for (int32_t end = boundary->next();
  89                                          end != BreakIterator::DONE;
  90                                          start = end, end = boundary->next())
  91                                 {
  92                                         printTextRange( *boundary, start, end );
  93                                 }
  94                         }
  95                 }
  96
  97
  98         }
  99
 100         virtual long getOperationsPerIteration()
 101         {
 102                 if(wordIteration) return 125*num;
 103                 else return 355*num;
 104         }
 105
 106         void printUnicodeString(const UnicodeString &s) {
 107                 char charBuf[1000];
 108                 s.extract(0, s.length(), charBuf, sizeof(charBuf)-1, 0);
 109                 charBuf[sizeof(charBuf)-1] = 0;
 110                 printf("%s", charBuf);
 111         }
 112
 113
 114         void printTextRange( BreakIterator& iterator,
 115                                                 int32_t start, int32_t end )
 116         {
 117                 CharacterIterator *strIter = iterator.getText().clone();
 118                 UnicodeString  s;
 119                 strIter->getText(s);
 120                 //printUnicodeString(UnicodeString(s, start, end-start));
 121                 //puts("");
 122                 delete strIter;
 123         }
 124
 125         // Print the given string to stdout (for debugging purposes)
 126         void uprintf(const UnicodeString &str) {
 127                 char *buf = 0;
 128                 int32_t len = str.length();
 129                 int32_t bufLen = len + 16;
 130                 int32_t actualLen;
 131                 buf = new char[bufLen + 1];
 132                 actualLen = str.extract(0, len, buf/*, bufLen*/); // Default codepage conversion
 133                 buf[actualLen] = 0;
 134                 printf("%s", buf);
 135                 delete[] buf;
 136         }
 137
 138 };
 139
 140 class DateFmtFunction : public UPerfFunction
 141 {
 142
 143 private:
 144         int num;
 145     char locale[25];
 146 public:
 147
 148         DateFmtFunction()
 149         {
 150                 num = -1;
 151         }
 152
 153         DateFmtFunction(int a, const char* loc)
 154         {
 155                 num = a;
 156         strcpy(locale, loc);
 157         }
 158
 159         virtual void call(UErrorCode* status)
 160         {
 161
 162                 UErrorCode status2 = U_ZERO_ERROR;
 163                 Calendar *cal;
 164                 TimeZone *zone;
 165                 UnicodeString str;
 166                 UDate date;
 167
 168                 cal = Calendar::createInstance(status2);
 169                 check(status2, "Calendar::createInstance");
 170                 zone = TimeZone::createTimeZone("GMT"); // Create a GMT zone
 171                 cal->adoptTimeZone(zone);
 172
 173                 Locale loc(locale);
 174                 DateFormat *fmt;
 175                 fmt = DateFormat::createDateTimeInstance(
 176                                                                 DateFormat::kShort, DateFormat::kFull, loc);
 177
 178
 179                 // (dates are imported from datedata.h)
 180                 for(int j = 0; j < num; j++)
 181                         for(int i = 0; i < NUM_DATES; i++)
 182                         {
 183                                 cal->clear();
 184                                 cal->set(years[i], months[i], days[i]);
 185                                 date = cal->getTime(status2);
 186                                 check(status2, "Calendar::getTime");
 187
 188                                 fmt->setCalendar(*cal);
 189
 190                                 // Format the date
 191                                 str.remove();
 192                                 fmt->format(date, str, status2);
 193
 194
 195                                 // Display the formatted date string
 196                                 //uprintf(str);
 197                                 //printf("\n");
 198
 199                         }
 200
 201                 delete fmt;
 202                 delete cal;
 203                 //u_cleanup();
 204         }
 205
 206         virtual long getOperationsPerIteration()
 207         {
 208                 return NUM_DATES * num;
 209         }
 210
 211         // Print the given string to stdout (for debugging purposes)
 212         void uprintf(const UnicodeString &str) {
 213                 char *buf = 0;
 214                 int32_t len = str.length();
 215                 int32_t bufLen = len + 16;
 216                 int32_t actualLen;
 217                 buf = new char[bufLen + 1];
 218                 actualLen = str.extract(0, len, buf/*, bufLen*/); // Default codepage conversion
 219                 buf[actualLen] = 0;
 220                 printf("%s", buf);
 221                 delete[] buf;
 222         }
 223
 224         // Verify that a UErrorCode is successful; exit(1) if not
 225         void check(UErrorCode& status, const char* msg) {
 226                 if (U_FAILURE(status)) {
 227                         printf("ERROR: %s (%s)\n", u_errorName(status), msg);
 228                         exit(1);
 229                 }
 230         }
 231
 232 };
 233
 234 class NumFmtFunction : public UPerfFunction
 235 {
 236
 237 private:
 238         int num;
 239     char locale[25];
 240 public:
 241
 242         NumFmtFunction()
 243         {
 244                 num = -1;
 245         }
 246
 247         NumFmtFunction(int a, const char* loc)
 248         {
 249                 num = a;
 250         strcpy(locale, loc);
 251         }
 252
 253         virtual void call(UErrorCode* status2)
 254         {
 255         Locale loc(locale);
 256         UErrorCode status = U_ZERO_ERROR;
 257
 258         // Create a number formatter for the locale
 259         NumberFormat *fmt = NumberFormat::createInstance(loc, status);
 260
 261         // Parse a string.  The string uses the digits '0' through '9'
 262         // and the decimal separator '.', standard in the US locale
 263
 264         for(int i = 0; i < num; i++)
 265         {
 266             UnicodeString str("9876543210.123");
 267             Formattable result;
 268             fmt->parse(str, result, status);
 269
 270             //uprintf(formattableToString(result));
 271             //printf("\n");
 272
 273             // Take the number parsed above, and use the formatter to
 274             // format it.
 275             str.remove(); // format() will APPEND to this string
 276             fmt->format(result, str, status);
 277
 278             //uprintf(str);
 279             //printf("\n");
 280         }
 281
 282         delete fmt; // Release the storage used by the formatter
 283     }
 284
 285     enum {
 286         U_SPACE=0x20,
 287         U_DQUOTE=0x22,
 288         U_COMMA=0x2c,
 289         U_LEFT_SQUARE_BRACKET=0x5b,
 290         U_BACKSLASH=0x5c,
 291         U_RIGHT_SQUARE_BRACKET=0x5d,
 292         U_SMALL_U=0x75
 293     };
 294
 295     // Create a display string for a formattable
 296     UnicodeString formattableToString(const Formattable& f) {
 297         switch (f.getType()) {
 298         case Formattable::kDate:
 299             // TODO: Finish implementing this
 300             return UNICODE_STRING_SIMPLE("Formattable_DATE_TBD");
 301         case Formattable::kDouble:
 302             {
 303                 char buf[256];
 304                 sprintf(buf, "%gD", f.getDouble());
 305                 return UnicodeString(buf, "");
 306             }
 307         case Formattable::kLong:
 308         case Formattable::kInt64:
 309             {
 310                 char buf[256];
 311                 sprintf(buf, "%ldL", f.getLong());
 312                 return UnicodeString(buf, "");
 313             }
 314         case Formattable::kString:
 315             return UnicodeString((UChar)U_DQUOTE).append(f.getString()).append((UChar)U_DQUOTE);
 316         case Formattable::kArray:
 317             {
 318                 int32_t i, count;
 319                 const Formattable* array = f.getArray(count);
 320                 UnicodeString result((UChar)U_LEFT_SQUARE_BRACKET);
 321                 for (i=0; i<count; ++i) {
 322                     if (i > 0) {
 323                         (result += (UChar)U_COMMA) += (UChar)U_SPACE;
 324                     }
 325                     result += formattableToString(array[i]);
 326                 }
 327                 result += (UChar)U_RIGHT_SQUARE_BRACKET;
 328                 return result;
 329             }
 330         default:
 331             return UNICODE_STRING_SIMPLE("INVALID_Formattable");
 332         }
 333     }
 334
 335         virtual long getOperationsPerIteration()
 336         {
 337                 return num;
 338         }
 339
 340     // Print the given string to stdout using the UTF-8 converter (for debugging purposes only)
 341     void uprintf(const UnicodeString &str) {
 342         char stackBuffer[100];
 343         char *buf = 0;
 344
 345         int32_t bufLen = str.extract(0, 0x7fffffff, stackBuffer, sizeof(stackBuffer), "UTF-8");
 346         if(bufLen < sizeof(stackBuffer)) {
 347             buf = stackBuffer;
 348         } else {
 349             buf = new char[bufLen + 1];
 350             bufLen = str.extract(0, 0x7fffffff, buf, bufLen + 1, "UTF-8");
 351         }
 352         printf("%s", buf);
 353         if(buf != stackBuffer) {
 354             delete[] buf;
 355         }
 356     }
 357 };
 358
 359
 360
 361 #define NUM_STRING "9876543210.123"
 362 #define NUM_NUM 9876543210.123
 363 class StdioNumFmtFunction : public UPerfFunction
 364 {
 365
 366  private:
 367   int num;
 368   char locale[25];
 369  public:
 370
 371   StdioNumFmtFunction()
 372     {
 373       num = -1;
 374     }
 375
 376   StdioNumFmtFunction(int a, const char* loc)
 377     {
 378       num = a;
 379       strcpy(locale, loc);
 380     }
 381
 382   virtual void call(UErrorCode* status2)
 383   {
 384     Locale loc(locale);
 385     UErrorCode status = U_ZERO_ERROR;
 386
 387     // Parse a string.  The string uses the digits '0' through '9'
 388     // and the decimal separator '.', standard in the US locale
 389
 390     double result;
 391     char outbuf[500];
 392     const char *str = NUM_STRING;
 393
 394     for(int i = 0; i < num; i++)
 395       {
 396         if(sscanf(str, "%lg", &result)!=1) {
 397           cout << "Failed Stdio: failed to sscanf" << endl;
 398           *status2 = U_PARSE_ERROR;
 399           return;
 400         }
 401
 402         sprintf(outbuf, "%lg", result);
 403       }
 404
 405     if(result!=NUM_NUM) {
 406       cout << "Failed Stdio: sscanf got wrong result, expected " << NUM_NUM << " got " << result << endl;
 407       *status2 = U_PARSE_ERROR;
 408     }
 409     if(strcmp(str,NUM_STRING)) {
 410       cout << "Failed Stdio: sprintf got wrong result, expected " << NUM_STRING << " got " << str << endl;
 411       *status2 = U_PARSE_ERROR;
 412     }
 413   }
 414
 415   virtual long getOperationsPerIteration()
 416   {
 417     return num;
 418   }
 419
 420 };
 421
 422 class CollationFunction : public UPerfFunction
 423 {
 424
 425 private:
 426         int num;
 427     char locale[25];
 428         UnicodeString *collation_strings;
 429
 430         /**
 431          * Unescape the strings
 432          */
 433         void init() {
 434         uint32_t listSize = sizeof(collation_strings_escaped)/sizeof(collation_strings_escaped[0]);
 435                 collation_strings = new UnicodeString[listSize];
 436                 for(uint32_t k=0;k<listSize;k++) {
 437                         collation_strings[k] = collation_strings_escaped[k].unescape();
 438                 }
 439                 UnicodeString shorty((UChar32)0x12345);
 440         }
 441 public:
 442
 443         CollationFunction()
 444         {
 445                 num = -1;
 446
 447                 init();
 448         }
 449
 450         ~CollationFunction() {
 451                 delete [] collation_strings;
 452         }
 453
 454         CollationFunction(int a, const char* loc)
 455         {
 456                 num = a;
 457         strcpy(locale, loc);
 458                 init();
 459         }
 460
 461         virtual void call(UErrorCode* status2)
 462         {
 463         uint32_t listSize = sizeof(collation_strings_escaped)/sizeof(collation_strings_escaped[0]);
 464         UErrorCode status = U_ZERO_ERROR;
 465         Collator *coll = Collator::createInstance(Locale(locale), status);
 466
 467         for(int k = 0; k < num; k++)
 468         {
 469             uint32_t i, j;
 470             for(i=listSize-1; i>=1; i--) {
 471                 for(j=0; j<i; j++) {
 472                     if(coll->compare(collation_strings[j], collation_strings[j+1]) == UCOL_LESS) {
 473                     //cout << "Success!" << endl;
 474                      }
 475                 }
 476             }
 477          }
 478         delete coll;
 479     }
 480
 481         virtual long getOperationsPerIteration()
 482         {
 483                 return num;
 484         }
 485 };
 486
 487 class DateFormatPerfTest : public UPerfTest
 488 {
 489 private:
 490
 491 public:
 492
 493         DateFormatPerfTest(int32_t argc, const char* argv[], UErrorCode& status);
 494         ~DateFormatPerfTest();
 495         virtual UPerfFunction* runIndexedTest(int32_t index, UBool exec,const char* &name, char* par);
 496
 497         UPerfFunction* DateFmt250();
 498         UPerfFunction* DateFmt10000();
 499         UPerfFunction* DateFmt100000();
 500         UPerfFunction* BreakItWord250();
 501         UPerfFunction* BreakItWord10000();
 502         UPerfFunction* BreakItChar250();
 503         UPerfFunction* BreakItChar10000();
 504     UPerfFunction* NumFmt10000();
 505     UPerfFunction* NumFmt100000();
 506     UPerfFunction* Collation10000();
 507     UPerfFunction* Collation100000();
 508 };
 509
 510 #endif // DateFmtPerf