edm::service::Timing Class Reference

Inheritance diagram for edm::service::Timing:

Classes
struct	CountAndTime

Public Member Functions
void	addToCPUTime (double iTime) override
double	getTotalCPU () const override
	Timing (ParameterSet const &, ActivityRegistry &)
	~Timing () override
Public Member Functions inherited from edm::TimingServiceBase
const TimingServiceBase &	operator= (const TimingServiceBase &)=delete
	TimingServiceBase ()
	TimingServiceBase (const TimingServiceBase &)=delete
virtual	~TimingServiceBase ()

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)
Static Public Member Functions inherited from edm::TimingServiceBase
static void	jobStarted ()
static double	jobStartTime ()

Private Member Functions
void	accumulateTimeBegin (std::atomic< CountAndTime * > &countAndTime, double &accumulatedTime)
void	accumulateTimeEnd (std::atomic< CountAndTime * > &countAndTime, double &accumulatedTime)
void	lastPostEvent (double curr_event_time, unsigned int index, StreamContext const &iStream)
void	postBeginJob ()
double	postCommon () const
void	postEndJob ()
void	postEvent (StreamContext const &)
void	postGlobalBeginLumi (GlobalContext const &)
void	postGlobalBeginRun (GlobalContext const &)
void	postModule (ModuleDescription const &md)
void	postModuleEvent (StreamContext const &, ModuleCallingContext const &)
void	postModuleGlobal (GlobalContext const &, ModuleCallingContext const &)
void	postModuleStream (StreamContext const &, ModuleCallingContext const &)
void	postOpenFile (std::string const &, bool)
void	postSourceEvent (StreamID)
void	postSourceLumi (LuminosityBlockIndex)
void	postSourceRun (RunIndex)
void	preBeginJob (PathsAndConsumesOfModulesBase const &, ProcessContext const &)
void	preEvent (StreamContext const &)
void	preModule (ModuleDescription const &md)
void	preModuleGlobal (GlobalContext const &, ModuleCallingContext const &)
void	preModuleStream (StreamContext const &, ModuleCallingContext const &)
void	preOpenFile (std::string const &, bool)
void	preSourceEvent (StreamID)
void	preSourceLumi (LuminosityBlockIndex)
void	preSourceRun (RunIndex)

Private Attributes
double	accumulatedTimeForGet_
double	accumulatedTimeForLock_
std::atomic< unsigned long >	begin_lumi_count_
std::atomic< unsigned long >	begin_run_count_
bool	configuredInTopLevelProcess_
std::atomic< CountAndTime * >	countAndTimeForGet_
std::atomic< CountAndTime * >	countAndTimeForLock_
CountAndTime	countAndTimeZero_
std::vector< std::unique_ptr< std::atomic< unsigned int > > >	countSubProcessesPostEvent_
std::vector< std::unique_ptr< std::atomic< unsigned int > > >	countSubProcessesPreEvent_
std::vector< double >	curr_events_time_
double	curr_job_cpu_
double	curr_job_time_
std::atomic< double >	extra_job_cpu_
std::atomic< double >	last_run_cpu_
std::atomic< double >	last_run_time_
std::vector< double >	max_events_time_
std::vector< double >	min_events_time_
unsigned int	nStreams_
unsigned int	nSubProcesses_
unsigned int	nThreads_
bool	report_summary_
std::vector< double >	sum_events_time_
bool	summary_only_
double	threshold_
std::atomic< unsigned long >	total_event_count_

Detailed Description

Definition at line 46 of file Timing.cc.

Constructor & Destructor Documentation

Timing()

edm::service::Timing::Timing	(	ParameterSet const &	iPS,
		ActivityRegistry &	iRegistry
	)

