Tracker.cxx

#include "Framework/Performance/Tracker.h"
 
namespace framework::performance {
 
const std::string Tracker::ALL = "__ALL__";
 
Tracker::Tracker(TDirectory* storage_directory,
                 const std::vector<std::string>& names)
    : storage_directory_{storage_directory} {
  storage_directory_->cd();
  event_data_ = new TTree("by_event", "by_event");
 
  names_.reserve(names.size() + 1);
  names_.push_back(Tracker::ALL);
  for (const std::string& name : names) {
    names_.push_back(name);
  }
 
  processor_timers_.resize(7);  // 7 different callbacks
  for (std::vector<Timer>& timer_set : processor_timers_) {
    timer_set.resize(names_.size());
  }
 
  event_data_->Branch("completed", &event_completed_);
  for (std::size_t i{0}; i < names_.size(); i++) {
    event_data_->Branch((names_[i] + ".").c_str(),
                        &(processor_timers_[to_index(Callback::process)][i]));
  }
}
 
Tracker::~Tracker() {
  storage_directory_->cd();
  absolute_.write(storage_directory_, "absolute");
 
  std::vector<Callback> non_event_callbacks = {
      Callback::onProcessStart, Callback::onProcessEnd, Callback::onFileOpen,
      Callback::onFileClose,    Callback::beforeNewRun, Callback::onNewRun};
  for (auto& callback : non_event_callbacks) {
    TDirectory* callback_d =
        storage_directory_->mkdir(to_name(callback).c_str());
    for (std::size_t i_proc{0}; i_proc < names_.size(); i_proc++) {
      processor_timers_[to_index(callback)][i_proc].write(callback_d,
                                                          names_[i_proc]);
    }
  }
}
 
void Tracker::absolute_start() { absolute_.start(); }
 
void Tracker::absolute_stop() { absolute_.stop(); }
 
void Tracker::start(Callback callback, std::size_t i_proc) {
  processor_timers_[to_index(callback)][i_proc].start();
}
 
void Tracker::stop(Callback callback, std::size_t i_proc) {
  processor_timers_[to_index(callback)][i_proc].stop();
}
 
void Tracker::end_event(bool completed) {
  event_completed_ = completed;
  event_data_->Fill();
  for (std::size_t i_proc{0}; i_proc < names_.size(); i_proc++) {
    processor_timers_[to_index(Callback::process)][i_proc].reset();
  }
}
 
}  // namespace framework::performance