| /******************************************************************** |
| * COPYRIGHT: |
| * Copyright (C) 2001-2006 IBM, Inc. All Rights Reserved. |
| * |
| ********************************************************************/ |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <locale.h> |
| #include <limits.h> |
| #include <string.h> |
| #include "unicode/uperf.h" |
| #include "uoptions.h" |
| #include "unicode/coll.h" |
| #include <unicode/ucoleitr.h> |
| |
| |
| |
| /* To store an array of string<UNIT> in continue space. |
| Since string<UNIT> itself is treated as an array of UNIT, this |
| class will ease our memory management for an array of string<UNIT>. |
| */ |
| |
| //template<typename UNIT> |
| #define COMPATCT_ARRAY(CompactArrays, UNIT) \ |
| struct CompactArrays{\ |
| CompactArrays(const CompactArrays & );\ |
| CompactArrays & operator=(const CompactArrays & );\ |
| int32_t count;/*total number of the strings*/ \ |
| int32_t * index;/*relative offset in data*/ \ |
| UNIT * data; /*the real space to hold strings*/ \ |
| \ |
| ~CompactArrays(){free(index);free(data);} \ |
| CompactArrays():data(NULL), index(NULL), count(0){ \ |
| index = (int32_t *) realloc(index, sizeof(int32_t)); \ |
| index[0] = 0; \ |
| } \ |
| void append_one(int32_t theLen){ /*include terminal NULL*/ \ |
| count++; \ |
| index = (int32_t *) realloc(index, sizeof(int32_t) * (count + 1)); \ |
| index[count] = index[count - 1] + theLen; \ |
| data = (UNIT *) realloc(data, sizeof(UNIT) * index[count]); \ |
| } \ |
| UNIT * last(){return data + index[count - 1];} \ |
| UNIT * dataOf(int32_t i){return data + index[i];} \ |
| int32_t lengthOf(int i){return index[i+1] - index[i] - 1; } /*exclude terminating NULL*/ \ |
| }; |
| |
| //typedef CompactArrays<UChar> CA_uchar; |
| //typedef CompactArrays<char> CA_char; |
| //typedef CompactArrays<uint8_t> CA_uint8; |
| //typedef CompactArrays<WCHAR> CA_win_wchar; |
| |
| COMPATCT_ARRAY(CA_uchar, UChar) |
| COMPATCT_ARRAY(CA_char, char) |
| COMPATCT_ARRAY(CA_uint8, uint8_t) |
| COMPATCT_ARRAY(CA_win_wchar, WCHAR) |
| |
| |
| struct DataIndex { |
| static DWORD win_langid; // for qsort callback function |
| static UCollator * col; // for qsort callback function |
| uint8_t * icu_key; |
| UChar * icu_data; |
| int32_t icu_data_len; |
| char* posix_key; |
| char* posix_data; |
| int32_t posix_data_len; |
| char* win_key; |
| WCHAR * win_data; |
| int32_t win_data_len; |
| }; |
| DWORD DataIndex::win_langid; |
| UCollator * DataIndex::col; |
| |
| |
| |
| class CmdKeyGen : public UPerfFunction { |
| typedef void (CmdKeyGen::* Func)(int32_t); |
| enum{MAX_KEY_LENGTH = 5000}; |
| UCollator * col; |
| DWORD win_langid; |
| int32_t count; |
| DataIndex * data; |
| Func fn; |
| |
| union { // to save sapce |
| uint8_t icu_key[MAX_KEY_LENGTH]; |
| char posix_key[MAX_KEY_LENGTH]; |
| WCHAR win_key[MAX_KEY_LENGTH]; |
| }; |
| public: |
| CmdKeyGen(UErrorCode, UCollator * col,DWORD win_langid, int32_t count, DataIndex * data,Func fn,int32_t) |
| :col(col),win_langid(win_langid), count(count), data(data), fn(fn){} |
| |
| virtual long getOperationsPerIteration(){return count;} |
| |
| virtual void call(UErrorCode* status){ |
| for(int32_t i = 0; i< count; i++){ |
| (this->*fn)(i); |
| } |
| } |
| |
| void icu_key_null(int32_t i){ |
| ucol_getSortKey(col, data[i].icu_data, -1, icu_key, MAX_KEY_LENGTH); |
| } |
| |
| void icu_key_len(int32_t i){ |
| ucol_getSortKey(col, data[i].icu_data, data[i].icu_data_len, icu_key, MAX_KEY_LENGTH); |
| } |
| |
| // pre-generated in CollPerfTest::prepareData(), need not to check error here |
| void win_key_null(int32_t i){ |
| //LCMAP_SORTsk 0x00000400 // WC sort sk (normalize) |
| LCMapStringW(win_langid, LCMAP_SORTKEY, data[i].win_data, -1, win_key, MAX_KEY_LENGTH); |
| } |
| |
| void win_key_len(int32_t i){ |
| LCMapStringW(win_langid, LCMAP_SORTKEY, data[i].win_data, data[i].win_data_len, win_key, MAX_KEY_LENGTH); |
| } |
| |
| void posix_key_null(int32_t i){ |
| strxfrm(posix_key, data[i].posix_data, MAX_KEY_LENGTH); |
| } |
| }; |
| |
| |
| class CmdIter : public UPerfFunction { |
| typedef void (CmdIter::* Func)(UErrorCode* , int32_t ); |
| int32_t count; |
| CA_uchar * data; |
| Func fn; |
| UCollationElements *iter; |
| int32_t exec_count; |
| public: |
| CmdIter(UErrorCode & status, UCollator * col, int32_t count, CA_uchar *data, Func fn, int32_t,int32_t) |
| :count(count), data(data), fn(fn){ |
| exec_count = 0; |
| UChar dummytext[] = {0, 0}; |
| iter = ucol_openElements(col, NULL, 0, &status); |
| ucol_setText(iter, dummytext, 1, &status); |
| } |
| ~CmdIter(){ |
| ucol_closeElements(iter); |
| } |
| |
| virtual long getOperationsPerIteration(){return exec_count ? exec_count : 1;} |
| |
| virtual void call(UErrorCode* status){ |
| exec_count = 0; |
| for(int32_t i = 0; i< count; i++){ |
| (this->*fn)(status, i); |
| } |
| } |
| |
| void icu_forward_null(UErrorCode* status, int32_t i){ |
| ucol_setText(iter, data->dataOf(i), -1, status); |
| while (ucol_next(iter, status) != UCOL_NULLORDER) exec_count++; |
| } |
| |
| void icu_forward_len(UErrorCode* status, int32_t i){ |
| ucol_setText(iter, data->dataOf(i), data->lengthOf(i) , status); |
| while (ucol_next(iter, status) != UCOL_NULLORDER) exec_count++; |
| } |
| |
| void icu_backward_null(UErrorCode* status, int32_t i){ |
| ucol_setText(iter, data->dataOf(i), -1, status); |
| while (ucol_previous(iter, status) != UCOL_NULLORDER) exec_count++; |
| } |
| |
| void icu_backward_len(UErrorCode* status, int32_t i){ |
| ucol_setText(iter, data->dataOf(i), data->lengthOf(i) , status); |
| while (ucol_previous(iter, status) != UCOL_NULLORDER) exec_count++; |
| } |
| }; |
| |
| class CmdIterAll : public UPerfFunction { |
| typedef void (CmdIterAll::* Func)(UErrorCode* status); |
| int32_t count; |
| UChar * data; |
| Func fn; |
| UCollationElements *iter; |
| int32_t exec_count; |
| |
| public: |
| enum CALL {forward_null, forward_len, backward_null, backward_len}; |
| |
| ~CmdIterAll(){ |
| ucol_closeElements(iter); |
| } |
| CmdIterAll(UErrorCode & status, UCollator * col, int32_t count, UChar * data, CALL call,int32_t,int32_t) |
| :count(count),data(data) |
| { |
| exec_count = 0; |
| if (call == forward_null || call == backward_null) { |
| iter = ucol_openElements(col, data, -1, &status); |
| } else { |
| iter = ucol_openElements(col, data, count, &status); |
| } |
| |
| if (call == forward_null || call == forward_len){ |
| fn = &CmdIterAll::icu_forward_all; |
| } else { |
| fn = &CmdIterAll::icu_backward_all; |
| } |
| } |
| virtual long getOperationsPerIteration(){return exec_count ? exec_count : 1;} |
| |
| virtual void call(UErrorCode* status){ |
| (this->*fn)(status); |
| } |
| |
| void icu_forward_all(UErrorCode* status){ |
| int strlen = count - 5; |
| int count5 = 5; |
| int strindex = 0; |
| ucol_setOffset(iter, strindex, status); |
| while (TRUE) { |
| if (ucol_next(iter, status) == UCOL_NULLORDER) { |
| break; |
| } |
| exec_count++; |
| count5 --; |
| if (count5 == 0) { |
| strindex += 10; |
| if (strindex > strlen) { |
| break; |
| } |
| ucol_setOffset(iter, strindex, status); |
| count5 = 5; |
| } |
| } |
| } |
| |
| void icu_backward_all(UErrorCode* status){ |
| int strlen = count; |
| int count5 = 5; |
| int strindex = 5; |
| ucol_setOffset(iter, strindex, status); |
| while (TRUE) { |
| if (ucol_previous(iter, status) == UCOL_NULLORDER) { |
| break; |
| } |
| exec_count++; |
| count5 --; |
| if (count5 == 0) { |
| strindex += 10; |
| if (strindex > strlen) { |
| break; |
| } |
| ucol_setOffset(iter, strindex, status); |
| count5 = 5; |
| } |
| } |
| } |
| |
| }; |
| |
| struct CmdQsort : public UPerfFunction{ |
| |
| static int q_random(const void * a, const void * b){ |
| uint8_t * key_a = ((DataIndex *)a)->icu_key; |
| uint8_t * key_b = ((DataIndex *)b)->icu_key; |
| |
| int val_a = 0; |
| int val_b = 0; |
| while (*key_a != 0) {val_a += val_a*37 + *key_a++;} |
| while (*key_b != 0) {val_b += val_b*37 + *key_b++;} |
| return val_a - val_b; |
| } |
| |
| #define QCAST() \ |
| DataIndex * da = (DataIndex *) a; \ |
| DataIndex * db = (DataIndex *) b; \ |
| ++exec_count |
| |
| static int icu_strcoll_null(const void *a, const void *b){ |
| QCAST(); |
| return ucol_strcoll(da->col, da->icu_data, -1, db->icu_data, -1) - UCOL_EQUAL; |
| } |
| |
| static int icu_strcoll_len(const void *a, const void *b){ |
| QCAST(); |
| return ucol_strcoll(da->col, da->icu_data, da->icu_data_len, db->icu_data, db->icu_data_len) - UCOL_EQUAL; |
| } |
| |
| static int icu_cmpkey (const void *a, const void *b){ |
| QCAST(); |
| return strcmp((char *) da->icu_key, (char *) db->icu_key); |
| } |
| |
| static int win_cmp_null(const void *a, const void *b) { |
| QCAST(); |
| //CSTR_LESS_THAN 1 |
| //CSTR_EQUAL 2 |
| //CSTR_GREATER_THAN 3 |
| int t = CompareStringW(da->win_langid, 0, da->win_data, -1, db->win_data, -1); |
| if (t == 0){ |
| fprintf(stderr, "CompareStringW error, error number %x\n", GetLastError()); |
| exit(-1); |
| } else{ |
| return t - CSTR_EQUAL; |
| } |
| } |
| |
| static int win_cmp_len(const void *a, const void *b) { |
| QCAST(); |
| int t = CompareStringW(da->win_langid, 0, da->win_data, da->win_data_len, db->win_data, db->win_data_len); |
| if (t == 0){ |
| fprintf(stderr, "CompareStringW error, error number %x\n", GetLastError()); |
| exit(-1); |
| } else{ |
| return t - CSTR_EQUAL; |
| } |
| } |
| |
| #define QFUNC(name, func, data) \ |
| static int name (const void *a, const void *b){ \ |
| QCAST(); \ |
| return func(da->data, db->data); \ |
| } |
| |
| QFUNC(posix_strcoll_null, strcoll, posix_data) |
| QFUNC(posix_cmpkey, strcmp, posix_key) |
| QFUNC(win_cmpkey, strcmp, win_key) |
| QFUNC(win_wcscmp, wcscmp, win_data) |
| QFUNC(icu_strcmp, u_strcmp, icu_data) |
| QFUNC(icu_cmpcpo, u_strcmpCodePointOrder, icu_data) |
| |
| private: |
| static int32_t exec_count; // potential muilt-thread problem |
| |
| typedef int (* Func)(const void *, const void *); |
| |
| Func fn; |
| void * base; //Start of target array. |
| int32_t num; //Array size in elements. |
| int32_t width; //Element size in bytes. |
| |
| void * backup; //copy source of base |
| public: |
| CmdQsort(UErrorCode & status,void *theBase, int32_t num, int32_t width, Func fn, int32_t,int32_t) |
| :backup(theBase),num(num),width(width),fn(fn){ |
| base = malloc(num * width); |
| time_empty(100, &status); // warm memory/cache |
| } |
| |
| ~CmdQsort(){ |
| free(base); |
| } |
| |
| void empty_call(){ |
| exec_count = 0; |
| memcpy(base, backup, num * width); |
| } |
| |
| double time_empty(int32_t n, UErrorCode* status) { |
| UTimer start, stop; |
| utimer_getTime(&start); |
| while (n-- > 0) { |
| empty_call(); |
| } |
| utimer_getTime(&stop); |
| return utimer_getDeltaSeconds(&start,&stop); // ms |
| } |
| |
| virtual void call(UErrorCode* status){ |
| exec_count = 0; |
| memcpy(base, backup, num * width); |
| qsort(base, num, width, fn); |
| } |
| virtual double time(int32_t n, UErrorCode* status) { |
| double t1 = time_empty(n,status); |
| double t2 = UPerfFunction::time(n, status); |
| return t2-t1;// < 0 ? t2 : t2-t1; |
| } |
| |
| virtual long getOperationsPerIteration(){ return exec_count?exec_count:1;} |
| }; |
| int32_t CmdQsort::exec_count; |
| |
| |
| class CmdBinSearch : public UPerfFunction{ |
| public: |
| typedef int (CmdBinSearch::* Func)(int, int); |
| |
| UCollator * col; |
| DWORD win_langid; |
| int32_t count; |
| DataIndex * rnd; |
| DataIndex * ord; |
| Func fn; |
| int32_t exec_count; |
| |
| CmdBinSearch(UErrorCode, UCollator * col,DWORD win_langid,int32_t count,DataIndex * rnd,DataIndex * ord,Func fn) |
| :col(col),win_langid(win_langid), count(count), rnd(rnd), ord(ord), fn(fn),exec_count(0){} |
| |
| |
| virtual void call(UErrorCode* status){ |
| exec_count = 0; |
| for(int32_t i = 0; i< count; i++){ // search all data |
| binary_search(i); |
| } |
| } |
| virtual long getOperationsPerIteration(){ return exec_count?exec_count:1;} |
| |
| void binary_search(int32_t random) { |
| int low = 0; |
| int high = count - 1; |
| int guess; |
| int last_guess = -1; |
| int r; |
| while (TRUE) { |
| guess = (high + low)/2; |
| if (last_guess == guess) break; // nothing to search |
| |
| r = (this->*fn)(random, guess); |
| exec_count++; |
| |
| if (r == 0) |
| return; // found, search end. |
| if (r < 0) { |
| high = guess; |
| } else { |
| low = guess; |
| } |
| last_guess = guess; |
| } |
| } |
| |
| int icu_strcoll_null(int32_t i, int32_t j){ |
| return ucol_strcoll(col, rnd[i].icu_data, -1, ord[j].icu_data,-1); |
| } |
| |
| int icu_strcoll_len(int32_t i, int32_t j){ |
| return ucol_strcoll(col, rnd[i].icu_data, rnd[i].icu_data_len, ord[j].icu_data, ord[j].icu_data_len); |
| } |
| |
| int icu_cmpkey(int32_t i, int32_t j) { |
| return strcmp( (char *) rnd[i].icu_key, (char *) ord[j].icu_key ); |
| } |
| |
| int win_cmp_null(int32_t i, int32_t j) { |
| int t = CompareStringW(win_langid, 0, rnd[i].win_data, -1, ord[j].win_data, -1); |
| if (t == 0){ |
| fprintf(stderr, "CompareStringW error, error number %x\n", GetLastError()); |
| exit(-1); |
| } else{ |
| return t - CSTR_EQUAL; |
| } |
| } |
| |
| int win_cmp_len(int32_t i, int32_t j) { |
| int t = CompareStringW(win_langid, 0, rnd[i].win_data, rnd[i].win_data_len, ord[j].win_data, ord[j].win_data_len); |
| if (t == 0){ |
| fprintf(stderr, "CompareStringW error, error number %x\n", GetLastError()); |
| exit(-1); |
| } else{ |
| return t - CSTR_EQUAL; |
| } |
| } |
| |
| #define BFUNC(name, func, data) \ |
| int name(int32_t i, int32_t j) { \ |
| return func(rnd[i].data, ord[j].data); \ |
| } |
| |
| BFUNC(posix_strcoll_null, strcoll, posix_data) |
| BFUNC(posix_cmpkey, strcmp, posix_key) |
| BFUNC(win_cmpkey, strcmp, win_key) |
| BFUNC(win_wcscmp, wcscmp, win_data) |
| BFUNC(icu_strcmp, u_strcmp, icu_data) |
| BFUNC(icu_cmpcpo, u_strcmpCodePointOrder, icu_data) |
| }; |
| |
| class CollPerfTest : public UPerfTest { |
| public: |
| UCollator * col; |
| DWORD win_langid; |
| |
| UChar * icu_data_all; |
| int32_t icu_data_all_len; |
| |
| int32_t count; |
| CA_uchar * icu_data; |
| CA_uint8 * icu_key; |
| CA_char * posix_data; |
| CA_char * posix_key; |
| CA_win_wchar * win_data; |
| CA_char * win_key; |
| |
| DataIndex * rnd_index; // random by icu key |
| DataIndex * ord_win_data; |
| DataIndex * ord_win_key; |
| DataIndex * ord_posix_data; |
| DataIndex * ord_posix_key; |
| DataIndex * ord_icu_data; |
| DataIndex * ord_icu_key; |
| DataIndex * ord_win_wcscmp; |
| DataIndex * ord_icu_strcmp; |
| DataIndex * ord_icu_cmpcpo; |
| |
| virtual ~CollPerfTest(){ |
| ucol_close(col); |
| delete [] icu_data_all; |
| delete icu_data; |
| delete icu_key; |
| delete posix_data; |
| delete posix_key; |
| delete win_data; |
| delete win_key; |
| delete[] rnd_index; |
| delete[] ord_win_data; |
| delete[] ord_win_key; |
| delete[] ord_posix_data; |
| delete[] ord_posix_key; |
| delete[] ord_icu_data; |
| delete[] ord_icu_key; |
| delete[] ord_win_wcscmp; |
| delete[] ord_icu_strcmp; |
| delete[] ord_icu_cmpcpo; |
| } |
| |
| CollPerfTest(int32_t argc, const char* argv[], UErrorCode& status):UPerfTest(argc, argv, status){ |
| col = NULL; |
| icu_data_all = NULL; |
| icu_data = NULL; |
| icu_key = NULL; |
| posix_data = NULL; |
| posix_key = NULL; |
| win_data =NULL; |
| win_key = NULL; |
| |
| rnd_index = NULL; |
| ord_win_data= NULL; |
| ord_win_key= NULL; |
| ord_posix_data= NULL; |
| ord_posix_key= NULL; |
| ord_icu_data= NULL; |
| ord_icu_key= NULL; |
| ord_win_wcscmp = NULL; |
| ord_icu_strcmp = NULL; |
| ord_icu_cmpcpo = NULL; |
| |
| if (U_FAILURE(status)){ |
| return; |
| } |
| |
| // Parse additional arguments |
| |
| UOption options[] = { |
| UOPTION_DEF("langid", 'i', UOPT_REQUIRES_ARG), // Windows Language ID number. |
| UOPTION_DEF("rulefile", 'r', UOPT_REQUIRES_ARG), // --rulefile <filename> |
| // Collation related arguments. All are optional. |
| // To simplify parsing, two choice arguments are disigned as NO_ARG. |
| // The default value is UPPER word in the comment |
| UOPTION_DEF("c_french", 'f', UOPT_NO_ARG), // --french <on | OFF> |
| UOPTION_DEF("c_alternate", 'a', UOPT_NO_ARG), // --alternate <NON_IGNORE | shifted> |
| UOPTION_DEF("c_casefirst", 'c', UOPT_REQUIRES_ARG), // --casefirst <lower | upper | OFF> |
| UOPTION_DEF("c_caselevel", 'l', UOPT_NO_ARG), // --caselevel <on | OFF> |
| UOPTION_DEF("c_normal", 'n', UOPT_NO_ARG), // --normal <on | OFF> |
| UOPTION_DEF("c_strength", 's', UOPT_REQUIRES_ARG), // --strength <1-5> |
| }; |
| int32_t opt_len = (sizeof(options)/sizeof(options[0])); |
| enum {i, r,f,a,c,l,n,s}; // The buffer between the option items' order and their references |
| |
| _remainingArgc = u_parseArgs(_remainingArgc, (char**)argv, opt_len, options); |
| |
| if (_remainingArgc < 0){ |
| status = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| |
| if (locale == NULL){ |
| locale = "en_US"; // set default locale |
| } |
| |
| //#ifdef U_WINDOWS |
| if (options[i].doesOccur) { |
| char *endp; |
| int tmp = strtol(options[i].value, &endp, 0); |
| if (endp == options[i].value) { |
| status = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| win_langid = MAKELCID(tmp, SORT_DEFAULT); |
| } else { |
| win_langid = uloc_getLCID(locale); |
| } |
| //#endif |
| |
| // Set up an ICU collator |
| if (options[r].doesOccur) { |
| // TODO: implement it |
| } else { |
| col = ucol_open(locale, &status); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| } |
| |
| if (options[f].doesOccur) { |
| ucol_setAttribute(col, UCOL_FRENCH_COLLATION, UCOL_ON, &status); |
| } else { |
| ucol_setAttribute(col, UCOL_FRENCH_COLLATION, UCOL_OFF, &status); |
| } |
| |
| if (options[a].doesOccur) { |
| ucol_setAttribute(col, UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, &status); |
| } |
| |
| if (options[c].doesOccur) { // strcmp() has i18n encoding problem |
| if (strcmp("lower", options[c].value) == 0){ |
| ucol_setAttribute(col, UCOL_CASE_FIRST, UCOL_LOWER_FIRST, &status); |
| } else if (strcmp("upper", options[c].value) == 0) { |
| ucol_setAttribute(col, UCOL_CASE_FIRST, UCOL_UPPER_FIRST, &status); |
| } else { |
| status = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| } |
| |
| if (options[l].doesOccur){ |
| ucol_setAttribute(col, UCOL_CASE_LEVEL, UCOL_ON, &status); |
| } |
| |
| if (options[n].doesOccur){ |
| ucol_setAttribute(col, UCOL_NORMALIZATION_MODE, UCOL_ON, &status); |
| } |
| |
| if (options[s].doesOccur) { |
| char *endp; |
| int tmp = strtol(options[l].value, &endp, 0); |
| if (endp == options[l].value) { |
| status = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| switch (tmp) { |
| case 1: ucol_setAttribute(col, UCOL_STRENGTH, UCOL_PRIMARY, &status); break; |
| case 2: ucol_setAttribute(col, UCOL_STRENGTH, UCOL_SECONDARY, &status); break; |
| case 3: ucol_setAttribute(col, UCOL_STRENGTH, UCOL_TERTIARY, &status); break; |
| case 4: ucol_setAttribute(col, UCOL_STRENGTH, UCOL_QUATERNARY, &status); break; |
| case 5: ucol_setAttribute(col, UCOL_STRENGTH, UCOL_IDENTICAL, &status); break; |
| default: status = U_ILLEGAL_ARGUMENT_ERROR; return; |
| } |
| } |
| prepareData(status); |
| } |
| |
| //to avoid use the annoying 'id' in TESTCASE(id,test) macro or the like |
| #define TEST(testname, classname, arg1, arg2, arg3, arg4, arg5, arg6) \ |
| if(temp == index) {\ |
| name = #testname;\ |
| if (exec) {\ |
| UErrorCode status = U_ZERO_ERROR;\ |
| UPerfFunction * t = new classname(status,arg1, arg2, arg3, arg4, arg5, arg6);\ |
| if (U_FAILURE(status)) {\ |
| delete t;\ |
| return NULL;\ |
| } else {\ |
| return t;\ |
| }\ |
| } else {\ |
| return NULL;\ |
| }\ |
| }\ |
| temp++\ |
| |
| |
| virtual UPerfFunction* runIndexedTest( /*[in]*/int32_t index, /*[in]*/UBool exec, /*[out]*/const char* &name, /*[in]*/ char* par = NULL ){ |
| int temp = 0; |
| |
| #define TEST_KEYGEN(testname, func)\ |
| TEST(testname, CmdKeyGen, col, win_langid, count, rnd_index, &CmdKeyGen::func, 0) |
| TEST_KEYGEN(TestIcu_KeyGen_null, icu_key_null); |
| TEST_KEYGEN(TestIcu_KeyGen_len, icu_key_len); |
| TEST_KEYGEN(TestPosix_KeyGen_null, posix_key_null); |
| TEST_KEYGEN(TestWin_KeyGen_null, win_key_null); |
| TEST_KEYGEN(TestWin_KeyGen_len, win_key_len); |
| |
| #define TEST_ITER(testname, func)\ |
| TEST(testname, CmdIter, col, count, icu_data, &CmdIter::func,0,0) |
| TEST_ITER(TestIcu_ForwardIter_null, icu_forward_null); |
| TEST_ITER(TestIcu_ForwardIter_len, icu_forward_len); |
| TEST_ITER(TestIcu_BackwardIter_null, icu_backward_null); |
| TEST_ITER(TestIcu_BackwardIter_len, icu_backward_len); |
| |
| #define TEST_ITER_ALL(testname, func)\ |
| TEST(testname, CmdIterAll, col, icu_data_all_len, icu_data_all, CmdIterAll::func,0,0) |
| TEST_ITER_ALL(TestIcu_ForwardIter_all_null, forward_null); |
| TEST_ITER_ALL(TestIcu_ForwardIter_all_len, forward_len); |
| TEST_ITER_ALL(TestIcu_BackwardIter_all_null, backward_null); |
| TEST_ITER_ALL(TestIcu_BackwardIter_all_len, backward_len); |
| |
| #define TEST_QSORT(testname, func)\ |
| TEST(testname, CmdQsort, rnd_index, count, sizeof(DataIndex), CmdQsort::func,0,0) |
| TEST_QSORT(TestIcu_qsort_strcoll_null, icu_strcoll_null); |
| TEST_QSORT(TestIcu_qsort_strcoll_len, icu_strcoll_len); |
| TEST_QSORT(TestIcu_qsort_usekey, icu_cmpkey); |
| TEST_QSORT(TestPosix_qsort_strcoll_null, posix_strcoll_null); |
| TEST_QSORT(TestPosix_qsort_usekey, posix_cmpkey); |
| TEST_QSORT(TestWin_qsort_CompareStringW_null, win_cmp_null); |
| TEST_QSORT(TestWin_qsort_CompareStringW_len, win_cmp_len); |
| TEST_QSORT(TestWin_qsort_usekey, win_cmpkey); |
| |
| #define TEST_BIN(testname, func)\ |
| TEST(testname, CmdBinSearch, col, win_langid, count, rnd_index, ord_icu_key, &CmdBinSearch::func) |
| TEST_BIN(TestIcu_BinarySearch_strcoll_null, icu_strcoll_null); |
| TEST_BIN(TestIcu_BinarySearch_strcoll_len, icu_strcoll_len); |
| TEST_BIN(TestIcu_BinarySearch_usekey, icu_cmpkey); |
| TEST_BIN(TestIcu_BinarySearch_strcmp, icu_strcmp); |
| TEST_BIN(TestIcu_BinarySearch_cmpCPO, icu_cmpcpo); |
| TEST_BIN(TestPosix_BinarySearch_strcoll_null, posix_strcoll_null); |
| TEST_BIN(TestPosix_BinarySearch_usekey, posix_cmpkey); |
| TEST_BIN(TestWin_BinarySearch_CompareStringW_null, win_cmp_null); |
| TEST_BIN(TestWin_BinarySearch_CompareStringW_len, win_cmp_len); |
| TEST_BIN(TestWin_BinarySearch_usekey, win_cmpkey); |
| TEST_BIN(TestWin_BinarySearch_wcscmp, win_wcscmp); |
| |
| name=""; |
| return NULL; |
| } |
| |
| |
| |
| void prepareData(UErrorCode& status){ |
| if(U_FAILURE(status)) return; |
| if (icu_data) return; // prepared |
| |
| icu_data = new CA_uchar(); |
| |
| // Following code is borrowed from UPerfTest::getLines(); |
| const UChar* line=NULL; |
| int32_t len =0; |
| for (;;) { |
| line = ucbuf_readline(ucharBuf,&len,&status); |
| if(line == NULL || U_FAILURE(status)){break;} |
| |
| // Refer to the source code of ucbuf_readline() |
| // 1. 'len' includs the line terminal symbols |
| // 2. The length of the line terminal symbols is only one character |
| // 3. The Windows CR LF line terminal symbols will be converted to CR |
| |
| if (len == 1) { |
| continue; //skip empty line |
| } else { |
| icu_data->append_one(len); |
| memcpy(icu_data->last(), line, len * sizeof(UChar)); |
| icu_data->last()[len -1] = NULL; |
| } |
| } |
| if(U_FAILURE(status)) return; |
| |
| // UTF-16 -> UTF-8 conversion. |
| UConverter *conv = ucnv_open("utf-8", &status); // just UTF-8 for now. |
| if (U_FAILURE(status)) return; |
| |
| count = icu_data->count; |
| |
| icu_data_all_len = icu_data->index[count]; // includes all NULLs |
| icu_data_all_len -= count; // excludes all NULLs |
| icu_data_all_len += 1; // the terminal NULL |
| icu_data_all = new UChar[icu_data_all_len]; |
| icu_data_all[icu_data_all_len - 1] = 0; //the terminal NULL |
| |
| icu_key = new CA_uint8; |
| win_data = new CA_win_wchar; |
| win_key = new CA_char; |
| posix_data = new CA_char; |
| posix_key = new CA_char; |
| rnd_index = new DataIndex[count]; |
| DataIndex::win_langid = win_langid; |
| DataIndex::col = col; |
| |
| |
| UChar * p = icu_data_all; |
| int32_t s; |
| int32_t t; |
| for (int i=0; i < count; i++) { |
| // ICU all data |
| s = sizeof(UChar) * icu_data->lengthOf(i); |
| memcpy(p, icu_data->dataOf(i), s); |
| p += icu_data->lengthOf(i); |
| |
| // ICU data |
| |
| // ICU key |
| s = ucol_getSortKey(col, icu_data->dataOf(i), -1,NULL, 0); |
| icu_key->append_one(s); |
| t = ucol_getSortKey(col, icu_data->dataOf(i), -1,icu_key->last(), s); |
| if (t != s) {status = U_INVALID_FORMAT_ERROR;return;} |
| |
| // POSIX data |
| s = ucnv_fromUChars(conv,NULL, 0, icu_data->dataOf(i), icu_data->lengthOf(i), &status); |
| if (status == U_BUFFER_OVERFLOW_ERROR || status == U_ZERO_ERROR){ |
| status = U_ZERO_ERROR; |
| } else { |
| return; |
| } |
| posix_data->append_one(s + 1); // plus terminal NULL |
| t = ucnv_fromUChars(conv,posix_data->last(), s, icu_data->dataOf(i), icu_data->lengthOf(i), &status); |
| if (U_FAILURE(status)) return; |
| if ( t != s){status = U_INVALID_FORMAT_ERROR;return;} |
| posix_data->last()[s] = 0; |
| |
| // POSIX key |
| s = strxfrm(NULL, posix_data->dataOf(i), 0); |
| if (s == INT_MAX){status = U_INVALID_FORMAT_ERROR;return;} |
| posix_key->append_one(s); |
| t = strxfrm(posix_key->last(), posix_data->dataOf(i), s); |
| if (t != s) {status = U_INVALID_FORMAT_ERROR;return;} |
| |
| // Win data |
| s = icu_data->lengthOf(i) + 1; // plus terminal NULL |
| win_data->append_one(s); |
| memcpy(win_data->last(), icu_data->dataOf(i), sizeof(WCHAR) * s); |
| |
| // Win key |
| s = LCMapStringW(win_langid, LCMAP_SORTKEY, win_data->dataOf(i), win_data->lengthOf(i), NULL,0); |
| if (s == 0) {status = U_INVALID_FORMAT_ERROR;return;} |
| win_key->append_one(s); |
| t = LCMapStringW(win_langid, LCMAP_SORTKEY, win_data->dataOf(i), win_data->lengthOf(i), (WCHAR *)(win_key->last()),s); |
| if (t != s) {status = U_INVALID_FORMAT_ERROR;return;} |
| |
| }; |
| |
| // append_one() will make points shifting, should not merge following code into previous iteration |
| for (int i=0; i < count; i++) { |
| rnd_index[i].icu_key = icu_key->dataOf(i); |
| rnd_index[i].icu_data = icu_data->dataOf(i); |
| rnd_index[i].icu_data_len = icu_data->lengthOf(i); |
| rnd_index[i].posix_key = posix_key->last(); |
| rnd_index[i].posix_data = posix_data->dataOf(i); |
| rnd_index[i].posix_data_len = posix_data->lengthOf(i); |
| rnd_index[i].win_key = win_key->dataOf(i); |
| rnd_index[i].win_data = win_data->dataOf(i); |
| rnd_index[i].win_data_len = win_data->lengthOf(i); |
| }; |
| |
| ucnv_close(conv); |
| qsort(rnd_index, count, sizeof(DataIndex), CmdQsort::q_random); |
| |
| #define SORT(data, func) \ |
| data = new DataIndex[count];\ |
| memcpy(data, rnd_index, count * sizeof(DataIndex));\ |
| qsort(data, count, sizeof(DataIndex), CmdQsort::func) |
| |
| SORT(ord_icu_data, icu_strcoll_len); |
| SORT(ord_icu_key, icu_cmpkey); |
| SORT(ord_posix_data, posix_strcoll_null); |
| SORT(ord_posix_key, posix_cmpkey); |
| SORT(ord_win_data, win_cmp_len); |
| SORT(ord_win_key, win_cmpkey); |
| SORT(ord_win_wcscmp, win_wcscmp); |
| SORT(ord_icu_strcmp, icu_strcmp); |
| SORT(ord_icu_cmpcpo, icu_cmpcpo); |
| } |
| }; |
| |
| |
| int main(int argc, const char *argv[]) |
| { |
| |
| UErrorCode status = U_ZERO_ERROR; |
| CollPerfTest test(argc, argv, status); |
| |
| if (U_FAILURE(status)){ |
| printf("The error is %s\n", u_errorName(status)); |
| //TODO: print usage here |
| return status; |
| } |
| |
| if (test.run() == FALSE){ |
| fprintf(stderr, "FAILED: Tests could not be run please check the " |
| "arguments.\n"); |
| return -1; |
| } |
| return 0; |
| } |
| |