Definition at line 207 of file Timing.cc.

        : curr_job_time_(0.),
          curr_job_cpu_(0.),
          extra_job_cpu_(0.0),
          last_run_time_(0.0),
          last_run_cpu_(0.0),
          curr_events_time_(),
          summary_only_(iPS.getUntrackedParameter<bool>("summaryOnly")),
          report_summary_(iPS.getUntrackedParameter<bool>("useJobReport")),
          threshold_(iPS.getUntrackedParameter<double>("excessiveTimeThreshold")),
          max_events_time_(),
          min_events_time_(),
          total_event_count_(0),
          begin_lumi_count_(0),
          begin_run_count_(0),
          countAndTimeZero_{0, 0.0},
          countAndTimeForLock_{&countAndTimeZero_},
          accumulatedTimeForLock_{0.0},
          countAndTimeForGet_{&countAndTimeZero_},
          accumulatedTimeForGet_{0.0},
          configuredInTopLevelProcess_{false},
          nSubProcesses_{0} {
      iRegistry.watchPreBeginJob(this, &Timing::preBeginJob);
      iRegistry.watchPostBeginJob(this, &Timing::postBeginJob);
      iRegistry.watchPostEndJob(this, &Timing::postEndJob);
 
      iRegistry.watchPreEvent(this, &Timing::preEvent);
      iRegistry.watchPostEvent(this, &Timing::postEvent);
 
      bool checkThreshold = true;
      if (threshold_ <= 0.0) {
        //we need to ignore the threshold check
        threshold_ = std::numeric_limits<double>::max();
        checkThreshold = false;
      }
 
      if ((not summary_only_) || (checkThreshold)) {
        iRegistry.watchPreModuleEvent(this, &Timing::preModuleStream);
        iRegistry.watchPostModuleEvent(this, &Timing::postModuleEvent);
      }
      if (checkThreshold) {
        iRegistry.watchPreSourceEvent(this, &Timing::preSourceEvent);
        iRegistry.watchPostSourceEvent(this, &Timing::postSourceEvent);
 
        iRegistry.watchPreSourceLumi(this, &Timing::preSourceLumi);
        iRegistry.watchPostSourceLumi(this, &Timing::postSourceLumi);
 
        iRegistry.watchPreSourceRun(this, &Timing::preSourceRun);
        iRegistry.watchPostSourceRun(this, &Timing::postSourceRun);
 
        iRegistry.watchPreOpenFile(this, &Timing::preOpenFile);
        iRegistry.watchPostOpenFile(this, &Timing::postOpenFile);
 
        iRegistry.watchPreEventReadFromSource(this, &Timing::preModuleStream);
        iRegistry.watchPostEventReadFromSource(this, &Timing::postModuleStream);
 
        iRegistry.watchPreModuleConstruction(this, &Timing::preModule);
        iRegistry.watchPostModuleConstruction(this, &Timing::postModule);
 
        iRegistry.watchPreModuleDestruction(this, &Timing::preModule);
        iRegistry.watchPostModuleDestruction(this, &Timing::postModule);
 
        iRegistry.watchPreModuleBeginJob(this, &Timing::preModule);
        iRegistry.watchPostModuleBeginJob(this, &Timing::postModule);
 
        iRegistry.watchPreModuleEndJob(this, &Timing::preModule);
        iRegistry.watchPostModuleEndJob(this, &Timing::postModule);
 
        iRegistry.watchPreModuleStreamBeginRun(this, &Timing::preModuleStream);
        iRegistry.watchPostModuleStreamBeginRun(this, &Timing::postModuleStream);
        iRegistry.watchPreModuleStreamEndRun(this, &Timing::preModuleStream);
        iRegistry.watchPostModuleStreamEndRun(this, &Timing::postModuleStream);
 
        iRegistry.watchPreModuleStreamBeginLumi(this, &Timing::preModuleStream);
        iRegistry.watchPostModuleStreamBeginLumi(this, &Timing::postModuleStream);
        iRegistry.watchPreModuleStreamEndLumi(this, &Timing::preModuleStream);
        iRegistry.watchPostModuleStreamEndLumi(this, &Timing::postModuleStream);
 
        iRegistry.watchPreModuleGlobalBeginRun(this, &Timing::preModuleGlobal);
        iRegistry.watchPostModuleGlobalBeginRun(this, &Timing::postModuleGlobal);
        iRegistry.watchPreModuleGlobalEndRun(this, &Timing::preModuleGlobal);
        iRegistry.watchPostModuleGlobalEndRun(this, &Timing::postModuleGlobal);
 
        iRegistry.watchPreModuleGlobalBeginLumi(this, &Timing::preModuleGlobal);
        iRegistry.watchPostModuleGlobalBeginLumi(this, &Timing::postModuleGlobal);
        iRegistry.watchPreModuleGlobalEndLumi(this, &Timing::preModuleGlobal);
        iRegistry.watchPostModuleGlobalEndLumi(this, &Timing::postModuleGlobal);
 
        iRegistry.watchPreSourceConstruction(this, &Timing::preModule);
        iRegistry.watchPostSourceConstruction(this, &Timing::postModule);
      }
 
      iRegistry.watchPostGlobalBeginRun(this, &Timing::postGlobalBeginRun);
      iRegistry.watchPostGlobalBeginLumi(this, &Timing::postGlobalBeginLumi);
 
      iRegistry.preallocateSignal_.connect([this](service::SystemBounds const& iBounds) {
        nStreams_ = iBounds.maxNumberOfStreams();
        nThreads_ = iBounds.maxNumberOfThreads();
        curr_events_time_.resize(nStreams_, 0.);
        sum_events_time_.resize(nStreams_, 0.);
        max_events_time_.resize(nStreams_, 0.);
        min_events_time_.resize(nStreams_, 1.E6);
        for (unsigned int i = 0; i < nStreams_; ++i) {
          countSubProcessesPreEvent_.emplace_back(std::make_unique<std::atomic<unsigned int>>(0));
          countSubProcessesPostEvent_.emplace_back(std::make_unique<std::atomic<unsigned int>>(0));
        }
      });
 
      iRegistry.postGlobalEndRunSignal_.connect([this](edm::GlobalContext const&) {
        last_run_time_ = getTime();
        last_run_cpu_ = getCPU();
      });
    }

