/*
**********************************************************************
* Copyright (C) 2002-2008, International Business Machines
* Corporation and others. All Rights Reserved.
**********************************************************************
* file name: utrie2perf.cpp
* encoding: US-ASCII
* tab size: 8 (not used)
* indentation:4
*
* created on: 2008sep07
* created by: Markus W. Scherer
*
* Performance test program for UTrie2.
*/
#include <stdio.h>
#include <stdlib.h>
#include "unicode/uchar.h"
#include "unicode/unorm.h"
#include "unicode/uperf.h"
#include "uoptions.h"
#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
#if 0
// Left over from when icu/branches/markus/utf8 could use both old UTrie
// and new UTrie2, switched with #if in unorm.cpp and ubidi_props.c.
// Comparative benchmarks were done in that branch on revision r24630
// and earlier.
U_CAPI void U_EXPORT2
unorm_initUTrie2(UErrorCode *pErrorCode);
U_CAPI void U_EXPORT2
ubidi_initUTrie2(UErrorCode *pErrorCode);
#endif
U_NAMESPACE_BEGIN
class UnicodeSet;
U_NAMESPACE_END
// Test object.
class UTrie2PerfTest : public UPerfTest {
public:
UTrie2PerfTest(int32_t argc, const char *argv[], UErrorCode &status)
: UPerfTest(argc, argv, NULL, 0, "", status),
utf8(NULL), utf8Length(0), countInputCodePoints(0) {
if (U_SUCCESS(status)) {
#if 0 // See comment at unorm_initUTrie2() forward declaration.
unorm_initUTrie2(&status);
ubidi_initUTrie2(&status);
#endif
int32_t inputLength;
UPerfTest::getBuffer(inputLength, status);
if(U_SUCCESS(status) && inputLength>0) {
countInputCodePoints = u_countChar32(buffer, bufferLen);
// Preflight the UTF-8 length and allocate utf8.
u_strToUTF8(NULL, 0, &utf8Length, buffer, bufferLen, &status);
if(status==U_BUFFER_OVERFLOW_ERROR) {
utf8=(char *)malloc(utf8Length);
if(utf8!=NULL) {
status=U_ZERO_ERROR;
u_strToUTF8(utf8, utf8Length, NULL, buffer, bufferLen, &status);
} else {
status=U_MEMORY_ALLOCATION_ERROR;
}
}
if(verbose) {
printf("code points:%ld len16:%ld len8:%ld "
"B/cp:%.3g\n",
(long)countInputCodePoints, (long)bufferLen, (long)utf8Length,
(double)utf8Length/countInputCodePoints);
}
}
}
}
virtual UPerfFunction* runIndexedTest(int32_t index, UBool exec, const char* &name, char* par = NULL);
const UChar *getBuffer() const { return buffer; }
int32_t getBufferLen() const { return bufferLen; }
char *utf8;
int32_t utf8Length;
// Number of code points in the input text.
int32_t countInputCodePoints;
};
// Performance test function object.
class Command : public UPerfFunction {
protected:
Command(const UTrie2PerfTest &testcase) : testcase(testcase) {}
public:
virtual ~Command() {}
// virtual void call(UErrorCode* pErrorCode) { ... }
virtual long getOperationsPerIteration() {
// Number of code points tested.
return testcase.countInputCodePoints;
}
// virtual long getEventsPerIteration();
const UTrie2PerfTest &testcase;
UNormalizationCheckResult qcResult;
};
class CheckFCD : public Command {
protected:
CheckFCD(const UTrie2PerfTest &testcase) : Command(testcase) {}
public:
static UPerfFunction* get(const UTrie2PerfTest &testcase) {
return new CheckFCD(testcase);
}
virtual void call(UErrorCode* pErrorCode) {
UErrorCode errorCode=U_ZERO_ERROR;
qcResult=unorm_quickCheck(testcase.getBuffer(), testcase.getBufferLen(),
UNORM_FCD, &errorCode);
if(U_FAILURE(errorCode)) {
fprintf(stderr, "error: unorm_quickCheck(UNORM_FCD) failed: %s\n",
u_errorName(errorCode));
}
}
};
#if 0 // See comment at unorm_initUTrie2() forward declaration.
class CheckFCDAlwaysGet : public Command {
protected:
CheckFCDAlwaysGet(const UTrie2PerfTest &testcase) : Command(testcase) {}
public:
static UPerfFunction* get(const UTrie2PerfTest &testcase) {
return new CheckFCDAlwaysGet(testcase);
}
virtual void call(UErrorCode* pErrorCode) {
UErrorCode errorCode=U_ZERO_ERROR;
qcResult=unorm_quickCheck(testcase.getBuffer(), testcase.getBufferLen(),
UNORM_FCD_ALWAYS_GET, &errorCode);
if(U_FAILURE(errorCode)) {
fprintf(stderr, "error: unorm_quickCheck(UNORM_FCD) failed: %s\n",
u_errorName(errorCode));
}
}
};
U_CAPI UBool U_EXPORT2
unorm_checkFCDUTF8(const uint8_t *src, int32_t srcLength, const UnicodeSet *nx);
class CheckFCDUTF8 : public Command {
protected:
CheckFCDUTF8(const UTrie2PerfTest &testcase) : Command(testcase) {}
public:
static UPerfFunction* get(const UTrie2PerfTest &testcase) {
return new CheckFCDUTF8(testcase);
}
virtual void call(UErrorCode* pErrorCode) {
UBool isFCD=unorm_checkFCDUTF8((const uint8_t *)testcase.utf8, testcase.utf8Length, NULL);
if(isFCD>1) {
fprintf(stderr, "error: bogus result from unorm_checkFCDUTF8()\n");
}
}
};
#endif
class ToNFC : public Command {
protected:
ToNFC(const UTrie2PerfTest &testcase) : Command(testcase) {
UErrorCode errorCode=U_ZERO_ERROR;
destCapacity=unorm_normalize(testcase.getBuffer(), testcase.getBufferLen(),
UNORM_NFC, 0,
NULL, 0,
&errorCode);
dest=new UChar[destCapacity];
}
~ToNFC() {
delete [] dest;
}
public:
static UPerfFunction* get(const UTrie2PerfTest &testcase) {
return new ToNFC(testcase);
}
virtual void call(UErrorCode* pErrorCode) {
UErrorCode errorCode=U_ZERO_ERROR;
int32_t destLength=unorm_normalize(testcase.getBuffer(), testcase.getBufferLen(),
UNORM_NFC, 0,
dest, destCapacity,
&errorCode);
if(U_FAILURE(errorCode) || destLength!=destCapacity) {
fprintf(stderr, "error: unorm_normalize(UNORM_NFC) failed: %s\n",
u_errorName(errorCode));
}
}
private:
UChar *dest;
int32_t destCapacity;
};
class GetBiDiClass : public Command {
protected:
GetBiDiClass(const UTrie2PerfTest &testcase) : Command(testcase) {}
public:
static UPerfFunction* get(const UTrie2PerfTest &testcase) {
return new GetBiDiClass(testcase);
}
virtual void call(UErrorCode* pErrorCode) {
const UChar *buffer=testcase.getBuffer();
int32_t length=testcase.getBufferLen();
UChar32 c;
int32_t i;
uint32_t bitSet=0;
for(i=0; i<length;) {
U16_NEXT(buffer, i, length, c);
bitSet|=(uint32_t)1<<u_charDirection(c);
}
if(length>0 && bitSet==0) {
fprintf(stderr, "error: GetBiDiClass() did not collect bits\n");
}
}
};
UPerfFunction* UTrie2PerfTest::runIndexedTest(int32_t index, UBool exec, const char* &name, char* par) {
switch (index) {
case 0: name = "CheckFCD"; if (exec) return CheckFCD::get(*this); break;
case 1: name = "ToNFC"; if (exec) return ToNFC::get(*this); break;
case 2: name = "GetBiDiClass"; if (exec) return GetBiDiClass::get(*this); break;
#if 0 // See comment at unorm_initUTrie2() forward declaration.
case 3: name = "CheckFCDAlwaysGet"; if (exec) return CheckFCDAlwaysGet::get(*this); break;
case 4: name = "CheckFCDUTF8"; if (exec) return CheckFCDUTF8::get(*this); break;
#endif
default: name = ""; break;
}
return NULL;
}
int main(int argc, const char *argv[]) {
UErrorCode status = U_ZERO_ERROR;
UTrie2PerfTest test(argc, argv, status);
if (U_FAILURE(status)){
printf("The error is %s\n", u_errorName(status));
test.usage();
return status;
}
if (test.run() == FALSE){
fprintf(stderr, "FAILED: Tests could not be run please check the "
"arguments.\n");
return -1;
}
return 0;
}