1 /*
2 **********************************************************************
3 * Copyright (C) 2002-2014, International Business Machines
4 * Corporation and others. All Rights Reserved.
5 **********************************************************************
6 * file name: utrie2perf.cpp
7 * encoding: US-ASCII
8 * tab size: 8 (not used)
9 * indentation:4
10 *
11 * created on: 2008sep07
12 * created by: Markus W. Scherer
13 *
14 * Performance test program for UTrie2.
15 */
16
17 #include <stdio.h>
18 #include <stdlib.h>
19 #include "unicode/uchar.h"
20 #include "unicode/unorm.h"
21 #include "unicode/uperf.h"
22 #include "uoptions.h"
23
24 #if 0
25 // Left over from when icu/branches/markus/utf8 could use both old UTrie
26 // and new UTrie2, switched with #if in unorm.cpp and ubidi_props.c.
27 // Comparative benchmarks were done in that branch on revision r24630
28 // and earlier.
29 U_CAPI void U_EXPORT2
30 unorm_initUTrie2(UErrorCode *pErrorCode);
31
32 U_CAPI void U_EXPORT2
33 ubidi_initUTrie2(UErrorCode *pErrorCode);
34 #endif
35
36 U_NAMESPACE_BEGIN
37
38 class UnicodeSet;
39
40 U_NAMESPACE_END
41
42 // Test object.
43 class UTrie2PerfTest : public UPerfTest {
44 public:
UTrie2PerfTest(int32_t argc,const char * argv[],UErrorCode & status)45 UTrie2PerfTest(int32_t argc, const char *argv[], UErrorCode &status)
46 : UPerfTest(argc, argv, NULL, 0, "", status),
47 utf8(NULL), utf8Length(0), countInputCodePoints(0) {
48 if (U_SUCCESS(status)) {
49 #if 0 // See comment at unorm_initUTrie2() forward declaration.
50 unorm_initUTrie2(&status);
51 ubidi_initUTrie2(&status);
52 #endif
53 int32_t inputLength;
54 UPerfTest::getBuffer(inputLength, status);
55 if(U_SUCCESS(status) && inputLength>0) {
56 countInputCodePoints = u_countChar32(buffer, bufferLen);
57
58 // Preflight the UTF-8 length and allocate utf8.
59 u_strToUTF8(NULL, 0, &utf8Length, buffer, bufferLen, &status);
60 if(status==U_BUFFER_OVERFLOW_ERROR) {
61 utf8=(char *)malloc(utf8Length);
62 if(utf8!=NULL) {
63 status=U_ZERO_ERROR;
64 u_strToUTF8(utf8, utf8Length, NULL, buffer, bufferLen, &status);
65 } else {
66 status=U_MEMORY_ALLOCATION_ERROR;
67 }
68 }
69
70 if(verbose) {
71 printf("code points:%ld len16:%ld len8:%ld "
72 "B/cp:%.3g\n",
73 (long)countInputCodePoints, (long)bufferLen, (long)utf8Length,
74 (double)utf8Length/countInputCodePoints);
75 }
76 }
77 }
78 }
79
80 virtual UPerfFunction* runIndexedTest(int32_t index, UBool exec, const char* &name, char* par = NULL);
81
getBuffer() const82 const UChar *getBuffer() const { return buffer; }
getBufferLen() const83 int32_t getBufferLen() const { return bufferLen; }
84
85 char *utf8;
86 int32_t utf8Length;
87
88 // Number of code points in the input text.
89 int32_t countInputCodePoints;
90 };
91
92 // Performance test function object.
93 class Command : public UPerfFunction {
94 protected:
Command(const UTrie2PerfTest & testcase)95 Command(const UTrie2PerfTest &testcase) : testcase(testcase) {}
96
97 public:
~Command()98 virtual ~Command() {}
99
100 // virtual void call(UErrorCode* pErrorCode) { ... }
101
getOperationsPerIteration()102 virtual long getOperationsPerIteration() {
103 // Number of code points tested.
104 return testcase.countInputCodePoints;
105 }
106
107 // virtual long getEventsPerIteration();
108
109 const UTrie2PerfTest &testcase;
110 UNormalizationCheckResult qcResult;
111 };
112
113 class CheckFCD : public Command {
114 protected:
CheckFCD(const UTrie2PerfTest & testcase)115 CheckFCD(const UTrie2PerfTest &testcase) : Command(testcase) {}
116 public:
get(const UTrie2PerfTest & testcase)117 static UPerfFunction* get(const UTrie2PerfTest &testcase) {
118 return new CheckFCD(testcase);
119 }
call(UErrorCode * pErrorCode)120 virtual void call(UErrorCode* pErrorCode) {
121 UErrorCode errorCode=U_ZERO_ERROR;
122 qcResult=unorm_quickCheck(testcase.getBuffer(), testcase.getBufferLen(),
123 UNORM_FCD, &errorCode);
124 if(U_FAILURE(errorCode)) {
125 fprintf(stderr, "error: unorm_quickCheck(UNORM_FCD) failed: %s\n",
126 u_errorName(errorCode));
127 }
128 }
129 };
130
131 #if 0 // See comment at unorm_initUTrie2() forward declaration.
132
133 class CheckFCDAlwaysGet : public Command {
134 protected:
135 CheckFCDAlwaysGet(const UTrie2PerfTest &testcase) : Command(testcase) {}
136 public:
137 static UPerfFunction* get(const UTrie2PerfTest &testcase) {
138 return new CheckFCDAlwaysGet(testcase);
139 }
140 virtual void call(UErrorCode* pErrorCode) {
141 UErrorCode errorCode=U_ZERO_ERROR;
142 qcResult=unorm_quickCheck(testcase.getBuffer(), testcase.getBufferLen(),
143 UNORM_FCD_ALWAYS_GET, &errorCode);
144 if(U_FAILURE(errorCode)) {
145 fprintf(stderr, "error: unorm_quickCheck(UNORM_FCD) failed: %s\n",
146 u_errorName(errorCode));
147 }
148 }
149 };
150
151 U_CAPI UBool U_EXPORT2
152 unorm_checkFCDUTF8(const uint8_t *src, int32_t srcLength, const UnicodeSet *nx);
153
154 class CheckFCDUTF8 : public Command {
155 protected:
156 CheckFCDUTF8(const UTrie2PerfTest &testcase) : Command(testcase) {}
157 public:
158 static UPerfFunction* get(const UTrie2PerfTest &testcase) {
159 return new CheckFCDUTF8(testcase);
160 }
161 virtual void call(UErrorCode* pErrorCode) {
162 UBool isFCD=unorm_checkFCDUTF8((const uint8_t *)testcase.utf8, testcase.utf8Length, NULL);
163 if(isFCD>1) {
164 fprintf(stderr, "error: bogus result from unorm_checkFCDUTF8()\n");
165 }
166 }
167 };
168
169 #endif
170
171 class ToNFC : public Command {
172 protected:
ToNFC(const UTrie2PerfTest & testcase)173 ToNFC(const UTrie2PerfTest &testcase) : Command(testcase) {
174 UErrorCode errorCode=U_ZERO_ERROR;
175 destCapacity=unorm_normalize(testcase.getBuffer(), testcase.getBufferLen(),
176 UNORM_NFC, 0,
177 NULL, 0,
178 &errorCode);
179 dest=new UChar[destCapacity];
180 }
~ToNFC()181 ~ToNFC() {
182 delete [] dest;
183 }
184 public:
get(const UTrie2PerfTest & testcase)185 static UPerfFunction* get(const UTrie2PerfTest &testcase) {
186 return new ToNFC(testcase);
187 }
call(UErrorCode * pErrorCode)188 virtual void call(UErrorCode* pErrorCode) {
189 UErrorCode errorCode=U_ZERO_ERROR;
190 int32_t destLength=unorm_normalize(testcase.getBuffer(), testcase.getBufferLen(),
191 UNORM_NFC, 0,
192 dest, destCapacity,
193 &errorCode);
194 if(U_FAILURE(errorCode) || destLength!=destCapacity) {
195 fprintf(stderr, "error: unorm_normalize(UNORM_NFC) failed: %s\n",
196 u_errorName(errorCode));
197 }
198 }
199
200 private:
201 UChar *dest;
202 int32_t destCapacity;
203 };
204
205 class GetBiDiClass : public Command {
206 protected:
GetBiDiClass(const UTrie2PerfTest & testcase)207 GetBiDiClass(const UTrie2PerfTest &testcase) : Command(testcase) {}
208 public:
get(const UTrie2PerfTest & testcase)209 static UPerfFunction* get(const UTrie2PerfTest &testcase) {
210 return new GetBiDiClass(testcase);
211 }
call(UErrorCode * pErrorCode)212 virtual void call(UErrorCode* pErrorCode) {
213 const UChar *buffer=testcase.getBuffer();
214 int32_t length=testcase.getBufferLen();
215 UChar32 c;
216 int32_t i;
217 uint32_t bitSet=0;
218 for(i=0; i<length;) {
219 U16_NEXT(buffer, i, length, c);
220 bitSet|=(uint32_t)1<<u_charDirection(c);
221 }
222 if(length>0 && bitSet==0) {
223 fprintf(stderr, "error: GetBiDiClass() did not collect bits\n");
224 }
225 }
226 };
227
runIndexedTest(int32_t index,UBool exec,const char * & name,char * par)228 UPerfFunction* UTrie2PerfTest::runIndexedTest(int32_t index, UBool exec, const char* &name, char* par) {
229 switch (index) {
230 case 0: name = "CheckFCD"; if (exec) return CheckFCD::get(*this); break;
231 case 1: name = "ToNFC"; if (exec) return ToNFC::get(*this); break;
232 case 2: name = "GetBiDiClass"; if (exec) return GetBiDiClass::get(*this); break;
233 #if 0 // See comment at unorm_initUTrie2() forward declaration.
234 case 3: name = "CheckFCDAlwaysGet"; if (exec) return CheckFCDAlwaysGet::get(*this); break;
235 case 4: name = "CheckFCDUTF8"; if (exec) return CheckFCDUTF8::get(*this); break;
236 #endif
237 default: name = ""; break;
238 }
239 return NULL;
240 }
241
main(int argc,const char * argv[])242 int main(int argc, const char *argv[]) {
243 UErrorCode status = U_ZERO_ERROR;
244 UTrie2PerfTest test(argc, argv, status);
245
246 if (U_FAILURE(status)){
247 printf("The error is %s\n", u_errorName(status));
248 test.usage();
249 return status;
250 }
251
252 if (test.run() == FALSE){
253 fprintf(stderr, "FAILED: Tests could not be run please check the "
254 "arguments.\n");
255 return -1;
256 }
257
258 return 0;
259 }
260