AdlibTiming.h

Go to the documentation of this file.

// -*- C++ -*-

// Copyright (C) 2003-2007 California Institute of Technology
// Ralf Deiterding, ralf@amroc.net
// Randolf Rotta

#ifndef ADLIB_TIMING_H
#define ADLIB_TIMING_H

#include <iostream>
#include <vector>

#ifndef WITH_MPI

#include <sys/time.h>
#include <time.h>
inline static double MPI_Wtime() { 
  struct timeval t; 
  gettimeofday(&t,0); 
  return (double)t.tv_sec + ((double)t.tv_usec)*0.000001; 
}

#endif

class AdlibTiming;
extern AdlibTiming adlib_timing;

#ifdef TIMING_ADLIB

#define ADLIB_START_WATCH                         adlib_timing.start();
#define ADLIB_END_WATCH(what)                     adlib_timing.stop(AdlibTiming::what);

#define ADLIB_START_WATCH_WHOLE                   adlib_timing.start_timing();
#define ADLIB_END_WATCH_WHOLE                     adlib_timing.stop(AdlibTiming::MISC);

#else

#define ADLIB_START_WATCH_WHOLE            
#define ADLIB_START_WATCH                 
#define ADLIB_END_WATCH(what)
#define ADLIB_END_WATCH_WHOLE              

#endif

class AdlibTiming {
public:
  enum TimingAccounts { 
    WHOLE, 
    
    MISC,

    /* user accounts */
    INITIALIZATION, INTEGRATION, ASSEMBLE, OUTPUT, 
    EXAMINE1, EXAMINE2, EXAMINE3, EXAMINE4,

    ELC_SNDBND_RCVPRS, 

    CPL_SEND_OVERHEAD, CPL_RECEIVE_OVERHEAD, 

    /* maker for internal use */
    _ACMAX };

public:
  /***************************************************************************/
  /* timing functions */

  inline void start_timing() 
    { tos = &timestack[0]; *tos = 0.0; start_time = MPI_Wtime(); }

  inline void start() { add_time(); tos++; *tos = 0.0; }

  inline void stop(enum TimingAccounts account) 
    { add_time(); times[account] += *tos; calls[account]++; tos--; }

protected:
  inline void add_time() {
    double end_time = MPI_Wtime();
    *tos += end_time - start_time; start_time = end_time;
  }

public:
  /***************************************************************************/
  /* global report generation interface */

  static void collect(MPI_Comm Comm) { 
#ifdef TIMING_ADLIB
    adlib_timing.collect_timing(Comm);
#endif
  }

  static void print(std::ostream& os) { 
#ifdef TIMING_ADLIB
    adlib_timing.print_local_times = false;
    adlib_timing.print_timing(os);
#endif
  }

  static void print_local(std::ostream& os) { 
#ifdef TIMING_ADLIB
    adlib_timing.print_local_times = true;
    adlib_timing.print_timing(os);
#endif
  }

  void collect_timing(MPI_Comm Comm, enum TimingAccounts ac, 
                      double* stat_times) {
#ifdef WITH_MPI
    MPI_Reduce(&times[ac], &stat_times[0], 1, MPI_DOUBLE, 
               MPI_MAX, 0, Comm);
    MPI_Reduce(&times[ac], &stat_times[1], 1, MPI_DOUBLE, 
               MPI_MIN, 0, Comm);
    MPI_Reduce(&times[ac], &stat_times[2], 1, MPI_DOUBLE, 
               MPI_SUM, 0, Comm);
 
    int procs;
    MPI_Comm_size(Comm, &procs);
    stat_times[2] /= procs;
#else
    stat_times[0] = times[ac];
    stat_times[1] = times[ac];
    stat_times[2] = times[ac];
#endif
  }

