0023880: Integration of grid "ncl" into the new testing system
[occt.git] / src / OSD / OSD_PerfMeter.cxx
1 /*
2  Created on: 2000-08-10
3  Created by: Michael SAZONOV
4  Copyright (c) 2000-2014 OPEN CASCADE SAS
5
6  This file is part of Open CASCADE Technology software library.
7
8  This library is free software; you can redistribute it and/or modify it under
9  the terms of the GNU Lesser General Public License version 2.1 as published
10  by the Free Software Foundation, with special exception defined in the file
11  OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12  distribution for complete text of the license and disclaimer of any warranty.
13
14  Alternatively, this file may be used under the terms of Open CASCADE
15  commercial license or contractual agreement.
16 */ 
17
18 /*======================================================================
19 */ 
20 /*Purpose :       Set of functions to measure the CPU user time
21 */ 
22 /*25/09/2001 : AGV : (const char *) in prototypes;
23 */ 
24 /*09/11/2001 : AGV : Add functions perf_*_imeter for performance
25 */ 
26 /*Add function perf_tick_meter
27 */ 
28 /*14/05/2002 : AGV : Portability UNIX/Windows
29 */ 
30 /*======================================================================*/ 
31 #include <string.h>
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <limits.h>
35 #include <time.h>
36 #include <OSD_Chronometer.hxx>
37 #include <OSD_PerfMeter.h>
38
39
40 /*======================================================================
41         DEFINITIONS
42 ======================================================================*/
43
44 typedef Standard_Real PERF_TIME;
45
46 #define PICK_TIME(_utime) {     \
47   Standard_Real ktime;          \
48   OSD_Chronometer::GetThreadCPU(_utime, ktime);\
49 }
50
51 typedef struct {
52   char*         name;           /* identifier */
53   PERF_TIME     cumul_time;     /* cumulative time */
54   PERF_TIME     start_time;     /* to store start time */
55   int           nb_enter;       /* number of enters */
56 } t_TimeCounter;
57
58 #define MAX_METERS 100
59
60 static t_TimeCounter MeterTable[MAX_METERS];
61 static int nb_meters = 0;
62
63 static int  find_meter (const char * const MeterName);
64 static int  _perf_init_meter (const char * const MeterName,
65                                   const int    doFind);
66
67 /*======================================================================
68 Function :      perf_init_meter
69 Purpose  :      Creates new counter (if it is absent) identified by
70                 MeterName and resets its cumulative value
71 Returns  :      iMeter if OK, -1 if alloc problem
72 ======================================================================*/
73 int perf_init_meter (const char * const MeterName)
74 {
75   return _perf_init_meter (MeterName, ~0);
76 }
77
78 /*======================================================================
79 Function :      perf_tick_meter
80 Purpose  :      Increments the counter of meter MeterName without changing
81                 its state with respect to measurement of time.
82                 creates new meter if there is no such meter
83 Returns  :      iMeter if OK, -1 if no such meter and cannot create a new one
84 ======================================================================*/
85 int perf_tick_meter (const char * const MeterName)
86 {
87   int ic = find_meter (MeterName);
88
89   if (ic == -1) {
90     /* create new meter */
91     ic = _perf_init_meter (MeterName, 0);
92   }
93
94   if (ic >= 0)
95     MeterTable[ic].nb_enter ++;
96
97   return ic;
98 }
99
100 /*======================================================================
101 Function :      perf_tick_imeter
102 Purpose  :      Increments the counter of meter iMeter without changing
103                 its state with respect to measurement of time.
104 Returns  :      iMeter if OK, -1 if no such meter
105 ======================================================================*/
106 int perf_tick_imeter (const int iMeter)
107 {
108   if (iMeter >= 0 && iMeter < nb_meters) {
109     MeterTable[iMeter].nb_enter ++;
110     return iMeter;
111   }
112   return -1;
113 }
114
115 /*======================================================================
116 Function :      perf_start_meter
117 Purpose  :      Forces meter MeterName to begin to count by remembering
118                 the current data of timer;
119                 creates new meter if there is no such meter
120 Returns  :      iMeter if OK, -1 if no such meter and cannot create a new one
121 ======================================================================*/
122 int perf_start_meter (const char * const MeterName)
123 {
124   int ic = find_meter (MeterName);
125
126   if (ic == -1) {
127     /* create new meter */
128     ic = _perf_init_meter (MeterName, 0);
129   }
130
131   if (ic >= 0)
132     PICK_TIME (MeterTable[ic].start_time)
133
134   return ic;
135 }
136
137 /*======================================================================
138 Function :      perf_start_imeter
139 Purpose  :      Forces meter with number iMeter to begin count by remembering
140                 the current data of timer;
141                 the meter must be previously created
142 Returns  :      iMeter if OK, -1 if no such meter
143 ======================================================================*/
144 int perf_start_imeter (const int iMeter)
145 {
146   if (iMeter >= 0 && iMeter < nb_meters) {
147     PICK_TIME (MeterTable[iMeter].start_time)
148     return iMeter;
149   }
150   return -1;
151 }
152
153 /*======================================================================
154 Function :      perf_stop_meter
155 Purpose  :      Forces meter MeterName to stop and cumulate time elapsed
156                 since start
157 Returns  :      iMeter if OK, -1 if no such meter or it is has not been started
158 ======================================================================*/
159 int perf_stop_meter (const char * const MeterName)
160 {
161   const int ic = find_meter (MeterName);
162
163   if (ic >= 0 && MeterTable[ic].start_time) {
164     t_TimeCounter * const ptc = &MeterTable[ic];
165     PERF_TIME utime;
166     PICK_TIME (utime)
167     ptc->cumul_time += utime - ptc->start_time;
168     ptc->start_time = 0;
169     ptc->nb_enter++;
170   }
171
172   return ic;
173 }
174
175 /*======================================================================
176 Function :      perf_stop_imeter
177 Purpose  :      Forces meter with number iMeter to stop and cumulate the time
178                 elapsed since the start
179 Returns  :      iMeter if OK, -1 if no such meter or it is has not been started
180 ======================================================================*/
181 int perf_stop_imeter (const int iMeter)
182 {
183   if (iMeter >= 0 && iMeter < nb_meters) {
184     t_TimeCounter * const ptc = &MeterTable[iMeter];
185     if (ptc->start_time) {
186       PERF_TIME utime;
187       PICK_TIME (utime)
188       ptc->cumul_time += utime - ptc->start_time;
189       ptc->start_time = 0;
190       ptc->nb_enter++;
191       return iMeter;
192     }
193   }
194   return -1;
195 }
196
197 /*======================================================================
198 Function :      perf_get_meter
199 Purpose  :      Tells the time cumulated by meter MeterName and the number
200                 of enters to this meter
201 Output   :      *nb_enter, *seconds if the pointers != NULL
202 Returns  :      iMeter if OK, -1 if no such meter
203 ======================================================================*/
204 int perf_get_meter (const char  * const MeterName,
205                     int         * nb_enter,
206                     double      * seconds)
207 {
208   const int ic = find_meter (MeterName);
209
210   if (ic >= 0) {
211     if (nb_enter) *nb_enter = MeterTable[ic].nb_enter;
212     if (seconds)  *seconds  = MeterTable[ic].cumul_time;
213   }
214   return ic;
215 }
216
217 /*======================================================================
218 Function :      perf_print_all_meters
219 Purpose  :      Prints on stdout the cumulated time and the number of
220                 enters for each meter in MeterTable;
221                 resets all meters if reset is non-null
222 ======================================================================*/
223 void perf_print_all_meters (int reset)
224 {
225   char buffer[MAX_METERS * 256];
226   perf_sprint_all_meters (buffer, MAX_METERS * 256, reset);
227   printf ("%s", buffer);
228 }
229
230 /*======================================================================
231 Function :      perf_print_all_meters
232 Purpose  :      Prints to string buffer the cumulated time and the number of
233                 enters for each meter in MeterTable;
234                 resets all meters if reset is non-null
235 ======================================================================*/
236 void perf_sprint_all_meters (char *buffer, int length, int reset)
237 {
238   char string[256];
239
240   int i;
241   for (i=0; i<nb_meters; i++) {
242     const t_TimeCounter * const ptc = &MeterTable[i];
243     if (ptc && ptc->nb_enter) {
244       int n = sprintf (string, "          Perf meter results               :   enters  seconds  sec/enter\n");
245       if (n < length)
246       {
247         memcpy (buffer, string, n);
248         buffer += n;
249         length -= n;
250       }
251       break;
252     }
253   }
254   
255   while (i < nb_meters) {
256     t_TimeCounter * const ptc = &MeterTable[i++];
257
258     if (ptc && ptc->nb_enter) {
259       const double secs = ptc->cumul_time;
260
261       int n = 0;
262       if (ptc->start_time)
263         n = sprintf (string, "Warning : meter %42s has not been stopped\n", ptc->name);
264
265       n += sprintf (string + n, "%-42s : %7d %8.2f %10.2f\n",
266                     ptc->name, ptc->nb_enter, secs,
267                     (secs>0. ? 1000000 * secs/ptc->nb_enter : 0.));
268       if (n < length)
269       {
270         memcpy (buffer, string, n);
271         buffer += n;
272         length -= n;
273       }
274
275       if (reset)
276       {
277         ptc->cumul_time = 0;
278         ptc->start_time = 0;
279         ptc->nb_enter   = 0;
280       }
281     }
282   }
283   *buffer = '\0';
284 }
285
286 /*======================================================================
287 Function :      perf_close_meter
288 Purpose  :      Prints out a meter and resets it
289 Returns  :      none
290 ======================================================================*/
291 void perf_close_meter (const char * const MeterName)
292 {
293   perf_close_imeter (find_meter (MeterName));
294 }
295
296 /*======================================================================
297 Function :      perf_close_imeter
298 Purpose  :      Prints out a meter and resets it
299 Returns  :      none
300 ======================================================================*/
301 void perf_close_imeter (const int iMeter)
302 {
303   if (iMeter >= 0 && iMeter < nb_meters && MeterTable[iMeter].nb_enter) {
304     t_TimeCounter * const ptc = &MeterTable[iMeter];
305     if (ptc->start_time)
306       printf ("  ===> Warning : meter %s has not been stopped\n", ptc->name);
307     printf ("  ===> [%s] : %d enters, %9.3f seconds\n",
308             ptc->name, ptc->nb_enter, ptc->cumul_time);
309     ptc->cumul_time = 0;
310     ptc->start_time = 0;
311     ptc->nb_enter   = 0;
312   }
313 }
314
315 /*======================================================================
316 Function :      perf_destroy_all_meters
317 Purpose  :      Deletes all meters and frees memory
318 Returns  :      none
319 ======================================================================*/
320 void perf_destroy_all_meters (void)
321 {
322   int i;
323   for (i=0; i<nb_meters; i++)
324     free (MeterTable[i].name);
325   nb_meters = 0;
326 }
327
328 /* agv - non portable: #pragma fini (perf_print_and_destroy)
329          using atexit instead (see _perf_init_meter below)            */
330
331 void perf_print_and_destroy (void)
332 {
333   perf_print_all_meters (0);
334   perf_destroy_all_meters ();
335 }
336
337 /*======================================================================
338 Function :      _perf_init_meter
339 Purpose  :      Creates new counter (if it is absent) identified by
340                 MeterName and resets its cumulative value
341 Returns  :      index of meter if OK, -1 if alloc problem
342 Remarks  :      For internal use in this module
343 ======================================================================*/
344 static int _perf_init_meter (const char * const MeterName,
345                              const int  doFind)
346 {
347   static int hasbeencalled = 0;
348   int ic = -1;
349   if (doFind)
350     ic = find_meter (MeterName);
351
352   if (ic == -1) {
353     if (nb_meters >= MAX_METERS) return 0;
354     ic = nb_meters;
355
356     MeterTable[ic].name = strdup (MeterName);
357     if (!MeterTable[ic].name)
358       return -1;
359
360     nb_meters++;
361   }
362
363   MeterTable[ic].cumul_time = 0;
364   MeterTable[ic].start_time = 0;
365   MeterTable[ic].nb_enter   = 0;
366   if (hasbeencalled == 0) {
367     atexit (perf_print_and_destroy);
368     hasbeencalled = ~0;
369   }
370   return ic;
371 }
372
373 /*======================================================================
374 Function :      find_meter
375 Purpose  :      Finds the meter MeterName in the MeterTable
376 Returns  :      Index of meter object, -1 if not found
377 Remarks  :      For internal use in this module
378 ======================================================================*/
379 static int find_meter (const char * const MeterName)
380 {
381   int i;
382   for (i=0; i<nb_meters; i++)
383     if (!strcmp (MeterTable[i].name, MeterName)) return i;
384   return -1;
385 }