]> git.saurik.com Git - apple/icu.git/blob - icuSources/test/perf/collperf/collperf.cpp
projects / apple / icu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ICU-66108.tar.gz
[apple/icu.git] / icuSources / test / perf / collperf / collperf.cpp
1 /***********************************************************************
2 * © 2016 and later: Unicode, Inc. and others.
3 * License & terms of use: http://www.unicode.org/copyright.html#License
4 *
5 ***********************************************************************
6 ***********************************************************************
7 * COPYRIGHT:
8 * Copyright (C) 2001-2016 IBM, Inc. All Rights Reserved.
9 *
10 ***********************************************************************/
11
12 #include <stdio.h>
13 #include <stdlib.h>
14 #include <locale.h>
15 #include <limits.h>
16 #include <string.h>
17 #include "cmemory.h"
18 #include "unicode/uperf.h"
19 #include "uoptions.h"
20 #include "unicode/coll.h"
21 #include <unicode/ucoleitr.h>
22
23 #if !U_PLATFORM_HAS_WIN32_API
24 #define DWORD uint32_t
25 #define WCHAR wchar_t
26 #endif
27
28 /* To store an array of string<UNIT> in continue space.
29 Since string<UNIT> itself is treated as an array of UNIT, this
30 class will ease our memory management for an array of string<UNIT>.
31 */
32
33 //template<typename UNIT>
34 #define COMPATCT_ARRAY(CompactArrays, UNIT) \
35 struct CompactArrays{\
36 CompactArrays(const CompactArrays & );\
37 CompactArrays & operator=(const CompactArrays & );\
38 int32_t count;/*total number of the strings*/ \
39 int32_t * index;/*relative offset in data*/ \
40 UNIT * data; /*the real space to hold strings*/ \
41 \
42 ~CompactArrays(){free(index);free(data);} \
43 CompactArrays():data(NULL), index(NULL), count(0){ \
44 index = (int32_t *) realloc(index, sizeof(int32_t)); \
45 index[0] = 0; \
46 } \
47 void append_one(int32_t theLen){ /*include terminal NULL*/ \
48 count++; \
49 index = (int32_t *) realloc(index, sizeof(int32_t) * (count + 1)); \
50 index[count] = index[count - 1] + theLen; \
51 data = (UNIT *) realloc(data, sizeof(UNIT) * index[count]); \
52 } \
53 UNIT * last(){return data + index[count - 1];} \
54 UNIT * dataOf(int32_t i){return data + index[i];} \
55 int32_t lengthOf(int i){return index[i+1] - index[i] - 1; } /*exclude terminating NULL*/ \
56 };
57
58 //typedef CompactArrays<UChar> CA_uchar;
59 //typedef CompactArrays<char> CA_char;
60 //typedef CompactArrays<uint8_t> CA_uint8;
61 //typedef CompactArrays<WCHAR> CA_win_wchar;
62
63 COMPATCT_ARRAY(CA_uchar, UChar)
64 COMPATCT_ARRAY(CA_char, char)
65 COMPATCT_ARRAY(CA_uint8, uint8_t)
66 COMPATCT_ARRAY(CA_win_wchar, WCHAR)
67
68
69 struct DataIndex {
70 static DWORD win_langid; // for qsort callback function
71 static UCollator * col; // for qsort callback function
72 uint8_t * icu_key;
73 UChar * icu_data;
74 int32_t icu_data_len;
75 char* posix_key;
76 char* posix_data;
77 int32_t posix_data_len;
78 char* win_key;
79 WCHAR * win_data;
80 int32_t win_data_len;
81 };
82 DWORD DataIndex::win_langid;
83 UCollator * DataIndex::col;
84
85
86
87 class CmdKeyGen : public UPerfFunction {
88 typedef void (CmdKeyGen::* Func)(int32_t);
89 enum{MAX_KEY_LENGTH = 5000};
90 UCollator * col;
91 DWORD win_langid;
92 int32_t count;
93 DataIndex * data;
94 Func fn;
95
96 union { // to save sapce
97 uint8_t icu_key[MAX_KEY_LENGTH];
98 char posix_key[MAX_KEY_LENGTH];
99 WCHAR win_key[MAX_KEY_LENGTH];
100 };
101 public:
102 CmdKeyGen(UErrorCode, UCollator * col,DWORD win_langid, int32_t count, DataIndex * data,Func fn,int32_t)
103 :col(col),win_langid(win_langid), count(count), data(data), fn(fn){}
104
105 virtual long getOperationsPerIteration(){return count;}
106
107 virtual void call(UErrorCode* status){
108 for(int32_t i = 0; i< count; i++){
109 (this->*fn)(i);
110 }
111 }
112
113 void icu_key_null(int32_t i){
114 ucol_getSortKey(col, data[i].icu_data, -1, icu_key, MAX_KEY_LENGTH);
115 }
116
117 void icu_key_len(int32_t i){
118 ucol_getSortKey(col, data[i].icu_data, data[i].icu_data_len, icu_key, MAX_KEY_LENGTH);
119 }
120
121 #if U_PLATFORM_HAS_WIN32_API
122 // pre-generated in CollPerfTest::prepareData(), need not to check error here
123 void win_key_null(int32_t i){
124 //LCMAP_SORTsk 0x00000400 // WC sort sk (normalize)
125 LCMapStringW(win_langid, LCMAP_SORTKEY, data[i].win_data, -1, win_key, MAX_KEY_LENGTH);
126 }
127
128 void win_key_len(int32_t i){
129 LCMapStringW(win_langid, LCMAP_SORTKEY, data[i].win_data, data[i].win_data_len, win_key, MAX_KEY_LENGTH);
130 }
131 #endif
132
133 void posix_key_null(int32_t i){
134 strxfrm(posix_key, data[i].posix_data, MAX_KEY_LENGTH);
135 }
136 };
137
138
139 class CmdIter : public UPerfFunction {
140 typedef void (CmdIter::* Func)(UErrorCode* , int32_t );
141 int32_t count;
142 CA_uchar * data;
143 Func fn;
144 UCollationElements *iter;
145 int32_t exec_count;
146 public:
147 CmdIter(UErrorCode & status, UCollator * col, int32_t count, CA_uchar *data, Func fn, int32_t,int32_t)
148 :count(count), data(data), fn(fn){
149 exec_count = 0;
150 UChar dummytext[] = {0, 0};
151 iter = ucol_openElements(col, NULL, 0, &status);
152 ucol_setText(iter, dummytext, 1, &status);
153 }
154 ~CmdIter(){
155 ucol_closeElements(iter);
156 }
157
158 virtual long getOperationsPerIteration(){return exec_count ? exec_count : 1;}
159
160 virtual void call(UErrorCode* status){
161 exec_count = 0;
162 for(int32_t i = 0; i< count; i++){
163 (this->*fn)(status, i);
164 }
165 }
166
167 void icu_forward_null(UErrorCode* status, int32_t i){
168 ucol_setText(iter, data->dataOf(i), -1, status);
169 while (ucol_next(iter, status) != UCOL_NULLORDER) exec_count++;
170 }
171
172 void icu_forward_len(UErrorCode* status, int32_t i){
173 ucol_setText(iter, data->dataOf(i), data->lengthOf(i) , status);
174 while (ucol_next(iter, status) != UCOL_NULLORDER) exec_count++;
175 }
176
177 void icu_backward_null(UErrorCode* status, int32_t i){
178 ucol_setText(iter, data->dataOf(i), -1, status);
179 while (ucol_previous(iter, status) != UCOL_NULLORDER) exec_count++;
180 }
181
182 void icu_backward_len(UErrorCode* status, int32_t i){
183 ucol_setText(iter, data->dataOf(i), data->lengthOf(i) , status);
184 while (ucol_previous(iter, status) != UCOL_NULLORDER) exec_count++;
185 }
186 };
187
188 class CmdIterAll : public UPerfFunction {
189 typedef void (CmdIterAll::* Func)(UErrorCode* status);
190 int32_t count;
191 UChar * data;
192 Func fn;
193 UCollationElements *iter;
194 int32_t exec_count;
195
196 public:
197 enum CALL {forward_null, forward_len, backward_null, backward_len};
198
199 ~CmdIterAll(){
200 ucol_closeElements(iter);
201 }
202 CmdIterAll(UErrorCode & status, UCollator * col, int32_t count, UChar * data, CALL call,int32_t,int32_t)
203 :count(count),data(data)
204 {
205 exec_count = 0;
206 if (call == forward_null || call == backward_null) {
207 iter = ucol_openElements(col, data, -1, &status);
208 } else {
209 iter = ucol_openElements(col, data, count, &status);
210 }
211
212 if (call == forward_null || call == forward_len){
213 fn = &CmdIterAll::icu_forward_all;
214 } else {
215 fn = &CmdIterAll::icu_backward_all;
216 }
217 }
218 virtual long getOperationsPerIteration(){return exec_count ? exec_count : 1;}
219
220 virtual void call(UErrorCode* status){
221 (this->*fn)(status);
222 }
223
224 void icu_forward_all(UErrorCode* status){
225 int strlen = count - 5;
226 int count5 = 5;
227 int strindex = 0;
228 ucol_setOffset(iter, strindex, status);
229 while (TRUE) {
230 if (ucol_next(iter, status) == UCOL_NULLORDER) {
231 break;
232 }
233 exec_count++;
234 count5 --;
235 if (count5 == 0) {
236 strindex += 10;
237 if (strindex > strlen) {
238 break;
239 }
240 ucol_setOffset(iter, strindex, status);
241 count5 = 5;
242 }
243 }
244 }
245
246 void icu_backward_all(UErrorCode* status){
247 int strlen = count;
248 int count5 = 5;
249 int strindex = 5;
250 ucol_setOffset(iter, strindex, status);
251 while (TRUE) {
252 if (ucol_previous(iter, status) == UCOL_NULLORDER) {
253 break;
254 }
255 exec_count++;
256 count5 --;
257 if (count5 == 0) {
258 strindex += 10;
259 if (strindex > strlen) {
260 break;
261 }
262 ucol_setOffset(iter, strindex, status);
263 count5 = 5;
264 }
265 }
266 }
267
268 };
269
270 struct CmdQsort : public UPerfFunction{
271
272 static int q_random(const void * a, const void * b){
273 uint8_t * key_a = ((DataIndex *)a)->icu_key;
274 uint8_t * key_b = ((DataIndex *)b)->icu_key;
275
276 int val_a = 0;
277 int val_b = 0;
278 while (*key_a != 0) {val_a += val_a*37 + *key_a++;}
279 while (*key_b != 0) {val_b += val_b*37 + *key_b++;}
280 return val_a - val_b;
281 }
282
283 #define QCAST() \
284 DataIndex * da = (DataIndex *) a; \
285 DataIndex * db = (DataIndex *) b; \
286 ++exec_count
287
288 static int icu_strcoll_null(const void *a, const void *b){
289 QCAST();
290 return ucol_strcoll(da->col, da->icu_data, -1, db->icu_data, -1) - UCOL_EQUAL;
291 }
292
293 static int icu_strcoll_len(const void *a, const void *b){
294 QCAST();
295 return ucol_strcoll(da->col, da->icu_data, da->icu_data_len, db->icu_data, db->icu_data_len) - UCOL_EQUAL;
296 }
297
298 static int icu_cmpkey (const void *a, const void *b){
299 QCAST();
300 return strcmp((char *) da->icu_key, (char *) db->icu_key);
301 }
302
303 #if U_PLATFORM_HAS_WIN32_API
304 static int win_cmp_null(const void *a, const void *b) {
305 QCAST();
306 //CSTR_LESS_THAN 1
307 //CSTR_EQUAL 2
308 //CSTR_GREATER_THAN 3
309 int t = CompareStringW(da->win_langid, 0, da->win_data, -1, db->win_data, -1);
310 if (t == 0){
311 fprintf(stderr, "CompareStringW error, error number %x\n", GetLastError());
312 exit(-1);
313 } else{
314 return t - CSTR_EQUAL;
315 }
316 }
317
318 static int win_cmp_len(const void *a, const void *b) {
319 QCAST();
320 int t = CompareStringW(da->win_langid, 0, da->win_data, da->win_data_len, db->win_data, db->win_data_len);
321 if (t == 0){
322 fprintf(stderr, "CompareStringW error, error number %x\n", GetLastError());
323 exit(-1);
324 } else{
325 return t - CSTR_EQUAL;
326 }
327 }
328 #endif
329
330 #define QFUNC(name, func, data) \
331 static int name (const void *a, const void *b){ \
332 QCAST(); \
333 return func(da->data, db->data); \
334 }
335
336 QFUNC(posix_strcoll_null, strcoll, posix_data)
337 QFUNC(posix_cmpkey, strcmp, posix_key)
338 #if U_PLATFORM_HAS_WIN32_API
339 QFUNC(win_cmpkey, strcmp, win_key)
340 QFUNC(win_wcscmp, wcscmp, win_data)
341 #endif
342 QFUNC(icu_strcmp, u_strcmp, icu_data)
343 QFUNC(icu_cmpcpo, u_strcmpCodePointOrder, icu_data)
344
345 private:
346 static int32_t exec_count; // potential muilt-thread problem
347
348 typedef int (* Func)(const void *, const void *);
349
350 Func fn;
351 void * base; //Start of target array.
352 int32_t num; //Array size in elements.
353 int32_t width; //Element size in bytes.
354
355 void * backup; //copy source of base
356 public:
357 CmdQsort(UErrorCode & status,void *theBase, int32_t num, int32_t width, Func fn, int32_t,int32_t)
358 :backup(theBase),num(num),width(width),fn(fn){
359 base = malloc(num * width);
360 time_empty(100, &status); // warm memory/cache
361 }
362
363 ~CmdQsort(){
364 free(base);
365 }
366
367 void empty_call(){
368 exec_count = 0;
369 memcpy(base, backup, num * width);
370 }
371
372 double time_empty(int32_t n, UErrorCode* status) {
373 UTimer start, stop;
374 utimer_getTime(&start);
375 while (n-- > 0) {
376 empty_call();
377 }
378 utimer_getTime(&stop);
379 return utimer_getDeltaSeconds(&start,&stop); // ms
380 }
381
382 virtual void call(UErrorCode* status){
383 exec_count = 0;
384 memcpy(base, backup, num * width);
385 qsort(base, num, width, fn);
386 }
387 virtual double time(int32_t n, UErrorCode* status) {
388 double t1 = time_empty(n,status);
389 double t2 = UPerfFunction::time(n, status);
390 return t2-t1;// < 0 ? t2 : t2-t1;
391 }
392
393 virtual long getOperationsPerIteration(){ return exec_count?exec_count:1;}
394 };
395 int32_t CmdQsort::exec_count;
396
397
398 class CmdBinSearch : public UPerfFunction{
399 public:
400 typedef int (CmdBinSearch::* Func)(int, int);
401
402 UCollator * col;
403 DWORD win_langid;
404 int32_t count;
405 DataIndex * rnd;
406 DataIndex * ord;
407 Func fn;
408 int32_t exec_count;
409
410 CmdBinSearch(UErrorCode, UCollator * col,DWORD win_langid,int32_t count,DataIndex * rnd,DataIndex * ord,Func fn)
411 :col(col),win_langid(win_langid), count(count), rnd(rnd), ord(ord), fn(fn),exec_count(0){}
412
413
414 virtual void call(UErrorCode* status){
415 exec_count = 0;
416 for(int32_t i = 0; i< count; i++){ // search all data
417 binary_search(i);
418 }
419 }
420 virtual long getOperationsPerIteration(){ return exec_count?exec_count:1;}
421
422 void binary_search(int32_t random) {
423 int low = 0;
424 int high = count - 1;
425 int guess;
426 int last_guess = -1;
427 int r;
428 while (TRUE) {
429 guess = (high + low)/2;
430 if (last_guess == guess) break; // nothing to search
431
432 r = (this->*fn)(random, guess);
433 exec_count++;
434
435 if (r == 0)
436 return; // found, search end.
437 if (r < 0) {
438 high = guess;
439 } else {
440 low = guess;
441 }
442 last_guess = guess;
443 }
444 }
445
446 int icu_strcoll_null(int32_t i, int32_t j){
447 return ucol_strcoll(col, rnd[i].icu_data, -1, ord[j].icu_data,-1);
448 }
449
450 int icu_strcoll_len(int32_t i, int32_t j){
451 return ucol_strcoll(col, rnd[i].icu_data, rnd[i].icu_data_len, ord[j].icu_data, ord[j].icu_data_len);
452 }
453
454 int icu_cmpkey(int32_t i, int32_t j) {
455 return strcmp( (char *) rnd[i].icu_key, (char *) ord[j].icu_key );
456 }
457
458 #if U_PLATFORM_HAS_WIN32_API
459 int win_cmp_null(int32_t i, int32_t j) {
460 int t = CompareStringW(win_langid, 0, rnd[i].win_data, -1, ord[j].win_data, -1);
461 if (t == 0){
462 fprintf(stderr, "CompareStringW error, error number %x\n", GetLastError());
463 exit(-1);
464 } else{
465 return t - CSTR_EQUAL;
466 }
467 }
468
469 int win_cmp_len(int32_t i, int32_t j) {
470 int t = CompareStringW(win_langid, 0, rnd[i].win_data, rnd[i].win_data_len, ord[j].win_data, ord[j].win_data_len);
471 if (t == 0){
472 fprintf(stderr, "CompareStringW error, error number %x\n", GetLastError());
473 exit(-1);
474 } else{
475 return t - CSTR_EQUAL;
476 }
477 }
478 #endif
479
480 #define BFUNC(name, func, data) \
481 int name(int32_t i, int32_t j) { \
482 return func(rnd[i].data, ord[j].data); \
483 }
484
485 BFUNC(posix_strcoll_null, strcoll, posix_data)
486 BFUNC(posix_cmpkey, strcmp, posix_key)
487 BFUNC(win_cmpkey, strcmp, win_key)
488 BFUNC(win_wcscmp, wcscmp, win_data)
489 BFUNC(icu_strcmp, u_strcmp, icu_data)
490 BFUNC(icu_cmpcpo, u_strcmpCodePointOrder, icu_data)
491 };
492
493 class CollPerfTest : public UPerfTest {
494 public:
495 UCollator * col;
496 DWORD win_langid;
497
498 UChar * icu_data_all;
499 int32_t icu_data_all_len;
500
501 int32_t count;
502 CA_uchar * icu_data;
503 CA_uint8 * icu_key;
504 CA_char * posix_data;
505 CA_char * posix_key;
506 CA_win_wchar * win_data;
507 CA_char * win_key;
508
509 DataIndex * rnd_index; // random by icu key
510 DataIndex * ord_win_data;
511 DataIndex * ord_win_key;
512 DataIndex * ord_posix_data;
513 DataIndex * ord_posix_key;
514 DataIndex * ord_icu_data;
515 DataIndex * ord_icu_key;
516 DataIndex * ord_win_wcscmp;
517 DataIndex * ord_icu_strcmp;
518 DataIndex * ord_icu_cmpcpo;
519
520 virtual ~CollPerfTest(){
521 ucol_close(col);
522 delete [] icu_data_all;
523 delete icu_data;
524 delete icu_key;
525 delete posix_data;
526 delete posix_key;
527 delete win_data;
528 delete win_key;
529 delete[] rnd_index;
530 delete[] ord_win_data;
531 delete[] ord_win_key;
532 delete[] ord_posix_data;
533 delete[] ord_posix_key;
534 delete[] ord_icu_data;
535 delete[] ord_icu_key;
536 delete[] ord_win_wcscmp;
537 delete[] ord_icu_strcmp;
538 delete[] ord_icu_cmpcpo;
539 }
540
541 CollPerfTest(int32_t argc, const char* argv[], UErrorCode& status):UPerfTest(argc, argv, status){
542 col = NULL;
543 icu_data_all = NULL;
544 icu_data = NULL;
545 icu_key = NULL;
546 posix_data = NULL;
547 posix_key = NULL;
548 win_data =NULL;
549 win_key = NULL;
550
551 rnd_index = NULL;
552 ord_win_data= NULL;
553 ord_win_key= NULL;
554 ord_posix_data= NULL;
555 ord_posix_key= NULL;
556 ord_icu_data= NULL;
557 ord_icu_key= NULL;
558 ord_win_wcscmp = NULL;
559 ord_icu_strcmp = NULL;
560 ord_icu_cmpcpo = NULL;
561
562 if (U_FAILURE(status)){
563 return;
564 }
565
566 // Parse additional arguments
567
568 UOption options[] = {
569 UOPTION_DEF("langid", 'i', UOPT_REQUIRES_ARG), // Windows Language ID number.
570 UOPTION_DEF("rulefile", 'r', UOPT_REQUIRES_ARG), // --rulefile <filename>
571 // Collation related arguments. All are optional.
572 // To simplify parsing, two choice arguments are disigned as NO_ARG.
573 // The default value is UPPER word in the comment
574 UOPTION_DEF("c_french", 'f', UOPT_NO_ARG), // --french <on | OFF>
575 UOPTION_DEF("c_alternate", 'a', UOPT_NO_ARG), // --alternate <NON_IGNORE | shifted>
576 UOPTION_DEF("c_casefirst", 'c', UOPT_REQUIRES_ARG), // --casefirst <lower | upper | OFF>
577 UOPTION_DEF("c_caselevel", 'l', UOPT_NO_ARG), // --caselevel <on | OFF>
578 UOPTION_DEF("c_normal", 'n', UOPT_NO_ARG), // --normal <on | OFF>
579 UOPTION_DEF("c_strength", 's', UOPT_REQUIRES_ARG), // --strength <1-5>
580 };
581 int32_t opt_len = UPRV_LENGTHOF(options);
582 enum {i, r,f,a,c,l,n,s}; // The buffer between the option items' order and their references
583
584 _remainingArgc = u_parseArgs(_remainingArgc, (char**)argv, opt_len, options);
585
586 if (_remainingArgc < 0){
587 status = U_ILLEGAL_ARGUMENT_ERROR;
588 return;
589 }
590
591 if (locale == NULL){
592 locale = "en_US"; // set default locale
593 }
594
595 #if U_PLATFORM_HAS_WIN32_API
596 if (options[i].doesOccur) {
597 char *endp;
598 int tmp = strtol(options[i].value, &endp, 0);
599 if (endp == options[i].value) {
600 status = U_ILLEGAL_ARGUMENT_ERROR;
601 return;
602 }
603 win_langid = MAKELCID(tmp, SORT_DEFAULT);
604 } else {
605 win_langid = uloc_getLCID(locale);
606 }
607 #endif
608
609 // Set up an ICU collator
610 if (options[r].doesOccur) {
611 // TODO: implement it
612 } else {
613 col = ucol_open(locale, &status);
614 if (U_FAILURE(status)) {
615 return;
616 }
617 }
618
619 if (options[f].doesOccur) {
620 ucol_setAttribute(col, UCOL_FRENCH_COLLATION, UCOL_ON, &status);
621 } else {
622 ucol_setAttribute(col, UCOL_FRENCH_COLLATION, UCOL_OFF, &status);
623 }
624
625 if (options[a].doesOccur) {
626 ucol_setAttribute(col, UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, &status);
627 }
628
629 if (options[c].doesOccur) { // strcmp() has i18n encoding problem
630 if (strcmp("lower", options[c].value) == 0){
631 ucol_setAttribute(col, UCOL_CASE_FIRST, UCOL_LOWER_FIRST, &status);
632 } else if (strcmp("upper", options[c].value) == 0) {
633 ucol_setAttribute(col, UCOL_CASE_FIRST, UCOL_UPPER_FIRST, &status);
634 } else {
635 status = U_ILLEGAL_ARGUMENT_ERROR;
636 return;
637 }
638 }
639
640 if (options[l].doesOccur){
641 ucol_setAttribute(col, UCOL_CASE_LEVEL, UCOL_ON, &status);
642 }
643
644 if (options[n].doesOccur){
645 ucol_setAttribute(col, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
646 }
647
648 if (options[s].doesOccur) {
649 char *endp;
650 int tmp = strtol(options[l].value, &endp, 0);
651 if (endp == options[l].value) {
652 status = U_ILLEGAL_ARGUMENT_ERROR;
653 return;
654 }
655 switch (tmp) {
656 case 1: ucol_setAttribute(col, UCOL_STRENGTH, UCOL_PRIMARY, &status); break;
657 case 2: ucol_setAttribute(col, UCOL_STRENGTH, UCOL_SECONDARY, &status); break;
658 case 3: ucol_setAttribute(col, UCOL_STRENGTH, UCOL_TERTIARY, &status); break;
659 case 4: ucol_setAttribute(col, UCOL_STRENGTH, UCOL_QUATERNARY, &status); break;
660 case 5: ucol_setAttribute(col, UCOL_STRENGTH, UCOL_IDENTICAL, &status); break;
661 default: status = U_ILLEGAL_ARGUMENT_ERROR; return;
662 }
663 }
664 prepareData(status);
665 }
666
667 //to avoid use the annoying 'id' in TESTCASE(id,test) macro or the like
668 #define TEST(testname, classname, arg1, arg2, arg3, arg4, arg5, arg6) \
669 if(temp == index) {\
670 name = #testname;\
671 if (exec) {\
672 UErrorCode status = U_ZERO_ERROR;\
673 UPerfFunction * t = new classname(status,arg1, arg2, arg3, arg4, arg5, arg6);\
674 if (U_FAILURE(status)) {\
675 delete t;\
676 return NULL;\
677 } else {\
678 return t;\
679 }\
680 } else {\
681 return NULL;\
682 }\
683 }\
684 temp++\
685
686
687 virtual UPerfFunction* runIndexedTest( /*[in]*/int32_t index, /*[in]*/UBool exec, /*[out]*/const char* &name, /*[in]*/ char* par = NULL ){
688 int temp = 0;
689
690 #define TEST_KEYGEN(testname, func)\
691 TEST(testname, CmdKeyGen, col, win_langid, count, rnd_index, &CmdKeyGen::func, 0)
692 TEST_KEYGEN(TestIcu_KeyGen_null, icu_key_null);
693 TEST_KEYGEN(TestIcu_KeyGen_len, icu_key_len);
694 TEST_KEYGEN(TestPosix_KeyGen_null, posix_key_null);
695 #if U_PLATFORM_HAS_WIN32_API
696 TEST_KEYGEN(TestWin_KeyGen_null, win_key_null);
697 TEST_KEYGEN(TestWin_KeyGen_len, win_key_len);
698 #endif
699
700 #define TEST_ITER(testname, func)\
701 TEST(testname, CmdIter, col, count, icu_data, &CmdIter::func,0,0)
702 TEST_ITER(TestIcu_ForwardIter_null, icu_forward_null);
703 TEST_ITER(TestIcu_ForwardIter_len, icu_forward_len);
704 TEST_ITER(TestIcu_BackwardIter_null, icu_backward_null);
705 TEST_ITER(TestIcu_BackwardIter_len, icu_backward_len);
706
707 #define TEST_ITER_ALL(testname, func)\
708 TEST(testname, CmdIterAll, col, icu_data_all_len, icu_data_all, CmdIterAll::func,0,0)
709 TEST_ITER_ALL(TestIcu_ForwardIter_all_null, forward_null);
710 TEST_ITER_ALL(TestIcu_ForwardIter_all_len, forward_len);
711 TEST_ITER_ALL(TestIcu_BackwardIter_all_null, backward_null);
712 TEST_ITER_ALL(TestIcu_BackwardIter_all_len, backward_len);
713
714 #define TEST_QSORT(testname, func)\
715 TEST(testname, CmdQsort, rnd_index, count, sizeof(DataIndex), CmdQsort::func,0,0)
716 TEST_QSORT(TestIcu_qsort_strcoll_null, icu_strcoll_null);
717 TEST_QSORT(TestIcu_qsort_strcoll_len, icu_strcoll_len);
718 TEST_QSORT(TestIcu_qsort_usekey, icu_cmpkey);
719 TEST_QSORT(TestPosix_qsort_strcoll_null, posix_strcoll_null);
720 TEST_QSORT(TestPosix_qsort_usekey, posix_cmpkey);
721 #if U_PLATFORM_HAS_WIN32_API
722 TEST_QSORT(TestWin_qsort_CompareStringW_null, win_cmp_null);
723 TEST_QSORT(TestWin_qsort_CompareStringW_len, win_cmp_len);
724 TEST_QSORT(TestWin_qsort_usekey, win_cmpkey);
725 #endif
726
727 #define TEST_BIN(testname, func)\
728 TEST(testname, CmdBinSearch, col, win_langid, count, rnd_index, ord_icu_key, &CmdBinSearch::func)
729 TEST_BIN(TestIcu_BinarySearch_strcoll_null, icu_strcoll_null);
730 TEST_BIN(TestIcu_BinarySearch_strcoll_len, icu_strcoll_len);
731 TEST_BIN(TestIcu_BinarySearch_usekey, icu_cmpkey);
732 TEST_BIN(TestIcu_BinarySearch_strcmp, icu_strcmp);
733 TEST_BIN(TestIcu_BinarySearch_cmpCPO, icu_cmpcpo);
734 TEST_BIN(TestPosix_BinarySearch_strcoll_null, posix_strcoll_null);
735 TEST_BIN(TestPosix_BinarySearch_usekey, posix_cmpkey);
736 #if U_PLATFORM_HAS_WIN32_API
737 TEST_BIN(TestWin_BinarySearch_CompareStringW_null, win_cmp_null);
738 TEST_BIN(TestWin_BinarySearch_CompareStringW_len, win_cmp_len);
739 #endif
740 TEST_BIN(TestWin_BinarySearch_usekey, win_cmpkey);
741 TEST_BIN(TestWin_BinarySearch_wcscmp, win_wcscmp);
742
743 name="";
744 return NULL;
745 }
746
747
748
749 void prepareData(UErrorCode& status){
750 if(U_FAILURE(status)) return;
751 if (icu_data) return; // prepared
752
753 icu_data = new CA_uchar();
754
755 // Following code is borrowed from UPerfTest::getLines();
756 const UChar* line=NULL;
757 int32_t len =0;
758 for (;;) {
759 line = ucbuf_readline(ucharBuf,&len,&status);
760 if(line == NULL || U_FAILURE(status)){break;}
761
762 // Refer to the source code of ucbuf_readline()
763 // 1. 'len' includs the line terminal symbols
764 // 2. The length of the line terminal symbols is only one character
765 // 3. The Windows CR LF line terminal symbols will be converted to CR
766
767 if (len == 1) {
768 continue; //skip empty line
769 } else {
770 icu_data->append_one(len);
771 memcpy(icu_data->last(), line, len * sizeof(UChar));
772 icu_data->last()[len -1] = NULL;
773 }
774 }
775 if(U_FAILURE(status)) return;
776
777 // UTF-16 -> UTF-8 conversion.
778 UConverter *conv = ucnv_open("utf-8", &status); // just UTF-8 for now.
779 if (U_FAILURE(status)) return;
780
781 count = icu_data->count;
782
783 icu_data_all_len = icu_data->index[count]; // includes all NULLs
784 icu_data_all_len -= count; // excludes all NULLs
785 icu_data_all_len += 1; // the terminal NULL
786 icu_data_all = new UChar[icu_data_all_len];
787 icu_data_all[icu_data_all_len - 1] = 0; //the terminal NULL
788
789 icu_key = new CA_uint8;
790 win_data = new CA_win_wchar;
791 win_key = new CA_char;
792 posix_data = new CA_char;
793 posix_key = new CA_char;
794 rnd_index = new DataIndex[count];
795 DataIndex::win_langid = win_langid;
796 DataIndex::col = col;
797
798
799 UChar * p = icu_data_all;
800 int32_t s;
801 int32_t t;
802 for (int i=0; i < count; i++) {
803 // ICU all data
804 s = sizeof(UChar) * icu_data->lengthOf(i);
805 memcpy(p, icu_data->dataOf(i), s);
806 p += icu_data->lengthOf(i);
807
808 // ICU data
809
810 // ICU key
811 s = ucol_getSortKey(col, icu_data->dataOf(i), -1,NULL, 0);
812 icu_key->append_one(s);
813 t = ucol_getSortKey(col, icu_data->dataOf(i), -1,icu_key->last(), s);
814 if (t != s) {status = U_INVALID_FORMAT_ERROR;return;}
815
816 // POSIX data
817 s = ucnv_fromUChars(conv,NULL, 0, icu_data->dataOf(i), icu_data->lengthOf(i), &status);
818 if (status == U_BUFFER_OVERFLOW_ERROR || status == U_ZERO_ERROR){
819 status = U_ZERO_ERROR;
820 } else {
821 return;
822 }
823 posix_data->append_one(s + 1); // plus terminal NULL
824 t = ucnv_fromUChars(conv,posix_data->last(), s, icu_data->dataOf(i), icu_data->lengthOf(i), &status);
825 if (U_FAILURE(status)) return;
826 if ( t != s){status = U_INVALID_FORMAT_ERROR;return;}
827 posix_data->last()[s] = 0;
828
829 // POSIX key
830 s = strxfrm(NULL, posix_data->dataOf(i), 0);
831 if (s == INT_MAX){status = U_INVALID_FORMAT_ERROR;return;}
832 posix_key->append_one(s);
833 t = strxfrm(posix_key->last(), posix_data->dataOf(i), s);
834 if (t != s) {status = U_INVALID_FORMAT_ERROR;return;}
835
836 #if U_PLATFORM_HAS_WIN32_API
837 // Win data
838 s = icu_data->lengthOf(i) + 1; // plus terminal NULL
839 win_data->append_one(s);
840 memcpy(win_data->last(), icu_data->dataOf(i), sizeof(WCHAR) * s);
841
842 // Win key
843 s = LCMapStringW(win_langid, LCMAP_SORTKEY, win_data->dataOf(i), win_data->lengthOf(i), NULL,0);
844 if (s == 0) {status = U_INVALID_FORMAT_ERROR;return;}
845 win_key->append_one(s);
846 t = LCMapStringW(win_langid, LCMAP_SORTKEY, win_data->dataOf(i), win_data->lengthOf(i), (WCHAR *)(win_key->last()),s);
847 if (t != s) {status = U_INVALID_FORMAT_ERROR;return;}
848 #endif
849 };
850
851 // append_one() will make points shifting, should not merge following code into previous iteration
852 for (int i=0; i < count; i++) {
853 rnd_index[i].icu_key = icu_key->dataOf(i);
854 rnd_index[i].icu_data = icu_data->dataOf(i);
855 rnd_index[i].icu_data_len = icu_data->lengthOf(i);
856 rnd_index[i].posix_key = posix_key->last();
857 rnd_index[i].posix_data = posix_data->dataOf(i);
858 rnd_index[i].posix_data_len = posix_data->lengthOf(i);
859 #if U_PLATFORM_HAS_WIN32_API
860 rnd_index[i].win_key = win_key->dataOf(i);
861 rnd_index[i].win_data = win_data->dataOf(i);
862 rnd_index[i].win_data_len = win_data->lengthOf(i);
863 #endif
864 };
865
866 ucnv_close(conv);
867 qsort(rnd_index, count, sizeof(DataIndex), CmdQsort::q_random);
868
869 #define SORT(data, func) \
870 data = new DataIndex[count];\
871 memcpy(data, rnd_index, count * sizeof(DataIndex));\
872 qsort(data, count, sizeof(DataIndex), CmdQsort::func)
873
874 SORT(ord_icu_data, icu_strcoll_len);
875 SORT(ord_icu_key, icu_cmpkey);
876 SORT(ord_posix_data, posix_strcoll_null);
877 SORT(ord_posix_key, posix_cmpkey);
878 #if U_PLATFORM_HAS_WIN32_API
879 SORT(ord_win_data, win_cmp_len);
880 SORT(ord_win_key, win_cmpkey);
881 SORT(ord_win_wcscmp, win_wcscmp);
882 #endif
883 SORT(ord_icu_strcmp, icu_strcmp);
884 SORT(ord_icu_cmpcpo, icu_cmpcpo);
885 }
886 };
887
888
889 int main(int argc, const char *argv[])
890 {
891
892 UErrorCode status = U_ZERO_ERROR;
893 CollPerfTest test(argc, argv, status);
894
895 if (U_FAILURE(status)){
896 printf("The error is %s\n", u_errorName(status));
897 //TODO: print usage here
898 return status;
899 }
900
901 if (test.run() == FALSE){
902 fprintf(stderr, "FAILED: Tests could not be run please check the "
903 "arguments.\n");
904 return -1;
905 }
906 return 0;
907 }
908
mirror of ICU