[sword-cvs] icu-sword/source/test/perf/normperf Makefile.in,NONE,1.1 NormPerf.pl,NONE,1.1 normperf.cpp,NONE,1.1 normperf.dsp,NONE,1.1 normperf.h,NONE,1.1
sword@www.crosswire.org
sword@www.crosswire.org
Tue, 9 Sep 2003 19:42:52 -0700
- Previous message: [sword-cvs] icu-sword/source/test/perf/charperf CharPerf.pl,NONE,1.1 Makefile.in,NONE,1.1 charperf.cpp,NONE,1.1 charperf.dsp,NONE,1.1 charperf.h,NONE,1.1
- Next message: [sword-cvs] icu-sword/source/test/perf/perldriver Dataset.pm,NONE,1.1 Format.pm,NONE,1.1 Output.pm,NONE,1.1 PerfFramework.pm,NONE,1.1
- Messages sorted by:
[ date ]
[ thread ]
[ subject ]
[ author ]
Update of /usr/local/cvsroot/icu-sword/source/test/perf/normperf
In directory www:/tmp/cvs-serv19862/source/test/perf/normperf
Added Files:
Makefile.in NormPerf.pl normperf.cpp normperf.dsp normperf.h
Log Message:
ICU 2.6 commit
--- NEW FILE: Makefile.in ---
## Makefile.in for ICU - test/collperf
## Copyright (c) 2001, International Business Machines Corporation and
## others. All Rights Reserved.
## Source directory information
srcdir = @srcdir@
top_srcdir = @top_srcdir@
top_builddir = ../..
include $(top_builddir)/icudefs.mk
## Platform-specific setup
include @platform_make_fragment@
## Build directory information
subdir = test/normperf
## Extra files to remove for 'make clean'
CLEANFILES = *~ $(DEPS)
## Target information
TARGET = normperf
DEFS = @DEFS@
CPPFLAGS = @CPPFLAGS@ -I$(top_builddir)/common -I$(top_srcdir)/common -I$(top_srcdir)/i18n
CFLAGS = @CFLAGS@
CXXFLAGS = @CXXFLAGS@
ENABLE_RPATH = @ENABLE_RPATH@
ifeq ($(ENABLE_RPATH),YES)
RPATHLDFLAGS = $(LD_RPATH)$(LD_RPATH_PRE)$(libdir)
endif
LDFLAGS = @LDFLAGS@ $(RPATHLDFLAGS)
LIBS = $(LIBICUI18N) $(LIBICUUC) @LIBS@ @LIB_M@
OBJECTS = normperf.o
DEPS = $(OBJECTS:.o=.d)
## List of phony targets
.PHONY : all all-local install install-local clean clean-local \
distclean distclean-local dist dist-local check check-local
## Clear suffix list
.SUFFIXES :
## List of standard targets
all: all-local
install: install-local
clean: clean-local
distclean : distclean-local
dist: dist-local
check: all check-local
all-local: $(TARGET)
install-local:
dist-local:
clean-local:
test -z "$(CLEANFILES)" || $(RMV) $(CLEANFILES)
$(RMV) $(OBJECTS) $(TARGET)
distclean-local: clean-local
$(RMV) Makefile
check-local: all-local
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
cd $(top_builddir) \
&& CONFIG_FILES=$(subdir)/$@ CONFIG_HEADERS= $(SHELL) ./config.status
$(TARGET) : $(OBJECTS)
$(LINK.cc) -o $@ $^ $(LIBS)
invoke:
ICU_DATA=$${ICU_DATA:-$(top_builddir)/data/} TZ=PST8PDT $(INVOKE) $(INVOCATION)
ifeq (,$(MAKECMDGOALS))
-include $(DEPS)
else
ifneq ($(patsubst %clean,,$(MAKECMDGOALS)),)
ifneq ($(patsubst %install,,$(MAKECMDGOALS)),)
-include $(DEPS)
endif
endif
endif
--- NEW FILE: NormPerf.pl ---
#!/usr/bin/perl -w
# ********************************************************************
# * COPYRIGHT:
# * Copyright (c) 2002, International Business Machines Corporation and
# * others. All Rights Reserved.
# ********************************************************************
use strict;
use lib '../perldriver';
use PerfFramework;
my $options = {
"title"=>"Normalization performance: ICU vs. Win",
"headers"=>"Win ICU",
"operationIs"=>"code point",
"passes"=>"10",
"time"=>"5",
#"outputType"=>"HTML",
"dataDir"=>"c:/src/perf/data",
"outputDir"=>"../results"
};
# programs
# tests will be done for all the programs. Results will be stored and connected
my $p = "normperf.exe -b -u";
my $tests = {
"NFC_NFD_Text", ["$p TestWin_NFC_NFD_Text" , "$p TestICU_NFC_NFD_Text" ],
"NFC_NFC_Text", ["$p TestWin_NFC_NFC_Text" , "$p TestICU_NFC_NFC_Text" ],
"NFC_Orig_Text", ["$p TestWin_NFC_Orig_Text" , "$p TestICU_NFC_Orig_Text"],
"NFD_NFD_Text", ["$p TestWin_NFD_NFD_Text" , "$p TestICU_NFD_NFD_Text" ],
"NFD_NFC_Text", ["$p TestWin_NFD_NFC_Text" , "$p TestICU_NFD_NFC_Text" ],
"NFD_Orig_Text", ["$p TestWin_NFD_Orig_Text" , "$p TestICU_NFD_Orig_Text"]
};
my $dataFiles = {
"",
[
"TestNames_Asian.txt",
"TestNames_Chinese.txt",
"TestNames_Japanese.txt",
"TestNames_Japanese_h.txt",
"TestNames_Japanese_k.txt",
"TestNames_Korean.txt",
"TestNames_Latin.txt",
"TestNames_SerbianSH.txt",
"TestNames_SerbianSR.txt",
"TestNames_Thai.txt",
"Testnames_Russian.txt",
"th18057.txt",
"thesis.txt",
"vfear11a.txt",
]
};
runTests($options, $tests, $dataFiles);
--- NEW FILE: normperf.cpp ---
/*
**********************************************************************
* Copyright (c) 2002-2003, International Business Machines
* Corporation and others. All Rights Reserved.
**********************************************************************
**********************************************************************
*/
/**
* This Program tests the performance of ICU's Normalization engine against Windows
* to run it use the command like
*
* c:\normperf.exe -s C:\work\ICUCupertinoRep\icu4c\collation-perf-data -i 10 -p 15 -f TestNames_Asian.txt -u -e UTF-8 -l
*/
#include "normperf.h"
#define LENGTHOF(array) (sizeof(array)/sizeof((array)[0]))
UPerfFunction* NormalizerPerformanceTest::runIndexedTest(int32_t index, UBool exec,const char* &name, char* par) {
switch (index) {
TESTCASE(0,TestICU_NFC_NFD_Text);
TESTCASE(1,TestICU_NFC_NFC_Text);
TESTCASE(2,TestICU_NFC_Orig_Text);
TESTCASE(3,TestICU_NFD_NFD_Text);
TESTCASE(4,TestICU_NFD_NFC_Text);
TESTCASE(5,TestICU_NFD_Orig_Text);
TESTCASE(6,TestICU_FCD_NFD_Text);
TESTCASE(7,TestICU_FCD_NFC_Text);
TESTCASE(8,TestICU_FCD_Orig_Text);
TESTCASE(9,TestWin_NFC_NFD_Text);
TESTCASE(10,TestWin_NFC_NFC_Text);
TESTCASE(11,TestWin_NFC_Orig_Text);
TESTCASE(12,TestWin_NFD_NFD_Text);
TESTCASE(13,TestWin_NFD_NFC_Text);
TESTCASE(14,TestWin_NFD_Orig_Text);
TESTCASE(15,TestQC_NFC_NFD_Text);
TESTCASE(16,TestQC_NFC_NFC_Text);
TESTCASE(17,TestQC_NFC_Orig_Text);
TESTCASE(18,TestQC_NFD_NFD_Text);
TESTCASE(19,TestQC_NFD_NFC_Text);
TESTCASE(20,TestQC_NFD_Orig_Text);
TESTCASE(21,TestQC_FCD_NFD_Text);
TESTCASE(22,TestQC_FCD_NFC_Text);
TESTCASE(23,TestQC_FCD_Orig_Text);
TESTCASE(24,TestIsNormalized_NFC_NFD_Text);
TESTCASE(25,TestIsNormalized_NFC_NFC_Text);
TESTCASE(26,TestIsNormalized_NFC_Orig_Text);
TESTCASE(27,TestIsNormalized_NFD_NFD_Text);
TESTCASE(28,TestIsNormalized_NFD_NFC_Text);
TESTCASE(29,TestIsNormalized_NFD_Orig_Text);
TESTCASE(30,TestIsNormalized_FCD_NFD_Text);
TESTCASE(31,TestIsNormalized_FCD_NFC_Text);
TESTCASE(32,TestIsNormalized_FCD_Orig_Text);
default:
name = "";
return NULL;
}
return NULL;
}
void NormalizerPerformanceTest::normalizeInput(ULine* dest,const UChar* src ,int32_t srcLen,UNormalizationMode mode, int32_t options){
int32_t reqLen = 0;
UErrorCode status = U_ZERO_ERROR;
for(;;){
/* pure pre-flight */
reqLen=unorm_normalize(src,srcLen,mode, options,NULL,0,&status);
if(status==U_BUFFER_OVERFLOW_ERROR){
status=U_ZERO_ERROR;
dest->name = new UChar[reqLen+1];
reqLen= unorm_normalize(src,srcLen,mode, options,dest->name,reqLen+1,&status);
dest->len=reqLen;
break;
}else if(U_FAILURE(status)){
printf("Could not normalize input. Error: %s", u_errorName(status));
}
}
}
UChar* NormalizerPerformanceTest::normalizeInput(int32_t& len, const UChar* src ,int32_t srcLen,UNormalizationMode mode, int32_t options){
int32_t reqLen = 0;
UErrorCode status = U_ZERO_ERROR;
UChar* dest = NULL;
for(;;){
/* pure pre-flight */
reqLen=unorm_normalize(src,srcLen,mode, options,NULL,0,&status);
if(status==U_BUFFER_OVERFLOW_ERROR){
status=U_ZERO_ERROR;
dest = new UChar[reqLen+1];
reqLen= unorm_normalize(src,srcLen,mode, options,dest,reqLen+1,&status);
len=reqLen;
break;
}else if(U_FAILURE(status)){
printf("Could not normalize input. Error: %s", u_errorName(status));
return NULL;
}
}
return dest;
}
static UOption cmdLineOptions[]={
UOPTION_DEF("options", 'o', UOPT_OPTIONAL_ARG)
};
NormalizerPerformanceTest::NormalizerPerformanceTest(int32_t argc, const char* argv[], UErrorCode& status)
: UPerfTest(argc,argv,status), options(0) {
NFDBuffer = NULL;
NFCBuffer = NULL;
NFDBufferLen = 0;
NFCBufferLen = 0;
NFDFileLines = NULL;
NFCFileLines = NULL;
if(status== U_ILLEGAL_ARGUMENT_ERROR){
fprintf(stderr,gUsageString, "normperf");
return;
}
if(U_FAILURE(status)){
fprintf(stderr, "FAILED to create UPerfTest object. Error: %s\n", u_errorName(status));
return;
}
_remainingArgc = u_parseArgs(_remainingArgc, (char **)argv, (int32_t)(LENGTHOF(cmdLineOptions)), cmdLineOptions);
if(cmdLineOptions[0].doesOccur && cmdLineOptions[0].value!=NULL) {
options=(int32_t)strtol(cmdLineOptions[0].value, NULL, 16);
}
if(line_mode){
ULine* filelines = getLines(status);
if(U_FAILURE(status)){
fprintf(stderr, "FAILED to read lines from file and create UPerfTest object. Error: %s\n", u_errorName(status));
return;
}
NFDFileLines = new ULine[numLines];
NFCFileLines = new ULine[numLines];
for(int32_t i=0;i<numLines;i++){
normalizeInput(&NFDFileLines[i],filelines[i].name,filelines[i].len,UNORM_NFD, options);
normalizeInput(&NFCFileLines[i],filelines[i].name,filelines[i].len,UNORM_NFC, options);
}
}else if(bulk_mode){
int32_t srcLen = 0;
const UChar* src = getBuffer(srcLen,status);
NFDBufferLen = 0;
NFCBufferLen = 0;
if(U_FAILURE(status)){
fprintf(stderr, "FAILED to read buffer from file and create UPerfTest object. Error: %s\n", u_errorName(status));
return;
}
NFDBuffer = normalizeInput(NFDBufferLen,src,srcLen,UNORM_NFD, options);
NFCBuffer = normalizeInput(NFCBufferLen,src,srcLen,UNORM_NFC, options);
}
}
NormalizerPerformanceTest::~NormalizerPerformanceTest(){
delete[] NFDFileLines;
delete[] NFCFileLines;
delete[] NFDBuffer;
delete[] NFCBuffer;
}
// Test NFC Performance
UPerfFunction* NormalizerPerformanceTest::TestICU_NFC_NFD_Text(){
if(line_mode){
NormPerfFunction* func= new NormPerfFunction(ICUNormNFC, options,NFDFileLines,numLines, uselen);
return func;
}else{
NormPerfFunction* func= new NormPerfFunction(ICUNormNFC, options,NFDBuffer, NFDBufferLen, uselen);
return func;
}
}
UPerfFunction* NormalizerPerformanceTest::TestICU_NFC_NFC_Text(){
if(line_mode){
NormPerfFunction* func = new NormPerfFunction(ICUNormNFC, options,NFCFileLines,numLines, uselen);
return func;
}else{
NormPerfFunction* func= new NormPerfFunction(ICUNormNFC, options,NFCBuffer, NFCBufferLen, uselen);
return func;
}
}
UPerfFunction* NormalizerPerformanceTest::TestICU_NFC_Orig_Text(){
if(line_mode){
NormPerfFunction* func = new NormPerfFunction(ICUNormNFC, options,lines,numLines, uselen);
return func;
}else{
NormPerfFunction* func = new NormPerfFunction(ICUNormNFC, options,buffer, bufferLen, uselen);
return func;
}
}
// Test NFD Performance
UPerfFunction* NormalizerPerformanceTest::TestICU_NFD_NFD_Text(){
if(line_mode){
NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,NFDFileLines,numLines, uselen);
return func;
}else{
NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,NFDBuffer,NFDBufferLen, uselen);
return func;
}
}
UPerfFunction* NormalizerPerformanceTest::TestICU_NFD_NFC_Text(){
if(line_mode){
NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,NFCFileLines,numLines, uselen);
return func;
}else{
NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,NFCBuffer,NFCBufferLen, uselen);
return func;
}
}
UPerfFunction* NormalizerPerformanceTest::TestICU_NFD_Orig_Text(){
if(line_mode){
NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,lines,numLines, uselen);
return func;
}else{
NormPerfFunction* func = new NormPerfFunction(ICUNormNFD, options,buffer,bufferLen, uselen);
return func;
}
}
// Test FCD Performance
UPerfFunction* NormalizerPerformanceTest::TestICU_FCD_NFD_Text(){
if(line_mode){
NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,NFDFileLines,numLines, uselen);
return func;
}else{
NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,NFDBuffer,NFDBufferLen, uselen);
return func;
}
}
UPerfFunction* NormalizerPerformanceTest::TestICU_FCD_NFC_Text(){
if(line_mode){
NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,NFCFileLines,numLines, uselen);
return func;
}else{
NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,NFCBuffer,NFCBufferLen, uselen);
return func;
}
}
UPerfFunction* NormalizerPerformanceTest::TestICU_FCD_Orig_Text(){
if(line_mode){
NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,lines,numLines, uselen);
return func;
}else{
NormPerfFunction* func = new NormPerfFunction(ICUNormFCD, options,buffer,bufferLen, uselen);
return func;
}
}
// Test Win NFC Performance
UPerfFunction* NormalizerPerformanceTest::TestWin_NFC_NFD_Text(){
if(line_mode){
NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,NFDFileLines,numLines, uselen);
return func;
}else{
NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,NFDBuffer,NFDBufferLen, uselen);
return func;
}
}
UPerfFunction* NormalizerPerformanceTest::TestWin_NFC_NFC_Text(){
if(line_mode){
NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,NFCFileLines,numLines, uselen);
return func;
}else{
NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,NFCBuffer,NFCBufferLen, uselen);
return func;
}
}
UPerfFunction* NormalizerPerformanceTest::TestWin_NFC_Orig_Text(){
if(line_mode){
NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,lines,numLines, uselen);
return func;
}else{
NormPerfFunction* func = new NormPerfFunction(WinNormNFC, options,buffer,bufferLen, uselen);
return func;
}
}
// Test Win NFD Performance
UPerfFunction* NormalizerPerformanceTest::TestWin_NFD_NFD_Text(){
if(line_mode){
NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,NFDFileLines,numLines, uselen);
return func;
}else{
NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,NFDBuffer,NFDBufferLen, uselen);
return func;
}
}
UPerfFunction* NormalizerPerformanceTest::TestWin_NFD_NFC_Text(){
if(line_mode){
NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,NFCFileLines,numLines, uselen);
return func;
}else{
NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,NFCBuffer,NFCBufferLen, uselen);
return func;
}
}
UPerfFunction* NormalizerPerformanceTest::TestWin_NFD_Orig_Text(){
if(line_mode){
NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,lines,numLines, uselen);
return func;
}else{
NormPerfFunction* func = new NormPerfFunction(WinNormNFD, options,buffer,bufferLen, uselen);
return func;
}
}
// Test Quick Check Performance
UPerfFunction* NormalizerPerformanceTest::TestQC_NFC_NFD_Text(){
if(line_mode){
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDFileLines, numLines, UNORM_NFC, options,uselen);
return func;
}else{
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDBuffer, NFDBufferLen, UNORM_NFC, options,uselen);
return func;
}
}
UPerfFunction* NormalizerPerformanceTest::TestQC_NFC_NFC_Text(){
if(line_mode){
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCFileLines, numLines, UNORM_NFC, options,uselen);
return func;
}else{
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCBuffer, NFCBufferLen, UNORM_NFC, options,uselen);
return func;
}
}
UPerfFunction* NormalizerPerformanceTest::TestQC_NFC_Orig_Text(){
if(line_mode){
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,lines, numLines, UNORM_NFC, options,uselen);
return func;
}else{
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,buffer, bufferLen, UNORM_NFC, options,uselen);
return func;
}
}
UPerfFunction* NormalizerPerformanceTest::TestQC_NFD_NFD_Text(){
if(line_mode){
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDFileLines, numLines, UNORM_NFD, options,uselen);
return func;
}else{
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDBuffer, NFDBufferLen, UNORM_NFD, options,uselen);
return func;
}
}
UPerfFunction* NormalizerPerformanceTest::TestQC_NFD_NFC_Text(){
if(line_mode){
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCFileLines, numLines, UNORM_NFD, options,uselen);
return func;
}else{
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCBuffer, NFCBufferLen, UNORM_NFD, options,uselen);
return func;
}
}
UPerfFunction* NormalizerPerformanceTest::TestQC_NFD_Orig_Text(){
if(line_mode){
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,lines, numLines, UNORM_NFD, options,uselen);
return func;
}else{
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,buffer, bufferLen, UNORM_NFD, options,uselen);
return func;
}
}
UPerfFunction* NormalizerPerformanceTest::TestQC_FCD_NFD_Text(){
if(line_mode){
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDFileLines, numLines, UNORM_FCD, options,uselen);
return func;
}else{
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFDBuffer, NFDBufferLen, UNORM_FCD, options,uselen);
return func;
}
}
UPerfFunction* NormalizerPerformanceTest::TestQC_FCD_NFC_Text(){
if(line_mode){
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCFileLines, numLines, UNORM_FCD, options,uselen);
return func;
}else{
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,NFCBuffer, NFCBufferLen, UNORM_FCD, options,uselen);
return func;
}
}
UPerfFunction* NormalizerPerformanceTest::TestQC_FCD_Orig_Text(){
if(line_mode){
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,lines, numLines, UNORM_FCD, options,uselen);
return func;
}else{
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUQuickCheck,buffer, bufferLen, UNORM_FCD, options,uselen);
return func;
}
}
// Test isNormalized Performance
UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFC_NFD_Text(){
if(line_mode){
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDFileLines, numLines, UNORM_NFC, options,uselen);
return func;
}else{
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDBuffer, NFDBufferLen, UNORM_NFC, options,uselen);
return func;
}
}
UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFC_NFC_Text(){
if(line_mode){
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCFileLines, numLines, UNORM_NFC, options,uselen);
return func;
}else{
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCBuffer, NFCBufferLen, UNORM_NFC, options,uselen);
return func;
}
}
UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFC_Orig_Text(){
if(line_mode){
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,lines, numLines, UNORM_NFC, options,uselen);
return func;
}else{
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,buffer, bufferLen, UNORM_NFC, options,uselen);
return func;
}
}
UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFD_NFD_Text(){
if(line_mode){
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDFileLines, numLines, UNORM_NFD, options,uselen);
return func;
}else{
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDBuffer, NFDBufferLen, UNORM_NFD, options,uselen);
return func;
}
}
UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFD_NFC_Text(){
if(line_mode){
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCFileLines, numLines, UNORM_NFD, options,uselen);
return func;
}else{
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCBuffer, NFCBufferLen, UNORM_NFD, options,uselen);
return func;
}
}
UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_NFD_Orig_Text(){
if(line_mode){
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,lines, numLines, UNORM_NFD, options,uselen);
return func;
}else{
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,buffer, bufferLen, UNORM_NFD, options,uselen);
return func;
}
}
UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_FCD_NFD_Text(){
if(line_mode){
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDFileLines, numLines, UNORM_FCD, options,uselen);
return func;
}else{
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFDBuffer, NFDBufferLen, UNORM_FCD, options,uselen);
return func;
}
}
UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_FCD_NFC_Text(){
if(line_mode){
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCFileLines, numLines, UNORM_FCD, options,uselen);
return func;
}else{
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,NFCBuffer, NFCBufferLen, UNORM_FCD, options,uselen);
return func;
}
}
UPerfFunction* NormalizerPerformanceTest::TestIsNormalized_FCD_Orig_Text(){
if(line_mode){
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,lines, numLines, UNORM_FCD, options,uselen);
return func;
}else{
QuickCheckPerfFunction* func = new QuickCheckPerfFunction(ICUIsNormalized,buffer, bufferLen, UNORM_FCD, options,uselen);
return func;
}
}
int main(int argc, const char* argv[]){
UErrorCode status = U_ZERO_ERROR;
NormalizerPerformanceTest test(argc, argv, status);
if(U_FAILURE(status)){
return status;
}
if(test.run()==FALSE){
fprintf(stderr,"FAILED: Tests could not be run please check the arguments.\n");
return -1;
}
return 0;
}
--- NEW FILE: normperf.dsp ---
# Microsoft Developer Studio Project File - Name="normperf" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Console Application" 0x0103
CFG=normperf - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "normperf.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "normperf.mak" CFG="normperf - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "normperf - Win32 Release" (based on "Win32 (x86) Console Application")
!MESSAGE "normperf - Win32 Debug" (based on "Win32 (x86) Console Application")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
RSC=rc.exe
!IF "$(CFG)" == "normperf - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
MTL=midl.exe
# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\..\..\..\include" /I "..\..\..\tools\toolutil" /I "..\..\..\common" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD BASE RSC /l 0x409 /d "NDEBUG"
# ADD RSC /l 0x409 /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
# ADD LINK32 icuuc.lib icuin.lib icutu.lib winmm.lib kernel32.lib /nologo /subsystem:console /machine:I386 /libpath:"..\..\..\..\lib\\"
!ELSEIF "$(CFG)" == "normperf - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "Debug"
# PROP Intermediate_Dir "Debug"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
MTL=midl.exe
# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD CPP /nologo /G6 /MDd /W3 /Gm /GX /ZI /Od /I "..\..\..\..\include" /I "..\..\..\tools\ctestfw" /I "..\..\..\common" /I "..\..\..\i18n" /I "..\..\..\tools\toolutil" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /D "_UNICODE" /FR /YX /FD /GZ /c
# ADD BASE RSC /l 0x409 /d "_DEBUG"
# ADD RSC /l 0x409 /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
# ADD LINK32 icuucd.lib icuind.lib icutud.lib winmm.lib kernel32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:"..\..\..\..\lib\\"
!ENDIF
# Begin Target
# Name "normperf - Win32 Release"
# Name "normperf - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=.\normperf.cpp
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# Begin Source File
SOURCE=.\normperf.h
# End Source File
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project
--- NEW FILE: normperf.h ---
/*
**********************************************************************
* Copyright (c) 2002-2003, International Business Machines
* Corporation and others. All Rights Reserved.
**********************************************************************
**********************************************************************
*/
#ifndef _NORMPERF_H
#define _NORMPERF_H
#include "uperf.h"
#include "unicode/unorm.h"
#include "unicode/ustring.h"
// Stubs for Windows API functions when building on UNIXes.
//
#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
// do nothing
#else
#define _UNICODE
typedef int DWORD;
inline int FoldStringW(DWORD dwMapFlags, const UChar* lpSrcStr,int cchSrc, UChar* lpDestStr,int cchDest);
#endif
#define DEST_BUFFER_CAPACITY 6000
typedef int32_t (*NormFn)(const UChar* src,int32_t srcLen, UChar* dest,int32_t dstLen, int32_t options, UErrorCode* status);
typedef int32_t (*QuickCheckFn)(const UChar* src,int32_t srcLen, UNormalizationMode mode, int32_t options, UErrorCode* status);
class QuickCheckPerfFunction : public UPerfFunction{
private:
ULine* lines;
int32_t numLines;
QuickCheckFn fn;
UNormalizationMode mode;
int32_t retVal;
UBool uselen;
const UChar* src;
int32_t srcLen;
UBool line_mode;
int32_t options;
public:
virtual void call(UErrorCode* status){
if(line_mode==TRUE){
if(uselen){
for(int32_t i = 0; i< numLines; i++){
retVal = (*fn)(lines[i].name,lines[i].len,mode, options, status);
}
}else{
for(int32_t i = 0; i< numLines; i++){
retVal = (*fn)(lines[i].name,-1,mode, options, status);
}
}
}else{
if(uselen){
retVal = (*fn)(src,srcLen,mode, options, status);
}else{
retVal = (*fn)(src,-1,mode, options, status);
}
}
}
virtual long getOperationsPerIteration(){
if(line_mode==TRUE){
int32_t totalChars=0;
for(int32_t i =0; i< numLines; i++){
totalChars+= lines[i].len;
}
return totalChars;
}else{
return srcLen;
}
}
QuickCheckPerfFunction(QuickCheckFn func, ULine* srcLines,int32_t srcNumLines, UNormalizationMode _mode, int32_t opts, UBool _uselen) : options(opts) {
fn = func;
lines = srcLines;
numLines = srcNumLines;
uselen = _uselen;
mode = _mode;
src = NULL;
srcLen = 0;
line_mode = TRUE;
}
QuickCheckPerfFunction(QuickCheckFn func, const UChar* source,int32_t sourceLen, UNormalizationMode _mode, int32_t opts, UBool _uselen) : options(opts) {
fn = func;
lines = NULL;
numLines = 0;
uselen = _uselen;
mode = _mode;
src = source;
srcLen = sourceLen;
line_mode = FALSE;
}
};
class NormPerfFunction : public UPerfFunction{
private:
ULine* lines;
int32_t numLines;
UChar dest[DEST_BUFFER_CAPACITY];
UChar* pDest;
int32_t destLen;
NormFn fn;
int32_t retVal;
UBool uselen;
const UChar* src;
int32_t srcLen;
UBool line_mode;
int32_t options;
public:
virtual void call(UErrorCode* status){
if(line_mode==TRUE){
if(uselen){
for(int32_t i = 0; i< numLines; i++){
retVal = (*fn)(lines[i].name,lines[i].len,pDest,destLen, options, status);
}
}else{
for(int32_t i = 0; i< numLines; i++){
retVal = (*fn)(lines[i].name,-1,pDest,destLen, options, status);
}
}
}else{
if(uselen){
retVal = (*fn)(src,srcLen,pDest,destLen, options, status);
}else{
retVal = (*fn)(src,-1,pDest,destLen, options, status);
}
}
}
virtual long getOperationsPerIteration(){
if(line_mode ==TRUE){
int32_t totalChars=0;
for(int32_t i =0; i< numLines; i++){
totalChars+= lines[i].len;
}
return totalChars;
}else{
return srcLen;
}
}
NormPerfFunction(NormFn func, int32_t opts, ULine* srcLines,int32_t srcNumLines,UBool _uselen) : options(opts) {
fn = func;
lines = srcLines;
numLines = srcNumLines;
uselen = _uselen;
destLen = DEST_BUFFER_CAPACITY;
pDest = dest;
src = NULL;
srcLen = 0;
line_mode = TRUE;
}
NormPerfFunction(NormFn func, int32_t opts, const UChar* source,int32_t sourceLen,UBool _uselen) : options(opts) {
fn = func;
lines = NULL;
numLines = 0;
uselen = _uselen;
destLen = sourceLen*3;
pDest = (UChar*) malloc(destLen * U_SIZEOF_UCHAR);
src = source;
srcLen = sourceLen;
line_mode = FALSE;
}
~NormPerfFunction(){
if(dest != pDest){
free(pDest);
}
}
};
class NormalizerPerformanceTest : public UPerfTest{
private:
ULine* NFDFileLines;
ULine* NFCFileLines;
UChar* NFDBuffer;
UChar* NFCBuffer;
UChar* origBuffer;
int32_t origBufferLen;
int32_t NFDBufferLen;
int32_t NFCBufferLen;
int32_t options;
void normalizeInput(ULine* dest,const UChar* src ,int32_t srcLen,UNormalizationMode mode, int32_t options);
UChar* normalizeInput(int32_t& len, const UChar* src ,int32_t srcLen,UNormalizationMode mode, int32_t options);
public:
NormalizerPerformanceTest(int32_t argc, const char* argv[], UErrorCode& status);
~NormalizerPerformanceTest();
virtual UPerfFunction* runIndexedTest(int32_t index, UBool exec,const char* &name, char* par = NULL);
/* NFC performance */
UPerfFunction* TestICU_NFC_NFD_Text();
UPerfFunction* TestICU_NFC_NFC_Text();
UPerfFunction* TestICU_NFC_Orig_Text();
/* NFD performance */
UPerfFunction* TestICU_NFD_NFD_Text();
UPerfFunction* TestICU_NFD_NFC_Text();
UPerfFunction* TestICU_NFD_Orig_Text();
/* FCD performance */
UPerfFunction* TestICU_FCD_NFD_Text();
UPerfFunction* TestICU_FCD_NFC_Text();
UPerfFunction* TestICU_FCD_Orig_Text();
/*Win NFC performance */
UPerfFunction* TestWin_NFC_NFD_Text();
UPerfFunction* TestWin_NFC_NFC_Text();
UPerfFunction* TestWin_NFC_Orig_Text();
/* Win NFD performance */
UPerfFunction* TestWin_NFD_NFD_Text();
UPerfFunction* TestWin_NFD_NFC_Text();
UPerfFunction* TestWin_NFD_Orig_Text();
/* Quick check performance */
UPerfFunction* TestQC_NFC_NFD_Text();
UPerfFunction* TestQC_NFC_NFC_Text();
UPerfFunction* TestQC_NFC_Orig_Text();
UPerfFunction* TestQC_NFD_NFD_Text();
UPerfFunction* TestQC_NFD_NFC_Text();
UPerfFunction* TestQC_NFD_Orig_Text();
UPerfFunction* TestQC_FCD_NFD_Text();
UPerfFunction* TestQC_FCD_NFC_Text();
UPerfFunction* TestQC_FCD_Orig_Text();
/* IsNormalized performnace */
UPerfFunction* TestIsNormalized_NFC_NFD_Text();
UPerfFunction* TestIsNormalized_NFC_NFC_Text();
UPerfFunction* TestIsNormalized_NFC_Orig_Text();
UPerfFunction* TestIsNormalized_NFD_NFD_Text();
UPerfFunction* TestIsNormalized_NFD_NFC_Text();
UPerfFunction* TestIsNormalized_NFD_Orig_Text();
UPerfFunction* TestIsNormalized_FCD_NFD_Text();
UPerfFunction* TestIsNormalized_FCD_NFC_Text();
UPerfFunction* TestIsNormalized_FCD_Orig_Text();
};
//---------------------------------------------------------------------------------------
// Platform / ICU version specific proto-types
//---------------------------------------------------------------------------------------
#if (U_ICU_VERSION_MAJOR_NUM > 1 ) || ((U_ICU_VERSION_MAJOR_NUM == 1 )&&(U_ICU_VERSION_MINOR_NUM > 8) && (U_ICU_VERSION_PATCHLEVEL_NUM >=1))
int32_t ICUNormNFD(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
return unorm_normalize(src,srcLen,UNORM_NFD, options,dest,dstLen,status);
}
int32_t ICUNormNFC(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
return unorm_normalize(src,srcLen,UNORM_NFC, options,dest,dstLen,status);
}
int32_t ICUNormNFKD(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
return unorm_normalize(src,srcLen,UNORM_NFKD, options,dest,dstLen,status);
}
int32_t ICUNormNFKC(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
return unorm_normalize(src,srcLen,UNORM_NFKC, options,dest,dstLen,status);
}
int32_t ICUNormFCD(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
return unorm_normalize(src,srcLen,UNORM_FCD, options,dest,dstLen,status);
}
int32_t ICUQuickCheck(const UChar* src,int32_t srcLen, UNormalizationMode mode, int32_t options, UErrorCode* status){
#if (U_ICU_VERSION_MAJOR_NUM > 2 ) || ((U_ICU_VERSION_MAJOR_NUM == 2 )&&(U_ICU_VERSION_MINOR_NUM >= 6))
return unorm_quickCheckWithOptions(src,srcLen,mode, options, status);
#else
return unorm_quickCheck(src,srcLen,mode,status);
#endif
}
int32_t ICUIsNormalized(const UChar* src,int32_t srcLen, UNormalizationMode mode, int32_t options, UErrorCode* status){
return unorm_isNormalized(src,srcLen,mode,status);
}
#else
int32_t ICUNormNFD(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
return unorm_normalize(src,srcLen,UCOL_DECOMP_CAN, options,dest,dstLen,status);
}
int32_t ICUNormNFC(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
return unorm_normalize(src,srcLen,UCOL_COMPOSE_CAN, options,dest,dstLen,status);
}
int32_t ICUNormNFKD(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
return unorm_normalize(src,srcLen,UCOL_DECOMP_COMPAT, options,dest,dstLen,status);
}
int32_t ICUNormNFKC(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
return unorm_normalize(src,srcLen,UCOL_COMPOSE_COMPAT, options,dest,dstLen,status);
}
int32_t ICUNormFCD(const UChar* src, int32_t srcLen,UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
return unorm_normalize(src,srcLen,UNORM_FCD, options,dest,dstLen,status);
}
int32_t ICUQuickCheck(const UChar* src,int32_t srcLen, UNormalizationMode mode, int32_t options, UErrorCode* status){
return unorm_quickCheck(src,srcLen,mode,status);
}
int32_t ICUIsNormalized(const UChar* src,int32_t srcLen, UNormalizationMode mode, int32_t options, UErrorCode* status){
return 0;
}
#endif
#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
int32_t WinNormNFD(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
return FoldStringW(MAP_COMPOSITE,src,srcLen,dest,dstLen);
}
int32_t WinNormNFC(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
return FoldStringW(MAP_PRECOMPOSED,src,srcLen,dest,dstLen);
}
int32_t WinNormNFKD(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
return FoldStringW(MAP_COMPOSITE+MAP_FOLDCZONE,src,srcLen,dest,dstLen);
}
int32_t WinNormNFKC(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
return FoldStringW(MAP_FOLDCZONE,src,srcLen,dest,dstLen);
}
#else
int32_t WinNormNFD(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
return 0 ;
}
int32_t WinNormNFC(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
return 0;
}
int32_t WinNormNFKD(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
return 0;
}
int32_t WinNormNFKC(const UChar* src, int32_t srcLen, UChar* dest, int32_t dstLen, int32_t options, UErrorCode* status) {
return 0;
}
#endif
#endif // NORMPERF_H
- Previous message: [sword-cvs] icu-sword/source/test/perf/charperf CharPerf.pl,NONE,1.1 Makefile.in,NONE,1.1 charperf.cpp,NONE,1.1 charperf.dsp,NONE,1.1 charperf.h,NONE,1.1
- Next message: [sword-cvs] icu-sword/source/test/perf/perldriver Dataset.pm,NONE,1.1 Format.pm,NONE,1.1 Output.pm,NONE,1.1 PerfFramework.pm,NONE,1.1
- Messages sorted by:
[ date ]
[ thread ]
[ subject ]
[ author ]