~Timing()

edm::service::Timing::~Timing ( )

override

Definition at line 321 of file Timing.cc.

{}

Member Function Documentation

accumulateTimeBegin()

void edm::service::Timing::accumulateTimeBegin ( std::atomic< CountAndTime * > &  countAndTime, double &  accumulatedTime  )

private

Definition at line 595 of file Timing.cc.

                                                                                                    {
      double newTime = getTime();
      auto newStat = std::make_unique<CountAndTime>(0, newTime);
 
      CountAndTime* oldStat = countAndTime.load();
      while (true) {
        if (oldStat == nullptr) {
          oldStat = countAndTime.load();
        } else if (countAndTime.compare_exchange_strong(oldStat, nullptr)) {
          break;
        }
      }
 
      newStat->count_ = oldStat->count_ + 1;
      if (oldStat->count_ != 0) {
        accumulatedTime += (newTime - oldStat->time_) * oldStat->count_;
      }
      countAndTime.store(newStat.release());
      if (oldStat != &countAndTimeZero_) {
        delete oldStat;
      }
    }

References edm::service::Timing::CountAndTime::count_, countAndTimeZero_, edm::service::getTime(), and edm::service::Timing::CountAndTime::time_.

accumulateTimeEnd()

void edm::service::Timing::accumulateTimeEnd ( std::atomic< CountAndTime * > &  countAndTime, double &  accumulatedTime  )

private

Definition at line 618 of file Timing.cc.

                                                                                                  {
      double newTime = getTime();
 
      CountAndTime* oldStat = countAndTime.load();
      while (true) {
        if (oldStat == nullptr) {
          oldStat = countAndTime.load();
        } else if (countAndTime.compare_exchange_strong(oldStat, nullptr)) {
          break;
        }
      }
 
      if (oldStat->count_ == 1) {
        accumulatedTime += newTime - oldStat->time_;
        countAndTime.store(&countAndTimeZero_);
      } else {
        try {
          auto newStat = std::make_unique<CountAndTime>(oldStat->count_ - 1, newTime);
          accumulatedTime += (newTime - oldStat->time_) * oldStat->count_;
          countAndTime.store(newStat.release());
        } catch (std::exception&) {
          countAndTime.store(oldStat);
          throw;
        }
      }
      delete oldStat;
    }

References edm::service::Timing::CountAndTime::count_, countAndTimeZero_, cppFunctionSkipper::exception, edm::service::getTime(), and edm::service::Timing::CountAndTime::time_.

addToCPUTime()

void edm::service::Timing::addToCPUTime ( double  iTime )

overridevirtual

Extra CPU time used by a job but not seen by cmsRun The value should be in seconds. This function is safe to call from multiple threads

Implements edm::TimingServiceBase.

Definition at line 323 of file Timing.cc.

                                          {
      //For accounting purposes we effectively can say we started earlier
      double expected = extra_job_cpu_.load();
      while (not extra_job_cpu_.compare_exchange_strong(expected, expected + iTime)) {
      }
    }

References extra_job_cpu_.

fillDescriptions()

void edm::service::Timing::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions )

static

