Index: icu46/source/tools/ctestfw/unicode/utimer.h |
=================================================================== |
--- icu46/source/tools/ctestfw/unicode/utimer.h (revision 0) |
+++ icu46/source/tools/ctestfw/unicode/utimer.h (revision 0) |
@@ -0,0 +1,280 @@ |
+/* |
+************************************************************************ |
+* Copyright (c) 1997-2010, International Business Machines |
+* Corporation and others. All Rights Reserved. |
+************************************************************************ |
+*/ |
+ |
+#ifndef _UTIMER_H |
+#define _UTIMER_H |
+ |
+#include "unicode/utypes.h" |
+ |
+#if defined(U_WINDOWS) |
+# define VC_EXTRALEAN |
+# define WIN32_LEAN_AND_MEAN |
+# include <windows.h> |
+#else |
+# if defined(OS390) |
+# define __UU /* Universal Unix - for struct timeval */ |
+# endif |
+# include <time.h> |
+# include <sys/time.h> |
+# include <unistd.h> |
+#endif |
+ |
+/** |
+ * This API provides functions for performing performance measurement |
+ * There are 3 main usage scenarios. |
+ * i) Loop until a threshold time is reached: |
+ * Example: |
+ * <code> |
+ * typedef Params Params; |
+ * struct Params{ |
+ * UChar* target; |
+ * int32_t targetLen; |
+ * const UChar* source; |
+ * int32_t sourceLen; |
+ * UNormalizationMode mode; |
+ * } |
+ * void NormFn( void* param){ |
+ * Params* parameters = ( Params*) param; |
+ * UErrorCode error = U_ZERO_ERROR; |
+ * unorm_normalize(parameters->source, parameters->sourceLen, parameters->mode, 0, parameters->target, parameters->targetLen, &error); |
+ * if(U_FAILURE(error)){ |
+ * printf("Normalization failed\n"); |
+ * } |
+ * } |
+ * |
+ * int main(){ |
+ * // time the normalization function |
+ * double timeTaken = 0; |
+ * Params param; |
+ * param.source // set up the source buffer |
+ * param.target // set up the target buffer |
+ * .... so on ... |
+ * UTimer timer; |
+ * // time the loop for 10 seconds at least and find out the loop count and time taken |
+ * timeTaken = utimer_loopUntilDone((double)10,(void*) param, NormFn, &loopCount); |
+ * } |
+ * </code> |
+ * |
+ * ii) Measure the time taken |
+ * Example: |
+ * <code> |
+ * double perfNormalization(NormFn fn,const char* mode,Line* fileLines,int32_t loopCount){ |
+ * int line; |
+ * int loops; |
+ * UErrorCode error = U_ZERO_ERROR; |
+ * UChar* dest=NULL; |
+ * int32_t destCapacity=0; |
+ * int len =-1; |
+ * double elapsedTime = 0; |
+ * int retVal=0; |
+ * |
+ * UChar arr[5000]; |
+ * dest=arr; |
+ * destCapacity = 5000; |
+ * UTimer start; |
+ * |
+ * // Initialize cache and ensure the data is loaded. |
+ * // This loop checks for errors in Normalization. Once we pass the initialization |
+ * // without errors we can safelly assume that there are no errors while timing the |
+ * // funtion |
+ * for (loops=0; loops<10; loops++) { |
+ * for (line=0; line < gNumFileLines; line++) { |
+ * if (opt_uselen) { |
+ * len = fileLines[line].len; |
+ * } |
+ * |
+ * retVal= fn(fileLines[line].name,len,dest,destCapacity,&error); |
+ * #if defined(U_WINDOWS) |
+ * if(retVal==0 ){ |
+ * fprintf(stderr,"Normalization of string in Windows API failed for mode %s. ErrorNo: %i at line number %i\n",mode,GetLastError(),line); |
+ * return 0; |
+ * } |
+ * #endif |
+ * if(U_FAILURE(error)){ |
+ * fprintf(stderr,"Normalization of string in ICU API failed for mode %s. Error: %s at line number %i\n",mode,u_errorName(error),line); |
+ * return 0; |
+ * } |
+ * |
+ * } |
+ * } |
+ * |
+ * //compute the time |
+ * |
+ * utimer_getTime(&start); |
+ * for (loops=0; loops<loopCount; loops++) { |
+ * for (line=0; line < gNumFileLines; line++) { |
+ * if (opt_uselen) { |
+ * len = fileLines[line].len; |
+ * } |
+ * |
+ * retVal= fn(fileLines[line].name,len,dest,destCapacity,&error); |
+ * |
+ * } |
+ * } |
+ * |
+ * return utimer_getElapsedSeconds(&start); |
+ * } |
+ * </code> |
+ * |
+ * iii) Let a higher level function do the calculation of confidence levels etc. |
+ * Example: |
+ * <code> |
+ * void perf(UTimer* timer, UChar* source, int32_t sourceLen, UChar* target, int32_t targetLen, int32_t loopCount,UNormalizationMode mode, UErrorCode* error){ |
+ * int32_t loops; |
+ * for (loops=0; loops<loopCount; loops++) { |
+ * unorm_normalize(source,sourceLen,target, targetLen,mode,error); |
+ * } |
+ * utimer_getTime(timer); |
+ * } |
+ * void main(const char* argsc, int argv){ |
+ * // read the file and setup the data |
+ * // set up options |
+ * UTimer start,timer1, timer2, timer3, timer4; |
+ * double NFDTimeTaken, NFCTimeTaken, FCDTimeTaken; |
+ * switch(opt){ |
+ * case 0: |
+ * utimer_getTime(start); |
+ * perf(timer1, source,sourceLen, target, targetLen,loopCount,UNORM_NFD,&error); |
+ * NFDTimeTaken = utimer_getDeltaSeconds(start,timer1); |
+ * case 1: |
+ * timer_getTime(start); |
+ * perf(timer2,source,sourceLen,target,targetLen,loopCount,UNORM_NFC,&error); |
+ * NFCTimeTaken = utimer_getDeltaSeconds(start,timer2); |
+ * perf(timer3, source, sourceLen, target,targetLen, loopCount, UNORM_FCD,&error); |
+ * // ........so on ............. |
+ * } |
+ * // calculate confidence levels etc and print |
+ * |
+ * } |
+ * |
+ * </code> |
+ * |
+ */ |
+ |
+typedef struct UTimer UTimer; |
+ |
+typedef void FuntionToBeTimed(void* param); |
+ |
+ |
+#if defined(U_WINDOWS) |
+ |
+ struct UTimer{ |
+ LARGE_INTEGER start; |
+ LARGE_INTEGER placeHolder; |
+ }; |
+ |
+ int uprv_initFrequency(UTimer* timer) |
+ { |
+ return QueryPerformanceFrequency(&timer->placeHolder); |
+ } |
+ void uprv_start(UTimer* timer) |
+ { |
+ QueryPerformanceCounter(&timer->start); |
+ } |
+ double uprv_delta(UTimer* timer1, UTimer* timer2){ |
+ return ((double)(timer2->start.QuadPart - timer1->start.QuadPart))/((double)timer1->placeHolder.QuadPart); |
+ } |
+ UBool uprv_compareFrequency(UTimer* timer1, UTimer* timer2){ |
+ return (timer1->placeHolder.QuadPart == timer2->placeHolder.QuadPart); |
+ } |
+ |
+#else |
+ |
+ struct UTimer{ |
+ struct timeval start; |
+ struct timeval placeHolder; |
+ }; |
+ |
+ int32_t uprv_initFrequency(UTimer* /*timer*/) |
+ { |
+ return 0; |
+ } |
+ void uprv_start(UTimer* timer) |
+ { |
+ gettimeofday(&timer->start, 0); |
+ } |
+ double uprv_delta(UTimer* timer1, UTimer* timer2){ |
+ double t1, t2; |
+ |
+ t1 = (double)timer1->start.tv_sec + (double)timer1->start.tv_usec/(1000*1000); |
+ t2 = (double)timer2->start.tv_sec + (double)timer2->start.tv_usec/(1000*1000); |
+ return (t2-t1); |
+ } |
+ UBool uprv_compareFrequency(UTimer* /*timer1*/, UTimer* /*timer2*/){ |
+ return TRUE; |
+ } |
+ |
+#endif |
+/** |
+ * Intializes the timer with the current time |
+ * |
+ * @param timer A pointer to UTimer struct to recieve the current time |
+ */ |
+static U_INLINE void U_EXPORT2 |
+utimer_getTime(UTimer* timer){ |
+ uprv_initFrequency(timer); |
+ uprv_start(timer); |
+} |
+ |
+/** |
+ * Returns the difference in times between timer1 and timer2 by subtracting |
+ * timer1's time from timer2's time |
+ * |
+ * @param timer1 A pointer to UTimer struct to be used as starting time |
+ * @param timer2 A pointer to UTimer struct to be used as end time |
+ * @return Time in seconds |
+ */ |
+static U_INLINE double U_EXPORT2 |
+utimer_getDeltaSeconds(UTimer* timer1, UTimer* timer2){ |
+ if(uprv_compareFrequency(timer1,timer2)){ |
+ return uprv_delta(timer1,timer2); |
+ } |
+ /* got error return -1 */ |
+ return -1; |
+} |
+ |
+/** |
+ * Returns the time elapsed from the starting time represented by the |
+ * UTimer struct pointer passed |
+ * @param timer A pointer to UTimer struct to be used as starting time |
+ * @return Time elapsed in seconds |
+ */ |
+static U_INLINE double U_EXPORT2 |
+utimer_getElapsedSeconds(UTimer* timer){ |
+ UTimer temp; |
+ utimer_getTime(&temp); |
+ return uprv_delta(timer,&temp); |
+} |
+ |
+/** |
+ * Executes the function pointed to for a given time and returns exact time |
+ * taken and number of iterations of the loop |
+ * @param thresholTimeVal |
+ * @param loopCount output param to recieve the number of iterations |
+ * @param fn The funtion to be executed |
+ * @param param Parameters to be passed to the fn |
+ * @return the time elapsed in seconds |
+ */ |
+static U_INLINE double U_EXPORT2 |
+utimer_loopUntilDone(double thresholdTimeVal, |
+ int32_t* loopCount, |
+ FuntionToBeTimed fn, |
+ void* param){ |
+ UTimer timer; |
+ double currentVal=0; |
+ *loopCount = 0; |
+ utimer_getTime(&timer); |
+ for(;currentVal<thresholdTimeVal;){ |
+ fn(param); |
+ currentVal = utimer_getElapsedSeconds(&timer); |
+ (*loopCount)++; |
+ } |
+ return currentVal; |
+} |
+ |
+#endif |
+ |
Property changes on: icu46/source/tools/ctestfw/unicode/utimer.h |
___________________________________________________________________ |
Added: svn:eol-style |
+ LF |