Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2024-04-06 12:13:07 

0001 #include "tracer_setupFile.h"
0002 #include "monitor_file_utilities.h"
0003 
0004 #include <chrono>
0005 
0006 #include <sstream>
0007 #include <type_traits>
0008 #include <cassert>
0009 #include <typeindex>
0010 
0011 #include "FWCore/Concurrency/interface/ThreadSafeOutputFileStream.h"
0012 
0013 #include "DataFormats/Provenance/interface/EventID.h"
0014 #include "DataFormats/Provenance/interface/LuminosityBlockID.h"
0015 #include "DataFormats/Provenance/interface/ModuleDescription.h"
0016 #include "DataFormats/Provenance/interface/RunID.h"
0017 #include "DataFormats/Provenance/interface/Timestamp.h"
0018 
0019 #include "FWCore/ServiceRegistry/interface/GlobalContext.h"
0020 #include "FWCore/ServiceRegistry/interface/ModuleCallingContext.h"
0021 #include "FWCore/ServiceRegistry/interface/ESModuleCallingContext.h"
0022 #include "FWCore/ServiceRegistry/interface/PathContext.h"
0023 #include "FWCore/ServiceRegistry/interface/ProcessContext.h"
0024 #include "FWCore/ServiceRegistry/interface/StreamContext.h"
0025 #include "FWCore/ServiceRegistry/interface/ActivityRegistry.h"
0026 
0027 #include "FWCore/Framework/interface/IOVSyncValue.h"
0028 #include "FWCore/Framework/interface/ESRecordsToProductResolverIndices.h"
0029 
0030 #include "FWCore/Utilities/interface/TimingServiceBase.h"
0031 
0032 using namespace edm::service::monitor_file_utilities;
0033 
0034 namespace {
0035   using duration_t = std::chrono::microseconds;
0036   using clock_t = std::chrono::steady_clock;
0037   auto const now = clock_t::now;
0038 
0039   enum class Step : char {
0040     preSourceTransition = 'S',
0041     postSourceTransition = 's',
0042     preModulePrefetching = 'P',
0043     postModulePrefetching = 'p',
0044     preModuleEventAcquire = 'A',
0045     postModuleEventAcquire = 'a',
0046     preModuleTransition = 'M',
0047     preEventReadFromSource = 'R',
0048     postEventReadFromSource = 'r',
0049     preModuleEventDelayedGet = 'D',
0050     postModuleEventDelayedGet = 'd',
0051     postModuleTransition = 'm',
0052     preESModulePrefetching = 'Q',
0053     postESModulePrefetching = 'q',
0054     preESModule = 'N',
0055     postESModule = 'n',
0056     preESModuleAcquire = 'B',
0057     postESModuleAcquire = 'b',
0058     preFrameworkTransition = 'F',
0059     postFrameworkTransition = 'f'
0060   };
0061 
0062   enum class Phase : short {
0063     destruction = -16,
0064     endJob = -12,
0065     endStream = -11,
0066     writeProcessBlock = -10,
0067     endProcessBlock = -9,
0068     globalWriteRun = -7,
0069     globalEndRun = -6,
0070     streamEndRun = -5,
0071     globalWriteLumi = -4,
0072     globalEndLumi = -3,
0073     streamEndLumi = -2,
0074     clearEvent = -1,
0075     Event = 0,
0076     streamBeginLumi = 2,
0077     globalBeginLumi = 3,
0078     streamBeginRun = 5,
0079     globalBeginRun = 6,
0080     accessInputProcessBlock = 8,
0081     beginProcessBlock = 9,
0082     openFile = 10,
0083     beginStream = 11,
0084     beginJob = 12,
0085     esSync = 13,
0086     esSyncEnqueue = 14,
0087     getNextTransition = 15,
0088     construction = 16,
0089     startTracing = 17
0090   };
0091 
0092   std::ostream& operator<<(std::ostream& os, Step const s) {
0093     os << static_cast<std::underlying_type_t<Step>>(s);
0094     return os;
0095   }
0096 
0097   std::ostream& operator<<(std::ostream& os, Phase const s) {
0098     os << static_cast<std::underlying_type_t<Phase>>(s);
0099     return os;
0100   }
0101 
0102   template <Step S, typename... ARGS>
0103   std::string assembleMessage(ARGS const... args) {
0104     std::ostringstream oss;
0105     oss << S;
0106     concatenate(oss, args...);
0107     oss << '\n';
0108     return oss.str();
0109   }
0110 
0111   Phase toTransitionImpl(edm::StreamContext const& iContext) {
0112     using namespace edm;
0113     switch (iContext.transition()) {
0114       case StreamContext::Transition::kBeginStream:
0115         return Phase::beginStream;
0116       case StreamContext::Transition::kBeginRun:
0117         return Phase::streamBeginRun;
0118       case StreamContext::Transition::kBeginLuminosityBlock:
0119         return Phase::streamBeginLumi;
0120       case StreamContext::Transition::kEvent:
0121         return Phase::Event;
0122       case StreamContext::Transition::kEndLuminosityBlock:
0123         return Phase::streamEndLumi;
0124       case StreamContext::Transition::kEndRun:
0125         return Phase::streamEndRun;
0126       case StreamContext::Transition::kEndStream:
0127         return Phase::endStream;
0128       default:
0129         break;
0130     }
0131     assert(false);
0132     return Phase::Event;
0133   }
0134 
0135   auto toTransition(edm::StreamContext const& iContext) -> std::underlying_type_t<Phase> {
0136     return static_cast<std::underlying_type_t<Phase>>(toTransitionImpl(iContext));
0137   }
0138 
0139   Phase toTransitionImpl(edm::GlobalContext const& iContext) {
0140     using namespace edm;
0141     switch (iContext.transition()) {
0142       case GlobalContext::Transition::kBeginProcessBlock:
0143         return Phase::beginProcessBlock;
0144       case GlobalContext::Transition::kAccessInputProcessBlock:
0145         return Phase::accessInputProcessBlock;
0146       case GlobalContext::Transition::kBeginRun:
0147         return Phase::globalBeginRun;
0148       case GlobalContext::Transition::kBeginLuminosityBlock:
0149         return Phase::globalBeginLumi;
0150       case GlobalContext::Transition::kEndLuminosityBlock:
0151         return Phase::globalEndLumi;
0152       case GlobalContext::Transition::kWriteLuminosityBlock:
0153         return Phase::globalWriteLumi;
0154       case GlobalContext::Transition::kEndRun:
0155         return Phase::globalEndRun;
0156       case GlobalContext::Transition::kWriteRun:
0157         return Phase::globalWriteRun;
0158       case GlobalContext::Transition::kEndProcessBlock:
0159         return Phase::endProcessBlock;
0160       case GlobalContext::Transition::kWriteProcessBlock:
0161         return Phase::writeProcessBlock;
0162       default:
0163         break;
0164     }
0165     assert(false);
0166     return Phase::Event;
0167   }
0168   auto toTransition(edm::GlobalContext const& iContext) -> std::underlying_type_t<Phase> {
0169     return static_cast<std::underlying_type_t<Phase>>(toTransitionImpl(iContext));
0170   }
0171 
0172   unsigned int toTransitionIndex(edm::GlobalContext const& iContext) {
0173     if (iContext.transition() == edm::GlobalContext::Transition::kBeginProcessBlock or
0174         iContext.transition() == edm::GlobalContext::Transition::kEndProcessBlock or
0175         iContext.transition() == edm::GlobalContext::Transition::kWriteProcessBlock or
0176         iContext.transition() == edm::GlobalContext::Transition::kAccessInputProcessBlock) {
0177       return 0;
0178     }
0179     if (iContext.transition() == edm::GlobalContext::Transition::kBeginRun or
0180         iContext.transition() == edm::GlobalContext::Transition::kEndRun or
0181         iContext.transition() == edm::GlobalContext::Transition::kWriteRun) {
0182       return iContext.runIndex();
0183     }
0184     return iContext.luminosityBlockIndex();
0185   }
0186 
0187   template <Step S>
0188   struct ESModuleState {
0189     ESModuleState(std::shared_ptr<edm::ThreadSafeOutputFileStream> logFile,
0190                   decltype(now()) beginTime,
0191                   std::shared_ptr<std::vector<std::type_index>> recordIndices)
0192         : logFile_{logFile}, recordIndices_{recordIndices}, beginTime_{beginTime} {}
0193 
0194     void operator()(edm::eventsetup::EventSetupRecordKey const& iKey,
0195                     edm::ESModuleCallingContext const& iContext) const {
0196       using namespace edm;
0197       auto const t = std::chrono::duration_cast<duration_t>(now() - beginTime_).count();
0198       auto top = iContext.getTopModuleCallingContext();
0199       short int phase = 0;
0200       unsigned long phaseID = 0xFFFFFFFF;
0201       if (top->type() == ParentContext::Type::kGlobal) {
0202         auto global = top->globalContext();
0203         phase = toTransition(*global);
0204         phaseID = toTransitionIndex(*global);
0205       } else if (top->type() == ParentContext::Type::kStream) {
0206         auto stream = top->getStreamContext();
0207         phase = toTransition(*stream);
0208         phaseID = stream_id(*stream);
0209       } else if (top->type() == ParentContext::Type::kPlaceInPath) {
0210         auto stream = top->getStreamContext();
0211         phase = toTransition(*stream);
0212         phaseID = stream_id(*stream);
0213       }
0214       auto recordIndex = findRecordIndices(iKey);
0215       long long requestingModuleID;
0216       decltype(iContext.moduleCallingContext()->callID()) requestingCallID;
0217       if (iContext.type() == ESParentContext::Type::kModule) {
0218         requestingModuleID = iContext.moduleCallingContext()->moduleDescription()->id();
0219         requestingCallID = iContext.moduleCallingContext()->callID();
0220       } else {
0221         requestingModuleID =
0222             -1 * static_cast<long long>(iContext.esmoduleCallingContext()->componentDescription()->id_ + 1);
0223         requestingCallID = iContext.esmoduleCallingContext()->callID();
0224       }
0225       auto msg = assembleMessage<S>(phase,
0226                                     phaseID,
0227                                     iContext.componentDescription()->id_ + 1,
0228                                     recordIndex,
0229                                     iContext.callID(),
0230                                     requestingModuleID,
0231                                     requestingCallID,
0232                                     t);
0233       logFile_->write(std::move(msg));
0234     }
0235 
0236   private:
0237     int findRecordIndices(edm::eventsetup::EventSetupRecordKey const& iKey) const {
0238       auto index = std::type_index(iKey.type().value());
0239       auto itFind = std::find(recordIndices_->begin(), recordIndices_->end(), index);
0240       return itFind - recordIndices_->begin();
0241     }
0242 
0243     std::shared_ptr<edm::ThreadSafeOutputFileStream> logFile_;
0244     std::shared_ptr<std::vector<std::type_index>> recordIndices_;
0245     decltype(now()) beginTime_;
0246   };
0247 
0248   template <Step S>
0249   struct GlobalEDModuleState {
0250     GlobalEDModuleState(std::shared_ptr<edm::ThreadSafeOutputFileStream> logFile, decltype(now()) beginTime)
0251         : logFile_{logFile}, beginTime_{beginTime} {}
0252 
0253     void operator()(edm::GlobalContext const& gc, edm::ModuleCallingContext const& mcc) {
0254       using namespace edm;
0255       auto const t = std::chrono::duration_cast<duration_t>(now() - beginTime_).count();
0256       long requestingModuleID = 0;
0257       decltype(mcc.parent().moduleCallingContext()->callID()) requestingCallID = 0;
0258       if (mcc.type() == ParentContext::Type::kModule) {
0259         requestingModuleID = module_id(*mcc.parent().moduleCallingContext());
0260         requestingCallID = mcc.parent().moduleCallingContext()->callID();
0261       }
0262       auto msg = assembleMessage<S>(toTransition(gc),
0263                                     toTransitionIndex(gc),
0264                                     module_id(mcc),
0265                                     module_callid(mcc),
0266                                     requestingModuleID,
0267                                     requestingCallID,
0268                                     t);
0269       logFile_->write(std::move(msg));
0270     }
0271 
0272   private:
0273     std::shared_ptr<edm::ThreadSafeOutputFileStream> logFile_;
0274     decltype(now()) beginTime_;
0275   };
0276 
0277   template <Step S>
0278   struct StreamEDModuleState {
0279     StreamEDModuleState(std::shared_ptr<edm::ThreadSafeOutputFileStream> logFile, decltype(now()) beginTime)
0280         : logFile_{logFile}, beginTime_{beginTime} {}
0281 
0282     void operator()(edm::StreamContext const& sc, edm::ModuleCallingContext const& mcc) {
0283       using namespace edm;
0284       auto const t = std::chrono::duration_cast<duration_t>(now() - beginTime_).count();
0285       long requestingModuleID = 0;
0286       decltype(mcc.parent().moduleCallingContext()->callID()) requestingCallID = 0;
0287       if (mcc.type() == ParentContext::Type::kModule) {
0288         requestingModuleID = module_id(*mcc.parent().moduleCallingContext());
0289         requestingCallID = mcc.parent().moduleCallingContext()->callID();
0290       }
0291       auto msg = assembleMessage<S>(
0292           toTransition(sc), stream_id(sc), module_id(mcc), module_callid(mcc), requestingModuleID, requestingCallID, t);
0293       logFile_->write(std::move(msg));
0294     }
0295 
0296   private:
0297     std::shared_ptr<edm::ThreadSafeOutputFileStream> logFile_;
0298     decltype(now()) beginTime_;
0299   };
0300 
0301   struct ModuleCtrDtr {
0302     long long beginConstruction = 0;
0303     long long endConstruction = 0;
0304     long long beginDestruction = 0;
0305     long long endDestruction = 0;
0306   };
0307 }  // namespace
0308 
0309 namespace edm::service::tracer {
0310   void setupFile(std::string const& iFileName, edm::ActivityRegistry& iRegistry) {
0311     auto beginTracer = now();
0312     using namespace std::chrono;
0313 
0314     if (iFileName.empty()) {
0315       return;
0316     }
0317 
0318     auto logFile = std::make_shared<edm::ThreadSafeOutputFileStream>(iFileName);
0319 
0320     auto beginTime = TimingServiceBase::jobStartTime();
0321 
0322     auto esModuleLabelsPtr = std::make_shared<std::vector<std::string>>();
0323     auto& esModuleLabels = *esModuleLabelsPtr;
0324     //acquire names for all the ED and ES modules
0325     iRegistry.watchPostESModuleRegistration([&esModuleLabels](auto const& iDescription) {
0326       if (esModuleLabels.size() <= iDescription.id_ + 1) {
0327         esModuleLabels.resize(iDescription.id_ + 2);
0328       }
0329       //NOTE: we want the id to start at 1 not 0
0330       if (not iDescription.label_.empty()) {
0331         esModuleLabels[iDescription.id_ + 1] = iDescription.label_;
0332       } else {
0333         esModuleLabels[iDescription.id_ + 1] = iDescription.type_;
0334       }
0335     });
0336     auto moduleCtrDtrPtr = std::make_shared<std::vector<ModuleCtrDtr>>();
0337     auto& moduleCtrDtr = *moduleCtrDtrPtr;
0338     auto moduleLabelsPtr = std::make_shared<std::vector<std::string>>();
0339     auto& moduleLabels = *moduleLabelsPtr;
0340     iRegistry.watchPreModuleConstruction([&moduleLabels, &moduleCtrDtr, beginTime](ModuleDescription const& md) {
0341       auto const t = duration_cast<duration_t>(now() - beginTime).count();
0342 
0343       auto const mid = md.id();
0344       if (mid < moduleLabels.size()) {
0345         moduleLabels[mid] = md.moduleLabel();
0346         moduleCtrDtr[mid].beginConstruction = t;
0347       } else {
0348         moduleLabels.resize(mid + 1);
0349         moduleLabels.back() = md.moduleLabel();
0350         moduleCtrDtr.resize(mid + 1);
0351         moduleCtrDtr.back().beginConstruction = t;
0352       }
0353     });
0354     iRegistry.watchPostModuleConstruction([&moduleCtrDtr, beginTime](auto const& md) {
0355       auto const t = duration_cast<duration_t>(now() - beginTime).count();
0356       moduleCtrDtr[md.id()].endConstruction = t;
0357     });
0358 
0359     iRegistry.watchPreModuleDestruction([&moduleCtrDtr, beginTime](auto const& md) {
0360       auto const t = duration_cast<duration_t>(now() - beginTime).count();
0361       moduleCtrDtr[md.id()].beginDestruction = t;
0362     });
0363     iRegistry.watchPostModuleDestruction([&moduleCtrDtr, beginTime](auto const& md) {
0364       auto const t = duration_cast<duration_t>(now() - beginTime).count();
0365       moduleCtrDtr[md.id()].endDestruction = t;
0366     });
0367 
0368     auto sourceCtrPtr = std::make_shared<ModuleCtrDtr>();
0369     auto& sourceCtr = *sourceCtrPtr;
0370     iRegistry.watchPreSourceConstruction([&sourceCtr, beginTime](auto const&) {
0371       auto const t = duration_cast<duration_t>(now() - beginTime).count();
0372       sourceCtr.beginConstruction = t;
0373     });
0374     iRegistry.watchPostSourceConstruction([&sourceCtr, beginTime](auto const&) {
0375       auto const t = duration_cast<duration_t>(now() - beginTime).count();
0376       sourceCtr.endConstruction = t;
0377     });
0378 
0379     auto recordIndices = std::make_shared<std::vector<std::type_index>>();
0380     iRegistry.watchEventSetupConfiguration(
0381         [logFile, recordIndices](auto const& recordsToResolvers, auto const&) mutable {
0382           std::ostringstream oss;
0383 
0384           auto recordKeys = recordsToResolvers.recordKeys();
0385           std::sort(recordKeys.begin(), recordKeys.end());
0386           std::vector<std::string> recordNames;
0387           //want id to start at 1 not 0
0388           recordNames.reserve(recordKeys.size() + 1);
0389           recordNames.emplace_back("");
0390           recordIndices->reserve(recordKeys.size() + 1);
0391           recordIndices->push_back(std::type_index(typeid(void)));
0392           for (auto const& r : recordKeys) {
0393             recordNames.push_back(r.name());
0394             recordIndices->push_back(std::type_index(r.type().value()));
0395           }
0396 
0397           moduleIdToLabel(oss, recordNames, 'R', "Record ID", "Record name");
0398           logFile->write(oss.str());
0399         });
0400 
0401     iRegistry.watchPreBeginJob([logFile,
0402                                 moduleLabelsPtr,
0403                                 esModuleLabelsPtr,
0404                                 moduleCtrDtrPtr,
0405                                 sourceCtrPtr,
0406                                 beginTime,
0407                                 beginTracer](auto&, auto&) mutable {
0408       {
0409         std::ostringstream oss;
0410         moduleIdToLabel(oss, *moduleLabelsPtr, 'M', "EDModule ID", "Module label");
0411         logFile->write(oss.str());
0412         moduleLabelsPtr.reset();
0413       }
0414       {
0415         std::ostringstream oss;
0416         moduleIdToLabel(oss, *esModuleLabelsPtr, 'N', "ESModule ID", "ESModule label");
0417         logFile->write(oss.str());
0418         esModuleLabelsPtr.reset();
0419       }
0420       {
0421         auto const tracerStart = duration_cast<duration_t>(beginTracer - beginTime).count();
0422         auto msg = assembleMessage<Step::preFrameworkTransition>(
0423             static_cast<std::underlying_type_t<Phase>>(Phase::startTracing), 0, 0, 0, 0, tracerStart);
0424         logFile->write(std::move(msg));
0425       }
0426       //NOTE: the source construction can run concurently with module construction so we need to properly
0427       // interleave its timing in with the modules
0428       auto srcBeginConstruction = sourceCtrPtr->beginConstruction;
0429       auto srcEndConstruction = sourceCtrPtr->endConstruction;
0430       sourceCtrPtr.reset();
0431       auto handleSource = [&srcBeginConstruction, &srcEndConstruction, &logFile](long long iTime) mutable {
0432         if (srcBeginConstruction != 0 and srcBeginConstruction < iTime) {
0433           auto bmsg = assembleMessage<Step::preSourceTransition>(
0434               static_cast<std::underlying_type_t<Phase>>(Phase::construction), 0, srcBeginConstruction);
0435           logFile->write(std::move(bmsg));
0436           srcBeginConstruction = 0;
0437         }
0438         if (srcEndConstruction != 0 and srcEndConstruction < iTime) {
0439           auto bmsg = assembleMessage<Step::postSourceTransition>(
0440               static_cast<std::underlying_type_t<Phase>>(Phase::construction), 0, srcEndConstruction);
0441           logFile->write(std::move(bmsg));
0442           srcEndConstruction = 0;
0443         }
0444       };
0445       {
0446         std::sort(moduleCtrDtrPtr->begin(), moduleCtrDtrPtr->end(), [](auto const& l, auto const& r) {
0447           return l.beginConstruction < r.beginConstruction;
0448         });
0449         int id = 0;
0450         for (auto const& ctr : *moduleCtrDtrPtr) {
0451           if (ctr.beginConstruction != 0) {
0452             handleSource(ctr.beginConstruction);
0453             auto bmsg = assembleMessage<Step::preModuleTransition>(
0454                 static_cast<std::underlying_type_t<Phase>>(Phase::construction), 0, id, 0, 0, 0, ctr.beginConstruction);
0455             logFile->write(std::move(bmsg));
0456             handleSource(ctr.endConstruction);
0457             auto emsg = assembleMessage<Step::postModuleTransition>(
0458                 static_cast<std::underlying_type_t<Phase>>(Phase::construction), 0, id, 0, 0, 0, ctr.endConstruction);
0459             logFile->write(std::move(emsg));
0460           }
0461           ++id;
0462         }
0463         id = 0;
0464         std::sort(moduleCtrDtrPtr->begin(), moduleCtrDtrPtr->end(), [](auto const& l, auto const& r) {
0465           return l.beginDestruction < r.beginDestruction;
0466         });
0467         for (auto const& dtr : *moduleCtrDtrPtr) {
0468           if (dtr.beginDestruction != 0) {
0469             handleSource(dtr.beginDestruction);
0470             auto bmsg = assembleMessage<Step::preModuleTransition>(
0471                 static_cast<std::underlying_type_t<Phase>>(Phase::destruction), 0, id, 0, 0, 0, dtr.beginDestruction);
0472             logFile->write(std::move(bmsg));
0473             handleSource(dtr.endDestruction);
0474             auto emsg = assembleMessage<Step::postModuleTransition>(
0475                 static_cast<std::underlying_type_t<Phase>>(Phase::destruction), 0, id, 0, 0, 0, dtr.endDestruction);
0476             logFile->write(std::move(emsg));
0477           }
0478           ++id;
0479         }
0480         moduleCtrDtrPtr.reset();
0481       }
0482       auto const t = duration_cast<duration_t>(now() - beginTime).count();
0483       handleSource(t);
0484       auto msg = assembleMessage<Step::preFrameworkTransition>(
0485           static_cast<std::underlying_type_t<Phase>>(Phase::beginJob), 0, 0, 0, 0, t);
0486       logFile->write(std::move(msg));
0487     });
0488     iRegistry.watchPostBeginJob([logFile, beginTime]() {
0489       auto const t = duration_cast<duration_t>(now() - beginTime).count();
0490       auto msg = assembleMessage<Step::postFrameworkTransition>(
0491           static_cast<std::underlying_type_t<Phase>>(Phase::beginJob), 0, 0, 0, 0, t);
0492       logFile->write(std::move(msg));
0493     });
0494 
0495     iRegistry.watchPreEndJob([logFile, beginTime]() {
0496       auto const t = duration_cast<duration_t>(now() - beginTime).count();
0497       auto msg = assembleMessage<Step::preFrameworkTransition>(
0498           static_cast<std::underlying_type_t<Phase>>(Phase::endJob), 0, 0, 0, 0, t);
0499       logFile->write(std::move(msg));
0500     });
0501     iRegistry.watchPostEndJob([logFile, beginTime]() {
0502       auto const t = duration_cast<duration_t>(now() - beginTime).count();
0503       auto msg = assembleMessage<Step::postFrameworkTransition>(
0504           static_cast<std::underlying_type_t<Phase>>(Phase::endJob), 0, 0, 0, 0, t);
0505       logFile->write(std::move(msg));
0506     });
0507 
0508     iRegistry.watchPreEvent([logFile, beginTime](auto const& sc) {
0509       auto const t = duration_cast<duration_t>(now() - beginTime).count();
0510       auto msg = assembleMessage<Step::preFrameworkTransition>(static_cast<std::underlying_type_t<Phase>>(Phase::Event),
0511                                                                stream_id(sc),
0512                                                                sc.eventID().run(),
0513                                                                sc.eventID().luminosityBlock(),
0514                                                                sc.eventID().event(),
0515                                                                t);
0516       logFile->write(std::move(msg));
0517     });
0518     iRegistry.watchPostEvent([logFile, beginTime](auto const& sc) {
0519       auto const t = duration_cast<duration_t>(now() - beginTime).count();
0520       auto msg =
0521           assembleMessage<Step::postFrameworkTransition>(static_cast<std::underlying_type_t<Phase>>(Phase::Event),
0522                                                          stream_id(sc),
0523                                                          sc.eventID().run(),
0524                                                          sc.eventID().luminosityBlock(),
0525                                                          sc.eventID().event(),
0526                                                          t);
0527       logFile->write(std::move(msg));
0528     });
0529 
0530     iRegistry.watchPreClearEvent([logFile, beginTime](auto const& sc) {
0531       auto const t = duration_cast<duration_t>(now() - beginTime).count();
0532       auto msg =
0533           assembleMessage<Step::preFrameworkTransition>(static_cast<std::underlying_type_t<Phase>>(Phase::clearEvent),
0534                                                         stream_id(sc),
0535                                                         sc.eventID().run(),
0536                                                         sc.eventID().luminosityBlock(),
0537                                                         sc.eventID().event(),
0538                                                         t);
0539       logFile->write(std::move(msg));
0540     });
0541     iRegistry.watchPostClearEvent([logFile, beginTime](auto const& sc) {
0542       auto const t = duration_cast<duration_t>(now() - beginTime).count();
0543       auto msg =
0544           assembleMessage<Step::postFrameworkTransition>(static_cast<std::underlying_type_t<Phase>>(Phase::clearEvent),
0545                                                          stream_id(sc),
0546                                                          sc.eventID().run(),
0547                                                          sc.eventID().luminosityBlock(),
0548                                                          sc.eventID().event(),
0549                                                          t);
0550       logFile->write(std::move(msg));
0551     });
0552 
0553     {
0554       auto preGlobal = [logFile, beginTime](GlobalContext const& gc) {
0555         auto const t = duration_cast<duration_t>(now() - beginTime).count();
0556         auto msg = assembleMessage<Step::preFrameworkTransition>(toTransition(gc),
0557                                                                  toTransitionIndex(gc),
0558                                                                  gc.luminosityBlockID().run(),
0559                                                                  gc.luminosityBlockID().luminosityBlock(),
0560                                                                  0,
0561                                                                  t);
0562         logFile->write(std::move(msg));
0563       };
0564       iRegistry.watchPreBeginProcessBlock(preGlobal);
0565       iRegistry.watchPreEndProcessBlock(preGlobal);
0566       iRegistry.watchPreWriteProcessBlock(preGlobal);
0567       iRegistry.watchPreAccessInputProcessBlock(preGlobal);
0568       iRegistry.watchPreGlobalBeginRun(preGlobal);
0569       iRegistry.watchPreGlobalBeginLumi(preGlobal);
0570       iRegistry.watchPreGlobalEndLumi(preGlobal);
0571       iRegistry.watchPreGlobalWriteLumi(preGlobal);
0572       iRegistry.watchPreGlobalEndRun(preGlobal);
0573       iRegistry.watchPreGlobalWriteRun(preGlobal);
0574     }
0575     {
0576       auto postGlobal = [logFile, beginTime](GlobalContext const& gc) {
0577         auto const t = duration_cast<duration_t>(now() - beginTime).count();
0578         auto msg = assembleMessage<Step::postFrameworkTransition>(toTransition(gc),
0579                                                                   toTransitionIndex(gc),
0580                                                                   gc.luminosityBlockID().run(),
0581                                                                   gc.luminosityBlockID().luminosityBlock(),
0582                                                                   0,
0583                                                                   t);
0584         logFile->write(std::move(msg));
0585       };
0586       iRegistry.watchPostBeginProcessBlock(postGlobal);
0587       iRegistry.watchPostEndProcessBlock(postGlobal);
0588       iRegistry.watchPostWriteProcessBlock(postGlobal);
0589       iRegistry.watchPostAccessInputProcessBlock(postGlobal);
0590       iRegistry.watchPostGlobalBeginRun(postGlobal);
0591       iRegistry.watchPostGlobalBeginLumi(postGlobal);
0592       iRegistry.watchPostGlobalEndLumi(postGlobal);
0593       iRegistry.watchPostGlobalWriteLumi(postGlobal);
0594       iRegistry.watchPostGlobalEndRun(postGlobal);
0595       iRegistry.watchPostGlobalWriteRun(postGlobal);
0596     }
0597     {
0598       auto preStream = [logFile, beginTime](StreamContext const& sc) {
0599         auto const t = duration_cast<duration_t>(now() - beginTime).count();
0600         auto msg = assembleMessage<Step::preFrameworkTransition>(
0601             toTransition(sc), stream_id(sc), sc.eventID().run(), sc.eventID().luminosityBlock(), 0, t);
0602         logFile->write(std::move(msg));
0603       };
0604       iRegistry.watchPreStreamBeginRun(preStream);
0605       iRegistry.watchPreStreamBeginLumi(preStream);
0606       iRegistry.watchPreStreamEndLumi(preStream);
0607       iRegistry.watchPreStreamEndRun(preStream);
0608     }
0609     {
0610       auto postStream = [logFile, beginTime](StreamContext const& sc) {
0611         auto const t = duration_cast<duration_t>(now() - beginTime).count();
0612         auto msg = assembleMessage<Step::postFrameworkTransition>(
0613             toTransition(sc), stream_id(sc), sc.eventID().run(), sc.eventID().luminosityBlock(), 0, t);
0614         logFile->write(std::move(msg));
0615       };
0616       iRegistry.watchPostStreamBeginRun(postStream);
0617       iRegistry.watchPostStreamBeginLumi(postStream);
0618       iRegistry.watchPostStreamEndLumi(postStream);
0619       iRegistry.watchPostStreamEndRun(postStream);
0620     }
0621     {
0622       iRegistry.watchESSyncIOVQueuing([logFile, beginTime](IOVSyncValue const& sv) {
0623         auto const t = duration_cast<duration_t>(now() - beginTime).count();
0624         auto msg = assembleMessage<Step::preFrameworkTransition>(
0625             static_cast<std::underlying_type_t<Phase>>(Phase::esSyncEnqueue),
0626             -1,
0627             sv.eventID().run(),
0628             sv.eventID().luminosityBlock(),
0629             0,
0630             t);
0631         logFile->write(std::move(msg));
0632       });
0633       iRegistry.watchPreESSyncIOV([logFile, beginTime](IOVSyncValue const& sv) {
0634         auto const t = duration_cast<duration_t>(now() - beginTime).count();
0635         auto msg =
0636             assembleMessage<Step::preFrameworkTransition>(static_cast<std::underlying_type_t<Phase>>(Phase::esSync),
0637                                                           -1,
0638                                                           sv.eventID().run(),
0639                                                           sv.eventID().luminosityBlock(),
0640                                                           0,
0641                                                           t);
0642         logFile->write(std::move(msg));
0643       });
0644       iRegistry.watchPostESSyncIOV([logFile, beginTime](IOVSyncValue const& sv) {
0645         auto const t = duration_cast<duration_t>(now() - beginTime).count();
0646         auto msg =
0647             assembleMessage<Step::postFrameworkTransition>(static_cast<std::underlying_type_t<Phase>>(Phase::esSync),
0648                                                            -1,
0649                                                            sv.eventID().run(),
0650                                                            sv.eventID().luminosityBlock(),
0651                                                            0,
0652                                                            t);
0653         logFile->write(std::move(msg));
0654       });
0655     }
0656     {
0657       iRegistry.watchPreOpenFile([logFile, beginTime](std::string const&) {
0658         auto const t = duration_cast<duration_t>(now() - beginTime).count();
0659         auto msg = assembleMessage<Step::preSourceTransition>(
0660             static_cast<std::underlying_type_t<Phase>>(Phase::openFile), 0, t);
0661         logFile->write(std::move(msg));
0662       });
0663       iRegistry.watchPostOpenFile([logFile, beginTime](std::string const&) {
0664         auto const t = duration_cast<duration_t>(now() - beginTime).count();
0665         auto msg = assembleMessage<Step::postSourceTransition>(
0666             static_cast<std::underlying_type_t<Phase>>(Phase::openFile), 0, t);
0667         logFile->write(std::move(msg));
0668       });
0669       iRegistry.watchPreSourceEvent([logFile, beginTime](StreamID id) {
0670         auto const t = duration_cast<duration_t>(now() - beginTime).count();
0671         auto msg = assembleMessage<Step::preSourceTransition>(
0672             static_cast<std::underlying_type_t<Phase>>(Phase::Event), id.value(), t);
0673         logFile->write(std::move(msg));
0674       });
0675       iRegistry.watchPostSourceEvent([logFile, beginTime](StreamID id) {
0676         auto const t = duration_cast<duration_t>(now() - beginTime).count();
0677         auto msg = assembleMessage<Step::postSourceTransition>(
0678             static_cast<std::underlying_type_t<Phase>>(Phase::Event), id.value(), t);
0679         logFile->write(std::move(msg));
0680       });
0681 
0682       iRegistry.watchPreSourceRun([logFile, beginTime](RunIndex id) {
0683         auto const t = duration_cast<duration_t>(now() - beginTime).count();
0684         auto msg = assembleMessage<Step::preSourceTransition>(
0685             static_cast<std::underlying_type_t<Phase>>(Phase::globalBeginRun), id.value(), t);
0686         logFile->write(std::move(msg));
0687       });
0688       iRegistry.watchPostSourceRun([logFile, beginTime](RunIndex id) {
0689         auto const t = duration_cast<duration_t>(now() - beginTime).count();
0690         auto msg = assembleMessage<Step::postSourceTransition>(
0691             static_cast<std::underlying_type_t<Phase>>(Phase::globalBeginRun), id.value(), t);
0692         logFile->write(std::move(msg));
0693       });
0694 
0695       iRegistry.watchPreSourceLumi([logFile, beginTime](auto id) {
0696         auto const t = duration_cast<duration_t>(now() - beginTime).count();
0697         auto msg = assembleMessage<Step::preSourceTransition>(
0698             static_cast<std::underlying_type_t<Phase>>(Phase::globalBeginLumi), id.value(), t);
0699         logFile->write(std::move(msg));
0700       });
0701       iRegistry.watchPostSourceLumi([logFile, beginTime](auto id) {
0702         auto const t = duration_cast<duration_t>(now() - beginTime).count();
0703         auto msg = assembleMessage<Step::postSourceTransition>(
0704             static_cast<std::underlying_type_t<Phase>>(Phase::globalBeginLumi), id.value(), t);
0705         logFile->write(std::move(msg));
0706       });
0707 
0708       iRegistry.watchPreSourceNextTransition([logFile, beginTime]() {
0709         auto const t = duration_cast<duration_t>(now() - beginTime).count();
0710         auto msg = assembleMessage<Step::preSourceTransition>(
0711             static_cast<std::underlying_type_t<Phase>>(Phase::getNextTransition), t);
0712         logFile->write(std::move(msg));
0713       });
0714       iRegistry.watchPostSourceNextTransition([logFile, beginTime]() {
0715         auto const t = duration_cast<duration_t>(now() - beginTime).count();
0716         auto msg = assembleMessage<Step::postSourceTransition>(
0717             static_cast<std::underlying_type_t<Phase>>(Phase::getNextTransition), t);
0718         logFile->write(std::move(msg));
0719       });
0720 
0721       //ED Modules
0722       iRegistry.watchPreModuleBeginJob([logFile, beginTime](auto const& md) {
0723         auto const t = duration_cast<duration_t>(now() - beginTime).count();
0724         auto msg = assembleMessage<Step::preModuleTransition>(
0725             static_cast<std::underlying_type_t<Phase>>(Phase::beginJob), 0, md.id(), 0, 0, 0, t);
0726         logFile->write(std::move(msg));
0727       });
0728       iRegistry.watchPostModuleBeginJob([logFile, beginTime](auto const& md) {
0729         auto const t = duration_cast<duration_t>(now() - beginTime).count();
0730         auto msg = assembleMessage<Step::postModuleTransition>(
0731             static_cast<std::underlying_type_t<Phase>>(Phase::beginJob), 0, md.id(), 0, 0, 0, t);
0732         logFile->write(std::move(msg));
0733       });
0734 
0735       iRegistry.watchPreModuleBeginStream(StreamEDModuleState<Step::preModuleTransition>(logFile, beginTime));
0736       iRegistry.watchPostModuleBeginStream(StreamEDModuleState<Step::postModuleTransition>(logFile, beginTime));
0737 
0738       iRegistry.watchPreModuleEndStream(StreamEDModuleState<Step::preModuleTransition>(logFile, beginTime));
0739       iRegistry.watchPostModuleEndStream(StreamEDModuleState<Step::postModuleTransition>(logFile, beginTime));
0740 
0741       iRegistry.watchPreModuleEndJob([logFile, beginTime](auto const& md) {
0742         auto const t = duration_cast<duration_t>(now() - beginTime).count();
0743         auto msg = assembleMessage<Step::preModuleTransition>(
0744             static_cast<std::underlying_type_t<Phase>>(Phase::endJob), 0, md.id(), 0, 0, 0, t);
0745         logFile->write(std::move(msg));
0746       });
0747       iRegistry.watchPostModuleEndJob([logFile, beginTime](auto const& md) {
0748         auto const t = duration_cast<duration_t>(now() - beginTime).count();
0749         auto msg = assembleMessage<Step::postModuleTransition>(
0750             static_cast<std::underlying_type_t<Phase>>(Phase::endJob), 0, md.id(), 0, 0, 0, t);
0751         logFile->write(std::move(msg));
0752       });
0753 
0754       iRegistry.watchPreModuleEventPrefetching(StreamEDModuleState<Step::preModulePrefetching>(logFile, beginTime));
0755       iRegistry.watchPostModuleEventPrefetching(StreamEDModuleState<Step::postModulePrefetching>(logFile, beginTime));
0756 
0757       iRegistry.watchPreModuleEvent(StreamEDModuleState<Step::preModuleTransition>(logFile, beginTime));
0758       iRegistry.watchPostModuleEvent(StreamEDModuleState<Step::postModuleTransition>(logFile, beginTime));
0759       iRegistry.watchPreModuleEventAcquire(StreamEDModuleState<Step::preModuleEventAcquire>(logFile, beginTime));
0760       iRegistry.watchPostModuleEventAcquire(StreamEDModuleState<Step::postModuleEventAcquire>(logFile, beginTime));
0761       iRegistry.watchPreModuleEventDelayedGet(StreamEDModuleState<Step::preModuleEventDelayedGet>(logFile, beginTime));
0762       iRegistry.watchPostModuleEventDelayedGet(
0763           StreamEDModuleState<Step::postModuleEventDelayedGet>(logFile, beginTime));
0764       iRegistry.watchPreEventReadFromSource(StreamEDModuleState<Step::preEventReadFromSource>(logFile, beginTime));
0765       iRegistry.watchPostEventReadFromSource(StreamEDModuleState<Step::postEventReadFromSource>(logFile, beginTime));
0766 
0767       iRegistry.watchPreModuleTransform(StreamEDModuleState<Step::preModuleTransition>(logFile, beginTime));
0768       iRegistry.watchPostModuleTransform(StreamEDModuleState<Step::postModuleTransition>(logFile, beginTime));
0769       iRegistry.watchPreModuleTransformPrefetching(StreamEDModuleState<Step::preModulePrefetching>(logFile, beginTime));
0770       iRegistry.watchPostModuleTransformPrefetching(
0771           StreamEDModuleState<Step::postModulePrefetching>(logFile, beginTime));
0772       iRegistry.watchPreModuleTransformAcquiring(StreamEDModuleState<Step::preModuleEventAcquire>(logFile, beginTime));
0773       iRegistry.watchPostModuleTransformAcquiring(
0774           StreamEDModuleState<Step::postModuleEventAcquire>(logFile, beginTime));
0775 
0776       iRegistry.watchPreModuleStreamPrefetching(StreamEDModuleState<Step::preModulePrefetching>(logFile, beginTime));
0777       iRegistry.watchPostModuleStreamPrefetching(StreamEDModuleState<Step::postModulePrefetching>(logFile, beginTime));
0778 
0779       iRegistry.watchPreModuleStreamBeginRun(StreamEDModuleState<Step::preModuleTransition>(logFile, beginTime));
0780       iRegistry.watchPostModuleStreamBeginRun(StreamEDModuleState<Step::postModuleTransition>(logFile, beginTime));
0781       iRegistry.watchPreModuleStreamEndRun(StreamEDModuleState<Step::preModuleTransition>(logFile, beginTime));
0782       iRegistry.watchPostModuleStreamEndRun(StreamEDModuleState<Step::postModuleTransition>(logFile, beginTime));
0783 
0784       iRegistry.watchPreModuleStreamBeginLumi(StreamEDModuleState<Step::preModuleTransition>(logFile, beginTime));
0785       iRegistry.watchPostModuleStreamBeginLumi(StreamEDModuleState<Step::postModuleTransition>(logFile, beginTime));
0786       iRegistry.watchPreModuleStreamEndLumi(StreamEDModuleState<Step::preModuleTransition>(logFile, beginTime));
0787       iRegistry.watchPostModuleStreamEndLumi(StreamEDModuleState<Step::postModuleTransition>(logFile, beginTime));
0788 
0789       iRegistry.watchPreModuleBeginProcessBlock(GlobalEDModuleState<Step::preModuleTransition>(logFile, beginTime));
0790       iRegistry.watchPostModuleBeginProcessBlock(GlobalEDModuleState<Step::postModuleTransition>(logFile, beginTime));
0791       iRegistry.watchPreModuleAccessInputProcessBlock(
0792           GlobalEDModuleState<Step::preModuleTransition>(logFile, beginTime));
0793       iRegistry.watchPostModuleAccessInputProcessBlock(
0794           GlobalEDModuleState<Step::postModuleTransition>(logFile, beginTime));
0795       iRegistry.watchPreModuleEndProcessBlock(GlobalEDModuleState<Step::preModuleTransition>(logFile, beginTime));
0796       iRegistry.watchPostModuleEndProcessBlock(GlobalEDModuleState<Step::postModuleTransition>(logFile, beginTime));
0797 
0798       iRegistry.watchPreModuleGlobalPrefetching(GlobalEDModuleState<Step::preModulePrefetching>(logFile, beginTime));
0799       iRegistry.watchPostModuleGlobalPrefetching(GlobalEDModuleState<Step::postModulePrefetching>(logFile, beginTime));
0800 
0801       iRegistry.watchPreModuleGlobalBeginRun(GlobalEDModuleState<Step::preModuleTransition>(logFile, beginTime));
0802       iRegistry.watchPostModuleGlobalBeginRun(GlobalEDModuleState<Step::postModuleTransition>(logFile, beginTime));
0803       iRegistry.watchPreModuleGlobalEndRun(GlobalEDModuleState<Step::preModuleTransition>(logFile, beginTime));
0804       iRegistry.watchPostModuleGlobalEndRun(GlobalEDModuleState<Step::postModuleTransition>(logFile, beginTime));
0805 
0806       iRegistry.watchPreModuleGlobalBeginLumi(GlobalEDModuleState<Step::preModuleTransition>(logFile, beginTime));
0807       iRegistry.watchPostModuleGlobalBeginLumi(GlobalEDModuleState<Step::postModuleTransition>(logFile, beginTime));
0808       iRegistry.watchPreModuleGlobalEndLumi(GlobalEDModuleState<Step::preModuleTransition>(logFile, beginTime));
0809       iRegistry.watchPostModuleGlobalEndLumi(GlobalEDModuleState<Step::postModuleTransition>(logFile, beginTime));
0810 
0811       iRegistry.watchPreModuleWriteProcessBlock(GlobalEDModuleState<Step::preModuleTransition>(logFile, beginTime));
0812       iRegistry.watchPostModuleWriteProcessBlock(GlobalEDModuleState<Step::postModuleTransition>(logFile, beginTime));
0813 
0814       iRegistry.watchPreModuleWriteRun(GlobalEDModuleState<Step::preModuleTransition>(logFile, beginTime));
0815       iRegistry.watchPostModuleWriteRun(GlobalEDModuleState<Step::postModuleTransition>(logFile, beginTime));
0816 
0817       iRegistry.watchPreModuleWriteLumi(GlobalEDModuleState<Step::preModuleTransition>(logFile, beginTime));
0818       iRegistry.watchPostModuleWriteLumi(GlobalEDModuleState<Step::postModuleTransition>(logFile, beginTime));
0819 
0820       //ES Modules
0821       iRegistry.watchPreESModulePrefetching(
0822           ESModuleState<Step::preESModulePrefetching>(logFile, beginTime, recordIndices));
0823       iRegistry.watchPostESModulePrefetching(
0824           ESModuleState<Step::postESModulePrefetching>(logFile, beginTime, recordIndices));
0825       iRegistry.watchPreESModule(ESModuleState<Step::preESModule>(logFile, beginTime, recordIndices));
0826       iRegistry.watchPostESModule(ESModuleState<Step::postESModule>(logFile, beginTime, recordIndices));
0827       iRegistry.watchPreESModuleAcquire(ESModuleState<Step::preESModuleAcquire>(logFile, beginTime, recordIndices));
0828       iRegistry.watchPostESModuleAcquire(ESModuleState<Step::postESModuleAcquire>(logFile, beginTime, recordIndices));
0829     }
0830 
0831     std::ostringstream oss;
0832     oss << "# Transition              Symbol\n";
0833     oss << "#------------------------ ------\n";
0834     oss << "# startTracing            " << Phase::startTracing << "\n"
0835         << "# construction            " << Phase::construction << "\n"
0836         << "# getNextTransition       " << Phase::getNextTransition << "\n"
0837         << "# esSyncEnqueue           " << Phase::esSyncEnqueue << "\n"
0838         << "# esSync                  " << Phase::esSync << "\n"
0839         << "# beginJob                " << Phase::beginJob << "\n"
0840         << "# beginStream             " << Phase::beginStream << "\n"
0841         << "# openFile                " << Phase::openFile << "\n"
0842         << "# beginProcessBlock       " << Phase::beginProcessBlock << "\n"
0843         << "# accessInputProcessBlock " << Phase::accessInputProcessBlock << "\n"
0844         << "# globalBeginRun          " << Phase::globalBeginRun << "\n"
0845         << "# streamBeginRun          " << Phase::streamBeginRun << "\n"
0846         << "# globalBeginLumi         " << Phase::globalBeginLumi << "\n"
0847         << "# streamBeginLumi         " << Phase::streamBeginLumi << "\n"
0848         << "# Event                   " << Phase::Event << "\n"
0849         << "# clearEvent              " << Phase::clearEvent << "\n"
0850         << "# streamEndLumi           " << Phase::streamEndLumi << "\n"
0851         << "# globalEndLumi           " << Phase::globalEndLumi << "\n"
0852         << "# globalWriteLumi         " << Phase::globalWriteLumi << "\n"
0853         << "# streamEndRun            " << Phase::streamEndRun << "\n"
0854         << "# globalEndRun            " << Phase::globalEndRun << "\n"
0855         << "# globalWriteRun          " << Phase::globalWriteRun << "\n"
0856         << "# endProcessBlock         " << Phase::endProcessBlock << "\n"
0857         << "# writeProcessBlock       " << Phase::writeProcessBlock << "\n"
0858         << "# endStream               " << Phase::endStream << "\n"
0859         << "# endJob                  " << Phase::endJob << "\n"
0860         << "# destruction             " << Phase::destruction << "\n\n";
0861     oss << "# Step                       Symbol Entries\n"
0862         << "# -------------------------- ------ ------------------------------------------\n"
0863         << "# preSourceTransition           " << Step::preSourceTransition
0864         << "   <Transition type> <Transition ID> <Time since begin of cmsRun (us)>\n"
0865         << "# postSourceTransition          " << Step::postSourceTransition
0866         << "   <Transition type> <Transition ID> <Time since begin of cmsRun (us)>\n"
0867         << "# preModulePrefetching          " << Step::preModulePrefetching
0868         << "   <Transition type> <Transition ID> <EDModule ID> <Call ID> <Requesting EDModule ID or 0> <Requesting "
0869            "Call ID> <Time since begin of "
0870            "cmsRun "
0871            "(us)>\n"
0872         << "# postModulePrefetching         " << Step::postModulePrefetching
0873         << "   <Transition type> <Transition ID> <EDModule ID> <Call ID> <Requesting EDModule ID or 0> <Requesting "
0874            "Call ID> <Time since begin of "
0875            "cmsRun "
0876            "(us)>\n"
0877         << "# preModuleEventAcquire         " << Step::preModuleEventAcquire
0878         << "   <Transition type> <Transition ID> <EDModule ID> <Call ID> <Requesting EDModule ID or 0> <Requesting "
0879            "Call ID> <Time since begin of "
0880            "cmsRun "
0881            "(us)>\n"
0882         << "# postModuleEventAcquire        " << Step::postModuleEventAcquire
0883         << "   <Transition type> <Transition ID> <EDModule ID> <Call ID> <Requesting EDModule ID or 0> <Requesting "
0884            "Call ID> <Time since begin of "
0885            "cmsRun "
0886            "(us)>\n"
0887         << "# preModuleTransition           " << Step::preModuleTransition
0888         << "   <Transition type> <Transition ID> <EDModule ID> <Call ID> <Requesting EDModule ID or 0> <Requesting "
0889            "Call ID> <Time since begin of "
0890            "cmsRun "
0891            "(us)>\n"
0892         << "# preEventReadFromSource        " << Step::preEventReadFromSource
0893         << "   <Transition type> <Transition ID> <EDModule ID> <Call ID> <Requesting EDModule ID or 0> <Requesting "
0894            "Call ID> <Time since begin of "
0895            "cmsRun "
0896            "(us)>\n"
0897         << "# postEventReadFromSource       " << Step::postEventReadFromSource
0898         << "   <Transition type> <Transition ID> <EDModule ID> <Call ID> <Requesting EDModule ID or 0> <Requesting "
0899            "Call ID> <Time since begin of "
0900            "cmsRun "
0901            "(us)>\n"
0902         << "# postModuleTransition          " << Step::postModuleTransition
0903         << "   <Transition type> <Transition ID> <EDModule ID> <Call ID> <Requesting EDModule ID> <Requesting Call ID> "
0904            "<Time since begin of cmsRun "
0905            "(us)>\n"
0906         << "# preESModulePrefetching        " << Step::preESModulePrefetching
0907         << "   <Transition type> <Transition ID> <ESModule ID> <Record ID> <Call ID> <Requesting module ID (+ED, -ES)> "
0908            "<Requesting Call ID> "
0909            "<Time "
0910            "since of cmsRun (us)>\n"
0911         << "# postESModulePrefetching       " << Step::postESModulePrefetching
0912         << "   <Transition type> <Transition ID> <ESModule ID> <Record ID> <Call ID> <Requesting module ID (+ED, -ES)> "
0913            "<Requesting Call ID> "
0914            "<Time "
0915            "since of cmsRun (us)>\n"
0916         << "# preESModuleTransition         " << Step::preESModule
0917         << "   <TransitionType> <Transition ID> <ESModule ID> <Record ID> <Call ID> <Requesting module ID (+ED, -ES)> "
0918            "<Requesting Call ID> "
0919            "<Time "
0920            "since of cmsRun (us)>\n"
0921         << "# postESModuleTransition        " << Step::postESModule
0922         << "   <TransitionType> <Transition ID> <ESModule ID> <Record ID> <Call ID> <Requesting module ID (+ED, -ES)> "
0923            "<Requesting Call ID> "
0924            "<Time "
0925            "since of cmsRun (us)>\n"
0926         << "# preFrameworkTransition        " << Step::preFrameworkTransition
0927         << "   <Transition type> <Transition ID> <Run#> <LumiBlock#> <Event #> <Time since begin of cmsRun (ms)>\n"
0928         << "# postFrameworkTransition       " << Step::postFrameworkTransition
0929         << "   <Transition type> <Transition ID> <Run#> <LumiBlock#> <Event #> <Time since begin of cmsRun (ms)>\n";
0930     logFile->write(oss.str());
0931     return;
0932   }
0933 }  // namespace edm::service::tracer
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!