convperf.h revision c73f511526464f8e56c242df80552e9b0d94ae3d 
1/*
2**********************************************************************
3* Copyright (c) 2002-2005, International Business Machines
4* Corporation and others.  All Rights Reserved.
5**********************************************************************
6**********************************************************************
7*/
8#ifndef _CONVPERF_H
9#define _CONVPERF_H
10
11#include <mlang.h>
12#include <objbase.h>
13#include <stdlib.h>
14#include "unicode/ucnv.h"
15#include "unicode/uclean.h"
16#include "unicode/ustring.h"
17
18#include "unicode/uperf.h"
19
20#define CONVERSION_FLAGS (0) /*WC_DEFAULTCHAR WC_COMPOSITECHECK & WC_SEPCHARS*/
21#define MAX_BUF_SIZE  3048
22#define LENGTHOF(array) (sizeof(array)/sizeof((array)[0]))
23
24class ICUToUnicodePerfFunction : public UPerfFunction{
25private:
26    UConverter* conv;
27    const char* src;
28    int32_t srcLen;
29    UChar* target;
30    UChar* targetLimit;
31
32public:
33    ICUToUnicodePerfFunction(const char* name,  const char* source, int32_t sourceLen, UErrorCode& status){
34        conv = ucnv_open(name,&status);
35        src = source;
36        srcLen = sourceLen;
37        if(U_FAILURE(status)){
38            conv = NULL;
39            return;
40        }
41        target = NULL;
42        targetLimit = NULL;
43        int32_t reqdLen = ucnv_toUChars(conv,   target, 0,
44                                        source, srcLen, &status);
45        if(status==U_BUFFER_OVERFLOW_ERROR) {
46            status=U_ZERO_ERROR;
47            target=(UChar*)malloc((reqdLen) * U_SIZEOF_UCHAR*2);
48            targetLimit = target + reqdLen;
49            if(target == NULL){
50                status = U_MEMORY_ALLOCATION_ERROR;
51                return;
52            }
53        }
54    }
55    virtual void call(UErrorCode* status){
56        const char* mySrc = src;
57        const char* sourceLimit = src + srcLen;
58        UChar* myTarget = target;
59        ucnv_toUnicode(conv, &myTarget, targetLimit, &mySrc, sourceLimit, NULL, TRUE, status);
60    }
61    virtual long getOperationsPerIteration(void){
62        return srcLen;
63    }
64    ~ICUToUnicodePerfFunction(){
65        free(target);
66        ucnv_close(conv);
67    }
68};
69class ICUFromUnicodePerfFunction : public UPerfFunction{
70private:
71    UConverter* conv;
72    const UChar* src;
73    int32_t srcLen;
74    char* target;
75    char* targetLimit;
76    const char* name;
77
78public:
79    ICUFromUnicodePerfFunction(const char* name,  const UChar* source, int32_t sourceLen, UErrorCode& status){
80        conv = ucnv_open(name,&status);
81        src = source;
82        srcLen = sourceLen;
83        if(U_FAILURE(status)){
84            conv = NULL;
85            return;
86        }
87        target = NULL;
88        targetLimit = NULL;
89        int32_t reqdLen = ucnv_fromUChars(conv,   target, 0,
90                                          source, srcLen, &status);
91        if(status==U_BUFFER_OVERFLOW_ERROR) {
92            status=U_ZERO_ERROR;
93            target=(char*)malloc((reqdLen*2));
94            targetLimit = target + reqdLen;
95            if(target == NULL){
96                status = U_MEMORY_ALLOCATION_ERROR;
97                return;
98            }
99        }
100    }
101    virtual void call(UErrorCode* status){
102        const UChar* mySrc = src;
103        const UChar* sourceLimit = src + srcLen;
104        char* myTarget = target;
105        ucnv_fromUnicode(conv,&myTarget, targetLimit, &mySrc, sourceLimit, NULL, TRUE, status);
106    }
107    virtual long getOperationsPerIteration(void){
108        return srcLen;
109    }
110    ~ICUFromUnicodePerfFunction(){
111        free(target);
112        ucnv_close(conv);
113    }
114};
115
116class ICUOpenAllConvertersFunction : public UPerfFunction{
117private:
118    UBool cleanup;
119    int32_t availableConverters;
120    const char **convNames;
121public:
122    ICUOpenAllConvertersFunction(UBool callCleanup, UErrorCode& status){
123        int32_t idx;
124        cleanup = callCleanup;
125        availableConverters = ucnv_countAvailable();
126        convNames = new const char *[availableConverters];
127        for (idx = 0; idx < availableConverters; idx++) {
128            convNames[idx] = ucnv_getAvailableName(idx);
129        }
130    }
131    virtual void call(UErrorCode* status){
132        int32_t idx;
133        if (cleanup) {
134            u_cleanup();
135        }
136        for (idx = 0; idx < availableConverters; idx++) {
137            ucnv_close(ucnv_open(convNames[idx], status));
138        }
139    }
140    virtual long getOperationsPerIteration(void){
141        return availableConverters;
142    }
143    ~ICUOpenAllConvertersFunction(){
144        delete []convNames;
145    }
146};
147
148class WinANSIToUnicodePerfFunction : public UPerfFunction{
149
150private:
151    DWORD uiCodePage;
152    char* src;
153    UINT  srcLen;
154    WCHAR dest[MAX_BUF_SIZE];
155    UINT  dstLen;
156    const char* name;
157public:
158    WinANSIToUnicodePerfFunction(const char* cpName, char* pszIn,UINT szLen, UErrorCode& status){
159        name = cpName;
160        src = pszIn;
161        srcLen = szLen;
162        dstLen = LENGTHOF(dest);
163        unsigned short bEnc[30]={'\0'};
164        const char* tenc=name;
165        for(int i=0;*tenc!='\0';i++){
166            bEnc[i]=*tenc;
167            tenc++;
168        }
169        LPMULTILANGUAGE2 pMulti;
170
171        CoInitialize(NULL);
172
173        /* create instance of converter object*/
174        CoCreateInstance(
175                          __uuidof(CMultiLanguage),
176                          NULL,
177                          CLSCTX_SERVER,
178                          __uuidof(IMultiLanguage2),
179                          (void**)&pMulti
180                          );
181
182
183
184        MIMECSETINFO mimeInfo;
185
186        mimeInfo.uiCodePage = 0;
187        mimeInfo.uiInternetEncoding =0;
188        /* get the charset info */
189        pMulti->GetCharsetInfo((wchar_t *)bEnc,&mimeInfo);
190        uiCodePage = (mimeInfo.uiInternetEncoding==0)?mimeInfo.uiCodePage:mimeInfo.uiInternetEncoding;
191    }
192    virtual void call(UErrorCode* status){
193        int winSize =MultiByteToWideChar(uiCodePage,CONVERSION_FLAGS,src,srcLen,dest,dstLen);
194    }
195    virtual long getOperationsPerIteration(void){
196        return srcLen;
197    }
198};
199
200class WinANSIFromUnicodePerfFunction : public UPerfFunction{
201
202private:
203    DWORD uiCodePage;
204    WCHAR* src;
205    UINT  srcLen;
206    char dest[MAX_BUF_SIZE];
207    UINT  dstLen;
208    const char* name;
209    BOOL lpUsedDefaultChar;
210
211public:
212    WinANSIFromUnicodePerfFunction(const char* cpName,  WCHAR* pszIn,UINT szLen, UErrorCode& status){
213        name = cpName;
214        src = pszIn;
215        srcLen = szLen;
216        dstLen = LENGTHOF(dest);
217        lpUsedDefaultChar=FALSE;
218        unsigned short bEnc[30]={'\0'};
219        const char* tenc=name;
220        for(int i=0;*tenc!='\0';i++){
221            bEnc[i]=*tenc;
222            tenc++;
223        }
224        LPMULTILANGUAGE2 pMulti;
225
226        CoInitialize(NULL);
227
228        /* create instance of converter object*/
229        CoCreateInstance(
230                          __uuidof(CMultiLanguage),
231                          NULL,
232                          CLSCTX_SERVER,
233                          __uuidof(IMultiLanguage2),
234                          (void**)&pMulti
235                          );
236
237
238
239        MIMECSETINFO mimeInfo;
240        mimeInfo.uiCodePage = 0;
241        mimeInfo.uiInternetEncoding =0;
242        /* get the charset info */
243        pMulti->GetCharsetInfo((wchar_t *)bEnc,&mimeInfo);
244        uiCodePage = (mimeInfo.uiInternetEncoding==0)?mimeInfo.uiCodePage:mimeInfo.uiInternetEncoding;
245    }
246    virtual void call(UErrorCode* status){
247        BOOL* pUsedDefaultChar =(uiCodePage==CP_UTF8)?NULL:&lpUsedDefaultChar;
248        int winSize = WideCharToMultiByte(uiCodePage,CONVERSION_FLAGS,src,srcLen,dest,dstLen,NULL, pUsedDefaultChar);
249    }
250    virtual long getOperationsPerIteration(void){
251        return srcLen;
252    }
253};
254static inline void getErr(HRESULT err, UErrorCode& status){
255
256    switch (err){
257
258    case S_OK:
259        //printf("Operation %s successful\n",operation);
260        break;
261    case S_FALSE:
262        status = U_INTERNAL_PROGRAM_ERROR;
263        break;
264    case E_FAIL:
265        status = U_ILLEGAL_CHAR_FOUND;
266    }
267}
268class WinIMultiLanguageToUnicodePerfFunction : public UPerfFunction{
269
270private:
271    LPMULTILANGUAGE2 pMulti;
272    LPMLANGCONVERTCHARSET pConvToUni;
273    char* src;
274    UINT  srcLen;
275    WCHAR dst[MAX_BUF_SIZE];
276    UINT  dstLen;
277    const char* cpName;
278
279public:
280    WinIMultiLanguageToUnicodePerfFunction(const char* name,char* source, UINT sourceLen, UErrorCode& status){
281
282        CoInitialize(NULL);
283
284        /* create instance of converter object*/
285        CoCreateInstance(
286                          __uuidof(CMultiLanguage),
287                          NULL,
288                          CLSCTX_SERVER,
289                          __uuidof(IMultiLanguage2),
290                          (void**)&pMulti
291                          );
292
293
294
295        MIMECSETINFO mimeInfo;
296        mimeInfo.uiCodePage = 0;
297        mimeInfo.uiInternetEncoding =0;
298        HRESULT err=S_OK;
299        unsigned short bEnc[30]={'\0'};
300        const char* tenc=name;
301        for(int i=0;*tenc!='\0';i++){
302            bEnc[i]=*tenc;
303            tenc++;
304        }
305        /* get the charset info */
306        pMulti->GetCharsetInfo((wchar_t *)bEnc,&mimeInfo);
307        pMulti->CreateConvertCharset(mimeInfo.uiCodePage, 1200 /*unicode*/, (DWORD)0,&pConvToUni);
308        getErr(err,status);
309        src = source;
310        srcLen = sourceLen;
311        dstLen = LENGTHOF(dst);
312        cpName = name;
313    }
314
315    virtual void call(UErrorCode* status){
316        HRESULT err= pConvToUni->DoConversionToUnicode(src,&srcLen,dst, &dstLen);
317        getErr(err,*status);
318    }
319    virtual long getOperationsPerIteration(void){
320        return srcLen;
321    }
322};
323
324class WinIMultiLanguageFromUnicodePerfFunction : public UPerfFunction{
325
326private:
327    LPMULTILANGUAGE2 pMulti;
328    LPMLANGCONVERTCHARSET pConvFromUni;
329    WCHAR* src;
330    UINT  srcLen;
331    char dst[MAX_BUF_SIZE];
332    UINT  dstLen;
333    const char* cpName;
334
335public:
336    WinIMultiLanguageFromUnicodePerfFunction(const char* name,WCHAR* source, UINT sourceLen, UErrorCode& status){
337
338        CoInitialize(NULL);
339
340        /* create instance of converter object*/
341        CoCreateInstance(
342                          __uuidof(CMultiLanguage),
343                          NULL,
344                          CLSCTX_SERVER,
345                          __uuidof(IMultiLanguage2),
346                          (void**)&pMulti
347                          );
348
349
350
351        MIMECSETINFO mimeInfo;
352        mimeInfo.uiCodePage = 0;
353        mimeInfo.uiInternetEncoding =0;
354        HRESULT err=S_OK;
355        unsigned short bEnc[30]={'\0'};
356        const char* tenc=name;
357        for(int i=0;*tenc!='\0';i++){
358            bEnc[i]=*tenc;
359            tenc++;
360        }
361        /* get the charset info */
362        pMulti->GetCharsetInfo((wchar_t *)bEnc,&mimeInfo);
363        pMulti->CreateConvertCharset(1200 /*unicode*/, mimeInfo.uiCodePage, (DWORD)0,&pConvFromUni);
364        getErr(err,status);
365        src = source;
366        srcLen = sourceLen;
367        dstLen = LENGTHOF(dst);
368        cpName = name;
369
370    }
371
372    virtual void call(UErrorCode* status){
373        HRESULT err= pConvFromUni->DoConversionFromUnicode(src,&srcLen,dst, &dstLen);
374        getErr(err,*status);
375    }
376    virtual long getOperationsPerIteration(void){
377        return srcLen;
378    }
379};
380
381class WinIMultiLanguage2ToUnicodePerfFunction : public UPerfFunction{
382
383private:
384    LPMULTILANGUAGE2 pMulti;
385    char* src;
386    UINT  srcLen;
387    WCHAR dst[MAX_BUF_SIZE];
388    UINT  dstLen;
389    const char* cpName;
390    DWORD dwEnc;
391public:
392    WinIMultiLanguage2ToUnicodePerfFunction(const char* name,char* source, UINT sourceLen, UErrorCode& status){
393
394        CoInitialize(NULL);
395
396        /* create instance of converter object*/
397        CoCreateInstance(
398                          __uuidof(CMultiLanguage),
399                          NULL,
400                          CLSCTX_SERVER,
401                          __uuidof(IMultiLanguage2),
402                          (void**)&pMulti
403                          );
404
405        src = source;
406        srcLen = sourceLen;
407        dstLen = LENGTHOF(dst);
408        cpName = name;
409        unsigned short bEnc[30]={'\0'};
410        const char* tenc=name;
411        for(int i=0;*tenc!='\0';i++){
412            bEnc[i]=*tenc;
413            tenc++;
414        }
415        /* get the charset info */
416        MIMECSETINFO mimeInfo;
417        mimeInfo.uiCodePage = 0;
418        mimeInfo.uiInternetEncoding =0;
419        pMulti->GetCharsetInfo((wchar_t *)bEnc,&mimeInfo);
420        dwEnc = (mimeInfo.uiInternetEncoding==0)?mimeInfo.uiCodePage:mimeInfo.uiInternetEncoding;
421    }
422
423    virtual void call(UErrorCode* status){
424        DWORD dwMode=0;
425        HRESULT err=  pMulti->ConvertStringToUnicode(&dwMode,dwEnc,(char*)src,&srcLen,dst, &dstLen);
426        getErr(err,*status);
427    }
428    virtual long getOperationsPerIteration(void){
429        return srcLen;
430    }
431};
432
433class WinIMultiLanguage2FromUnicodePerfFunction : public UPerfFunction{
434
435private:
436    LPMULTILANGUAGE2 pMulti;
437    LPMLANGCONVERTCHARSET pConvFromUni;
438    WCHAR* src;
439    UINT  srcLen;
440    char dst[MAX_BUF_SIZE];
441    UINT  dstLen;
442    const char* cpName;
443    DWORD dwEnc;
444
445public:
446    WinIMultiLanguage2FromUnicodePerfFunction(const char* name,WCHAR* source, UINT sourceLen, UErrorCode& status){
447
448        CoInitialize(NULL);
449
450        /* create instance of converter object*/
451        CoCreateInstance(
452                          __uuidof(CMultiLanguage),
453                          NULL,
454                          CLSCTX_SERVER,
455                          __uuidof(IMultiLanguage2),
456                          (void**)&pMulti
457                          );
458
459
460        unsigned short bEnc[30]={'\0'};
461        const char* tenc=name;
462        for(int i=0;*tenc!='\0';i++){
463            bEnc[i]=*tenc;
464            tenc++;
465        }
466        src = source;
467        srcLen = sourceLen;
468        dstLen = LENGTHOF(dst);
469        cpName = name;
470        /* get the charset info */
471        MIMECSETINFO mimeInfo;
472        mimeInfo.uiCodePage = 0;
473        mimeInfo.uiInternetEncoding =0;
474
475        pMulti->GetCharsetInfo((wchar_t *)bEnc,&mimeInfo);
476        dwEnc = (mimeInfo.uiInternetEncoding==0)?mimeInfo.uiCodePage:mimeInfo.uiInternetEncoding;
477    }
478
479    virtual void call(UErrorCode* status){
480        DWORD dwMode=0;
481        HRESULT err= pMulti->ConvertStringFromUnicode(&dwMode,dwEnc,src,&srcLen,dst, &dstLen);
482        getErr(err,*status);
483    }
484    virtual long getOperationsPerIteration(void){
485        return srcLen;
486    }
487};
488
489class  ConverterPerformanceTest : public UPerfTest{
490
491public:
492
493    ConverterPerformanceTest(int32_t argc, const char* argv[], UErrorCode& status);
494    ~ConverterPerformanceTest();
495    virtual UPerfFunction* runIndexedTest(int32_t index, UBool exec,const char* &name, char* par = NULL);
496
497    UPerfFunction* TestICU_CleanOpenAllConverters();
498    UPerfFunction* TestICU_OpenAllConverters();
499
500    UPerfFunction* TestICU_UTF8_ToUnicode();
501    UPerfFunction* TestICU_UTF8_FromUnicode();
502    UPerfFunction* TestWinANSI_UTF8_ToUnicode();
503    UPerfFunction* TestWinANSI_UTF8_FromUnicode();
504    UPerfFunction* TestWinIML2_UTF8_ToUnicode();
505    UPerfFunction* TestWinIML2_UTF8_FromUnicode();
506
507    UPerfFunction* TestICU_Latin1_ToUnicode();
508    UPerfFunction* TestICU_Latin1_FromUnicode();
509    UPerfFunction* TestWinANSI_Latin1_ToUnicode();
510    UPerfFunction* TestWinANSI_Latin1_FromUnicode();
511    UPerfFunction* TestWinIML2_Latin1_ToUnicode();
512    UPerfFunction* TestWinIML2_Latin1_FromUnicode();
513
514    UPerfFunction* TestICU_EBCDIC_Arabic_ToUnicode();
515    UPerfFunction* TestICU_EBCDIC_Arabic_FromUnicode();
516    UPerfFunction* TestWinANSI_EBCDIC_Arabic_ToUnicode();
517    UPerfFunction* TestWinANSI_EBCDIC_Arabic_FromUnicode();
518    UPerfFunction* TestWinIML2_EBCDIC_Arabic_ToUnicode();
519    UPerfFunction* TestWinIML2_EBCDIC_Arabic_FromUnicode();
520
521    UPerfFunction* TestICU_Latin8_ToUnicode();
522    UPerfFunction* TestICU_Latin8_FromUnicode();
523    UPerfFunction* TestWinANSI_Latin8_ToUnicode();
524    UPerfFunction* TestWinANSI_Latin8_FromUnicode();
525    UPerfFunction* TestWinIML2_Latin8_ToUnicode();
526    UPerfFunction* TestWinIML2_Latin8_FromUnicode();
527
528
529    UPerfFunction* TestICU_SJIS_ToUnicode();
530    UPerfFunction* TestICU_SJIS_FromUnicode();
531    UPerfFunction* TestWinANSI_SJIS_ToUnicode();
532    UPerfFunction* TestWinANSI_SJIS_FromUnicode();
533    UPerfFunction* TestWinIML2_SJIS_ToUnicode();
534    UPerfFunction* TestWinIML2_SJIS_FromUnicode();
535
536    UPerfFunction* TestICU_EUCJP_ToUnicode();
537    UPerfFunction* TestICU_EUCJP_FromUnicode();
538    UPerfFunction* TestWinANSI_EUCJP_ToUnicode();
539    UPerfFunction* TestWinANSI_EUCJP_FromUnicode();
540    UPerfFunction* TestWinIML2_EUCJP_ToUnicode();
541    UPerfFunction* TestWinIML2_EUCJP_FromUnicode();
542
543    UPerfFunction* TestICU_GB2312_ToUnicode();
544    UPerfFunction* TestICU_GB2312_FromUnicode();
545    UPerfFunction* TestWinANSI_GB2312_ToUnicode();
546    UPerfFunction* TestWinANSI_GB2312_FromUnicode();
547    UPerfFunction* TestWinIML2_GB2312_ToUnicode();
548    UPerfFunction* TestWinIML2_GB2312_FromUnicode();
549
550
551    UPerfFunction* TestICU_ISO2022KR_ToUnicode();
552    UPerfFunction* TestICU_ISO2022KR_FromUnicode();
553    UPerfFunction* TestWinANSI_ISO2022KR_ToUnicode();
554    UPerfFunction* TestWinANSI_ISO2022KR_FromUnicode();
555    UPerfFunction* TestWinIML2_ISO2022KR_ToUnicode();
556    UPerfFunction* TestWinIML2_ISO2022KR_FromUnicode();
557
558    UPerfFunction* TestICU_ISO2022JP_ToUnicode();
559    UPerfFunction* TestICU_ISO2022JP_FromUnicode();
560    UPerfFunction* TestWinANSI_ISO2022JP_ToUnicode();
561    UPerfFunction* TestWinANSI_ISO2022JP_FromUnicode();
562    UPerfFunction* TestWinIML2_ISO2022JP_ToUnicode();
563    UPerfFunction* TestWinIML2_ISO2022JP_FromUnicode();
564
565};
566
567#endif
568
569