Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2025-06-12 23:30:01 

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