Definition at line 332 of file Timing.cc.

                                                                         {
      ParameterSetDescription desc;
      desc.addUntracked<bool>("summaryOnly", false)->setComment("If 'true' do not report timing for each event");
      desc.addUntracked<bool>("useJobReport", true)->setComment("If 'true' write summary information to JobReport");
      desc.addUntracked<double>("excessiveTimeThreshold", 0.)
          ->setComment(
              "Amount of time in seconds before reporting a module or source has taken excessive time. A value of 0.0 "
              "turns off this reporting.");
      descriptions.add("Timing", desc);
      descriptions.setComment("This service reports the time it takes to run each module in a job.");
    }

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, and edm::ConfigurationDescriptions::setComment().

getTotalCPU()

double edm::service::Timing::getTotalCPU ( ) const

overridevirtual

CPU time used by this process and all its children. The value returned should be in seconds.

Implements edm::TimingServiceBase.

Definition at line 330 of file Timing.cc.

{ return getCPU(); }

References edm::service::getCPU().

lastPostEvent()

void edm::service::Timing::lastPostEvent ( double  curr_event_time, unsigned int  index, StreamContext const &  iStream  )

private

Definition at line 504 of file Timing.cc.

                                                                                                       {
      sum_events_time_[index] += curr_event_time;
 
      if (not summary_only_) {
        auto const& eventID = iStream.eventID();
        LogPrint("TimeEvent") << "TimeEvent> " << eventID.event() << " " << eventID.run() << " " << curr_event_time;
      }
      if (curr_event_time > max_events_time_[index])
        max_events_time_[index] = curr_event_time;
      if (curr_event_time < min_events_time_[index])
        min_events_time_[index] = curr_event_time;
      ++total_event_count_;
    }

References edm::StreamContext::eventID(), max_events_time_, min_events_time_, sum_events_time_, summary_only_, and total_event_count_.

Referenced by postEvent().

postBeginJob()

void edm::service::Timing::postBeginJob ( )

private

Definition at line 352 of file Timing.cc.

                              {
      if (!configuredInTopLevelProcess_) {
        return;
      }
      curr_job_time_ = getTime();
      curr_job_cpu_ = getCPU();
 
      if (not summary_only_) {
        LogImportant("TimeReport") << "TimeReport> Report activated"
                                   << "\n"
                                   << "TimeReport> Report columns headings for events: "
                                   << "eventnum runnum timetaken\n"
                                   << "TimeReport> Report columns headings for modules: "
                                   << "eventnum runnum modulelabel modulename timetakeni\n"
                                   << "TimeReport> JobTime=" << curr_job_time_ << " JobCPU=" << curr_job_cpu_ << "\n";
      }
    }

References configuredInTopLevelProcess_, curr_job_cpu_, curr_job_time_, edm::service::getCPU(), edm::service::getTime(), and summary_only_.

postCommon()

double edm::service::Timing::postCommon ( ) const

private

Definition at line 581 of file Timing.cc.

                                    {
      if (!configuredInTopLevelProcess_) {
        return 0.0;
      }
      double t = popStack();
      if (t > threshold_) {
        LogError("ExcessiveTime")
            << "ExcessiveTime: Module used " << t
            << " seconds of time which exceeds the error threshold configured in the Timing Service of " << threshold_
            << " seconds.";
      }
      return t;
    }

References configuredInTopLevelProcess_, edm::service::popStack(), submitPVValidationJobs::t, and threshold_.

Referenced by postModule(), postModuleEvent(), postModuleGlobal(), postModuleStream(), postOpenFile(), postSourceEvent(), postSourceLumi(), and postSourceRun().

postEndJob()

void edm::service::Timing::postEndJob ( )

private

