source: CIVL/examples/mpi-omp/AMG2013/utilities/timing.c

main
Last change on this file was ea777aa, checked in by Alex Wilton <awilton@…>, 3 years ago

Moved examples, include, build_default.properties, common.xml, and README out from dev.civl.com into the root of the repo.

git-svn-id: ​svn://vsl.cis.udel.edu/civl/trunk@5704 fb995dde-84ed-4084-dfe6-e5aef3e2452c
  • Property mode set to 100644
File size: 17.6 KB
Line 
1/*BHEADER**********************************************************************
2 * Copyright (c) 2008, Lawrence Livermore National Security, LLC.
3 * Produced at the Lawrence Livermore National Laboratory.
4 * This file is part of HYPRE. See file COPYRIGHT for details.
5 *
6 * HYPRE is free software; you can redistribute it and/or modify it under the
7 * terms of the GNU Lesser General Public License (as published by the Free
8 * Software Foundation) version 2.1 dated February 1999.
9 *
10 * $Revision: 2.4 $
11 ***********************************************************************EHEADER*/
12
13
14/******************************************************************************
15 *
16 * Routines for doing timing.
17 *
18 *****************************************************************************/
19
20#define HYPRE_TIMING_GLOBALS
21#include "utilities.h"
22#include "timing.h"
23
24
25/*-------------------------------------------------------
26 * Timing macros
27 *-------------------------------------------------------*/
28
29#define hypre_StartTiming() \
30hypre_TimingWallCount -= time_getWallclockSeconds();\
31hypre_TimingCPUCount -= time_getCPUSeconds()
32
33#define hypre_StopTiming() \
34hypre_TimingWallCount += time_getWallclockSeconds();\
35hypre_TimingCPUCount += time_getCPUSeconds()
36
37#ifndef HYPRE_USE_PTHREADS
38#define hypre_global_timing_ref(index,field) hypre_global_timing->field
39#else
40#define hypre_global_timing_ref(index,field) \
41 hypre_global_timing[index].field
42#endif
43
44/*--------------------------------------------------------------------------
45 * hypre_InitializeTiming
46 *--------------------------------------------------------------------------*/
47
48int
49hypre_InitializeTiming( const char *name )
50{
51 int time_index;
52
53 double *old_wall_time;
54 double *old_cpu_time;
55 double *old_flops;
56 char **old_name;
57 int *old_state;
58 int *old_num_regs;
59
60 int new_name;
61 int i;
62#ifdef HYPRE_USE_PTHREADS
63 int threadid = hypre_GetThreadID();
64#endif
65
66 /*-------------------------------------------------------
67 * Allocate global TimingType structure if needed
68 *-------------------------------------------------------*/
69
70 if (hypre_global_timing == NULL)
71 {
72#ifndef HYPRE_USE_PTHREADS
73 hypre_global_timing = hypre_CTAlloc(hypre_TimingType, 1);
74#else
75 hypre_global_timing = hypre_CTAlloc(hypre_TimingType,
76 hypre_NumThreads + 1);
77#endif
78 }
79
80 /*-------------------------------------------------------
81 * Check to see if name has already been registered
82 *-------------------------------------------------------*/
83
84 new_name = 1;
85 for (i = 0; i < (hypre_global_timing_ref(threadid, size)); i++)
86 {
87 if (hypre_TimingNumRegs(i) > 0)
88 {
89 if (strcmp(name, hypre_TimingName(i)) == 0)
90 {
91 new_name = 0;
92 time_index = i;
93 hypre_TimingNumRegs(time_index) ++;
94 break;
95 }
96 }
97 }
98
99 if (new_name)
100 {
101 for (i = 0; i < hypre_global_timing_ref(threadid ,size); i++)
102 {
103 if (hypre_TimingNumRegs(i) == 0)
104 {
105 break;
106 }
107 }
108 time_index = i;
109 }
110
111 /*-------------------------------------------------------
112 * Register the new timing name
113 *-------------------------------------------------------*/
114
115 if (new_name)
116 {
117 if (time_index == (hypre_global_timing_ref(threadid, size)))
118 {
119 old_wall_time = (hypre_global_timing_ref(threadid, wall_time));
120 old_cpu_time = (hypre_global_timing_ref(threadid, cpu_time));
121 old_flops = (hypre_global_timing_ref(threadid, flops));
122 old_name = (hypre_global_timing_ref(threadid, name));
123 old_state = (hypre_global_timing_ref(threadid, state));
124 old_num_regs = (hypre_global_timing_ref(threadid, num_regs));
125
126 (hypre_global_timing_ref(threadid, wall_time)) =
127 hypre_CTAlloc(double, (time_index+1));
128 (hypre_global_timing_ref(threadid, cpu_time)) =
129 hypre_CTAlloc(double, (time_index+1));
130 (hypre_global_timing_ref(threadid, flops)) =
131 hypre_CTAlloc(double, (time_index+1));
132 (hypre_global_timing_ref(threadid, name)) =
133 hypre_CTAlloc(char *, (time_index+1));
134 (hypre_global_timing_ref(threadid, state)) =
135 hypre_CTAlloc(int, (time_index+1));
136 (hypre_global_timing_ref(threadid, num_regs)) =
137 hypre_CTAlloc(int, (time_index+1));
138 (hypre_global_timing_ref(threadid, size)) ++;
139
140 for (i = 0; i < time_index; i++)
141 {
142 hypre_TimingWallTime(i) = old_wall_time[i];
143 hypre_TimingCPUTime(i) = old_cpu_time[i];
144 hypre_TimingFLOPS(i) = old_flops[i];
145 hypre_TimingName(i) = old_name[i];
146 hypre_TimingState(i) = old_state[i];
147 hypre_TimingNumRegs(i) = old_num_regs[i];
148 }
149
150 hypre_TFree(old_wall_time);
151 hypre_TFree(old_cpu_time);
152 hypre_TFree(old_flops);
153 hypre_TFree(old_name);
154 hypre_TFree(old_state);
155 hypre_TFree(old_num_regs);
156 }
157
158 hypre_TimingName(time_index) = hypre_CTAlloc(char, 80);
159 strncpy(hypre_TimingName(time_index), name, 79);
160 hypre_TimingState(time_index) = 0;
161 hypre_TimingNumRegs(time_index) = 1;
162 (hypre_global_timing_ref(threadid, num_names)) ++;
163 }
164
165 return time_index;
166}
167
168/*--------------------------------------------------------------------------
169 * hypre_FinalizeTiming
170 *--------------------------------------------------------------------------*/
171
172int
173hypre_FinalizeTiming( int time_index )
174{
175 int ierr = 0;
176 int i;
177#ifdef HYPRE_USE_PTHREADS
178 int threadid = hypre_GetThreadID();
179 int free_global_timing;
180#endif
181
182 if (hypre_global_timing == NULL)
183 return ierr;
184
185 if (time_index < (hypre_global_timing_ref(threadid, size)))
186 {
187 if (hypre_TimingNumRegs(time_index) > 0)
188 {
189 hypre_TimingNumRegs(time_index) --;
190 }
191
192 if (hypre_TimingNumRegs(time_index) == 0)
193 {
194 hypre_TFree(hypre_TimingName(time_index));
195 (hypre_global_timing_ref(threadid, num_names)) --;
196 }
197 }
198
199#ifdef HYPRE_USE_PTHREADS
200
201 free_global_timing = 1;
202 for (i = 0; i <= hypre_NumThreads; i++)
203 {
204 if (hypre_global_timing_ref(i, num_names))
205 {
206 free_global_timing = 0;
207 break;
208 }
209 }
210
211 if (free_global_timing)
212 {
213 pthread_mutex_lock(&time_mtx);
214 if(hypre_global_timing)
215 {
216 for (i = 0; i <= hypre_NumThreads; i++)
217
218 {
219 hypre_TFree(hypre_global_timing_ref(i, wall_time));
220 hypre_TFree(hypre_global_timing_ref(i, cpu_time));
221 hypre_TFree(hypre_global_timing_ref(i, flops));
222 hypre_TFree(hypre_global_timing_ref(i, name));
223 hypre_TFree(hypre_global_timing_ref(i, state));
224 hypre_TFree(hypre_global_timing_ref(i, num_regs));
225 }
226
227 hypre_TFree(hypre_global_timing);
228 hypre_global_timing = NULL;
229 }
230 pthread_mutex_unlock(&time_mtx);
231 }
232
233#else
234
235 if ((hypre_global_timing -> num_names) == 0)
236 {
237 for (i = 0; i < (hypre_global_timing -> size); i++)
238 {
239 hypre_TFree(hypre_global_timing_ref(i, wall_time));
240 hypre_TFree(hypre_global_timing_ref(i, cpu_time));
241 hypre_TFree(hypre_global_timing_ref(i, flops));
242 hypre_TFree(hypre_global_timing_ref(i, name));
243 hypre_TFree(hypre_global_timing_ref(i, state));
244 hypre_TFree(hypre_global_timing_ref(i, num_regs));
245 }
246
247 hypre_TFree(hypre_global_timing);
248 hypre_global_timing = NULL;
249 }
250
251#endif
252
253 return ierr;
254}
255
256/*--------------------------------------------------------------------------
257 * hypre_IncFLOPCount
258 *--------------------------------------------------------------------------*/
259
260int
261hypre_IncFLOPCount( int inc )
262{
263 int ierr = 0;
264#ifdef HYPRE_USE_PTHREADS
265 int threadid = hypre_GetThreadID();
266#endif
267
268 if (hypre_global_timing == NULL)
269 return ierr;
270
271 hypre_TimingFLOPCount += (double) (inc);
272
273#ifdef HYPRE_USE_PTHREADS
274 if (threadid != hypre_NumThreads)
275 {
276 pthread_mutex_lock(&time_mtx);
277 hypre_TimingAllFLOPS += (double) (inc);
278 pthread_mutex_unlock(&time_mtx);
279 }
280#endif
281
282 return ierr;
283}
284
285/*--------------------------------------------------------------------------
286 * hypre_BeginTiming
287 *--------------------------------------------------------------------------*/
288
289int
290hypre_BeginTiming( int time_index )
291{
292 int ierr = 0;
293#ifdef HYPRE_USE_PTHREADS
294 int threadid = hypre_GetThreadID();
295#endif
296
297 if (hypre_global_timing == NULL)
298 return ierr;
299
300 if (hypre_TimingState(time_index) == 0)
301 {
302 hypre_StopTiming();
303 hypre_TimingWallTime(time_index) -= hypre_TimingWallCount;
304 hypre_TimingCPUTime(time_index) -= hypre_TimingCPUCount;
305#ifdef HYPRE_USE_PTHREADS
306 if (threadid != hypre_NumThreads)
307 hypre_TimingFLOPS(time_index) -= hypre_TimingFLOPCount;
308 else
309 hypre_TimingFLOPS(time_index) -= hypre_TimingAllFLOPS;
310#else
311 hypre_TimingFLOPS(time_index) -= hypre_TimingFLOPCount;
312#endif
313
314 hypre_StartTiming();
315 }
316 hypre_TimingState(time_index) ++;
317
318 return ierr;
319}
320
321/*--------------------------------------------------------------------------
322 * hypre_EndTiming
323 *--------------------------------------------------------------------------*/
324
325int
326hypre_EndTiming( int time_index )
327{
328 int ierr = 0;
329#ifdef HYPRE_USE_PTHREADS
330 int threadid = hypre_GetThreadID();
331#endif
332
333 if (hypre_global_timing == NULL)
334 return ierr;
335
336 hypre_TimingState(time_index) --;
337 if (hypre_TimingState(time_index) == 0)
338 {
339 hypre_StopTiming();
340 hypre_TimingWallTime(time_index) += hypre_TimingWallCount;
341 hypre_TimingCPUTime(time_index) += hypre_TimingCPUCount;
342#ifdef HYPRE_USE_PTHREADS
343 if (threadid != hypre_NumThreads)
344 hypre_TimingFLOPS(time_index) += hypre_TimingFLOPCount;
345 else
346 hypre_TimingFLOPS(time_index) += hypre_TimingAllFLOPS;
347#else
348 hypre_TimingFLOPS(time_index) += hypre_TimingFLOPCount;
349#endif
350 hypre_StartTiming();
351 }
352
353 return ierr;
354}
355
356/*--------------------------------------------------------------------------
357 * hypre_ClearTiming
358 *--------------------------------------------------------------------------*/
359
360int
361hypre_ClearTiming( )
362{
363 int ierr = 0;
364 int i;
365#ifdef HYPRE_USE_PTHREADS
366 int threadid = hypre_GetThreadID();
367#endif
368
369 if (hypre_global_timing == NULL)
370 return ierr;
371
372 for (i = 0; i < (hypre_global_timing_ref(threadid,size)); i++)
373 {
374 hypre_TimingWallTime(i) = 0.0;
375 hypre_TimingCPUTime(i) = 0.0;
376 hypre_TimingFLOPS(i) = 0.0;
377 }
378
379 return ierr;
380}
381
382/*--------------------------------------------------------------------------
383 * hypre_PrintTiming
384 *--------------------------------------------------------------------------*/
385
386#ifndef HYPRE_USE_PTHREADS /* non-threaded version of hypre_PrintTiming */
387
388int
389hypre_PrintTiming( const char *heading,
390 double *wall_time_ptr,
391 MPI_Comm comm )
392{
393 int ierr = 0;
394
395 double local_wall_time;
396 double local_cpu_time;
397 double wall_time;
398 double cpu_time;
399 double wall_mflops;
400 double cpu_mflops;
401
402 int i;
403 int myrank;
404
405 if (hypre_global_timing == NULL)
406 return ierr;
407
408 MPI_Comm_rank(comm, &myrank );
409
410 /* print heading */
411 if (myrank == 0)
412 {
413 printf("=============================================\n");
414 printf("%s:\n", heading);
415 printf("=============================================\n");
416 }
417
418 for (i = 0; i < (hypre_global_timing -> size); i++)
419 {
420 if (hypre_TimingNumRegs(i) > 0)
421 {
422 local_wall_time = hypre_TimingWallTime(i);
423 local_cpu_time = hypre_TimingCPUTime(i);
424 MPI_Allreduce(&local_wall_time, &wall_time, 1,
425 MPI_DOUBLE, MPI_MAX, comm);
426 MPI_Allreduce(&local_cpu_time, &cpu_time, 1,
427 MPI_DOUBLE, MPI_MAX, comm);
428
429 if (myrank == 0)
430 {
431 printf("%s:\n", hypre_TimingName(i));
432 *wall_time_ptr = wall_time;
433 /* print wall clock info */
434 printf("%s wall clock time = %f seconds\n", hypre_TimingName(i), wall_time);
435 if (wall_time)
436 wall_mflops = hypre_TimingFLOPS(i) / wall_time / 1.0E6;
437 else
438 wall_mflops = 0.0;
439 /*printf(" wall MFLOPS = %f\n", wall_mflops);*/
440
441 /* print CPU clock info */
442 printf("%s cpu clock time = %f seconds\n", hypre_TimingName(i), cpu_time);
443 if (cpu_time)
444 cpu_mflops = hypre_TimingFLOPS(i) / cpu_time / 1.0E6;
445 else
446 cpu_mflops = 0.0;
447 /*printf(" cpu MFLOPS = %f\n\n", cpu_mflops);*/
448 }
449 }
450 }
451
452 return ierr;
453}
454
455#else /* threaded version of hypre_PrintTiming */
456
457#ifdef MPI_Comm_rank
458#undef MPI_Comm_rank
459#endif
460#ifdef MPI_Allreduce
461#undef MPI_Allreduce
462#endif
463
464int
465hypre_PrintTiming( const char *heading,
466 MPI_Comm comm )
467{
468 int ierr = 0;
469
470 double local_wall_time;
471 double local_cpu_time;
472 double wall_time;
473 double cpu_time;
474 double wall_mflops;
475 double cpu_mflops;
476
477 int i, j, index;
478 int myrank;
479 int my_thread = hypre_GetThreadID();
480 int threadid;
481 int max_size;
482 int num_regs;
483
484 char target_name[32];
485
486 if (my_thread == hypre_NumThreads)
487 {
488 if (hypre_global_timing == NULL)
489 return ierr;
490
491 MPI_Comm_rank(comm, &myrank );
492
493 /* print heading */
494 if (myrank == 0)
495 {
496 printf("=============================================\n");
497 printf("%s:\n", heading);
498 printf("=============================================\n");
499 }
500
501 for (i = 0; i < 7; i++)
502 {
503 switch (i)
504 {
505 case 0:
506 threadid = my_thread;
507 strcpy(target_name, hypre_TimingName(i));
508 break;
509 case 1:
510 strcpy(target_name, "SMG");
511 break;
512 case 2:
513 strcpy(target_name, "SMGRelax");
514 break;
515 case 3:
516 strcpy(target_name, "SMGResidual");
517 break;
518 case 4:
519 strcpy(target_name, "CyclicReduction");
520 break;
521 case 5:
522 strcpy(target_name, "SMGIntAdd");
523 break;
524 case 6:
525 strcpy(target_name, "SMGRestrict");
526 break;
527 }
528
529 threadid = 0;
530 for (j = 0; j < hypre_global_timing[threadid].size; j++)
531 {
532 if (strcmp(target_name, hypre_TimingName(j)) == 0)
533 {
534 index = j;
535 break;
536 }
537 else
538 index = -1;
539 }
540
541 if (i < hypre_global_timing[my_thread].size)
542 {
543 threadid = my_thread;
544 num_regs = hypre_TimingNumRegs(i);
545 }
546 else
547 num_regs = hypre_TimingNumRegs(index);
548
549 if (num_regs > 0)
550 {
551 local_wall_time = 0.0;
552 local_cpu_time = 0.0;
553 if (index >= 0)
554 {
555 for (threadid = 0; threadid < hypre_NumThreads; threadid++)
556 {
557 local_wall_time =
558 hypre_max(local_wall_time, hypre_TimingWallTime(index));
559 local_cpu_time =
560 hypre_max(local_cpu_time, hypre_TimingCPUTime(index));
561 }
562 }
563
564 if (i < hypre_global_timing[my_thread].size)
565 {
566 threadid = my_thread;
567 local_wall_time += hypre_TimingWallTime(i);
568 local_cpu_time += hypre_TimingCPUTime(i);
569 }
570
571 MPI_Allreduce(&local_wall_time, &wall_time, 1,
572 MPI_DOUBLE, MPI_MAX, comm);
573 MPI_Allreduce(&local_cpu_time, &cpu_time, 1,
574 MPI_DOUBLE, MPI_MAX, comm);
575
576 if (myrank == 0)
577 {
578 printf("%s:\n", target_name);
579
580 /* print wall clock info */
581 printf(" wall clock time = %f seconds\n", wall_time);
582 wall_mflops = 0.0;
583 if (wall_time)
584 {
585 if (index >= 0)
586 {
587 for (threadid = 0; threadid < hypre_NumThreads; threadid++)
588 {
589 wall_mflops +=
590 hypre_TimingFLOPS(index) / wall_time / 1.0E6;
591 }
592 }
593 if (i < hypre_global_timing[my_thread].size)
594 {
595 threadid = my_thread;
596 wall_mflops += hypre_TimingFLOPS(i) / wall_time / 1.0E6;
597 }
598 }
599
600 /*printf(" wall MFLOPS = %f\n", wall_mflops);*/
601
602 /* print CPU clock info */
603 printf(" cpu clock time = %f seconds\n", cpu_time);
604 cpu_mflops = 0.0;
605 if (cpu_time)
606 {
607 if (index >= 0)
608 {
609 for (threadid = 0; threadid < hypre_NumThreads; threadid++)
610 {
611 cpu_mflops +=
612 hypre_TimingFLOPS(index) / cpu_time / 1.0E6;
613 }
614 }
615 if (i < hypre_global_timing[my_thread].size)
616 {
617 threadid = my_thread;
618 cpu_mflops += hypre_TimingFLOPS(i) / cpu_time / 1.0E6;
619 }
620 }
621
622 /*printf(" cpu MFLOPS = %f\n\n", cpu_mflops);*/
623 }
624 }
625 }
626 }
627
628 return ierr;
629}
630
631#endif
Note: See TracBrowser for help on using the repository browser.