OLD | NEW |
| (Empty) |
1 /* | |
2 ********************************************************************** | |
3 * Copyright (c) 2002-2011, International Business Machines | |
4 * Corporation and others. All Rights Reserved. | |
5 ********************************************************************** | |
6 ********************************************************************** | |
7 */ | |
8 #ifndef _NORMPERF_H | |
9 #define _NORMPERF_H | |
10 | |
11 #include "unicode/unorm.h" | |
12 #include "unicode/ustring.h" | |
13 | |
14 #include "unicode/uperf.h" | |
15 #include <stdlib.h> | |
16 | |
17 // Stubs for Windows API functions when building on UNIXes. | |
18 // | |
19 #if U_PLATFORM_USES_ONLY_WIN32_API | |
20 // do nothing | |
21 #else | |
22 #define _UNICODE | |
23 typedef int DWORD; | |
24 inline int FoldStringW(DWORD dwMapFlags, const UChar* lpSrcStr,int cchSrc, UChar
* lpDestStr,int cchDest); | |
25 #endif | |
26 | |
27 #define DEST_BUFFER_CAPACITY 6000 | |
28 typedef int32_t (*NormFn)(const UChar* src,int32_t srcLen, UChar* dest,int32_t d
stLen, int32_t options, UErrorCode* status); | |
29 typedef int32_t (*QuickCheckFn)(const UChar* src,int32_t srcLen, UNormalizationM
ode mode, int32_t options, UErrorCode* status); | |
30 | |
31 class QuickCheckPerfFunction : public UPerfFunction{ | |
32 private: | |
33 ULine* lines; | |
34 int32_t numLines; | |
35 QuickCheckFn fn; | |
36 UNormalizationMode mode; | |
37 int32_t retVal; | |
38 UBool uselen; | |
39 const UChar* src; | |
40 int32_t srcLen; | |
41 UBool line_mode; | |
42 int32_t options; | |
43 | |
44 public: | |
45 virtual void call(UErrorCode* status){ | |
46 if(line_mode==TRUE){ | |
47 if(uselen){ | |
48 for(int32_t i = 0; i< numLines; i++){ | |
49 retVal = (*fn)(lines[i].name,lines[i].len,mode, options, st
atus); | |
50 } | |
51 }else{ | |
52 for(int32_t i = 0; i< numLines; i++){ | |
53 retVal = (*fn)(lines[i].name,-1,mode, options, status); | |
54 } | |
55 } | |
56 }else{ | |
57 if(uselen){ | |
58 | |
59 retVal = (*fn)(src,srcLen,mode, options, status); | |
60 }else{ | |
61 retVal = (*fn)(src,-1,mode, options, status); | |
62 } | |
63 } | |
64 | |
65 } | |
66 virtual long getOperationsPerIteration(){ | |
67 if(line_mode==TRUE){ | |
68 int32_t totalChars=0; | |
69 for(int32_t i =0; i< numLines; i++){ | |
70 totalChars+= lines[i].len; | |
71 } | |
72 return totalChars; | |
73 }else{ | |
74 return srcLen; | |
75 } | |
76 } | |
77 QuickCheckPerfFunction(QuickCheckFn func, ULine* srcLines,int32_t srcNumLine
s, UNormalizationMode _mode, int32_t opts, UBool _uselen) : options(opts) { | |
78 fn = func; | |
79 lines = srcLines; | |
80 numLines = srcNumLines; | |
81 uselen = _uselen; | |
82 mode = _mode; | |
83 src = NULL; | |
84 srcLen = 0; | |
85 line_mode = TRUE; | |
86 } | |
87 QuickCheckPerfFunction(QuickCheckFn func, const UChar* source,int32_t source
Len, UNormalizationMode _mode, int32_t opts, UBool _uselen) : options(opts) { | |
88 fn = func; | |
89 lines = NULL; | |
90 numLines = 0; | |
91 uselen = _uselen; | |
92 mode = _mode; | |
93 src = source; | |
94 srcLen = sourceLen; | |
95 line_mode = FALSE; | |
96 } | |
97 }; | |
98 | |
99 | |
100 class NormPerfFunction : public UPerfFunction{ | |
101 private: | |
102 ULine* lines; | |
103 int32_t numLines; | |
104 UChar dest[DEST_BUFFER_CAPACITY]; | |
105 UChar* pDest; | |
106 int32_t destLen; | |
107 NormFn fn; | |
108 int32_t retVal; | |
109 UBool uselen; | |
110 const UChar* src; | |
111 int32_t srcLen; | |
112 UBool line_mode; | |
113 int32_t options; | |
114 | |
115 public: | |
116 virtual void call(UErrorCode* status){ | |
117 if(line_mode==TRUE){ | |
118 if(uselen){ | |
119 for(int32_t i = 0; i< numLines; i++){ | |
120 retVal = (*fn)(lines[i].name,lines[i].len,pDest,destLen, op
tions, status); | |
121 } | |
122 }else{ | |
123 for(int32_t i = 0; i< numLines; i++){ | |
124 retVal = (*fn)(lines[i].name,-1,pDest,destLen, options, sta
tus); | |
125 } | |
126 } | |
127 }else{ | |
128 if(uselen){ | |
129 retVal = (*fn)(src,srcLen,pDest,destLen, options, status); | |
130 }else{ | |
131 retVal = (*fn)(src,-1,pDest,destLen, options, status); | |
132 } | |
133 } | |
134 } | |
135 virtual long getOperationsPerIteration(){ | |
136 if(line_mode ==TRUE){ | |
137 int32_t totalChars=0; | |
138 for(int32_t i =0; i< numLines; i++){ | |
139 totalChars+= lines[i].len; | |
140 } | |
141 return totalChars; | |
142 }else{ | |
143 return srcLen; | |
144 } | |
145 } | |
146 NormPerfFunction(NormFn func, int32_t opts, ULine* srcLines,int32_t srcNumLi
nes,UBool _uselen) : options(opts) { | |
147 fn = func; | |
148 lines = srcLines; | |
149 numLines = srcNumLines; | |
150 uselen = _uselen; | |
151 destLen = DEST_BUFFER_CAPACITY; | |
152 pDest = dest; | |
153 src = NULL; | |
154 srcLen = 0; | |
155 line_mode = TRUE; | |
156 } | |
157 NormPerfFunction(NormFn func, int32_t opts, const UChar* source,int32_t sour
ceLen,UBool _uselen) : options(opts) { | |
158 fn = func; | |
159 lines = NULL; | |
160 numLines = 0; | |
161 uselen = _uselen; | |
162 destLen = sourceLen*3; | |
163 pDest = (UChar*) malloc(destLen * U_SIZEOF_UCHAR); | |
164 src = source; | |
165 srcLen = sourceLen; | |
166 line_mode = FALSE; | |
167 } | |
168 ~NormPerfFunction(){ | |
169 if(dest != pDest){ | |
170 free(pDest); | |
171 } | |
172 } | |
173 }; | |
174 | |
175 | |
176 | |
177 class NormalizerPerformanceTest : public UPerfTest{ | |
178 private: | |
179 ULine* NFDFileLines; | |
180 ULine* NFCFileLines; | |
181 UChar* NFDBuffer; | |
182 UChar* NFCBuffer; | |
183 UChar* origBuffer; | |
184 int32_t origBufferLen; | |
185 int32_t NFDBufferLen; | |
186 int32_t NFCBufferLen; | |
187 int32_t options; | |
188 | |
189 void normalizeInput(ULine* dest,const UChar* src ,int32_t srcLen,UNormalizat
ionMode mode, int32_t options); | |
190 UChar* normalizeInput(int32_t& len, const UChar* src ,int32_t srcLen,UNormal
izationMode mode, int32_t options); | |
191 | |
192 public: | |
193 | |
194 NormalizerPerformanceTest(int32_t argc, const char* argv[], UErrorCode& stat
us); | |
195 ~NormalizerPerformanceTest(); | |
196 virtual UPerfFunction* runIndexedTest(int32_t index, UBool exec,const char*
&name, char* par = NULL); | |
197 /* NFC performance */ | |
198 UPerfFunction* TestICU_NFC_NFD_Text(); | |
199 UPerfFunction* TestICU_NFC_NFC_Text(); | |
200 UPerfFunction* TestICU_NFC_Orig_Text(); | |
201 | |
202 /* NFD performance */ | |
203 UPerfFunction* TestICU_NFD_NFD_Text(); | |
204 UPerfFunction* TestICU_NFD_NFC_Text(); | |
205 UPerfFunction* TestICU_NFD_Orig_Text(); | |
206 | |
207 /* FCD performance */ | |
208 UPerfFunction* TestICU_FCD_NFD_Text(); | |
209 UPerfFunction* TestICU_FCD_NFC_Text(); | |
210 UPerfFunction* TestICU_FCD_Orig_Text(); | |
211 | |
212 /*Win NFC performance */ | |
213 UPerfFunction* TestWin_NFC_NFD_Text(); | |
214 UPerfFunction* TestWin_NFC_NFC_Text(); | |
215 UPerfFunction* TestWin_NFC_Orig_Text(); | |
216 | |
217 /* Win NFD performance */ | |
218 UPerfFunction* TestWin_NFD_NFD_Text(); | |
219 UPerfFunction* TestWin_NFD_NFC_Text(); | |
220 UPerfFunction* TestWin_NFD_Orig_Text(); | |
221 | |
222 /* Quick check performance */ | |
223 UPerfFunction* TestQC_NFC_NFD_Text(); | |
224 UPerfFunction* TestQC_NFC_NFC_Text(); | |
225 UPerfFunction* TestQC_NFC_Orig_Text(); | |
226 | |
227 UPerfFunction* TestQC_NFD_NFD_Text(); | |
228 UPerfFunction* TestQC_NFD_NFC_Text(); | |
229 UPerfFunction* TestQC_NFD_Orig_Text(); | |
230 | |
231 UPerfFunction* TestQC_FCD_NFD_Text(); | |
232 UPerfFunction* TestQC_FCD_NFC_Text(); | |
233 UPerfFunction* TestQC_FCD_Orig_Text(); | |
234 | |
235 /* IsNormalized performnace */ | |
236 UPerfFunction* TestIsNormalized_NFC_NFD_Text(); | |
237 UPerfFunction* TestIsNormalized_NFC_NFC_Text(); | |
238 UPerfFunction* TestIsNormalized_NFC_Orig_Text(); | |
239 | |
240 UPerfFunction* TestIsNormalized_NFD_NFD_Text(); | |
241 UPerfFunction* TestIsNormalized_NFD_NFC_Text(); | |
242 UPerfFunction* TestIsNormalized_NFD_Orig_Text(); | |
243 | |
244 UPerfFunction* TestIsNormalized_FCD_NFD_Text(); | |
245 UPerfFunction* TestIsNormalized_FCD_NFC_Text(); | |
246 UPerfFunction* TestIsNormalized_FCD_Orig_Text(); | |
247 | |
248 }; | |
249 | |
250 //------------------------------------------------------------------------------
--------- | |
251 // Platform / ICU version specific proto-types | |
252 //------------------------------------------------------------------------------
--------- | |
253 | |
254 | |
255 #if (U_ICU_VERSION_MAJOR_NUM > 1 ) || ((U_ICU_VERSION_MAJOR_NUM == 1 )&&(U_ICU_V
ERSION_MINOR_NUM > 8) && (U_ICU_VERSION_PATCHLEVEL_NUM >=1)) | |
256 | |
257 int32_t ICUNormNFD(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen,
int32_t options, UErrorCode* status) { | |
258 return unorm_normalize(src,srcLen,UNORM_NFD, options,dest,dstLen,status); | |
259 } | |
260 | |
261 int32_t ICUNormNFC(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen,
int32_t options, UErrorCode* status) { | |
262 return unorm_normalize(src,srcLen,UNORM_NFC, options,dest,dstLen,status); | |
263 } | |
264 | |
265 int32_t ICUNormNFKD(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen
, int32_t options, UErrorCode* status) { | |
266 return unorm_normalize(src,srcLen,UNORM_NFKD, options,dest,dstLen,status); | |
267 } | |
268 int32_t ICUNormNFKC(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen
, int32_t options, UErrorCode* status) { | |
269 return unorm_normalize(src,srcLen,UNORM_NFKC, options,dest,dstLen,status); | |
270 } | |
271 | |
272 int32_t ICUNormFCD(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen,
int32_t options, UErrorCode* status) { | |
273 return unorm_normalize(src,srcLen,UNORM_FCD, options,dest,dstLen,status); | |
274 } | |
275 | |
276 int32_t ICUQuickCheck(const UChar* src,int32_t srcLen, UNormalizationMode mode,
int32_t options, UErrorCode* status){ | |
277 #if (U_ICU_VERSION_MAJOR_NUM > 2 ) || ((U_ICU_VERSION_MAJOR_NUM == 2 )&&(U_ICU_V
ERSION_MINOR_NUM >= 6)) | |
278 return unorm_quickCheckWithOptions(src,srcLen,mode, options, status); | |
279 #else | |
280 return unorm_quickCheck(src,srcLen,mode,status); | |
281 #endif | |
282 } | |
283 int32_t ICUIsNormalized(const UChar* src,int32_t srcLen, UNormalizationMode mode
, int32_t options, UErrorCode* status){ | |
284 return unorm_isNormalized(src,srcLen,mode,status); | |
285 } | |
286 | |
287 | |
288 #else | |
289 | |
290 int32_t ICUNormNFD(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen,
int32_t options, UErrorCode* status) { | |
291 return unorm_normalize(src,srcLen,UCOL_DECOMP_CAN, options,dest,dstLen,statu
s); | |
292 } | |
293 | |
294 int32_t ICUNormNFC(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen,
int32_t options, UErrorCode* status) { | |
295 return unorm_normalize(src,srcLen,UCOL_COMPOSE_CAN, options,dest,dstLen,stat
us); | |
296 } | |
297 | |
298 int32_t ICUNormNFKD(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen
, int32_t options, UErrorCode* status) { | |
299 return unorm_normalize(src,srcLen,UCOL_DECOMP_COMPAT, options,dest,dstLen,st
atus); | |
300 } | |
301 int32_t ICUNormNFKC(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen
, int32_t options, UErrorCode* status) { | |
302 return unorm_normalize(src,srcLen,UCOL_COMPOSE_COMPAT, options,dest,dstLen,s
tatus); | |
303 } | |
304 | |
305 int32_t ICUNormFCD(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen,
int32_t options, UErrorCode* status) { | |
306 return unorm_normalize(src,srcLen,UNORM_FCD, options,dest,dstLen,status); | |
307 } | |
308 | |
309 int32_t ICUQuickCheck(const UChar* src,int32_t srcLen, UNormalizationMode mode,
int32_t options, UErrorCode* status){ | |
310 return unorm_quickCheck(src,srcLen,mode,status); | |
311 } | |
312 | |
313 int32_t ICUIsNormalized(const UChar* src,int32_t srcLen, UNormalizationMode mode
, int32_t options, UErrorCode* status){ | |
314 return 0; | |
315 } | |
316 #endif | |
317 | |
318 #if U_PLATFORM_HAS_WIN32_API | |
319 | |
320 int32_t WinNormNFD(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen
, int32_t options, UErrorCode* status) { | |
321 return FoldStringW(MAP_COMPOSITE,src,srcLen,dest,dstLen); | |
322 } | |
323 | |
324 int32_t WinNormNFC(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen
, int32_t options, UErrorCode* status) { | |
325 return FoldStringW(MAP_PRECOMPOSED,src,srcLen,dest,dstLen); | |
326 } | |
327 | |
328 int32_t WinNormNFKD(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLe
n, int32_t options, UErrorCode* status) { | |
329 return FoldStringW(MAP_COMPOSITE+MAP_FOLDCZONE,src,srcLen,dest,dstLen); | |
330 } | |
331 int32_t WinNormNFKC(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLe
n, int32_t options, UErrorCode* status) { | |
332 return FoldStringW(MAP_FOLDCZONE,src,srcLen,dest,dstLen); | |
333 } | |
334 #else | |
335 int32_t WinNormNFD(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen
, int32_t options, UErrorCode* status) { | |
336 return 0 ; | |
337 } | |
338 | |
339 int32_t WinNormNFC(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen
, int32_t options, UErrorCode* status) { | |
340 return 0; | |
341 } | |
342 | |
343 int32_t WinNormNFKD(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLe
n, int32_t options, UErrorCode* status) { | |
344 return 0; | |
345 } | |
346 int32_t WinNormNFKC(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLe
n, int32_t options, UErrorCode* status) { | |
347 return 0; | |
348 } | |
349 #endif | |
350 | |
351 | |
352 #endif // NORMPERF_H | |
353 | |
OLD | NEW |