intl/icu/source/tools/ctestfw/unicode/utimer.h@6474c204b198
intl/icu/source/tools/ctestfw/unicode/utimer.h
Wed, 31 Dec 2014 06:09:35 +0100
- author
- Michael Schloh von Bennewitz <michael@schloh.com>
- date
- Wed, 31 Dec 2014 06:09:35 +0100
- changeset 0
- 6474c204b198
- permissions
- -rw-r--r--
Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.
1 /*
2 ************************************************************************
3 * Copyright (c) 1997-2012, International Business Machines
4 * Corporation and others. All Rights Reserved.
5 ************************************************************************
6 */
8 #ifndef _UTIMER_H
9 #define _UTIMER_H
11 #include "unicode/utypes.h"
13 #if U_PLATFORM_HAS_WIN32_API
14 # define VC_EXTRALEAN
15 # define WIN32_LEAN_AND_MEAN
16 # include <windows.h>
17 #else
18 # if U_PLATFORM == U_PF_OS390 && !defined(__UU)
19 # define __UU /* Universal Unix - for struct timeval */
20 # endif
21 # include <time.h>
22 # include <sys/time.h>
23 # include <unistd.h>
24 #endif
26 /**
27 * This API provides functions for performing performance measurement
28 * There are 3 main usage scenarios.
29 * i) Loop until a threshold time is reached:
30 * Example:
31 * <code>
32 * typedef Params Params;
33 * struct Params{
34 * UChar* target;
35 * int32_t targetLen;
36 * const UChar* source;
37 * int32_t sourceLen;
38 * UNormalizationMode mode;
39 * }
40 * void NormFn( void* param){
41 * Params* parameters = ( Params*) param;
42 * UErrorCode error = U_ZERO_ERROR;
43 * unorm_normalize(parameters->source, parameters->sourceLen, parameters->mode, 0, parameters->target, parameters->targetLen, &error);
44 * if(U_FAILURE(error)){
45 * printf("Normalization failed\n");
46 * }
47 * }
48 *
49 * int main(){
50 * // time the normalization function
51 * double timeTaken = 0;
52 * Params param;
53 * param.source // set up the source buffer
54 * param.target // set up the target buffer
55 * .... so on ...
56 * UTimer timer;
57 * // time the loop for 10 seconds at least and find out the loop count and time taken
58 * timeTaken = utimer_loopUntilDone((double)10,(void*) param, NormFn, &loopCount);
59 * }
60 * </code>
61 *
62 * ii) Measure the time taken
63 * Example:
64 * <code>
65 * double perfNormalization(NormFn fn,const char* mode,Line* fileLines,int32_t loopCount){
66 * int line;
67 * int loops;
68 * UErrorCode error = U_ZERO_ERROR;
69 * UChar* dest=NULL;
70 * int32_t destCapacity=0;
71 * int len =-1;
72 * double elapsedTime = 0;
73 * int retVal=0;
74 *
75 * UChar arr[5000];
76 * dest=arr;
77 * destCapacity = 5000;
78 * UTimer start;
79 *
80 * // Initialize cache and ensure the data is loaded.
81 * // This loop checks for errors in Normalization. Once we pass the initialization
82 * // without errors we can safelly assume that there are no errors while timing the
83 * // funtion
84 * for (loops=0; loops<10; loops++) {
85 * for (line=0; line < gNumFileLines; line++) {
86 * if (opt_uselen) {
87 * len = fileLines[line].len;
88 * }
89 *
90 * retVal= fn(fileLines[line].name,len,dest,destCapacity,&error);
91 * #if U_PLATFORM_HAS_WIN32_API
92 * if(retVal==0 ){
93 * fprintf(stderr,"Normalization of string in Windows API failed for mode %s. ErrorNo: %i at line number %i\n",mode,GetLastError(),line);
94 * return 0;
95 * }
96 * #endif
97 * if(U_FAILURE(error)){
98 * fprintf(stderr,"Normalization of string in ICU API failed for mode %s. Error: %s at line number %i\n",mode,u_errorName(error),line);
99 * return 0;
100 * }
101 *
102 * }
103 * }
104 *
105 * //compute the time
106 *
107 * utimer_getTime(&start);
108 * for (loops=0; loops<loopCount; loops++) {
109 * for (line=0; line < gNumFileLines; line++) {
110 * if (opt_uselen) {
111 * len = fileLines[line].len;
112 * }
113 *
114 * retVal= fn(fileLines[line].name,len,dest,destCapacity,&error);
115 *
116 * }
117 * }
118 *
119 * return utimer_getElapsedSeconds(&start);
120 * }
121 * </code>
122 *
123 * iii) Let a higher level function do the calculation of confidence levels etc.
124 * Example:
125 * <code>
126 * void perf(UTimer* timer, UChar* source, int32_t sourceLen, UChar* target, int32_t targetLen, int32_t loopCount,UNormalizationMode mode, UErrorCode* error){
127 * int32_t loops;
128 * for (loops=0; loops<loopCount; loops++) {
129 * unorm_normalize(source,sourceLen,target, targetLen,mode,error);
130 * }
131 * utimer_getTime(timer);
132 * }
133 * void main(const char* argsc, int argv){
134 * // read the file and setup the data
135 * // set up options
136 * UTimer start,timer1, timer2, timer3, timer4;
137 * double NFDTimeTaken, NFCTimeTaken, FCDTimeTaken;
138 * switch(opt){
139 * case 0:
140 * utimer_getTime(start);
141 * perf(timer1, source,sourceLen, target, targetLen,loopCount,UNORM_NFD,&error);
142 * NFDTimeTaken = utimer_getDeltaSeconds(start,timer1);
143 * case 1:
144 * timer_getTime(start);
145 * perf(timer2,source,sourceLen,target,targetLen,loopCount,UNORM_NFC,&error);
146 * NFCTimeTaken = utimer_getDeltaSeconds(start,timer2);
147 * perf(timer3, source, sourceLen, target,targetLen, loopCount, UNORM_FCD,&error);
148 * // ........so on .............
149 * }
150 * // calculate confidence levels etc and print
151 *
152 * }
153 *
154 * </code>
155 *
156 */
158 typedef struct UTimer UTimer;
160 typedef void FuntionToBeTimed(void* param);
163 #if U_PLATFORM_HAS_WIN32_API
165 struct UTimer{
166 LARGE_INTEGER start;
167 LARGE_INTEGER placeHolder;
168 };
170 static int uprv_initFrequency(UTimer* timer)
171 {
172 return QueryPerformanceFrequency(&timer->placeHolder);
173 }
174 static void uprv_start(UTimer* timer)
175 {
176 QueryPerformanceCounter(&timer->start);
177 }
178 static double uprv_delta(UTimer* timer1, UTimer* timer2){
179 return ((double)(timer2->start.QuadPart - timer1->start.QuadPart))/((double)timer1->placeHolder.QuadPart);
180 }
181 static UBool uprv_compareFrequency(UTimer* timer1, UTimer* timer2){
182 return (timer1->placeHolder.QuadPart == timer2->placeHolder.QuadPart);
183 }
185 #else
187 struct UTimer{
188 struct timeval start;
189 struct timeval placeHolder;
190 };
192 static int32_t uprv_initFrequency(UTimer* /*timer*/)
193 {
194 return 0;
195 }
196 static void uprv_start(UTimer* timer)
197 {
198 gettimeofday(&timer->start, 0);
199 }
200 static double uprv_delta(UTimer* timer1, UTimer* timer2){
201 double t1, t2;
203 t1 = (double)timer1->start.tv_sec + (double)timer1->start.tv_usec/(1000*1000);
204 t2 = (double)timer2->start.tv_sec + (double)timer2->start.tv_usec/(1000*1000);
205 return (t2-t1);
206 }
207 static UBool uprv_compareFrequency(UTimer* /*timer1*/, UTimer* /*timer2*/){
208 return TRUE;
209 }
211 #endif
212 /**
213 * Intializes the timer with the current time
214 *
215 * @param timer A pointer to UTimer struct to recieve the current time
216 */
217 static inline void U_EXPORT2
218 utimer_getTime(UTimer* timer){
219 uprv_initFrequency(timer);
220 uprv_start(timer);
221 }
223 /**
224 * Returns the difference in times between timer1 and timer2 by subtracting
225 * timer1's time from timer2's time
226 *
227 * @param timer1 A pointer to UTimer struct to be used as starting time
228 * @param timer2 A pointer to UTimer struct to be used as end time
229 * @return Time in seconds
230 */
231 static inline double U_EXPORT2
232 utimer_getDeltaSeconds(UTimer* timer1, UTimer* timer2){
233 if(uprv_compareFrequency(timer1,timer2)){
234 return uprv_delta(timer1,timer2);
235 }
236 /* got error return -1 */
237 return -1;
238 }
240 /**
241 * Returns the time elapsed from the starting time represented by the
242 * UTimer struct pointer passed
243 * @param timer A pointer to UTimer struct to be used as starting time
244 * @return Time elapsed in seconds
245 */
246 static inline double U_EXPORT2
247 utimer_getElapsedSeconds(UTimer* timer){
248 UTimer temp;
249 utimer_getTime(&temp);
250 return uprv_delta(timer,&temp);
251 }
253 /**
254 * Executes the function pointed to for a given time and returns exact time
255 * taken and number of iterations of the loop
256 * @param thresholTimeVal
257 * @param loopCount output param to recieve the number of iterations
258 * @param fn The funtion to be executed
259 * @param param Parameters to be passed to the fn
260 * @return the time elapsed in seconds
261 */
262 static inline double U_EXPORT2
263 utimer_loopUntilDone(double thresholdTimeVal,
264 int32_t* loopCount,
265 FuntionToBeTimed fn,
266 void* param){
267 UTimer timer;
268 double currentVal=0;
269 *loopCount = 0;
270 utimer_getTime(&timer);
271 for(;currentVal<thresholdTimeVal;){
272 fn(param);
273 currentVal = utimer_getElapsedSeconds(&timer);
274 (*loopCount)++;
275 }
276 return currentVal;
277 }
279 #endif
