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