  void collect_timing(MPI_Comm Comm) {
    /* calculate summs */
    times[WHOLE] = calcsum(times, MISC, _ACMAX-1, 0.0);
    calls[WHOLE] = calcsum(calls, MISC, _ACMAX-1, (unsigned)0);

    /* collect values from all nodes */
    stat_times_max.resize(_ACMAX);
    stat_times_min.resize(_ACMAX);
    stat_times_avg.resize(_ACMAX);
#ifdef WITH_MPI
    MPI_Reduce(&times[0], &stat_times_max[0], _ACMAX, MPI_DOUBLE, 
               MPI_MAX, 0, Comm);
    MPI_Reduce(&times[0], &stat_times_min[0], _ACMAX, MPI_DOUBLE, 
               MPI_MIN, 0, Comm);
    MPI_Reduce(&times[0], &stat_times_avg[0], _ACMAX, MPI_DOUBLE, 
               MPI_SUM, 0, Comm);
 
    int procs;
    MPI_Comm_size(Comm, &procs);
    for (int i=0; i<_ACMAX; i++)
      stat_times_avg[i] /= procs;
#else
    stat_times_max = times;
    stat_times_min = times;
    stat_times_avg = times;
#endif
  }

  void print_timing(std::ostream& os) {
    pl(os,"Initialization               ", INITIALIZATION);
    pl(os,"Integration                  ", INTEGRATION); 
    pl(os,"Assemble                     ", ASSEMBLE);
    pl(os,"ELC - sendrcv_()             ", ELC_SNDBND_RCVPRS,true);
    pl(os,"Coupling Send - Overhead     ", CPL_SEND_OVERHEAD,true);
    pl(os,"Coupling Receive - Overhead  ", CPL_RECEIVE_OVERHEAD,true);
    pl(os,"Output                       ", OUTPUT); 
    pl(os,"Examined in detail 1         ", EXAMINE1,true);
    pl(os,"Examined in detail 2         ", EXAMINE2,true);
    pl(os,"Examined in detail 3         ", EXAMINE3,true);
    pl(os,"Examined in detail 4         ", EXAMINE4,true);
    pl(os,"Misc                         ", MISC);
    pl(os,"Whole time                   ", WHOLE);
  }

protected:
  template<typename T>
  inline T calcsum(typename std::vector<T> &data, 
                   int start, int end, T sum) {
    for (int i=start; i<=end; i++) sum += data[i];
    return sum;
  }

  inline void pl(std::ostream& OS, char *name,
                 enum TimingAccounts ac, bool opt=false) {
    char str[500];
    if (print_local_times) {
      if (opt && times[ac]==0.) return;
      std::sprintf(str, "   %s : %4.3fs (%3.2f%%)   calls: %4ix", 
                   name,
                   times[ac], (times[WHOLE]>0. ? 100.0*times[ac]/times[WHOLE] : 0.),
                   calls[ac]     
                   );
    } else {
      if (opt && stat_times_avg[ac]==0.) return;
      std::sprintf(str, "   %s : %4.3fs (%3.2f%%)   balance: %2.3f   diff: %4.2fs (%9.2fs - %4.2fs)", 
                   name,
                   stat_times_avg[ac], (stat_times_avg[WHOLE]>0. ? 
                                        100.0*stat_times_avg[ac]/stat_times_avg[WHOLE] : 0.),
                   (stat_times_avg[ac]>0. ? stat_times_max[ac] / stat_times_avg[ac] : 1.),
                   stat_times_max[ac] - stat_times_min[ac],
                   stat_times_max[ac], stat_times_min[ac]
                   );
    }
    OS << str << std::endl;
  }

public:
  AdlibTiming() { 
    times.resize(_ACMAX, 0.0);
    calls.resize(_ACMAX, 0);
    timestack.resize(MAXRECURSIONS);
  }

protected:
  std::vector<double> times; // [_ACMAX]
  std::vector<unsigned int> calls; // [_ACMAX]
  
  enum {MAXRECURSIONS=300};
  std::vector<double> timestack; // [MAXRECURSIONS]
  double *tos;

  bool print_local_times;
  std::vector<double> stat_times_max; // [_ACMAX]
  std::vector<double> stat_times_min; // [_ACMAX]
  std::vector<double> stat_times_avg; // [_ACMAX]

  double start_time;
};

#endif

---