File indexing completed on 2024-06-13 03:23:56
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/Utilities/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 }
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
0369 iRegistry.watchPostESModuleRegistration([&esModuleLabels](auto const& iDescription) {
0370 if (esModuleLabels.size() <= iDescription.id_ + 1) {
0371 esModuleLabels.resize(iDescription.id_ + 2);
0372 }
0373
0374 if (not iDescription.label_.empty()) {
0375 esModuleLabels[iDescription.id_ + 1] = iDescription.label_;
0376 } else {
0377 esModuleLabels[iDescription.id_ + 1] = iDescription.type_;
0378 }
0379 });
0380 auto moduleCtrDtrPtr = std::make_shared<std::vector<ModuleCtrDtr>>();
0381 auto& moduleCtrDtr = *moduleCtrDtrPtr;
0382 auto moduleLabelsPtr = std::make_shared<std::vector<std::string>>();
0383 auto& moduleLabels = *moduleLabelsPtr;
0384 iRegistry.watchPreModuleConstruction(
0385 [&moduleLabels, &moduleCtrDtr, beginTime, iFilter](ModuleDescription const& md) {
0386 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0387
0388 auto const mid = md.id();
0389 if (mid < moduleLabels.size()) {
0390 moduleLabels[mid] = md.moduleLabel();
0391 moduleCtrDtr[mid].beginConstruction = t;
0392 } else {
0393 moduleLabels.resize(mid + 1);
0394 moduleLabels.back() = md.moduleLabel();
0395 moduleCtrDtr.resize(mid + 1);
0396 moduleCtrDtr.back().beginConstruction = t;
0397 }
0398 iFilter->startOnThread(mid);
0399 });
0400 iRegistry.watchPostModuleConstruction([&moduleCtrDtr, beginTime, iFilter](auto const& md) {
0401 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0402 moduleCtrDtr[md.id()].endConstruction = t;
0403 auto alloc = iFilter->stopOnThread(md.id());
0404 if (alloc) {
0405 moduleCtrDtr[md.id()].constructionAllocInfo = *alloc;
0406 }
0407 });
0408
0409 auto addDataInDtr = std::make_shared<bool>(false);
0410 iRegistry.watchPreModuleDestruction([&moduleCtrDtr, beginTime, iFilter, addDataInDtr, logFile](auto const& md) {
0411 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0412 if (*addDataInDtr) {
0413 if (iFilter->keepModuleInfo(md.id())) {
0414 auto bmsg = assembleMessage<Step::preModuleTransition>(
0415 static_cast<std::underlying_type_t<Phase>>(Phase::destruction), 0, md.id(), 0, 0, 0, t);
0416 logFile->write(std::move(bmsg));
0417 }
0418 } else {
0419 moduleCtrDtr[md.id()].beginDestruction = t;
0420 }
0421 iFilter->startOnThread(md.id());
0422 });
0423 iRegistry.watchPostModuleDestruction([&moduleCtrDtr, beginTime, iFilter, addDataInDtr, logFile](auto const& md) {
0424 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0425 if (not *addDataInDtr) {
0426 moduleCtrDtr[md.id()].endDestruction = t;
0427 }
0428 auto info = iFilter->stopOnThread(md.id());
0429 if (info) {
0430 if (*addDataInDtr) {
0431 if (iFilter->keepModuleInfo(md.id())) {
0432 auto emsg = assembleAllocMessage<Step::postModuleTransition>(
0433 *info, static_cast<std::underlying_type_t<Phase>>(Phase::destruction), 0, md.id(), 0, 0, 0, t);
0434 logFile->write(std::move(emsg));
0435 }
0436
0437 } else {
0438 moduleCtrDtr[md.id()].destructionAllocInfo = *info;
0439 }
0440 }
0441 });
0442
0443 auto sourceCtrPtr = std::make_shared<ModuleCtrDtr>();
0444 auto& sourceCtr = *sourceCtrPtr;
0445 iRegistry.watchPreSourceConstruction([&sourceCtr, beginTime, iFilter](auto const&) {
0446 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0447 sourceCtr.beginConstruction = t;
0448 iFilter->startOnThread();
0449 });
0450 iRegistry.watchPostSourceConstruction([&sourceCtr, beginTime, iFilter](auto const&) {
0451 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0452 sourceCtr.endConstruction = t;
0453 auto info = iFilter->stopOnThread();
0454 if (info) {
0455 sourceCtr.constructionAllocInfo = *info;
0456 }
0457 });
0458
0459 auto recordIndices = std::make_shared<std::vector<std::type_index>>();
0460 iRegistry.watchEventSetupConfiguration(
0461 [logFile, recordIndices](auto const& recordsToResolvers, auto const&) mutable {
0462 std::ostringstream oss;
0463
0464 auto recordKeys = recordsToResolvers.recordKeys();
0465 std::sort(recordKeys.begin(), recordKeys.end());
0466 std::vector<std::string> recordNames;
0467
0468 recordNames.reserve(recordKeys.size() + 1);
0469 recordNames.emplace_back("");
0470 recordIndices->reserve(recordKeys.size() + 1);
0471 recordIndices->push_back(std::type_index(typeid(void)));
0472 for (auto const& r : recordKeys) {
0473 recordNames.push_back(r.name());
0474 recordIndices->push_back(std::type_index(r.type().value()));
0475 }
0476
0477 moduleIdToLabel(oss, recordNames, 'R', "Record ID", "Record name");
0478 logFile->write(oss.str());
0479 });
0480
0481 iRegistry.watchPreBeginJob([logFile,
0482 iFilter,
0483 moduleLabelsPtr,
0484 esModuleLabelsPtr,
0485 moduleCtrDtrPtr,
0486 sourceCtrPtr,
0487 beginTime,
0488 beginModuleAlloc,
0489 addDataInDtr](auto&, auto&) mutable {
0490 *addDataInDtr = true;
0491 {
0492 std::ostringstream oss;
0493 moduleIdToLabel(oss, *moduleLabelsPtr, 'M', "EDModule ID", "Module label");
0494 logFile->write(oss.str());
0495 moduleLabelsPtr.reset();
0496 }
0497 {
0498 std::ostringstream oss;
0499 moduleIdToLabel(oss, *esModuleLabelsPtr, 'N', "ESModule ID", "ESModule label");
0500 logFile->write(oss.str());
0501 esModuleLabelsPtr.reset();
0502 }
0503 {
0504 auto const moduleAllocStart = duration_cast<duration_t>(beginModuleAlloc - beginTime).count();
0505 auto msg = assembleMessage<Step::preFrameworkTransition>(
0506 static_cast<std::underlying_type_t<Phase>>(Phase::startTracing), 0, 0, 0, 0, moduleAllocStart);
0507 logFile->write(std::move(msg));
0508 }
0509 if (not iFilter->globalKeep()) {
0510 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0511 auto msg = assembleMessage<Step::preFrameworkTransition>(
0512 static_cast<std::underlying_type_t<Phase>>(Phase::beginJob), 0, 0, 0, 0, t);
0513 logFile->write(std::move(msg));
0514 return;
0515 }
0516
0517
0518 auto srcBeginConstruction = sourceCtrPtr->beginConstruction;
0519 auto srcEndConstruction = sourceCtrPtr->endConstruction;
0520 auto srcAllocInfo = sourceCtrPtr->constructionAllocInfo;
0521 sourceCtrPtr.reset();
0522 auto handleSource =
0523 [&srcBeginConstruction, &srcEndConstruction, &logFile, &srcAllocInfo](long long iTime) mutable {
0524 if (srcBeginConstruction != 0 and srcBeginConstruction < iTime) {
0525 auto bmsg = assembleMessage<Step::preSourceTransition>(
0526 static_cast<std::underlying_type_t<Phase>>(Phase::construction), 0, srcBeginConstruction);
0527 logFile->write(std::move(bmsg));
0528 srcBeginConstruction = 0;
0529 }
0530 if (srcEndConstruction != 0 and srcEndConstruction < iTime) {
0531 auto bmsg = assembleAllocMessage<Step::postSourceTransition>(
0532 srcAllocInfo, static_cast<std::underlying_type_t<Phase>>(Phase::construction), 0, srcEndConstruction);
0533 logFile->write(std::move(bmsg));
0534 srcEndConstruction = 0;
0535 }
0536 };
0537 {
0538 std::sort(moduleCtrDtrPtr->begin(), moduleCtrDtrPtr->end(), [](auto const& l, auto const& r) {
0539 return l.beginConstruction < r.beginConstruction;
0540 });
0541 int id = 0;
0542 for (auto const& ctr : *moduleCtrDtrPtr) {
0543 if (ctr.beginConstruction != 0) {
0544 handleSource(ctr.beginConstruction);
0545 if (iFilter->keepModuleInfo(id)) {
0546 auto bmsg = assembleMessage<Step::preModuleTransition>(
0547 static_cast<std::underlying_type_t<Phase>>(Phase::construction), 0, id, 0, ctr.beginConstruction);
0548 logFile->write(std::move(bmsg));
0549 }
0550 handleSource(ctr.endConstruction);
0551 if (iFilter->keepModuleInfo(id)) {
0552 auto const& allocInfo = ctr.constructionAllocInfo;
0553 auto emsg = assembleAllocMessage<Step::postModuleTransition>(
0554 allocInfo,
0555 static_cast<std::underlying_type_t<Phase>>(Phase::construction),
0556 0,
0557 id,
0558 0,
0559 ctr.endConstruction);
0560 logFile->write(std::move(emsg));
0561 }
0562 }
0563 ++id;
0564 }
0565 id = 0;
0566 std::sort(moduleCtrDtrPtr->begin(), moduleCtrDtrPtr->end(), [](auto const& l, auto const& r) {
0567 return l.beginDestruction < r.beginDestruction;
0568 });
0569 for (auto const& dtr : *moduleCtrDtrPtr) {
0570 if (dtr.beginDestruction != 0) {
0571 handleSource(dtr.beginDestruction);
0572 if (iFilter->keepModuleInfo(id)) {
0573 auto bmsg = assembleMessage<Step::preModuleTransition>(
0574 static_cast<std::underlying_type_t<Phase>>(Phase::destruction), 0, id, 0, 0, 0, dtr.beginDestruction);
0575 logFile->write(std::move(bmsg));
0576 }
0577 handleSource(dtr.endDestruction);
0578 if (iFilter->keepModuleInfo(id)) {
0579 auto emsg = assembleAllocMessage<Step::postModuleTransition>(
0580 dtr.destructionAllocInfo,
0581 static_cast<std::underlying_type_t<Phase>>(Phase::destruction),
0582 0,
0583 id,
0584 0,
0585 0,
0586 0,
0587 dtr.endDestruction);
0588 logFile->write(std::move(emsg));
0589 }
0590 }
0591 ++id;
0592 }
0593 moduleCtrDtrPtr.reset();
0594 }
0595 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0596 handleSource(t);
0597 auto msg = assembleMessage<Step::preFrameworkTransition>(
0598 static_cast<std::underlying_type_t<Phase>>(Phase::beginJob), 0, 0, 0, 0, t);
0599 logFile->write(std::move(msg));
0600 });
0601 iRegistry.watchPostBeginJob([logFile, beginTime]() {
0602 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0603 auto msg = assembleMessage<Step::postFrameworkTransition>(
0604 static_cast<std::underlying_type_t<Phase>>(Phase::beginJob), 0, 0, 0, 0, t);
0605 logFile->write(std::move(msg));
0606 });
0607
0608 iRegistry.watchPreEndJob([logFile, beginTime]() {
0609 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0610 auto msg = assembleMessage<Step::preFrameworkTransition>(
0611 static_cast<std::underlying_type_t<Phase>>(Phase::endJob), 0, 0, 0, 0, t);
0612 logFile->write(std::move(msg));
0613 });
0614 iRegistry.watchPostEndJob([logFile, beginTime]() {
0615 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0616 auto msg = assembleMessage<Step::postFrameworkTransition>(
0617 static_cast<std::underlying_type_t<Phase>>(Phase::endJob), 0, 0, 0, 0, t);
0618 logFile->write(std::move(msg));
0619 });
0620
0621 iRegistry.watchPreEvent([logFile, beginTime](auto const& sc) {
0622 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0623 auto msg = assembleMessage<Step::preFrameworkTransition>(static_cast<std::underlying_type_t<Phase>>(Phase::Event),
0624 stream_id(sc),
0625 sc.eventID().run(),
0626 sc.eventID().luminosityBlock(),
0627 sc.eventID().event(),
0628 t);
0629 logFile->write(std::move(msg));
0630 });
0631 iRegistry.watchPostEvent([logFile, beginTime](auto const& sc) {
0632 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0633 auto msg =
0634 assembleMessage<Step::postFrameworkTransition>(static_cast<std::underlying_type_t<Phase>>(Phase::Event),
0635 stream_id(sc),
0636 sc.eventID().run(),
0637 sc.eventID().luminosityBlock(),
0638 sc.eventID().event(),
0639 t);
0640 logFile->write(std::move(msg));
0641 });
0642
0643 iRegistry.watchPreClearEvent([logFile, beginTime, iFilter](auto const& sc) {
0644 if (iFilter->startOnThread()) {
0645 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0646 auto msg =
0647 assembleMessage<Step::preFrameworkTransition>(static_cast<std::underlying_type_t<Phase>>(Phase::clearEvent),
0648 stream_id(sc),
0649 sc.eventID().run(),
0650 sc.eventID().luminosityBlock(),
0651 sc.eventID().event(),
0652 t);
0653 logFile->write(std::move(msg));
0654 }
0655 });
0656 iRegistry.watchPostClearEvent([logFile, beginTime, iFilter](auto const& sc) {
0657 auto info = iFilter->stopOnThread();
0658 if (info) {
0659 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0660 auto msg = assembleAllocMessage<Step::postFrameworkTransition>(
0661 *info,
0662 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
0672 {
0673 auto preGlobal = [logFile, beginTime](GlobalContext const& gc) {
0674 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0675 auto msg = assembleMessage<Step::preFrameworkTransition>(toTransition(gc),
0676 toTransitionIndex(gc),
0677 gc.luminosityBlockID().run(),
0678 gc.luminosityBlockID().luminosityBlock(),
0679 0,
0680 t);
0681 logFile->write(std::move(msg));
0682 };
0683 iRegistry.watchPreBeginProcessBlock(preGlobal);
0684 iRegistry.watchPreEndProcessBlock(preGlobal);
0685 iRegistry.watchPreWriteProcessBlock(preGlobal);
0686 iRegistry.watchPreAccessInputProcessBlock(preGlobal);
0687 iRegistry.watchPreGlobalBeginRun(preGlobal);
0688 iRegistry.watchPreGlobalBeginLumi(preGlobal);
0689 iRegistry.watchPreGlobalEndLumi(preGlobal);
0690 iRegistry.watchPreGlobalWriteLumi(preGlobal);
0691 iRegistry.watchPreGlobalEndRun(preGlobal);
0692 iRegistry.watchPreGlobalWriteRun(preGlobal);
0693 }
0694 {
0695 auto postGlobal = [logFile, beginTime](GlobalContext const& gc) {
0696 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0697 auto msg = assembleMessage<Step::postFrameworkTransition>(toTransition(gc),
0698 toTransitionIndex(gc),
0699 gc.luminosityBlockID().run(),
0700 gc.luminosityBlockID().luminosityBlock(),
0701 0,
0702 t);
0703 logFile->write(std::move(msg));
0704 };
0705 iRegistry.watchPostBeginProcessBlock(postGlobal);
0706 iRegistry.watchPostEndProcessBlock(postGlobal);
0707 iRegistry.watchPostWriteProcessBlock(postGlobal);
0708 iRegistry.watchPostAccessInputProcessBlock(postGlobal);
0709 iRegistry.watchPostGlobalBeginRun(postGlobal);
0710 iRegistry.watchPostGlobalBeginLumi(postGlobal);
0711 iRegistry.watchPostGlobalEndLumi(postGlobal);
0712 iRegistry.watchPostGlobalWriteLumi(postGlobal);
0713 iRegistry.watchPostGlobalEndRun(postGlobal);
0714 iRegistry.watchPostGlobalWriteRun(postGlobal);
0715 }
0716 {
0717 auto preStream = [logFile, beginTime](StreamContext const& sc) {
0718 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0719 auto msg = assembleMessage<Step::preFrameworkTransition>(
0720 toTransition(sc), stream_id(sc), sc.eventID().run(), sc.eventID().luminosityBlock(), 0, t);
0721 logFile->write(std::move(msg));
0722 };
0723 iRegistry.watchPreStreamBeginRun(preStream);
0724 iRegistry.watchPreStreamBeginLumi(preStream);
0725 iRegistry.watchPreStreamEndLumi(preStream);
0726 iRegistry.watchPreStreamEndRun(preStream);
0727 }
0728 {
0729 auto postStream = [logFile, beginTime](StreamContext const& sc) {
0730 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0731 auto msg = assembleMessage<Step::postFrameworkTransition>(
0732 toTransition(sc), stream_id(sc), sc.eventID().run(), sc.eventID().luminosityBlock(), 0, t);
0733 logFile->write(std::move(msg));
0734 };
0735 iRegistry.watchPostStreamBeginRun(postStream);
0736 iRegistry.watchPostStreamBeginLumi(postStream);
0737 iRegistry.watchPostStreamEndLumi(postStream);
0738 iRegistry.watchPostStreamEndRun(postStream);
0739 }
0740 {
0741 iRegistry.watchPreOpenFile([logFile, beginTime, iFilter](std::string const&) {
0742 if (iFilter->startOnThread()) {
0743 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0744 auto msg = assembleMessage<Step::preSourceTransition>(
0745 static_cast<std::underlying_type_t<Phase>>(Phase::openFile), 0, t);
0746 logFile->write(std::move(msg));
0747 }
0748 });
0749 iRegistry.watchPostOpenFile([logFile, beginTime, iFilter](std::string const&) {
0750 auto info = iFilter->stopOnThread();
0751 if (info) {
0752 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0753 auto msg = assembleAllocMessage<Step::postSourceTransition>(
0754 *info, static_cast<std::underlying_type_t<Phase>>(Phase::openFile), 0, t);
0755 logFile->write(std::move(msg));
0756 }
0757 });
0758 iRegistry.watchPreSourceEvent([logFile, beginTime, iFilter](StreamID id) {
0759 if (iFilter->startOnThread()) {
0760 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0761 auto msg = assembleMessage<Step::preSourceTransition>(
0762 static_cast<std::underlying_type_t<Phase>>(Phase::Event), id.value(), t);
0763 logFile->write(std::move(msg));
0764 }
0765 });
0766 iRegistry.watchPostSourceEvent([logFile, beginTime, iFilter](StreamID id) {
0767 auto info = iFilter->stopOnThread();
0768 if (info) {
0769 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0770 auto msg = assembleAllocMessage<Step::postSourceTransition>(
0771 *info, static_cast<std::underlying_type_t<Phase>>(Phase::Event), id.value(), t);
0772 logFile->write(std::move(msg));
0773 }
0774 });
0775
0776 iRegistry.watchPreSourceRun([logFile, beginTime, iFilter](RunIndex id) {
0777 if (iFilter->startOnThread()) {
0778 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0779 auto msg = assembleMessage<Step::preSourceTransition>(
0780 static_cast<std::underlying_type_t<Phase>>(Phase::globalBeginRun), id.value(), t);
0781 logFile->write(std::move(msg));
0782 }
0783 });
0784 iRegistry.watchPostSourceRun([logFile, beginTime, iFilter](RunIndex id) {
0785 auto info = iFilter->stopOnThread();
0786 if (info) {
0787 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0788 auto msg = assembleAllocMessage<Step::postSourceTransition>(
0789 *info, static_cast<std::underlying_type_t<Phase>>(Phase::globalBeginRun), id.value(), t);
0790 logFile->write(std::move(msg));
0791 }
0792 });
0793
0794 iRegistry.watchPreSourceLumi([logFile, beginTime, iFilter](auto id) {
0795 if (iFilter->startOnThread()) {
0796 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0797 auto msg = assembleMessage<Step::preSourceTransition>(
0798 static_cast<std::underlying_type_t<Phase>>(Phase::globalBeginLumi), id.value(), t);
0799 logFile->write(std::move(msg));
0800 }
0801 });
0802 iRegistry.watchPostSourceLumi([logFile, beginTime, iFilter](auto id) {
0803 auto info = iFilter->stopOnThread();
0804 if (info) {
0805 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0806 auto msg = assembleAllocMessage<Step::postSourceTransition>(
0807 *info, static_cast<std::underlying_type_t<Phase>>(Phase::globalBeginLumi), id.value(), t);
0808 logFile->write(std::move(msg));
0809 }
0810 });
0811
0812 iRegistry.watchPreSourceNextTransition([logFile, beginTime, iFilter]() {
0813 if (iFilter->startOnThread()) {
0814 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0815 auto msg = assembleMessage<Step::preSourceTransition>(
0816 static_cast<std::underlying_type_t<Phase>>(Phase::getNextTransition), t);
0817 logFile->write(std::move(msg));
0818 }
0819 });
0820 iRegistry.watchPostSourceNextTransition([logFile, beginTime, iFilter]() {
0821 auto info = iFilter->stopOnThread();
0822 if (info) {
0823 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0824 auto msg = assembleAllocMessage<Step::postSourceTransition>(
0825 *info, static_cast<std::underlying_type_t<Phase>>(Phase::getNextTransition), t);
0826 logFile->write(std::move(msg));
0827 }
0828 });
0829
0830
0831 iRegistry.watchPreModuleBeginJob([logFile, beginTime, iFilter](auto const& md) {
0832 if (iFilter->startOnThread(md.id())) {
0833 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0834 auto msg = assembleMessage<Step::preModuleTransition>(
0835 static_cast<std::underlying_type_t<Phase>>(Phase::beginJob), 0, md.id(), 0, t);
0836 logFile->write(std::move(msg));
0837 }
0838 });
0839 iRegistry.watchPostModuleBeginJob([logFile, beginTime, iFilter](auto const& md) {
0840 auto info = iFilter->stopOnThread(md.id());
0841 if (info) {
0842 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0843 auto msg = assembleAllocMessage<Step::postModuleTransition>(
0844 *info, static_cast<std::underlying_type_t<Phase>>(Phase::beginJob), 0, md.id(), 0, t);
0845 logFile->write(std::move(msg));
0846 }
0847 });
0848
0849 iRegistry.watchPreModuleBeginStream(StreamEDModuleState<Step::preModuleTransition>(logFile, beginTime, iFilter));
0850 iRegistry.watchPostModuleBeginStream(
0851 StreamEDModuleState<Step::postModuleTransition>(logFile, beginTime, iFilter));
0852
0853 iRegistry.watchPreModuleEndStream(StreamEDModuleState<Step::preModuleTransition>(logFile, beginTime, iFilter));
0854 iRegistry.watchPostModuleEndStream(StreamEDModuleState<Step::postModuleTransition>(logFile, beginTime, iFilter));
0855
0856 iRegistry.watchPreModuleEndJob([logFile, beginTime, iFilter](auto const& md) {
0857 if (iFilter->startOnThread(md.id())) {
0858 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0859 auto msg = assembleMessage<Step::preModuleTransition>(
0860 static_cast<std::underlying_type_t<Phase>>(Phase::endJob), 0, md.id(), 0, t);
0861 logFile->write(std::move(msg));
0862 }
0863 });
0864 iRegistry.watchPostModuleEndJob([logFile, beginTime, iFilter](auto const& md) {
0865 auto info = iFilter->stopOnThread(md.id());
0866 if (info) {
0867 auto const t = duration_cast<duration_t>(now() - beginTime).count();
0868 auto msg = assembleAllocMessage<Step::postModuleTransition>(
0869 *info, static_cast<std::underlying_type_t<Phase>>(Phase::endJob), 0, md.id(), 0, t);
0870 logFile->write(std::move(msg));
0871 }
0872 });
0873
0874 iRegistry.watchPreModuleEvent(StreamEDModuleState<Step::preModuleTransition>(logFile, beginTime, iFilter));
0875 iRegistry.watchPostModuleEvent(StreamEDModuleState<Step::postModuleTransition>(logFile, beginTime, iFilter));
0876 iRegistry.watchPreModuleEventAcquire(
0877 StreamEDModuleState<Step::preModuleEventAcquire>(logFile, beginTime, iFilter));
0878 iRegistry.watchPostModuleEventAcquire(
0879 StreamEDModuleState<Step::postModuleEventAcquire>(logFile, beginTime, iFilter));
0880 iRegistry.watchPreModuleEventDelayedGet(
0881 StreamEDModuleState<Step::preModuleEventDelayedGet>(logFile, beginTime, iFilter));
0882 iRegistry.watchPostModuleEventDelayedGet(
0883 StreamEDModuleState<Step::postModuleEventDelayedGet>(logFile, beginTime, iFilter));
0884 iRegistry.watchPreEventReadFromSource(
0885 StreamEDModuleState<Step::preEventReadFromSource>(logFile, beginTime, iFilter));
0886 iRegistry.watchPostEventReadFromSource(
0887 StreamEDModuleState<Step::postEventReadFromSource>(logFile, beginTime, iFilter));
0888
0889 iRegistry.watchPreModuleTransform(StreamEDModuleState<Step::preModuleTransition>(logFile, beginTime, iFilter));
0890 iRegistry.watchPostModuleTransform(StreamEDModuleState<Step::postModuleTransition>(logFile, beginTime, iFilter));
0891 iRegistry.watchPreModuleTransformAcquiring(
0892 StreamEDModuleState<Step::preModuleEventAcquire>(logFile, beginTime, iFilter));
0893 iRegistry.watchPostModuleTransformAcquiring(
0894 StreamEDModuleState<Step::postModuleEventAcquire>(logFile, beginTime, iFilter));
0895
0896 iRegistry.watchPreModuleStreamBeginRun(
0897 StreamEDModuleState<Step::preModuleTransition>(logFile, beginTime, iFilter));
0898 iRegistry.watchPostModuleStreamBeginRun(
0899 StreamEDModuleState<Step::postModuleTransition>(logFile, beginTime, iFilter));
0900 iRegistry.watchPreModuleStreamEndRun(StreamEDModuleState<Step::preModuleTransition>(logFile, beginTime, iFilter));
0901 iRegistry.watchPostModuleStreamEndRun(
0902 StreamEDModuleState<Step::postModuleTransition>(logFile, beginTime, iFilter));
0903
0904 iRegistry.watchPreModuleStreamBeginLumi(
0905 StreamEDModuleState<Step::preModuleTransition>(logFile, beginTime, iFilter));
0906 iRegistry.watchPostModuleStreamBeginLumi(
0907 StreamEDModuleState<Step::postModuleTransition>(logFile, beginTime, iFilter));
0908 iRegistry.watchPreModuleStreamEndLumi(
0909 StreamEDModuleState<Step::preModuleTransition>(logFile, beginTime, iFilter));
0910 iRegistry.watchPostModuleStreamEndLumi(
0911 StreamEDModuleState<Step::postModuleTransition>(logFile, beginTime, iFilter));
0912
0913 iRegistry.watchPreModuleBeginProcessBlock(
0914 GlobalEDModuleState<Step::preModuleTransition>(logFile, beginTime, iFilter));
0915 iRegistry.watchPostModuleBeginProcessBlock(
0916 GlobalEDModuleState<Step::postModuleTransition>(logFile, beginTime, iFilter));
0917 iRegistry.watchPreModuleAccessInputProcessBlock(
0918 GlobalEDModuleState<Step::preModuleTransition>(logFile, beginTime, iFilter));
0919 iRegistry.watchPostModuleAccessInputProcessBlock(
0920 GlobalEDModuleState<Step::postModuleTransition>(logFile, beginTime, iFilter));
0921 iRegistry.watchPreModuleEndProcessBlock(
0922 GlobalEDModuleState<Step::preModuleTransition>(logFile, beginTime, iFilter));
0923 iRegistry.watchPostModuleEndProcessBlock(
0924 GlobalEDModuleState<Step::postModuleTransition>(logFile, beginTime, iFilter));
0925
0926 iRegistry.watchPreModuleGlobalBeginRun(
0927 GlobalEDModuleState<Step::preModuleTransition>(logFile, beginTime, iFilter));
0928 iRegistry.watchPostModuleGlobalBeginRun(
0929 GlobalEDModuleState<Step::postModuleTransition>(logFile, beginTime, iFilter));
0930 iRegistry.watchPreModuleGlobalEndRun(GlobalEDModuleState<Step::preModuleTransition>(logFile, beginTime, iFilter));
0931 iRegistry.watchPostModuleGlobalEndRun(
0932 GlobalEDModuleState<Step::postModuleTransition>(logFile, beginTime, iFilter));
0933
0934 iRegistry.watchPreModuleGlobalBeginLumi(
0935 GlobalEDModuleState<Step::preModuleTransition>(logFile, beginTime, iFilter));
0936 iRegistry.watchPostModuleGlobalBeginLumi(
0937 GlobalEDModuleState<Step::postModuleTransition>(logFile, beginTime, iFilter));
0938 iRegistry.watchPreModuleGlobalEndLumi(
0939 GlobalEDModuleState<Step::preModuleTransition>(logFile, beginTime, iFilter));
0940 iRegistry.watchPostModuleGlobalEndLumi(
0941 GlobalEDModuleState<Step::postModuleTransition>(logFile, beginTime, iFilter));
0942
0943 iRegistry.watchPreModuleWriteProcessBlock(
0944 GlobalEDModuleState<Step::preModuleTransition>(logFile, beginTime, iFilter));
0945 iRegistry.watchPostModuleWriteProcessBlock(
0946 GlobalEDModuleState<Step::postModuleTransition>(logFile, beginTime, iFilter));
0947
0948 iRegistry.watchPreModuleWriteRun(GlobalEDModuleState<Step::preModuleTransition>(logFile, beginTime, iFilter));
0949 iRegistry.watchPostModuleWriteRun(GlobalEDModuleState<Step::postModuleTransition>(logFile, beginTime, iFilter));
0950
0951 iRegistry.watchPreModuleWriteLumi(GlobalEDModuleState<Step::preModuleTransition>(logFile, beginTime, iFilter));
0952 iRegistry.watchPostModuleWriteLumi(GlobalEDModuleState<Step::postModuleTransition>(logFile, beginTime, iFilter));
0953
0954
0955 iRegistry.watchPreESModule(ESModuleState<Step::preESModule>(logFile, beginTime, recordIndices, iFilter));
0956 iRegistry.watchPostESModule(ESModuleState<Step::postESModule>(logFile, beginTime, recordIndices, iFilter));
0957 iRegistry.watchPreESModuleAcquire(
0958 ESModuleState<Step::preESModuleAcquire>(logFile, beginTime, recordIndices, iFilter));
0959 iRegistry.watchPostESModuleAcquire(
0960 ESModuleState<Step::postESModuleAcquire>(logFile, beginTime, recordIndices, iFilter));
0961 }
0962
0963 std::ostringstream oss;
0964 oss << "# Transition Type Symbol\n";
0965 oss << "#------------------------ ------\n";
0966 oss << "# startTracing " << Phase::startTracing << "\n"
0967 << "# construction " << Phase::construction << "\n"
0968 << "# getNextTransition " << Phase::getNextTransition << "\n"
0969 << "# beginJob " << Phase::beginJob << "\n"
0970 << "# beginStream " << Phase::beginStream << "\n"
0971 << "# openFile " << Phase::openFile << "\n"
0972 << "# beginProcessBlock " << Phase::beginProcessBlock << "\n"
0973 << "# accessInputProcessBlock " << Phase::accessInputProcessBlock << "\n"
0974 << "# globalBeginRun " << Phase::globalBeginRun << "\n"
0975 << "# streamBeginRun " << Phase::streamBeginRun << "\n"
0976 << "# globalBeginLumi " << Phase::globalBeginLumi << "\n"
0977 << "# streamBeginLumi " << Phase::streamBeginLumi << "\n"
0978 << "# Event " << Phase::Event << "\n"
0979 << "# clearEvent " << Phase::clearEvent << "\n"
0980 << "# streamEndLumi " << Phase::streamEndLumi << "\n"
0981 << "# globalEndLumi " << Phase::globalEndLumi << "\n"
0982 << "# globalWriteLumi " << Phase::globalWriteLumi << "\n"
0983 << "# streamEndRun " << Phase::streamEndRun << "\n"
0984 << "# globalEndRun " << Phase::globalEndRun << "\n"
0985 << "# globalWriteRun " << Phase::globalWriteRun << "\n"
0986 << "# endProcessBlock " << Phase::endProcessBlock << "\n"
0987 << "# writeProcessBlock " << Phase::writeProcessBlock << "\n"
0988 << "# endStream " << Phase::endStream << "\n"
0989 << "# endJob " << Phase::endJob << "\n"
0990 << "# destruction " << Phase::destruction << "\n\n";
0991 constexpr std::string_view kTransition = " <Transition type> <Transition ID>";
0992 constexpr std::string_view kTransitionInfo = " <Run #> <LumiBlock #> <Event #>";
0993 constexpr std::string_view kTime = " <Time since begin of cmsRun (us)>";
0994 constexpr std::string_view kEDModule = " <EDModule ID> <Call ID>";
0995 constexpr std::string_view kESModule = " <ESModule ID> <Record ID> <Call ID>";
0996 constexpr std::string_view kAllocInfo =
0997 " <# allocs> <# deallocs> <additional bytes> <min bytes> <max bytes> <max allocation bytes>";
0998
0999 oss << "# Step Symbol Entries\n"
1000 << "# -------------------------- ------ ------------------------------------------\n"
1001 << "# preSourceTransition " << Step::preSourceTransition << kTransition << kTime << "\n"
1002 << "# postSourceTransition " << Step::postSourceTransition << kTransition << kTime << " " << kAllocInfo
1003 << "\n"
1004 << "# preModuleEventAcquire " << Step::preModuleEventAcquire << kTransition << kEDModule << kTime
1005 << "\n"
1006 << "# postModuleEventAcquire " << Step::postModuleEventAcquire << kTransition << kEDModule << kTime
1007 << kAllocInfo << "\n"
1008 << "# preModuleTransition " << Step::preModuleTransition << kTransition << kEDModule << kTime << "\n"
1009 << "# preEventReadFromSource " << Step::preEventReadFromSource << kTransition << kEDModule << kTime
1010 << "\n"
1011 << "# postEventReadFromSource " << Step::postEventReadFromSource << kTransition << kEDModule << kTime
1012 << kAllocInfo << "\n"
1013 << "# postModuleTransition " << Step::postModuleTransition << kTransition << kEDModule << kTime
1014 << kAllocInfo << "\n"
1015 << "# preESModuleTransition " << Step::preESModule << kTransition << kESModule << kTime << "\n"
1016 << "# postESModuleTransition " << Step::postESModule << kTransition << kESModule << kTime << kAllocInfo
1017 << "\n"
1018 << "# preFrameworkTransition " << Step::preFrameworkTransition << kTransition << kTransitionInfo << kTime
1019 << "\n"
1020 << "# preFrameworkTransition " << Step::preFrameworkTransition << " "
1021 << Phase::clearEvent << " <Transition ID>" << kTransitionInfo << kTime << kAllocInfo << "\n"
1022 << "# postFrameworkTransition " << Step::postFrameworkTransition << kTransition << kTransitionInfo
1023 << kTime << "\n";
1024 logFile->write(oss.str());
1025 return;
1026 }
1027 }