Definition at line 370 of file Timing.cc.

                            {
      if (!configuredInTopLevelProcess_) {
        LogImportant("TimeReport") << "\nTimeReport> This instance of the Timing Service will be disabled because it "
                                      "is configured in a SubProcess.\n"
                                   << "If multiple instances of the TimingService were configured only the one in the "
                                      "top level process will function.\n"
                                   << "The other instance(s) will simply print this message and do nothing.\n\n";
        return;
      }
 
      const double job_end_time = getTime();
      const double job_end_cpu = getCPU();
      double total_job_time = job_end_time - jobStartTime();
 
      double total_job_cpu = job_end_cpu + extra_job_cpu_;
 
      const double total_initialization_time = curr_job_time_ - jobStartTime();
      const double total_initialization_cpu = curr_job_cpu_;
 
      if (0.0 == jobStartTime()) {
        //did not capture beginning time
        total_job_time = job_end_time - curr_job_time_;
        total_job_cpu = job_end_cpu + extra_job_cpu_ - curr_job_cpu_;
      }
 
      double min_event_time = *(std::min_element(min_events_time_.begin(), min_events_time_.end()));
      double max_event_time = *(std::max_element(max_events_time_.begin(), max_events_time_.end()));
 
      auto total_loop_time = last_run_time_ - curr_job_time_;
      auto total_loop_cpu = last_run_cpu_ + extra_job_cpu_ - curr_job_cpu_;
 
      if (last_run_time_ == 0.0) {
        total_loop_time = 0.0;
        total_loop_cpu = 0.0;
      }
 
      double sum_all_events_time = 0;
      for (auto t : sum_events_time_) {
        sum_all_events_time += t;
      }
 
      double average_event_time = 0.0;
      if (total_event_count_ != 0) {
        average_event_time = sum_all_events_time / total_event_count_;
      }
 
      double event_throughput = 0.0;
      if (total_loop_time != 0.0) {
        event_throughput = total_event_count_ / total_loop_time;
      }
 
      LogImportant("TimeReport") << "TimeReport> Time report complete in " << total_job_time << " seconds"
                                 << "\n"
                                 << " Time Summary: \n"
                                 << " - Min event:   " << min_event_time << "\n"
                                 << " - Max event:   " << max_event_time << "\n"
                                 << " - Avg event:   " << average_event_time << "\n"
                                 << " - Total loop:  " << total_loop_time << "\n"
                                 << " - Total init:  " << total_initialization_time << "\n"
                                 << " - Total job:   " << total_job_time << "\n"
                                 << " - EventSetup Lock:   " << accumulatedTimeForLock_ << "\n"
                                 << " - EventSetup Get:   " << accumulatedTimeForGet_ << "\n"
                                 << " Event Throughput: " << event_throughput << " ev/s\n"
                                 << " CPU Summary: \n"
                                 << " - Total loop:  " << total_loop_cpu << "\n"
                                 << " - Total init:  " << total_initialization_cpu << "\n"
                                 << " - Total extra: " << extra_job_cpu_ << "\n"
                                 << " - Total job:   " << total_job_cpu << "\n"
                                 << " Processing Summary: \n"
                                 << " - Number of Events:  " << total_event_count_ << "\n"
                                 << " - Number of Global Begin Lumi Calls:  " << begin_lumi_count_ << "\n"
                                 << " - Number of Global Begin Run Calls: " << begin_run_count_ << "\n";
 
      if (report_summary_) {
        Service<JobReport> reportSvc;
        std::map<std::string, std::string> reportData;
 
        reportData.insert(std::make_pair("MinEventTime", d2str(min_event_time)));
        reportData.insert(std::make_pair("MaxEventTime", d2str(max_event_time)));
        reportData.insert(std::make_pair("AvgEventTime", d2str(average_event_time)));
        reportData.insert(std::make_pair("EventThroughput", d2str(event_throughput)));
        reportData.insert(std::make_pair("TotalJobTime", d2str(total_job_time)));
        reportData.insert(std::make_pair("TotalJobCPU", d2str(total_job_cpu)));
        reportData.insert(std::make_pair("TotalLoopTime", d2str(total_loop_time)));
        reportData.insert(std::make_pair("TotalLoopCPU", d2str(total_loop_cpu)));
        reportData.insert(std::make_pair("TotalInitTime", d2str(total_initialization_time)));
        reportData.insert(std::make_pair("TotalInitCPU", d2str(total_initialization_cpu)));
        reportData.insert(std::make_pair("NumberOfStreams", ui2str(nStreams_)));
        reportData.insert(std::make_pair("NumberOfThreads", ui2str(nThreads_)));
        reportData.insert(std::make_pair("EventSetup Lock", d2str(accumulatedTimeForLock_)));
        reportData.insert(std::make_pair("EventSetup Get", d2str(accumulatedTimeForGet_)));
        reportSvc->reportPerformanceSummary("Timing", reportData);
 
        std::map<std::string, std::string> reportData1;
        reportData1.insert(std::make_pair("NumberEvents", ui2str(total_event_count_)));
        reportData1.insert(std::make_pair("NumberBeginLumiCalls", ui2str(begin_lumi_count_)));
        reportData1.insert(std::make_pair("NumberBeginRunCalls", ui2str(begin_run_count_)));
        reportSvc->reportPerformanceSummary("ProcessingSummary", reportData1);
      }
    }

