File indexing completed on 2025-06-06 01:33:20
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
0016 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0017
0018 #include "MessageLogger.h"
0019 #include "MessageServicePSetValidation.h"
0020
0021 #include "FWCore/MessageLogger/interface/MessageLoggerQ.h"
0022 #include "FWCore/MessageLogger/interface/MessageDrop.h"
0023
0024 #include "DataFormats/Provenance/interface/ModuleDescription.h"
0025
0026 #include "FWCore/Framework/interface/ComponentDescription.h"
0027 #include "FWCore/MessageLogger/interface/JobReport.h"
0028 #include "FWCore/Utilities/interface/EDMException.h"
0029 #include "FWCore/ServiceRegistry/interface/Service.h"
0030 #include "FWCore/ServiceRegistry/interface/ActivityRegistry.h"
0031 #include "FWCore/ServiceRegistry/interface/SystemBounds.h"
0032 #include "FWCore/ServiceRegistry/interface/StreamContext.h"
0033 #include "FWCore/ServiceRegistry/interface/ModuleCallingContext.h"
0034 #include "FWCore/ServiceRegistry/interface/ESModuleCallingContext.h"
0035 #include "FWCore/ServiceRegistry/interface/GlobalContext.h"
0036 #include "FWCore/ServiceRegistry/interface/PathContext.h"
0037
0038 #include <sstream>
0039 #include <limits>
0040 #include <algorithm>
0041 #include <type_traits>
0042 #include <cstring>
0043 #include <charconv>
0044 #include <cassert>
0045
0046 using namespace edm;
0047 using namespace edm::service;
0048 using namespace edm::messagelogger;
0049
0050 namespace {
0051 constexpr std::array<char const*, 12> s_globalTransitionNames = {{"@beginJob",
0052 "@beginProcessBlock",
0053 "@accessInputProcessBlock",
0054 "@beginRun",
0055 "@beginLumi",
0056 "@endLumi",
0057 "@endRun",
0058 "@endProcessBlock",
0059 "@endJob",
0060 "@writeProcessBlock",
0061 "@writeRun",
0062 "@writeLumi"}};
0063
0064 constexpr std::array<char const*, 7> s_streamTransitionNames = {{"@beginStream",
0065 "@streamBeginRun",
0066 "@streamBeginLumi",
0067 "",
0068 "@streamEndLumi",
0069 "@streamEndRun",
0070 "@endStream"}};
0071
0072 char* fill_buffer(char* p, char*) { return p; }
0073
0074 template <typename T, typename... U>
0075 char* fill_buffer(char* first, char* last, T value, U... u) {
0076 if constexpr (std::is_arithmetic<T>::value) {
0077 auto v = std::to_chars(first, last, value);
0078 assert(v.ec == std::errc{});
0079 return fill_buffer(v.ptr, last, std::forward<U>(u)...);
0080 } else {
0081 auto l = strlen(value);
0082 assert(first + l < last);
0083 std::copy(value, value + l, first);
0084 return fill_buffer(first + l, last, std::forward<U>(u)...);
0085 }
0086 }
0087
0088 template <typename... T>
0089 std::string_view fill_buffer(std::array<char, 64>& buffer, T... t) {
0090 auto e = fill_buffer(buffer.begin(), buffer.end(), std::forward<T>(t)...);
0091 assert(e < buffer.end());
0092 *e = 0;
0093 return std::string_view(buffer.begin(), e - buffer.begin());
0094 }
0095
0096 }
0097
0098 namespace edm {
0099
0100
0101
0102
0103 void clearLoggedErrorsSummary(unsigned int);
0104 void setMaxLoggedErrorsSummaryIndicies(unsigned int iMax);
0105
0106 namespace service {
0107
0108 bool edm::service::MessageLogger::anyDebugEnabled_ = false;
0109 bool edm::service::MessageLogger::everyDebugEnabled_ = false;
0110 bool edm::service::MessageLogger::fjrSummaryRequested_ = false;
0111
0112
0113
0114
0115 edm::service::MessageLogger::MessageLogger(ParameterSet const& iPS, ActivityRegistry& iRegistry)
0116 : debugEnabled_(false),
0117 messageServicePSetHasBeenValidated_(false),
0118 messageServicePSetValidatationResults_(),
0119 nonModule_debugEnabled(false),
0120 nonModule_infoEnabled(true),
0121 nonModule_warningEnabled(true),
0122 nonModule_errorEnabled(true)
0123 {
0124
0125 MessageServicePSetValidation validator;
0126 messageServicePSetValidatationResults_ = validator(iPS);
0127
0128 typedef std::vector<std::string> vString;
0129 vString empty_vString;
0130 vString debugModules;
0131 vString suppressDebug;
0132 vString suppressInfo;
0133 vString suppressFwkInfo;
0134 vString suppressWarning;
0135 vString suppressError;
0136
0137 try {
0138
0139 fjrSummaryRequested_ = iPS.getUntrackedParameter<bool>("messageSummaryToJobReport", false);
0140
0141
0142 debugModules = iPS.getUntrackedParameter<vString>("debugModules", empty_vString);
0143
0144
0145 suppressDebug = iPS.getUntrackedParameter<vString>("suppressDebug", empty_vString);
0146
0147 suppressInfo = iPS.getUntrackedParameter<vString>("suppressInfo", empty_vString);
0148
0149 suppressFwkInfo = iPS.getUntrackedParameter<vString>("suppressFwkInfo", empty_vString);
0150
0151 suppressWarning = iPS.getUntrackedParameter<vString>("suppressWarning", empty_vString);
0152
0153 suppressError =
0154 iPS.getUntrackedParameter<vString>("suppressError", empty_vString);
0155 } catch (cms::Exception& e) {
0156 }
0157
0158
0159
0160
0161 for (vString::const_iterator it = suppressDebug.begin(); it != suppressDebug.end(); ++it) {
0162 suppression_levels_[*it] = ELseverityLevel::ELsev_success;
0163 }
0164
0165 for (vString::const_iterator it = suppressInfo.begin(); it != suppressInfo.end(); ++it) {
0166 suppression_levels_[*it] = ELseverityLevel::ELsev_info;
0167 }
0168
0169 for (vString::const_iterator it = suppressFwkInfo.begin(); it != suppressFwkInfo.end(); ++it) {
0170 suppression_levels_[*it] = ELseverityLevel::ELsev_fwkInfo;
0171 }
0172
0173 for (vString::const_iterator it = suppressWarning.begin(); it != suppressWarning.end(); ++it) {
0174 suppression_levels_[*it] = ELseverityLevel::ELsev_warning;
0175 }
0176
0177 for (vString::const_iterator it = suppressError.begin();
0178 it != suppressError.end();
0179 ++it) {
0180 suppression_levels_[*it] = ELseverityLevel::ELsev_error;
0181 }
0182
0183
0184
0185 if (debugModules.empty()) {
0186 anyDebugEnabled_ = true;
0187 everyDebugEnabled_ = true;
0188 MessageDrop::instance()->debugEnabled = true;
0189 } else {
0190 anyDebugEnabled_ = true;
0191 MessageDrop::instance()->debugEnabled = false;
0192
0193 }
0194
0195 for (vString::const_iterator it = debugModules.begin(); it != debugModules.end(); ++it) {
0196 if (*it == "*") {
0197 everyDebugEnabled_ = true;
0198 MessageDrop::instance()->debugEnabled = true;
0199 } else {
0200 debugEnabledModules_.insert(*it);
0201 }
0202 }
0203
0204
0205 std::string jm = edm::MessageDrop::jobMode;
0206 std::string* jm_p = new std::string(jm);
0207 MessageLoggerQ::MLqMOD(jm_p);
0208
0209 MessageLoggerQ::MLqCFG(new ParameterSet(iPS));
0210
0211 iRegistry.watchPreallocate([this](edm::service::SystemBounds const& iBounds) {
0212
0213 constexpr unsigned int maxNumberOfConcurrentProcessBlocks = 1;
0214 this->transitionInfoCache_.resize(iBounds.maxNumberOfStreams() +
0215 iBounds.maxNumberOfConcurrentLuminosityBlocks() +
0216 iBounds.maxNumberOfConcurrentRuns() + maxNumberOfConcurrentProcessBlocks);
0217 lumiInfoBegin_ = iBounds.maxNumberOfStreams();
0218 runInfoBegin_ = lumiInfoBegin_ + iBounds.maxNumberOfConcurrentLuminosityBlocks();
0219 processBlockInfoBegin_ = runInfoBegin_ + iBounds.maxNumberOfConcurrentRuns();
0220
0221 setMaxLoggedErrorsSummaryIndicies(iBounds.maxNumberOfStreams());
0222 });
0223
0224 iRegistry.watchPostBeginJob(this, &MessageLogger::postBeginJob);
0225 iRegistry.watchPreEndJob(this, &MessageLogger::preEndJob);
0226 iRegistry.watchPostEndJob(this, &MessageLogger::postEndJob);
0227 iRegistry.watchJobFailure(this, &MessageLogger::jobFailure);
0228
0229 iRegistry.watchPreModuleConstruction(this, &MessageLogger::preModuleConstruction);
0230 iRegistry.watchPostModuleConstruction(this, &MessageLogger::postModuleConstruction);
0231
0232
0233 iRegistry.watchPreSourceConstruction(this, &MessageLogger::preSourceConstruction);
0234 iRegistry.watchPostSourceConstruction(this, &MessageLogger::postSourceConstruction);
0235
0236
0237 iRegistry.watchPreModuleDestruction(this, &MessageLogger::preModuleDestruction);
0238 iRegistry.watchPostModuleDestruction(this, &MessageLogger::postModuleDestruction);
0239
0240 iRegistry.watchPreModuleEvent(this, &MessageLogger::preModuleEvent);
0241 iRegistry.watchPostModuleEvent(this, &MessageLogger::postModuleEvent);
0242
0243 iRegistry.watchPreModuleEventAcquire(this, &MessageLogger::preModuleEventAcquire);
0244 iRegistry.watchPostModuleEventAcquire(this, &MessageLogger::postModuleEventAcquire);
0245
0246 iRegistry.watchPreSourceEvent(this, &MessageLogger::preSourceEvent);
0247 iRegistry.watchPostSourceEvent(this, &MessageLogger::postSourceEvent);
0248
0249 iRegistry.watchPreSourceRun([this](RunIndex) { preSourceRunLumi(); });
0250 iRegistry.watchPostSourceRun([this](RunIndex) { postSourceRunLumi(); });
0251 iRegistry.watchPreSourceLumi([this](LuminosityBlockIndex) { preSourceRunLumi(); });
0252 iRegistry.watchPostSourceLumi([this](LuminosityBlockIndex) { postSourceRunLumi(); });
0253 iRegistry.watchPreOpenFile(this, &MessageLogger::preFile);
0254 iRegistry.watchPostOpenFile(this, &MessageLogger::postFile);
0255 iRegistry.watchPreCloseFile(this, &MessageLogger::preFileClose);
0256 iRegistry.watchPostCloseFile(this, &MessageLogger::postFile);
0257
0258
0259
0260 iRegistry.watchPreModuleBeginJob(this, &MessageLogger::preModuleBeginJob);
0261 iRegistry.watchPostModuleBeginJob(this, &MessageLogger::postModuleBeginJob);
0262 iRegistry.watchPreModuleEndJob(this, &MessageLogger::preModuleEndJob);
0263 iRegistry.watchPostModuleEndJob(this, &MessageLogger::postModuleEndJob);
0264
0265 iRegistry.watchPreModuleBeginStream(this, &MessageLogger::preModuleBeginStream);
0266 iRegistry.watchPostModuleBeginStream(this, &MessageLogger::postModuleBeginStream);
0267 iRegistry.watchPreModuleEndStream(this, &MessageLogger::preModuleEndStream);
0268 iRegistry.watchPostModuleEndStream(this, &MessageLogger::postModuleEndStream);
0269
0270 iRegistry.watchPreModuleStreamBeginRun(this, &MessageLogger::preModuleStreamBeginRun);
0271 iRegistry.watchPostModuleStreamBeginRun(this, &MessageLogger::postModuleStreamBeginRun);
0272 iRegistry.watchPreModuleStreamEndRun(this, &MessageLogger::preModuleStreamEndRun);
0273 iRegistry.watchPostModuleStreamEndRun(this, &MessageLogger::postModuleStreamEndRun);
0274 iRegistry.watchPreModuleStreamBeginLumi(this, &MessageLogger::preModuleStreamBeginLumi);
0275 iRegistry.watchPostModuleStreamBeginLumi(this, &MessageLogger::postModuleStreamBeginLumi);
0276 iRegistry.watchPreModuleStreamEndLumi(this, &MessageLogger::preModuleStreamEndLumi);
0277 iRegistry.watchPostModuleStreamEndLumi(this, &MessageLogger::postModuleStreamEndLumi);
0278
0279 iRegistry.watchPreModuleBeginProcessBlock(this, &MessageLogger::preModuleBeginProcessBlock);
0280 iRegistry.watchPostModuleBeginProcessBlock(this, &MessageLogger::postModuleBeginProcessBlock);
0281 iRegistry.watchPreModuleAccessInputProcessBlock(this, &MessageLogger::preModuleAccessInputProcessBlock);
0282 iRegistry.watchPostModuleAccessInputProcessBlock(this, &MessageLogger::postModuleAccessInputProcessBlock);
0283 iRegistry.watchPreModuleEndProcessBlock(this, &MessageLogger::preModuleEndProcessBlock);
0284 iRegistry.watchPostModuleEndProcessBlock(this, &MessageLogger::postModuleEndProcessBlock);
0285
0286 iRegistry.watchPreModuleGlobalBeginRun(this, &MessageLogger::preModuleGlobalBeginRun);
0287 iRegistry.watchPostModuleGlobalBeginRun(this, &MessageLogger::postModuleGlobalBeginRun);
0288 iRegistry.watchPreModuleGlobalEndRun(this, &MessageLogger::preModuleGlobalEndRun);
0289 iRegistry.watchPostModuleGlobalEndRun(this, &MessageLogger::postModuleGlobalEndRun);
0290 iRegistry.watchPreModuleWriteRun(this, &MessageLogger::preModuleWriteRun);
0291 iRegistry.watchPostModuleWriteRun(this, &MessageLogger::postModuleWriteRun);
0292 iRegistry.watchPreModuleGlobalBeginLumi(this, &MessageLogger::preModuleGlobalBeginLumi);
0293 iRegistry.watchPostModuleGlobalBeginLumi(this, &MessageLogger::postModuleGlobalBeginLumi);
0294 iRegistry.watchPreModuleGlobalEndLumi(this, &MessageLogger::preModuleGlobalEndLumi);
0295 iRegistry.watchPostModuleGlobalEndLumi(this, &MessageLogger::postModuleGlobalEndLumi);
0296 iRegistry.watchPreModuleWriteLumi(this, &MessageLogger::preModuleWriteLumi);
0297 iRegistry.watchPostModuleWriteLumi(this, &MessageLogger::postModuleWriteLumi);
0298
0299 iRegistry.watchPreEvent(this, &MessageLogger::preEvent);
0300 iRegistry.watchPostEvent(this, &MessageLogger::postEvent);
0301
0302 iRegistry.watchPreStreamBeginRun(this, &MessageLogger::preStreamBeginRun);
0303 iRegistry.watchPostStreamBeginRun(this, &MessageLogger::postStreamBeginRun);
0304 iRegistry.watchPreStreamEndRun(this, &MessageLogger::preStreamEndRun);
0305 iRegistry.watchPostStreamEndRun(this, &MessageLogger::postStreamEndRun);
0306 iRegistry.watchPreStreamBeginLumi(this, &MessageLogger::preStreamBeginLumi);
0307 iRegistry.watchPostStreamBeginLumi(this, &MessageLogger::postStreamBeginLumi);
0308 iRegistry.watchPreStreamEndLumi(this, &MessageLogger::preStreamEndLumi);
0309 iRegistry.watchPostStreamEndLumi(this, &MessageLogger::postStreamEndLumi);
0310
0311 iRegistry.watchPreBeginProcessBlock(this, &MessageLogger::preBeginProcessBlock);
0312 iRegistry.watchPostBeginProcessBlock(this, &MessageLogger::postBeginProcessBlock);
0313 iRegistry.watchPreAccessInputProcessBlock(this, &MessageLogger::preAccessInputProcessBlock);
0314 iRegistry.watchPostAccessInputProcessBlock(this, &MessageLogger::postAccessInputProcessBlock);
0315 iRegistry.watchPreEndProcessBlock(this, &MessageLogger::preEndProcessBlock);
0316 iRegistry.watchPostEndProcessBlock(this, &MessageLogger::postEndProcessBlock);
0317
0318 iRegistry.watchPreGlobalBeginRun(this, &MessageLogger::preGlobalBeginRun);
0319 iRegistry.watchPostGlobalBeginRun(this, &MessageLogger::postGlobalBeginRun);
0320 iRegistry.watchPreGlobalEndRun(this, &MessageLogger::preGlobalEndRun);
0321 iRegistry.watchPostGlobalEndRun(this, &MessageLogger::postGlobalEndRun);
0322 iRegistry.watchPreGlobalBeginLumi(this, &MessageLogger::preGlobalBeginLumi);
0323 iRegistry.watchPostGlobalBeginLumi(this, &MessageLogger::postGlobalBeginLumi);
0324 iRegistry.watchPreGlobalEndLumi(this, &MessageLogger::preGlobalEndLumi);
0325 iRegistry.watchPostGlobalEndLumi(this, &MessageLogger::postGlobalEndLumi);
0326
0327 iRegistry.watchPrePathEvent(this, &MessageLogger::prePathEvent);
0328 iRegistry.watchPostPathEvent(this, &MessageLogger::postPathEvent);
0329
0330 iRegistry.watchPreESModule(this, &MessageLogger::preESModule);
0331 iRegistry.watchPostESModule(this, &MessageLogger::postESModule);
0332
0333 MessageDrop* messageDrop = MessageDrop::instance();
0334 nonModule_debugEnabled = messageDrop->debugEnabled;
0335 nonModule_infoEnabled = messageDrop->infoEnabled;
0336 nonModule_warningEnabled = messageDrop->warningEnabled;
0337 nonModule_errorEnabled = messageDrop->errorEnabled;
0338 }
0339
0340 void MessageLogger::setThreadContext(ModuleCallingContext const& iModContext) {
0341
0342 auto top = iModContext.getTopModuleCallingContext();
0343 assert(nullptr != top);
0344 if (ParentContext::Type::kGlobal == top->type()) {
0345 auto globalContext = iModContext.getGlobalContext();
0346 auto tran = globalContext->transition();
0347 if (tran == GlobalContext::Transition::kBeginLuminosityBlock or
0348 tran == GlobalContext::Transition::kEndLuminosityBlock) {
0349 establishModule(lumiInfoBegin_ + globalContext->luminosityBlockIndex(),
0350 iModContext,
0351 s_globalTransitionNames[static_cast<int>(tran)]);
0352 } else if (tran == GlobalContext::Transition::kBeginRun or tran == GlobalContext::Transition::kEndRun) {
0353 establishModule(
0354 runInfoBegin_ + globalContext->runIndex(), iModContext, s_globalTransitionNames[static_cast<int>(tran)]);
0355 } else if (tran == GlobalContext::Transition::kBeginProcessBlock ||
0356 tran == GlobalContext::Transition::kAccessInputProcessBlock ||
0357 tran == GlobalContext::Transition::kEndProcessBlock) {
0358 establishModule(processBlockInfoBegin_, iModContext, s_globalTransitionNames[static_cast<int>(tran)]);
0359 } else {
0360 MessageDrop* messageDrop = MessageDrop::instance();
0361 messageDrop->streamID = std::numeric_limits<unsigned int>::max();
0362 messageDrop->setSinglet("unknown context");
0363 MessageDrop::instance()->runEvent = "";
0364 messageDrop->debugEnabled = nonModule_debugEnabled;
0365 messageDrop->infoEnabled = nonModule_infoEnabled;
0366 messageDrop->warningEnabled = nonModule_warningEnabled;
0367 messageDrop->errorEnabled = nonModule_errorEnabled;
0368 }
0369 } else {
0370 auto stream = iModContext.getStreamContext();
0371 establishModule(
0372 stream->streamID().value(), iModContext, s_streamTransitionNames[static_cast<int>(stream->transition())]);
0373 }
0374 }
0375
0376
0377
0378
0379
0380 void MessageLogger::establishModule(ModuleDescription const& desc,
0381 const char* whichPhase)
0382 {
0383 MessageDrop* messageDrop = MessageDrop::instance();
0384
0385
0386
0387 messageDrop->setModuleWithPhase(desc.moduleName(), desc.moduleLabel(), desc.id(), whichPhase);
0388
0389
0390
0391 if (!anyDebugEnabled_) {
0392 messageDrop->debugEnabled = false;
0393 } else if (everyDebugEnabled_) {
0394 messageDrop->debugEnabled = true;
0395 } else {
0396 messageDrop->debugEnabled = debugEnabledModules_.count(desc.moduleLabel());
0397 }
0398
0399 auto it = suppression_levels_.find(desc.moduleLabel());
0400 if (it != suppression_levels_.end()) {
0401 messageDrop->debugEnabled = messageDrop->debugEnabled && (it->second < ELseverityLevel::ELsev_success);
0402 messageDrop->infoEnabled = (it->second < ELseverityLevel::ELsev_info);
0403 messageDrop->fwkInfoEnabled = (it->second < ELseverityLevel::ELsev_fwkInfo);
0404 messageDrop->warningEnabled = (it->second < ELseverityLevel::ELsev_warning);
0405 messageDrop->errorEnabled = (it->second < ELseverityLevel::ELsev_error);
0406 } else {
0407 messageDrop->infoEnabled = true;
0408 messageDrop->fwkInfoEnabled = true;
0409 messageDrop->warningEnabled = true;
0410 messageDrop->errorEnabled = true;
0411 }
0412 }
0413
0414 void MessageLogger::establishModule(unsigned int transitionIndex,
0415 ModuleCallingContext const& mod,
0416 const char* whichPhase)
0417 {
0418 MessageDrop* messageDrop = MessageDrop::instance();
0419
0420
0421
0422 auto const desc = mod.moduleDescription();
0423 messageDrop->runEvent = transitionInfoCache_[transitionIndex].begin();
0424 messageDrop->setModuleWithPhase(desc->moduleName(), desc->moduleLabel(), desc->id(), whichPhase);
0425 messageDrop->streamID = transitionIndex;
0426 if (transitionIndex >= lumiInfoBegin_) {
0427 messageDrop->streamID = std::numeric_limits<unsigned int>::max();
0428 }
0429
0430
0431
0432 if (!anyDebugEnabled_) {
0433 messageDrop->debugEnabled = false;
0434 } else if (everyDebugEnabled_) {
0435 messageDrop->debugEnabled = true;
0436 } else {
0437 messageDrop->debugEnabled = debugEnabledModules_.count(desc->moduleLabel());
0438 }
0439
0440 auto it = suppression_levels_.find(desc->moduleLabel());
0441 if (it != suppression_levels_.end()) {
0442 messageDrop->debugEnabled = messageDrop->debugEnabled && (it->second < ELseverityLevel::ELsev_success);
0443 messageDrop->infoEnabled = (it->second < ELseverityLevel::ELsev_info);
0444 messageDrop->fwkInfoEnabled = (it->second < ELseverityLevel::ELsev_fwkInfo);
0445 messageDrop->warningEnabled = (it->second < ELseverityLevel::ELsev_warning);
0446 messageDrop->errorEnabled = (it->second < ELseverityLevel::ELsev_error);
0447 } else {
0448 messageDrop->infoEnabled = true;
0449 messageDrop->fwkInfoEnabled = true;
0450 messageDrop->warningEnabled = true;
0451 messageDrop->errorEnabled = true;
0452 }
0453 }
0454
0455 void MessageLogger::unEstablishModule(ModuleDescription const& , const char* state) {
0456
0457
0458
0459 MessageDrop* messageDrop = MessageDrop::instance();
0460 messageDrop->setSinglet(state);
0461 messageDrop->debugEnabled = nonModule_debugEnabled;
0462 messageDrop->infoEnabled = nonModule_infoEnabled;
0463 messageDrop->warningEnabled = nonModule_warningEnabled;
0464 messageDrop->errorEnabled = nonModule_errorEnabled;
0465 }
0466
0467 void MessageLogger::unEstablishModule(ModuleCallingContext const& mod, const char* state) {
0468
0469 auto previous = mod.previousModuleOnThread();
0470 if (previous) {
0471
0472 auto top = previous->getTopModuleCallingContext();
0473 assert(nullptr != top);
0474 if (ParentContext::Type::kGlobal == top->type()) {
0475 auto globalContext = top->globalContext();
0476 assert(nullptr != globalContext);
0477 auto tran = globalContext->transition();
0478 if (tran == GlobalContext::Transition::kBeginLuminosityBlock or
0479 tran == GlobalContext::Transition::kEndLuminosityBlock) {
0480 establishModule(lumiInfoBegin_ + globalContext->luminosityBlockIndex(),
0481 *previous,
0482 s_globalTransitionNames[static_cast<int>(tran)]);
0483 } else if (tran == GlobalContext::Transition::kBeginRun or tran == GlobalContext::Transition::kEndRun) {
0484 establishModule(
0485 runInfoBegin_ + globalContext->runIndex(), *previous, s_globalTransitionNames[static_cast<int>(tran)]);
0486 } else if (tran == GlobalContext::Transition::kBeginProcessBlock ||
0487 tran == GlobalContext::Transition::kAccessInputProcessBlock ||
0488 tran == GlobalContext::Transition::kEndProcessBlock) {
0489 establishModule(processBlockInfoBegin_, *previous, s_globalTransitionNames[static_cast<int>(tran)]);
0490 } else {
0491 MessageDrop* messageDrop = MessageDrop::instance();
0492 messageDrop->streamID = std::numeric_limits<unsigned int>::max();
0493 messageDrop->setSinglet("unknown context");
0494 MessageDrop::instance()->runEvent = "";
0495 messageDrop->debugEnabled = nonModule_debugEnabled;
0496 messageDrop->infoEnabled = nonModule_infoEnabled;
0497 messageDrop->warningEnabled = nonModule_warningEnabled;
0498 messageDrop->errorEnabled = nonModule_errorEnabled;
0499 }
0500 } else {
0501 auto stream = previous->getStreamContext();
0502 establishModule(
0503 stream->streamID().value(), *previous, s_streamTransitionNames[static_cast<int>(stream->transition())]);
0504 }
0505 } else {
0506 MessageDrop* messageDrop = MessageDrop::instance();
0507 messageDrop->streamID = std::numeric_limits<unsigned int>::max();
0508 messageDrop->setSinglet(state);
0509 messageDrop->debugEnabled = nonModule_debugEnabled;
0510 messageDrop->infoEnabled = nonModule_infoEnabled;
0511 messageDrop->warningEnabled = nonModule_warningEnabled;
0512 messageDrop->errorEnabled = nonModule_errorEnabled;
0513 }
0514
0515
0516
0517 }
0518
0519 void MessageLogger::establish(const char* state) {
0520 MessageDrop* messageDrop = MessageDrop::instance();
0521 messageDrop->setSinglet(state);
0522 if (!anyDebugEnabled_) {
0523 messageDrop->debugEnabled = false;
0524 } else if (everyDebugEnabled_) {
0525 messageDrop->debugEnabled = true;
0526 } else {
0527 messageDrop->debugEnabled = debugEnabledModules_.count(state);
0528 }
0529 std::map<const std::string, ELseverityLevel>::const_iterator it =
0530 suppression_levels_.find(state);
0531 if (it != suppression_levels_.end()) {
0532 messageDrop->debugEnabled = messageDrop->debugEnabled && (it->second < ELseverityLevel::ELsev_success);
0533 messageDrop->infoEnabled = (it->second < ELseverityLevel::ELsev_info);
0534 messageDrop->fwkInfoEnabled = (it->second < ELseverityLevel::ELsev_fwkInfo);
0535 messageDrop->warningEnabled = (it->second < ELseverityLevel::ELsev_warning);
0536 messageDrop->errorEnabled = (it->second < ELseverityLevel::ELsev_error);
0537 } else {
0538 messageDrop->infoEnabled = true;
0539 messageDrop->fwkInfoEnabled = true;
0540 messageDrop->warningEnabled = true;
0541 messageDrop->errorEnabled = true;
0542 }
0543 }
0544
0545 void MessageLogger::unEstablish(const char* state) {
0546 MessageDrop::instance()->setSinglet(state);
0547 }
0548
0549
0550
0551
0552
0553 void MessageLogger::preModuleConstruction(const ModuleDescription& desc) {
0554 if (!messageServicePSetHasBeenValidated_) {
0555 if (!messageServicePSetValidatationResults_.empty()) {
0556 throw(edm::Exception(edm::errors::Configuration, messageServicePSetValidatationResults_));
0557 }
0558 messageServicePSetHasBeenValidated_ = true;
0559 }
0560 establishModule(desc, "@ctor");
0561 }
0562
0563 void MessageLogger::postModuleConstruction(const ModuleDescription& iDescription) {
0564 unEstablishModule(iDescription, "AfterModConstruction");
0565 }
0566
0567 void MessageLogger::preModuleDestruction(const ModuleDescription& desc) { establishModule(desc, "@dtor"); }
0568
0569 void MessageLogger::postModuleDestruction(const ModuleDescription& iDescription) {
0570 unEstablishModule(iDescription, "AfterModDestruction");
0571 }
0572
0573 void MessageLogger::preModuleBeginJob(const ModuleDescription& desc) {
0574 establishModule(desc, "@beginJob");
0575 }
0576 void MessageLogger::postModuleBeginJob(const ModuleDescription& iDescription) {
0577 unEstablishModule(iDescription, "AfterModBeginJob");
0578 }
0579
0580 void MessageLogger::preSourceConstruction(const ModuleDescription& desc) {
0581 if (!messageServicePSetHasBeenValidated_) {
0582 if (!messageServicePSetValidatationResults_.empty()) {
0583 throw(edm::Exception(edm::errors::Configuration, messageServicePSetValidatationResults_));
0584 }
0585 messageServicePSetHasBeenValidated_ = true;
0586 }
0587 establishModule(desc, "@sourceConstruction");
0588 }
0589 void MessageLogger::postSourceConstruction(const ModuleDescription& iDescription) {
0590 unEstablishModule(iDescription, "AfterSourceConstruction");
0591 }
0592
0593 void MessageLogger::preModuleBeginStream(StreamContext const& stream, ModuleCallingContext const& mcc) {
0594 ModuleDescription const& desc = *mcc.moduleDescription();
0595 establishModule(desc, "@beginStream");
0596 }
0597 void MessageLogger::postModuleBeginStream(StreamContext const& stream, ModuleCallingContext const& mcc) {
0598 ModuleDescription const& desc = *mcc.moduleDescription();
0599 unEstablishModule(desc, "AfterModBeginStream");
0600 }
0601
0602 void MessageLogger::preModuleStreamBeginRun(StreamContext const& stream, ModuleCallingContext const& mod) {
0603 establishModule(stream.streamID().value(),
0604 mod,
0605 s_streamTransitionNames[static_cast<int>(StreamContext::Transition::kBeginRun)]);
0606 }
0607 void MessageLogger::postModuleStreamBeginRun(StreamContext const& stream, ModuleCallingContext const& mod) {
0608 unEstablishModule(mod, "AfterModStreamBeginRun");
0609 }
0610
0611 void MessageLogger::preModuleStreamBeginLumi(StreamContext const& stream, ModuleCallingContext const& mod) {
0612 establishModule(stream.streamID().value(),
0613 mod,
0614 s_streamTransitionNames[static_cast<int>(StreamContext::Transition::kBeginLuminosityBlock)]);
0615 }
0616 void MessageLogger::postModuleStreamBeginLumi(StreamContext const& stream, ModuleCallingContext const& mod) {
0617 unEstablishModule(mod, "AfterModStreamBeginLumi");
0618 }
0619
0620 void MessageLogger::preModuleEvent(StreamContext const& stream, ModuleCallingContext const& mod) {
0621 establishModule(
0622 stream.streamID().value(), mod, s_streamTransitionNames[static_cast<int>(StreamContext::Transition::kEvent)]);
0623 }
0624
0625 void MessageLogger::postModuleEvent(StreamContext const& stream, ModuleCallingContext const& mod) {
0626 unEstablishModule(mod, "PostModuleEvent");
0627 }
0628
0629 void MessageLogger::preModuleEventAcquire(StreamContext const& stream, ModuleCallingContext const& mod) {
0630 establishModule(
0631 stream.streamID().value(), mod, s_streamTransitionNames[static_cast<int>(StreamContext::Transition::kEvent)]);
0632 }
0633
0634 void MessageLogger::postModuleEventAcquire(StreamContext const& stream, ModuleCallingContext const& mod) {
0635 unEstablishModule(mod, "PostModuleEventAcquire");
0636 }
0637
0638 void MessageLogger::preModuleStreamEndLumi(StreamContext const& stream, ModuleCallingContext const& mod) {
0639 establishModule(stream.streamID().value(),
0640 mod,
0641 s_streamTransitionNames[static_cast<int>(StreamContext::Transition::kEndLuminosityBlock)]);
0642 }
0643 void MessageLogger::postModuleStreamEndLumi(StreamContext const& stream, ModuleCallingContext const& mod) {
0644 unEstablishModule(mod, "AfterModStreamEndLumi");
0645 }
0646
0647 void MessageLogger::preModuleStreamEndRun(StreamContext const& stream, ModuleCallingContext const& mod) {
0648 establishModule(stream.streamID().value(),
0649 mod,
0650 s_streamTransitionNames[static_cast<int>(StreamContext::Transition::kEndRun)]);
0651 }
0652 void MessageLogger::postModuleStreamEndRun(StreamContext const& stream, ModuleCallingContext const& mod) {
0653 unEstablishModule(mod, "AfterModStreamEndRun");
0654 }
0655
0656
0657
0658 void MessageLogger::preModuleBeginProcessBlock(GlobalContext const&, ModuleCallingContext const& mod) {
0659 establishModule(processBlockInfoBegin_,
0660 mod,
0661 s_globalTransitionNames[static_cast<int>(GlobalContext::Transition::kBeginProcessBlock)]);
0662 }
0663
0664 void MessageLogger::postModuleBeginProcessBlock(GlobalContext const&, ModuleCallingContext const& mod) {
0665 unEstablishModule(mod, "AfterModBeginProcessBlock");
0666 }
0667
0668 void MessageLogger::preModuleAccessInputProcessBlock(GlobalContext const&, ModuleCallingContext const& mod) {
0669 establishModule(processBlockInfoBegin_,
0670 mod,
0671 s_globalTransitionNames[static_cast<int>(GlobalContext::Transition::kAccessInputProcessBlock)]);
0672 }
0673
0674 void MessageLogger::postModuleAccessInputProcessBlock(GlobalContext const&, ModuleCallingContext const& mod) {
0675 unEstablishModule(mod, "AfterModAccessInputProcessBlock");
0676 }
0677
0678 void MessageLogger::preModuleEndProcessBlock(GlobalContext const&, ModuleCallingContext const& mod) {
0679 establishModule(processBlockInfoBegin_,
0680 mod,
0681 s_globalTransitionNames[static_cast<int>(GlobalContext::Transition::kEndProcessBlock)]);
0682 }
0683
0684 void MessageLogger::postModuleEndProcessBlock(GlobalContext const&, ModuleCallingContext const& mod) {
0685 unEstablishModule(mod, "AfterModEndProcessBlock");
0686 }
0687
0688 void MessageLogger::preModuleGlobalBeginRun(GlobalContext const& context, ModuleCallingContext const& mod) {
0689 establishModule(runInfoBegin_ + context.runIndex().value(),
0690 mod,
0691 s_globalTransitionNames[static_cast<int>(GlobalContext::Transition::kBeginRun)]);
0692 }
0693 void MessageLogger::postModuleGlobalBeginRun(GlobalContext const& context, ModuleCallingContext const& mod) {
0694 unEstablishModule(mod, "AfterModGlobalBeginRun");
0695 }
0696
0697 void MessageLogger::preModuleGlobalBeginLumi(GlobalContext const& context, ModuleCallingContext const& mod) {
0698 establishModule(lumiInfoBegin_ + context.luminosityBlockIndex().value(),
0699 mod,
0700 s_globalTransitionNames[static_cast<int>(GlobalContext::Transition::kBeginLuminosityBlock)]);
0701 }
0702 void MessageLogger::postModuleGlobalBeginLumi(GlobalContext const& stream, ModuleCallingContext const& mod) {
0703 unEstablishModule(mod, "AfterModGlobalBeginLumi");
0704 }
0705
0706 void MessageLogger::preModuleGlobalEndLumi(GlobalContext const& context, ModuleCallingContext const& mod) {
0707 establishModule(lumiInfoBegin_ + context.luminosityBlockIndex().value(),
0708 mod,
0709 s_globalTransitionNames[static_cast<int>(GlobalContext::Transition::kEndLuminosityBlock)]);
0710 }
0711 void MessageLogger::postModuleGlobalEndLumi(GlobalContext const& stream, ModuleCallingContext const& mod) {
0712 unEstablishModule(mod, "AfterModGlobalEndLumi");
0713 }
0714
0715 void MessageLogger::preModuleWriteLumi(GlobalContext const& context, ModuleCallingContext const& mod) {
0716 establishModule(lumiInfoBegin_ + context.luminosityBlockIndex().value(),
0717 mod,
0718 s_globalTransitionNames[static_cast<int>(GlobalContext::Transition::kWriteLuminosityBlock)]);
0719 }
0720 void MessageLogger::postModuleWriteLumi(GlobalContext const& stream, ModuleCallingContext const& mod) {
0721 unEstablishModule(mod, "AfterModWriteLumi");
0722 }
0723
0724 void MessageLogger::preModuleGlobalEndRun(GlobalContext const& context, ModuleCallingContext const& mod) {
0725 establishModule(runInfoBegin_ + context.runIndex().value(),
0726 mod,
0727 s_globalTransitionNames[static_cast<int>(GlobalContext::Transition::kEndRun)]);
0728 }
0729 void MessageLogger::postModuleGlobalEndRun(GlobalContext const& stream, ModuleCallingContext const& mod) {
0730 unEstablishModule(mod, "AfterModGlobalEndRun");
0731 }
0732
0733 void MessageLogger::preModuleWriteRun(GlobalContext const& context, ModuleCallingContext const& mod) {
0734 establishModule(runInfoBegin_ + context.runIndex().value(),
0735 mod,
0736 s_globalTransitionNames[static_cast<int>(GlobalContext::Transition::kWriteRun)]);
0737 }
0738 void MessageLogger::postModuleWriteRun(GlobalContext const& stream, ModuleCallingContext const& mod) {
0739 unEstablishModule(mod, "AfterModWriteRun");
0740 }
0741
0742 void MessageLogger::preModuleEndStream(StreamContext const&, ModuleCallingContext const& mcc) {
0743 ModuleDescription const& desc = *mcc.moduleDescription();
0744 establishModule(desc, "@endStream");
0745 }
0746
0747 void MessageLogger::postModuleEndStream(StreamContext const&, ModuleCallingContext const& mcc) {
0748 ModuleDescription const& desc = *mcc.moduleDescription();
0749 unEstablishModule(desc, "AfterModEndStream");
0750 }
0751
0752 void MessageLogger::preModuleEndJob(const ModuleDescription& desc) {
0753 establishModule(desc, "@endJob");
0754 }
0755 void MessageLogger::postModuleEndJob(const ModuleDescription& iDescription) {
0756 unEstablishModule(iDescription, "AfterModEndJob");
0757 }
0758
0759 void MessageLogger::preESModule(eventsetup::EventSetupRecordKey const&, ESModuleCallingContext const& context) {
0760 MessageDrop* messageDrop = MessageDrop::instance();
0761 auto desc = context.componentDescription();
0762
0763
0764 auto label = &desc->label_;
0765 if (label->empty() or (*label)[0] == '\0') {
0766 label = &desc->type_;
0767 }
0768
0769 messageDrop->setModuleWithPhase(desc->type_, *label, 1000000 + desc->id_, "@callESModule");
0770 }
0771 void MessageLogger::postESModule(eventsetup::EventSetupRecordKey const&, ESModuleCallingContext const&) {
0772 MessageDrop* messageDrop = MessageDrop::instance();
0773 messageDrop->setSinglet("@finishedCallESModule");
0774 }
0775
0776
0777
0778
0779 void MessageLogger::postBeginJob() {
0780 MessageDrop::instance()->runEvent = "BeforeEvents";
0781 MessageDrop::instance()->setSinglet("AfterBeginJob");
0782 }
0783
0784 void MessageLogger::preSourceEvent(StreamID) {
0785 establish("source");
0786 MessageDrop::instance()->runEvent = "PreSource";
0787 }
0788 void MessageLogger::postSourceEvent(StreamID) {
0789 unEstablish("AfterSource");
0790 MessageDrop::instance()->runEvent = "AfterSource";
0791 }
0792 void MessageLogger::preSourceRunLumi() { establish("source"); }
0793 void MessageLogger::postSourceRunLumi() { unEstablish("AfterSource"); }
0794
0795 void MessageLogger::preFile(std::string const&) { establish("file_open"); }
0796 void MessageLogger::preFileClose(std::string const&) { establish("file_close"); }
0797 void MessageLogger::postFile(std::string const&) { unEstablish("AfterFile"); }
0798
0799 void MessageLogger::preEvent(StreamContext const& iContext) {
0800 assert(iContext.streamID().value() < transitionInfoCache_.size());
0801 auto& buffer = transitionInfoCache_[iContext.streamID().value()];
0802 auto const& id = iContext.eventID();
0803 auto v = fill_buffer(buffer, "Run: ", id.run(), " Event: ", id.event());
0804 edm::MessageDrop::instance()->runEvent = v;
0805 edm::MessageDrop::instance()->setSinglet("PreEventProcessing");
0806
0807
0808 }
0809
0810 void MessageLogger::postEvent(StreamContext const& iContext) {
0811 edm::MessageDrop::instance()->runEvent = "PostProcessEvent";
0812 edm::clearLoggedErrorsSummary(iContext.streamID().value());
0813 }
0814
0815 void MessageLogger::preStreamBeginRun(StreamContext const& iContext)
0816 {
0817 auto& buffer = transitionInfoCache_[iContext.streamID().value()];
0818 auto v = fill_buffer(buffer, "Run: ", iContext.eventID().run(), " Stream: ", iContext.streamID().value());
0819
0820 edm::MessageDrop::instance()->runEvent = v;
0821 edm::MessageDrop::instance()->setSinglet("PreStreamBeginRun");
0822 }
0823 void MessageLogger::postStreamBeginRun(StreamContext const&) {
0824 edm::MessageDrop::instance()->runEvent = "PostStreamBeginRun";
0825 edm::MessageDrop::instance()->setSinglet("PostStreamBeginRun");
0826
0827 }
0828
0829 void MessageLogger::preStreamEndRun(StreamContext const& iContext) {
0830 auto& buffer = transitionInfoCache_[iContext.streamID().value()];
0831 auto v = fill_buffer(buffer, "End Run: ", iContext.eventID().run(), " Stream: ", iContext.streamID().value());
0832
0833 edm::MessageDrop::instance()->runEvent = v;
0834 edm::MessageDrop::instance()->setSinglet("PreStreamEndRun");
0835 }
0836
0837 void MessageLogger::postStreamEndRun(StreamContext const&) {
0838 edm::MessageDrop::instance()->runEvent = "PostStreamEndRun";
0839 edm::MessageDrop::instance()->setSinglet("PostStreaEndRun");
0840 }
0841
0842 void MessageLogger::preStreamBeginLumi(StreamContext const& iContext) {
0843 auto& buffer = transitionInfoCache_[iContext.streamID().value()];
0844 auto const& id = iContext.eventID();
0845 auto v = fill_buffer(
0846 buffer, "Run: ", id.run(), " Lumi: ", id.luminosityBlock(), " Stream: ", iContext.streamID().value());
0847 edm::MessageDrop::instance()->runEvent = v;
0848 edm::MessageDrop::instance()->setSinglet("PreStreamBeginLumi");
0849 }
0850
0851 void MessageLogger::postStreamBeginLumi(StreamContext const&) {
0852 edm::MessageDrop::instance()->runEvent = "PostStreamBeginLumi";
0853 edm::MessageDrop::instance()->setSinglet("PostStreamBeginLumi");
0854 }
0855
0856 void MessageLogger::preStreamEndLumi(StreamContext const& iContext) {
0857 auto& buffer = transitionInfoCache_[iContext.streamID().value()];
0858 auto const& id = iContext.eventID();
0859 auto v = fill_buffer(
0860 buffer, "Run: ", id.run(), " Lumi: ", id.luminosityBlock(), " Stream: ", iContext.streamID().value());
0861
0862 edm::MessageDrop::instance()->runEvent = v;
0863 edm::MessageDrop::instance()->setSinglet("PreStreamEndLumi");
0864 }
0865 void MessageLogger::postStreamEndLumi(StreamContext const&) {
0866 edm::MessageDrop::instance()->runEvent = "PostStreamEndLumi";
0867 edm::MessageDrop::instance()->setSinglet("PostStreamEndLumi");
0868 }
0869
0870 void MessageLogger::preBeginProcessBlock(GlobalContext const& gc) {
0871 auto& buffer = transitionInfoCache_[processBlockInfoBegin_];
0872 auto v = fill_buffer(buffer, "pre-events");
0873 edm::MessageDrop::instance()->runEvent = v;
0874 edm::MessageDrop::instance()->setSinglet("PreBeginProcessBlock");
0875 }
0876
0877 void MessageLogger::postBeginProcessBlock(GlobalContext const& gc) {
0878 edm::MessageDrop::instance()->runEvent = "PostBeginProcessBlock";
0879 edm::MessageDrop::instance()->setSinglet("PostBeginProcessBlock");
0880 }
0881
0882 void MessageLogger::preAccessInputProcessBlock(GlobalContext const& gc) {
0883 auto& buffer = transitionInfoCache_[processBlockInfoBegin_];
0884 auto v = fill_buffer(buffer, "pre-events");
0885 edm::MessageDrop::instance()->runEvent = v;
0886 edm::MessageDrop::instance()->setSinglet("PreAccessInputProcessBlock");
0887 }
0888
0889 void MessageLogger::postAccessInputProcessBlock(GlobalContext const& gc) {
0890 edm::MessageDrop::instance()->runEvent = "PostAccessInputProcessBlock";
0891 edm::MessageDrop::instance()->setSinglet("PostAccessInputProcessBlock");
0892 }
0893
0894 void MessageLogger::preEndProcessBlock(GlobalContext const& gc) {
0895 auto& buffer = transitionInfoCache_[processBlockInfoBegin_];
0896 auto v = fill_buffer(buffer, "post-events");
0897 edm::MessageDrop::instance()->runEvent = v;
0898 edm::MessageDrop::instance()->setSinglet("PreEndProcessBlock");
0899 }
0900
0901 void MessageLogger::postEndProcessBlock(GlobalContext const& gc) {
0902 edm::MessageDrop::instance()->runEvent = "PostEndProcessBlock";
0903 edm::MessageDrop::instance()->setSinglet("PostEndProcessBlock");
0904 }
0905
0906 void MessageLogger::preGlobalBeginRun(GlobalContext const& iContext)
0907 {
0908 auto& buffer = transitionInfoCache_[runInfoBegin_ + iContext.runIndex()];
0909 auto v = fill_buffer(buffer, "Run: ", iContext.luminosityBlockID().run());
0910 edm::MessageDrop::instance()->runEvent = v;
0911 edm::MessageDrop::instance()->setSinglet("PreGlobalBeginRun");
0912 }
0913 void MessageLogger::postGlobalBeginRun(GlobalContext const&) {
0914 edm::MessageDrop::instance()->runEvent = "PostGlobalBeginRun";
0915 edm::MessageDrop::instance()->setSinglet("PostGlobalBeginRun");
0916
0917 }
0918
0919 void MessageLogger::prePathEvent(StreamContext const& stream, PathContext const& iPath)
0920 {
0921 auto messageDrop = edm::MessageDrop::instance();
0922 messageDrop->runEvent = transitionInfoCache_[stream.streamID().value()].begin();
0923 messageDrop->setPath("PreProcPath ", iPath.pathName());
0924
0925 }
0926
0927 void MessageLogger::postPathEvent(StreamContext const&, PathContext const&, HLTPathStatus const&) {
0928 edm::MessageDrop::instance()->setSinglet("PostProcessPath");
0929 }
0930
0931 void MessageLogger::preGlobalEndRun(GlobalContext const& iContext) {
0932 auto& buffer = transitionInfoCache_[runInfoBegin_ + iContext.runIndex()];
0933 auto v = fill_buffer(buffer, "End Run: ", iContext.luminosityBlockID().run());
0934 edm::MessageDrop::instance()->runEvent = v;
0935 edm::MessageDrop::instance()->setSinglet("PreGlobalEndRun");
0936 }
0937
0938 void MessageLogger::postGlobalEndRun(GlobalContext const&) {
0939 edm::MessageDrop::instance()->runEvent = "PostGlobalEndRun";
0940 edm::MessageDrop::instance()->setSinglet("PostGlobalEndRun");
0941 }
0942
0943 void MessageLogger::preGlobalBeginLumi(GlobalContext const& iContext) {
0944 auto& buffer = transitionInfoCache_[lumiInfoBegin_ + iContext.luminosityBlockIndex()];
0945 auto const& id = iContext.luminosityBlockID();
0946 auto v = fill_buffer(buffer, "Run: ", id.run(), " Lumi: ", id.luminosityBlock());
0947 edm::MessageDrop::instance()->runEvent = v;
0948 edm::MessageDrop::instance()->setSinglet("PreGlobalBeginLumi");
0949 }
0950
0951 void MessageLogger::postGlobalBeginLumi(GlobalContext const&) {
0952 edm::MessageDrop::instance()->runEvent = "PostGlobalBeginLumi";
0953 edm::MessageDrop::instance()->setSinglet("PostGlobalBeginLumi");
0954 }
0955
0956 void MessageLogger::preGlobalEndLumi(GlobalContext const& iContext) {
0957 auto& buffer = transitionInfoCache_[lumiInfoBegin_ + iContext.luminosityBlockIndex()];
0958 auto const& id = iContext.luminosityBlockID();
0959 auto v = fill_buffer(buffer, "Run: ", id.run(), " Lumi: ", id.luminosityBlock());
0960 edm::MessageDrop::instance()->runEvent = v;
0961 edm::MessageDrop::instance()->setSinglet("PreGlobalEndLumi");
0962 }
0963 void MessageLogger::postGlobalEndLumi(GlobalContext const&) {
0964 edm::MessageDrop::instance()->runEvent = "PostGlobalEndLumi";
0965 edm::MessageDrop::instance()->setSinglet("PostGlobalEndLumi");
0966 }
0967
0968 void MessageLogger::preEndJob() {
0969 edm::MessageDrop::instance()->runEvent = "EndJob";
0970 edm::MessageDrop::instance()->setSinglet("EndJob");
0971 }
0972
0973 void MessageLogger::postEndJob() {
0974 summarizeInJobReport();
0975 MessageLoggerQ::MLqSUM();
0976 }
0977
0978 void MessageLogger::jobFailure() {
0979 MessageDrop* messageDrop = MessageDrop::instance();
0980 messageDrop->setSinglet("jobFailure");
0981 summarizeInJobReport();
0982 MessageLoggerQ::MLqSUM();
0983 }
0984
0985
0986
0987
0988
0989 void MessageLogger::summarizeInJobReport() {
0990 if (fjrSummaryRequested_) {
0991 std::map<std::string, double>* smp = new std::map<std::string, double>();
0992 MessageLoggerQ::MLqJRS(smp);
0993 Service<JobReport> reportSvc;
0994 reportSvc->reportMessageInfo(*smp);
0995 delete smp;
0996 }
0997 }
0998
0999 }
1000 }