L1Timer.h

Go to the documentation of this file.

#ifndef _L1Timer_H
#define _L1Timer_H

/*
 *=====================================================
 *
 *  Authors: I.Kulakov
 *
 */

#include "TStopwatch.h"
#include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <map>

using std::cout;
using std::endl;
using std::ios;
using std::setw;
using std::string;
using std::vector;
using std::map;

class TimerInfo {
 public:
  TimerInfo():fName(""),fReal(0),fCpu(0){ };
  TimerInfo( const string& name ):fName(name),fReal(0),fCpu(0){ };

  void Clear() { fReal = 0; fCpu = 0; }
  
  void operator =( TStopwatch& sw ) { fReal  = sw.RealTime(); fCpu  = sw.CpuTime(); };
  void operator+=( TStopwatch& sw ) { fReal += sw.RealTime(); fCpu += sw.CpuTime(); };
  void operator+=( const TimerInfo& t ){ fReal += t.fReal; fCpu += t.fCpu; }
  TimerInfo operator/( const float f ) const { TimerInfo r; r.fName = fName; r.fReal = fReal/f; r.fCpu = fCpu/f; return r; }
  
  // void Print(){ cout << fReal << "/" << fCpu; };
  void PrintReal(){ cout << fReal ; };
  float Real(){ return fReal; };
  string& Name(){ return fName; };
 private:
  string fName;
  float fReal, fCpu;
};

class L1CATFIterTimerInfo {
 public:
  void Clear() {
    for( unsigned int i = 0; i < fTIs.size(); i++ )
      fTIs[i].Clear();
  };
  
  void Add( string name ) { fNameToI[name] = fTIs.size(); fTIs.push_back(TimerInfo(name)); };
  TimerInfo& operator[]( string name ) { return fTIs[fNameToI[name]]; };
  TimerInfo& operator[]( int i ) { return fTIs[i]; };
  void operator+=( L1CATFIterTimerInfo& t ){ for( unsigned int i = 0; i < fTIs.size(); ++i ) fTIs[i] += t[i]; }
  L1CATFIterTimerInfo operator/( float f ){
    L1CATFIterTimerInfo r;
    r.fNameToI = fNameToI;
    r.fTIs.resize(fTIs.size());
    for( unsigned int i = 0; i < fTIs.size(); ++i ) {
      r.fTIs[i] = fTIs[i]/f;
    }
    return r;
  }
  
  void PrintReal( int f = 0 ){
    if (f) { PrintNames(); cout << endl; }
    fTIs[0].PrintReal(); for( unsigned int i = 1; i < fTIs.size(); ++i ) { cout << " | " << setw(fTIs[i].Name().size()); fTIs[i].PrintReal(); }
    if (f) cout << endl;
  };
  void PrintNames(){ cout << fTIs[0].Name(); for( unsigned int i = 1; i < fTIs.size(); ++i ) { cout << " | " << fTIs[i].Name(); } };
 private:
  map< string, int > fNameToI;
  vector<TimerInfo> fTIs;
};

class L1CATFTimerInfo {
 public:
  L1CATFTimerInfo(){};
  L1CATFTimerInfo(int n ) { fTIIs.resize(n); };
  void SetNIter( int n ) { fTIIs.resize(n); };

  void Clear() {
    for( unsigned int i = 0; i < fTIIs.size(); i++ )
      fTIIs[i].Clear();
    fTIAll.Clear();
  };
  
  void Add( string name ) {
    for( unsigned int i = 0; i < fTIIs.size(); ++i )
      fTIIs[i].Add(name);
    fTIAll.Add(name);
  }; // use after setniter
  L1CATFIterTimerInfo& GetTimerAll() { return fTIAll; };
  L1CATFIterTimerInfo& operator[]( int i ) { return fTIIs[i]; };
  void operator+=( L1CATFTimerInfo& t ){ for( unsigned int i = 0; i < fTIIs.size(); ++i ) fTIIs[i] += t[i]; fTIAll += t.GetAllInfo(); }
  L1CATFTimerInfo operator/( float f ){
    L1CATFTimerInfo r;
    r.fTIAll = fTIAll/f;
    r.SetNIter( fTIIs.size() );
    for( unsigned int i = 0; i < fTIIs.size(); ++i ) {
      r.fTIIs[i] = fTIIs[i]/f;
    }
    return r;
  }
  
  void Calc() {
    fTIAll = fTIIs[0];
    for( unsigned int i = 1; i < fTIIs.size(); ++i )
      fTIAll += fTIIs[i];
  }
  
  L1CATFIterTimerInfo& GetAllInfo() { return fTIAll; };
  void PrintReal() {
    //save original cout flags
    std::ios_base::fmtflags coutFlags = cout.flags();

    int old_precision = cout.precision(1);
    cout.setf(ios::fixed);
    cout << " stage "<< " : "; fTIAll.PrintNames(); cout << endl;
    for( unsigned int i = 0; i < fTIIs.size(); ++i ) {
      cout << " iter " << i << " : "; fTIIs[i].PrintReal(); cout << endl;
    }
    cout << " all   "<< " : "; fTIAll.PrintReal(); cout << endl;

    //restore original cout flags
    cout.flags(coutFlags);
    cout.precision(old_precision);
  };
 private:
  vector<L1CATFIterTimerInfo> fTIIs;
  L1CATFIterTimerInfo fTIAll;
};

#endif