References accumulatedTimeForGet_, accumulatedTimeForLock_, begin_lumi_count_, begin_run_count_, configuredInTopLevelProcess_, curr_job_cpu_, curr_job_time_, edm::service::d2str(), extra_job_cpu_, edm::service::getCPU(), edm::service::getTime(), edm::TimingServiceBase::jobStartTime(), last_run_cpu_, last_run_time_, max_events_time_, min_events_time_, nStreams_, nThreads_, report_summary_, sum_events_time_, submitPVValidationJobs::t, total_event_count_, and edm::service::ui2str().

postEvent()

void edm::service::Timing::postEvent ( StreamContext const &  iStream )

private

Definition at line 488 of file Timing.cc.

                                                       {
      if (!configuredInTopLevelProcess_) {
        return;
      }
      auto index = iStream.streamID().value();
      if (nSubProcesses_ == 0u) {
        lastPostEvent(getTime() - curr_events_time_[index], index, iStream);
      } else {
        unsigned int count = ++(*countSubProcessesPostEvent_[index]);
        if (count == (nSubProcesses_ + 1)) {
          lastPostEvent(getTime() - curr_events_time_[index], index, iStream);
          *countSubProcessesPostEvent_[index] = 0;
        }
      }
    }

References configuredInTopLevelProcess_, submitPVResolutionJobs::count, countSubProcessesPostEvent_, curr_events_time_, edm::service::getTime(), lastPostEvent(), nSubProcesses_, edm::StreamContext::streamID(), and edm::StreamID::value().

postGlobalBeginLumi()

void edm::service::Timing::postGlobalBeginLumi ( GlobalContext const &  gc )

private

Definition at line 566 of file Timing.cc.

                                                            {
      if (!configuredInTopLevelProcess_) {
        return;
      }
      if (!gc.processContext()->isSubProcess()) {
        ++begin_lumi_count_;
      }
    }

References begin_lumi_count_, configuredInTopLevelProcess_, edm::ProcessContext::isSubProcess(), and edm::GlobalContext::processContext().

postGlobalBeginRun()

void edm::service::Timing::postGlobalBeginRun ( GlobalContext const &  gc )

private

Definition at line 557 of file Timing.cc.

                                                           {
      if (!configuredInTopLevelProcess_) {
        return;
      }
      if (!gc.processContext()->isSubProcess()) {
        ++begin_run_count_;
      }
    }

References begin_run_count_, configuredInTopLevelProcess_, edm::ProcessContext::isSubProcess(), and edm::GlobalContext::processContext().

postModule()

void edm::service::Timing::postModule ( ModuleDescription const &  md )

private

Definition at line 549 of file Timing.cc.

{ postCommon(); }

References postCommon().

postModuleEvent()

void edm::service::Timing::postModuleEvent ( StreamContext const &  iStream, ModuleCallingContext const &  iModule  )

private

Definition at line 518 of file Timing.cc.

                                                                                                  {
      if (!configuredInTopLevelProcess_) {
        return;
      }
      auto const& eventID = iStream.eventID();
      auto const& desc = *(iModule.moduleDescription());
      double t = postCommon();
      if (not summary_only_) {
        LogPrint("TimeModule") << "TimeModule> " << eventID.event() << " " << eventID.run() << " " << desc.moduleLabel()
                               << " " << desc.moduleName() << " " << t;
      }
    }

References configuredInTopLevelProcess_, submitPVResolutionJobs::desc, edm::StreamContext::eventID(), edm::ModuleCallingContext::moduleDescription(), postCommon(), summary_only_, and submitPVValidationJobs::t.

postModuleGlobal()

void edm::service::Timing::postModuleGlobal ( GlobalContext const &  , ModuleCallingContext const &  mcc  )

private

Definition at line 555 of file Timing.cc.

{ postCommon(); }

References postCommon().

postModuleStream()

void edm::service::Timing::postModuleStream ( StreamContext const &  , ModuleCallingContext const &  mcc  )

private

Definition at line 579 of file Timing.cc.

{ postCommon(); }

References postCommon().

postOpenFile()

void edm::service::Timing::postOpenFile ( std::string const &  lfn, bool  b  )

private

Definition at line 545 of file Timing.cc.

{ postCommon(); }

References postCommon().

postSourceEvent()

void edm::service::Timing::postSourceEvent ( StreamID  sid )

private

Definition at line 533 of file Timing.cc.

{ postCommon(); }

References postCommon().

postSourceLumi()

void edm::service::Timing::postSourceLumi ( LuminosityBlockIndex  index )

private

Definition at line 537 of file Timing.cc.

{ postCommon(); }

References postCommon().

postSourceRun()

void edm::service::Timing::postSourceRun ( RunIndex  index )

private

Definition at line 541 of file Timing.cc.

{ postCommon(); }

References postCommon().

preBeginJob()

void edm::service::Timing::preBeginJob ( PathsAndConsumesOfModulesBase const &  pathsAndConsumes, ProcessContext const &  pc  )

private

Definition at line 344 of file Timing.cc.

                                                                                                            {
      if (pc.isSubProcess()) {
        ++nSubProcesses_;
      } else {
        configuredInTopLevelProcess_ = true;
      }
    }

References configuredInTopLevelProcess_, edm::ProcessContext::isSubProcess(), and nSubProcesses_.

preEvent()

void edm::service::Timing::preEvent ( StreamContext const &  iStream )

private

Definition at line 471 of file Timing.cc.

                                                      {
      if (!configuredInTopLevelProcess_) {
        return;
      }
      auto index = iStream.streamID().value();
      if (nSubProcesses_ == 0u) {
        curr_events_time_[index] = getTime();
      } else {
        unsigned int count = ++(*countSubProcessesPreEvent_[index]);
        if (count == 1) {
          curr_events_time_[index] = getTime();
        } else if (count == (nSubProcesses_ + 1)) {
          *countSubProcessesPreEvent_[index] = 0;
        }
      }
    }

References configuredInTopLevelProcess_, submitPVResolutionJobs::count, countSubProcessesPreEvent_, curr_events_time_, edm::service::getTime(), nSubProcesses_, edm::StreamContext::streamID(), and edm::StreamID::value().

preModule()

void edm::service::Timing::preModule ( ModuleDescription const &  md )

private

Definition at line 547 of file Timing.cc.

{ pushStack(configuredInTopLevelProcess_); }

References configuredInTopLevelProcess_, and edm::service::pushStack().

preModuleGlobal()

void edm::service::Timing::preModuleGlobal ( GlobalContext const &  , ModuleCallingContext const &    )

private

Definition at line 551 of file Timing.cc.

                                                                                  {
      pushStack(configuredInTopLevelProcess_);
    }

References configuredInTopLevelProcess_, and edm::service::pushStack().

preModuleStream()

void edm::service::Timing::preModuleStream ( StreamContext const &  , ModuleCallingContext const &    )

private

Definition at line 575 of file Timing.cc.

                                                                                  {
      pushStack(configuredInTopLevelProcess_);
    }

References configuredInTopLevelProcess_, and edm::service::pushStack().

preOpenFile()

void edm::service::Timing::preOpenFile ( std::string const &  lfn, bool  b  )

private

Definition at line 543 of file Timing.cc.

{ pushStack(configuredInTopLevelProcess_); }

References configuredInTopLevelProcess_, and edm::service::pushStack().

preSourceEvent()

void edm::service::Timing::preSourceEvent ( StreamID  sid )

private

Definition at line 531 of file Timing.cc.

{ pushStack(configuredInTopLevelProcess_); }

References configuredInTopLevelProcess_, and edm::service::pushStack().

preSourceLumi()

void edm::service::Timing::preSourceLumi ( LuminosityBlockIndex  index )

private

Definition at line 535 of file Timing.cc.

{ pushStack(configuredInTopLevelProcess_); }

References configuredInTopLevelProcess_, and edm::service::pushStack().

preSourceRun()

void edm::service::Timing::preSourceRun ( RunIndex  index )

private

Definition at line 539 of file Timing.cc.

{ pushStack(configuredInTopLevelProcess_); }

References configuredInTopLevelProcess_, and edm::service::pushStack().

Member Data Documentation

accumulatedTimeForGet_

double edm::service::Timing::accumulatedTimeForGet_

private

Definition at line 131 of file Timing.cc.

Referenced by postEndJob().

accumulatedTimeForLock_

double edm::service::Timing::accumulatedTimeForLock_

private

Definition at line 128 of file Timing.cc.

Referenced by postEndJob().

begin_lumi_count_

std::atomic<unsigned long> edm::service::Timing::begin_lumi_count_

private

Definition at line 120 of file Timing.cc.

Referenced by postEndJob(), and postGlobalBeginLumi().

begin_run_count_

