L1Timer.h

Go to the documentation of this file.

//****************************************************************************
//*                   This file is part of PandaRoot.                        *
//*                                                                          *
//*            PandaRoot is distributed under the terms of the               *
//*              GNU General Public License (GPL) version 3,                 *
//*                 copied verbatim in the file "LICENSE".                   *
//*                                                                          *
//*  Copyright (C) 2006 - 2024 FAIR GmbH and copyright holders of PandaRoot  *
//*     The copyright holders are listed in the file "COPYRIGHTHOLDERS".     *
//*               The authors are listed in the file "AUTHORS".              *
//****************************************************************************

#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::map;
using std::setw;
using std::string;
using std::vector;

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