1 // 2016 and later: Unicode, Inc. and others. 2 // License & terms of use: http://www.unicode.org/copyright.html 3 /******************************************************************** 4 * COPYRIGHT: 5 * Copyright (c) 2002-2012, International Business Machines Corporation and 6 * others. All Rights Reserved. 7 ********************************************************************/ 8 9 // Defines _XOPEN_SOURCE for access to POSIX functions. 10 // Must be before any other #includes. 11 #include "uposixdefs.h" 12 13 #include "unicode/uperf.h" 14 #include "uoptions.h" 15 #include "cmemory.h" 16 #include <stdio.h> 17 #include <stdlib.h> 18 19 #if !UCONFIG_NO_CONVERSION 20 21 UPerfFunction::~UPerfFunction() {} 22 23 static const char delim = '/'; 24 static int32_t execCount = 0; 25 UPerfTest* UPerfTest::gTest = NULL; 26 static const int MAXLINES = 40000; 27 const char UPerfTest::gUsageString[] = 28 "Usage: %s [OPTIONS] [FILES]\n" 29 "\tReads the input file and prints out time taken in seconds\n" 30 "Options:\n" 31 "\t-h or -? or --help this usage text\n" 32 "\t-v or --verbose print extra information when processing files\n" 33 "\t-s or --sourcedir source directory for files followed by path\n" 34 "\t followed by path\n" 35 "\t-e or --encoding encoding of source files\n" 36 "\t-u or --uselen perform timing analysis on non-null terminated buffer using length\n" 37 "\t-f or --file-name file to be used as input data\n" 38 "\t-p or --passes Number of passes to be performed. Requires Numeric argument.\n" 39 "\t Cannot be used with --time\n" 40 "\t-i or --iterations Number of iterations to be performed. Requires Numeric argument\n" 41 "\t-t or --time Threshold time for looping until in seconds. Requires Numeric argument.\n" 42 "\t Cannot be used with --iterations\n" 43 "\t-l or --line-mode The data file should be processed in line mode\n" 44 "\t-b or --bulk-mode The data file should be processed in file based.\n" 45 "\t Cannot be used with --line-mode\n" 46 "\t-L or --locale Locale for the test\n"; 47 48 enum 49 { 50 HELP1, 51 HELP2, 52 VERBOSE, 53 SOURCEDIR, 54 ENCODING, 55 USELEN, 56 FILE_NAME, 57 PASSES, 58 ITERATIONS, 59 TIME, 60 LINE_MODE, 61 BULK_MODE, 62 LOCALE, 63 OPTIONS_COUNT 64 }; 65 66 67 static UOption options[OPTIONS_COUNT+20]={ 68 UOPTION_HELP_H, 69 UOPTION_HELP_QUESTION_MARK, 70 UOPTION_VERBOSE, 71 UOPTION_SOURCEDIR, 72 UOPTION_ENCODING, 73 UOPTION_DEF( "uselen", 'u', UOPT_NO_ARG), 74 UOPTION_DEF( "file-name", 'f', UOPT_REQUIRES_ARG), 75 UOPTION_DEF( "passes", 'p', UOPT_REQUIRES_ARG), 76 UOPTION_DEF( "iterations", 'i', UOPT_REQUIRES_ARG), 77 UOPTION_DEF( "time", 't', UOPT_REQUIRES_ARG), 78 UOPTION_DEF( "line-mode", 'l', UOPT_NO_ARG), 79 UOPTION_DEF( "bulk-mode", 'b', UOPT_NO_ARG), 80 UOPTION_DEF( "locale", 'L', UOPT_REQUIRES_ARG) 81 }; 82 83 UPerfTest::UPerfTest(int32_t argc, const char* argv[], UErrorCode& status) 84 : _argc(argc), _argv(argv), _addUsage(NULL), 85 ucharBuf(NULL), encoding(""), 86 uselen(FALSE), 87 fileName(NULL), sourceDir("."), 88 lines(NULL), numLines(0), line_mode(TRUE), 89 buffer(NULL), bufferLen(0), 90 verbose(FALSE), bulk_mode(FALSE), 91 passes(1), iterations(0), time(0), 92 locale(NULL) { 93 init(NULL, 0, status); 94 } 95 96 UPerfTest::UPerfTest(int32_t argc, const char* argv[], 97 UOption addOptions[], int32_t addOptionsCount, 98 const char *addUsage, 99 UErrorCode& status) 100 : _argc(argc), _argv(argv), _addUsage(addUsage), 101 ucharBuf(NULL), encoding(""), 102 uselen(FALSE), 103 fileName(NULL), sourceDir("."), 104 lines(NULL), numLines(0), line_mode(TRUE), 105 buffer(NULL), bufferLen(0), 106 verbose(FALSE), bulk_mode(FALSE), 107 passes(1), iterations(0), time(0), 108 locale(NULL) { 109 init(addOptions, addOptionsCount, status); 110 } 111 112 void UPerfTest::init(UOption addOptions[], int32_t addOptionsCount, 113 UErrorCode& status) { 114 //initialize the argument list 115 U_MAIN_INIT_ARGS(_argc, _argv); 116 117 resolvedFileName = NULL; 118 119 // add specific options 120 int32_t optionsCount = OPTIONS_COUNT; 121 if (addOptionsCount > 0) { 122 memcpy(options+optionsCount, addOptions, addOptionsCount*sizeof(UOption)); 123 optionsCount += addOptionsCount; 124 } 125 126 //parse the arguments 127 _remainingArgc = u_parseArgs(_argc, (char**)_argv, optionsCount, options); 128 129 // copy back values for additional options 130 if (addOptionsCount > 0) { 131 memcpy(addOptions, options+OPTIONS_COUNT, addOptionsCount*sizeof(UOption)); 132 } 133 134 // Now setup the arguments 135 if(_argc==1 || options[HELP1].doesOccur || options[HELP2].doesOccur) { 136 status = U_ILLEGAL_ARGUMENT_ERROR; 137 return; 138 } 139 140 if(options[VERBOSE].doesOccur) { 141 verbose = TRUE; 142 } 143 144 if(options[SOURCEDIR].doesOccur) { 145 sourceDir = options[SOURCEDIR].value; 146 } 147 148 if(options[ENCODING].doesOccur) { 149 encoding = options[ENCODING].value; 150 } 151 152 if(options[USELEN].doesOccur) { 153 uselen = TRUE; 154 } 155 156 if(options[FILE_NAME].doesOccur){ 157 fileName = options[FILE_NAME].value; 158 } 159 160 if(options[PASSES].doesOccur) { 161 passes = atoi(options[PASSES].value); 162 } 163 if(options[ITERATIONS].doesOccur) { 164 iterations = atoi(options[ITERATIONS].value); 165 if(options[TIME].doesOccur) { 166 status = U_ILLEGAL_ARGUMENT_ERROR; 167 return; 168 } 169 } else if(options[TIME].doesOccur) { 170 time = atoi(options[TIME].value); 171 } else { 172 iterations = 1000; // some default 173 } 174 175 if(options[LINE_MODE].doesOccur) { 176 line_mode = TRUE; 177 bulk_mode = FALSE; 178 } 179 180 if(options[BULK_MODE].doesOccur) { 181 bulk_mode = TRUE; 182 line_mode = FALSE; 183 } 184 185 if(options[LOCALE].doesOccur) { 186 locale = options[LOCALE].value; 187 } 188 189 int32_t len = 0; 190 if(fileName!=NULL){ 191 //pre-flight 192 ucbuf_resolveFileName(sourceDir, fileName, NULL, &len, &status); 193 resolvedFileName = (char*) uprv_malloc(len); 194 if(resolvedFileName==NULL){ 195 status= U_MEMORY_ALLOCATION_ERROR; 196 return; 197 } 198 if(status == U_BUFFER_OVERFLOW_ERROR){ 199 status = U_ZERO_ERROR; 200 } 201 ucbuf_resolveFileName(sourceDir, fileName, resolvedFileName, &len, &status); 202 ucharBuf = ucbuf_open(resolvedFileName,&encoding,TRUE,FALSE,&status); 203 204 if(U_FAILURE(status)){ 205 printf("Could not open the input file %s. Error: %s\n", fileName, u_errorName(status)); 206 return; 207 } 208 } 209 } 210 211 ULine* UPerfTest::getLines(UErrorCode& status){ 212 if (U_FAILURE(status)) { 213 return NULL; 214 } 215 if (lines != NULL) { 216 return lines; // don't do it again 217 } 218 lines = new ULine[MAXLINES]; 219 int maxLines = MAXLINES; 220 numLines=0; 221 const UChar* line=NULL; 222 int32_t len =0; 223 for (;;) { 224 line = ucbuf_readline(ucharBuf,&len,&status); 225 if(line == NULL || U_FAILURE(status)){ 226 break; 227 } 228 lines[numLines].name = new UChar[len]; 229 lines[numLines].len = len; 230 memcpy(lines[numLines].name, line, len * U_SIZEOF_UCHAR); 231 232 numLines++; 233 len = 0; 234 if (numLines >= maxLines) { 235 maxLines += MAXLINES; 236 ULine *newLines = new ULine[maxLines]; 237 if(newLines == NULL) { 238 fprintf(stderr, "Out of memory reading line %d.\n", (int)numLines); 239 status= U_MEMORY_ALLOCATION_ERROR; 240 delete []lines; 241 return NULL; 242 } 243 244 memcpy(newLines, lines, numLines*sizeof(ULine)); 245 delete []lines; 246 lines = newLines; 247 } 248 } 249 return lines; 250 } 251 const UChar* UPerfTest::getBuffer(int32_t& len, UErrorCode& status){ 252 if (U_FAILURE(status)) { 253 return NULL; 254 } 255 len = ucbuf_size(ucharBuf); 256 buffer = (UChar*) uprv_malloc(U_SIZEOF_UCHAR * (len+1)); 257 u_strncpy(buffer,ucbuf_getBuffer(ucharBuf,&bufferLen,&status),len); 258 buffer[len]=0; 259 len = bufferLen; 260 return buffer; 261 } 262 UBool UPerfTest::run(){ 263 if(_remainingArgc==1){ 264 // Testing all methods 265 return runTest(); 266 } 267 UBool res=FALSE; 268 // Test only the specified fucntion 269 for (int i = 1; i < _remainingArgc; ++i) { 270 if (_argv[i][0] != '-') { 271 char* name = (char*) _argv[i]; 272 if(verbose==TRUE){ 273 //fprintf(stdout, "\n=== Handling test: %s: ===\n", name); 274 //fprintf(stdout, "\n%s:\n", name); 275 } 276 char* parameter = strchr( name, '@' ); 277 if (parameter) { 278 *parameter = 0; 279 parameter += 1; 280 } 281 execCount = 0; 282 res = runTest( name, parameter ); 283 if (!res || (execCount <= 0)) { 284 fprintf(stdout, "\n---ERROR: Test doesn't exist: %s!\n", name); 285 return FALSE; 286 } 287 } 288 } 289 return res; 290 } 291 UBool UPerfTest::runTest(char* name, char* par ){ 292 UBool rval; 293 char* pos = NULL; 294 295 if (name) 296 pos = strchr( name, delim ); // check if name contains path (by looking for '/') 297 if (pos) { 298 path = pos+1; // store subpath for calling subtest 299 *pos = 0; // split into two strings 300 }else{ 301 path = NULL; 302 } 303 304 if (!name || (name[0] == 0) || (strcmp(name, "*") == 0)) { 305 rval = runTestLoop( NULL, NULL ); 306 307 }else if (strcmp( name, "LIST" ) == 0) { 308 this->usage(); 309 rval = TRUE; 310 311 }else{ 312 rval = runTestLoop( name, par ); 313 } 314 315 if (pos) 316 *pos = delim; // restore original value at pos 317 return rval; 318 } 319 320 321 void UPerfTest::setPath( char* pathVal ) 322 { 323 this->path = pathVal; 324 } 325 326 // call individual tests, to be overridden to call implementations 327 UPerfFunction* UPerfTest::runIndexedTest( int32_t /*index*/, UBool /*exec*/, const char* & /*name*/, char* /*par*/ ) 328 { 329 // to be overridden by a method like: 330 /* 331 switch (index) { 332 case 0: name = "First Test"; if (exec) FirstTest( par ); break; 333 case 1: name = "Second Test"; if (exec) SecondTest( par ); break; 334 default: name = ""; break; 335 } 336 */ 337 fprintf(stderr,"*** runIndexedTest needs to be overridden! ***"); 338 return NULL; 339 } 340 341 342 UBool UPerfTest::runTestLoop( char* testname, char* par ) 343 { 344 int32_t index = 0; 345 const char* name; 346 UBool run_this_test; 347 UBool rval = FALSE; 348 UErrorCode status = U_ZERO_ERROR; 349 UPerfTest* saveTest = gTest; 350 gTest = this; 351 int32_t loops = 0; 352 double t=0; 353 int32_t n = 1; 354 long ops; 355 do { 356 this->runIndexedTest( index, FALSE, name ); 357 if (!name || (name[0] == 0)) 358 break; 359 if (!testname) { 360 run_this_test = TRUE; 361 }else{ 362 run_this_test = (UBool) (strcmp( name, testname ) == 0); 363 } 364 if (run_this_test) { 365 UPerfFunction* testFunction = this->runIndexedTest( index, TRUE, name, par ); 366 execCount++; 367 rval=TRUE; 368 if(testFunction==NULL){ 369 fprintf(stderr,"%s function returned NULL", name); 370 return FALSE; 371 } 372 ops = testFunction->getOperationsPerIteration(); 373 if (ops < 1) { 374 fprintf(stderr, "%s returned an illegal operations/iteration()\n", name); 375 return FALSE; 376 } 377 if(iterations == 0) { 378 n = time; 379 // Run for specified duration in seconds 380 if(verbose==TRUE){ 381 fprintf(stdout,"= %s calibrating %i seconds \n", name, (int)n); 382 } 383 384 //n *= 1000; // s => ms 385 //System.out.println("# " + meth.getName() + " " + n + " sec"); 386 int32_t failsafe = 1; // last resort for very fast methods 387 t = 0; 388 while (t < (int)(n * 0.9)) { // 90% is close enough 389 if (loops == 0 || t == 0) { 390 loops = failsafe; 391 failsafe *= 10; 392 } else { 393 //System.out.println("# " + meth.getName() + " x " + loops + " = " + t); 394 loops = (int)((double)n / t * loops + 0.5); 395 if (loops == 0) { 396 fprintf(stderr,"Unable to converge on desired duration"); 397 return FALSE; 398 } 399 } 400 //System.out.println("# " + meth.getName() + " x " + loops); 401 t = testFunction->time(loops,&status); 402 if(U_FAILURE(status)){ 403 printf("Performance test failed with error: %s \n", u_errorName(status)); 404 break; 405 } 406 } 407 } else { 408 loops = iterations; 409 } 410 411 double min_t=1000000.0, sum_t=0.0; 412 long events = -1; 413 414 for(int32_t ps =0; ps < passes; ps++){ 415 fprintf(stdout,"= %s begin " ,name); 416 if(verbose==TRUE){ 417 if(iterations > 0) { 418 fprintf(stdout, "%i\n", (int)loops); 419 } else { 420 fprintf(stdout, "%i\n", (int)n); 421 } 422 } else { 423 fprintf(stdout, "\n"); 424 } 425 t = testFunction->time(loops, &status); 426 if(U_FAILURE(status)){ 427 printf("Performance test failed with error: %s \n", u_errorName(status)); 428 break; 429 } 430 sum_t+=t; 431 if(t<min_t) { 432 min_t=t; 433 } 434 events = testFunction->getEventsPerIteration(); 435 //print info only in verbose mode 436 if(verbose==TRUE){ 437 if(events == -1){ 438 fprintf(stdout, "= %s end: %f loops: %i operations: %li \n", name, t, (int)loops, ops); 439 }else{ 440 fprintf(stdout, "= %s end: %f loops: %i operations: %li events: %li\n", name, t, (int)loops, ops, events); 441 } 442 }else{ 443 if(events == -1){ 444 fprintf(stdout,"= %s end %f %i %li\n", name, t, (int)loops, ops); 445 }else{ 446 fprintf(stdout,"= %s end %f %i %li %li\n", name, t, (int)loops, ops, events); 447 } 448 } 449 } 450 if(verbose && U_SUCCESS(status)) { 451 double avg_t = sum_t/passes; 452 if (loops == 0 || ops == 0) { 453 fprintf(stderr, "%s did not run\n", name); 454 } 455 else if(events == -1) { 456 fprintf(stdout, "%%= %s avg: %.4g loops: %i avg/op: %.4g ns\n", 457 name, avg_t, (int)loops, (avg_t*1E9)/(loops*ops)); 458 fprintf(stdout, "_= %s min: %.4g loops: %i min/op: %.4g ns\n", 459 name, min_t, (int)loops, (min_t*1E9)/(loops*ops)); 460 } 461 else { 462 fprintf(stdout, "%%= %s avg: %.4g loops: %i avg/op: %.4g ns avg/event: %.4g ns\n", 463 name, avg_t, (int)loops, (avg_t*1E9)/(loops*ops), (avg_t*1E9)/(loops*events)); 464 fprintf(stdout, "_= %s min: %.4g loops: %i min/op: %.4g ns min/event: %.4g ns\n", 465 name, min_t, (int)loops, (min_t*1E9)/(loops*ops), (min_t*1E9)/(loops*events)); 466 } 467 } 468 delete testFunction; 469 } 470 index++; 471 }while(name); 472 473 gTest = saveTest; 474 return rval; 475 } 476 477 /** 478 * Print a usage message for this test class. 479 */ 480 void UPerfTest::usage( void ) 481 { 482 puts(gUsageString); 483 if (_addUsage != NULL) { 484 puts(_addUsage); 485 } 486 487 UBool save_verbose = verbose; 488 verbose = TRUE; 489 fprintf(stdout,"Test names:\n"); 490 fprintf(stdout,"-----------\n"); 491 492 int32_t index = 0; 493 const char* name = NULL; 494 do{ 495 this->runIndexedTest( index, FALSE, name ); 496 if (!name) 497 break; 498 fprintf(stdout, "%s\n", name); 499 index++; 500 }while (name && (name[0] != 0)); 501 verbose = save_verbose; 502 } 503 504 505 506 507 void UPerfTest::setCaller( UPerfTest* callingTest ) 508 { 509 caller = callingTest; 510 if (caller) { 511 verbose = caller->verbose; 512 } 513 } 514 515 UBool UPerfTest::callTest( UPerfTest& testToBeCalled, char* par ) 516 { 517 execCount--; // correct a previously assumed test-exec, as this only calls a subtest 518 testToBeCalled.setCaller( this ); 519 return testToBeCalled.runTest( path, par ); 520 } 521 522 UPerfTest::~UPerfTest(){ 523 if(lines!=NULL){ 524 delete[] lines; 525 } 526 if(buffer!=NULL){ 527 uprv_free(buffer); 528 } 529 if(resolvedFileName!=NULL){ 530 uprv_free(resolvedFileName); 531 } 532 ucbuf_close(ucharBuf); 533 } 534 535 #endif 536