std::atomic<unsigned long> edm::service::Timing::begin_run_count_

private

Definition at line 121 of file Timing.cc.

Referenced by postEndJob(), and postGlobalBeginRun().

configuredInTopLevelProcess_

bool edm::service::Timing::configuredInTopLevelProcess_

private

Definition at line 136 of file Timing.cc.

Referenced by postBeginJob(), postCommon(), postEndJob(), postEvent(), postGlobalBeginLumi(), postGlobalBeginRun(), postModuleEvent(), preBeginJob(), preEvent(), preModule(), preModuleGlobal(), preModuleStream(), preOpenFile(), preSourceEvent(), preSourceLumi(), and preSourceRun().

countAndTimeForGet_

std::atomic<CountAndTime*> edm::service::Timing::countAndTimeForGet_

private

Definition at line 130 of file Timing.cc.

countAndTimeForLock_

std::atomic<CountAndTime*> edm::service::Timing::countAndTimeForLock_

private

Definition at line 127 of file Timing.cc.

countAndTimeZero_

CountAndTime edm::service::Timing::countAndTimeZero_

private

Definition at line 125 of file Timing.cc.

Referenced by accumulateTimeBegin(), and accumulateTimeEnd().

countSubProcessesPostEvent_

std::vector<std::unique_ptr<std::atomic<unsigned int> > > edm::service::Timing::countSubProcessesPostEvent_

private

Definition at line 134 of file Timing.cc.

Referenced by postEvent().

countSubProcessesPreEvent_

std::vector<std::unique_ptr<std::atomic<unsigned int> > > edm::service::Timing::countSubProcessesPreEvent_

private

Definition at line 133 of file Timing.cc.

Referenced by preEvent().

curr_events_time_

std::vector<double> edm::service::Timing::curr_events_time_

private

Definition at line 109 of file Timing.cc.

Referenced by postEvent(), and preEvent().

curr_job_cpu_

double edm::service::Timing::curr_job_cpu_

private

Definition at line 104 of file Timing.cc.

Referenced by postBeginJob(), and postEndJob().

curr_job_time_

double edm::service::Timing::curr_job_time_

private

Definition at line 103 of file Timing.cc.

Referenced by postBeginJob(), and postEndJob().

extra_job_cpu_

std::atomic<double> edm::service::Timing::extra_job_cpu_

private

Definition at line 105 of file Timing.cc.

Referenced by addToCPUTime(), and postEndJob().

last_run_cpu_

std::atomic<double> edm::service::Timing::last_run_cpu_

private

Definition at line 108 of file Timing.cc.

Referenced by postEndJob().

last_run_time_

std::atomic<double> edm::service::Timing::last_run_time_

private

Definition at line 107 of file Timing.cc.

Referenced by postEndJob().

max_events_time_

std::vector<double> edm::service::Timing::max_events_time_

private

Definition at line 116 of file Timing.cc.

Referenced by lastPostEvent(), and postEndJob().

min_events_time_

std::vector<double> edm::service::Timing::min_events_time_

private

Definition at line 117 of file Timing.cc.

Referenced by lastPostEvent(), and postEndJob().

nStreams_

unsigned int edm::service::Timing::nStreams_

private

Definition at line 122 of file Timing.cc.

Referenced by postEndJob().

nSubProcesses_

unsigned int edm::service::Timing::nSubProcesses_

private

Definition at line 137 of file Timing.cc.

Referenced by postEvent(), preBeginJob(), and preEvent().

nThreads_

unsigned int edm::service::Timing::nThreads_

private

Definition at line 123 of file Timing.cc.

Referenced by postEndJob().

report_summary_

bool edm::service::Timing::report_summary_

private

Definition at line 111 of file Timing.cc.

Referenced by postEndJob().

sum_events_time_

std::vector<double> edm::service::Timing::sum_events_time_

private

Definition at line 118 of file Timing.cc.

Referenced by lastPostEvent(), and postEndJob().

summary_only_

bool edm::service::Timing::summary_only_

private

Definition at line 110 of file Timing.cc.

Referenced by lastPostEvent(), postBeginJob(), and postModuleEvent().

threshold_

double edm::service::Timing::threshold_

private

Definition at line 112 of file Timing.cc.

Referenced by postCommon().

total_event_count_

std::atomic<unsigned long> edm::service::Timing::total_event_count_

private

Definition at line 119 of file Timing.cc.

Referenced by lastPostEvent(), and postEndJob().