The Tor Browser / file comparison

comparison: intl/icu/source/tools/ctestfw/uperf.cpp

intl/icu/source/tools/ctestfw/uperf.cpp

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

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial