Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2025-06-06 01:33:20 

0001 // -*- C++ -*-
0002 //
0003 // Package:     Services
0004 // Class  :     MessageLogger
0005 //
0006 // Implementation:
0007 //     <Notes on implementation>
0008 //
0009 // Original Author:  W. Brown, M. Fischler
0010 //         Created:  Fri Nov 11 16:42:39 CST 2005
0011 //
0012 
0013 // system include files
0014 // user include files
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                                                                    "",  //event
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 }  // namespace
0097 
0098 namespace edm {
0099   //Forward declare here
0100   // Only the MessageLogger::postEVent function is allowed to call this function.
0101   // So although the function is defined in MessageSender.cc this is the
0102   //  only place where we want it declared.
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     // constructors and destructor
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)  // change log 20
0123     {
0124       // prepare cfg validation string for later use
0125       MessageServicePSetValidation validator;
0126       messageServicePSetValidatationResults_ = validator(iPS);  // change log 12
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;  // change log 20
0136 
0137       try {  // change log 13
0138              // decide whether a summary should be placed in job report
0139         fjrSummaryRequested_ = iPS.getUntrackedParameter<bool>("messageSummaryToJobReport", false);
0140 
0141         // grab list of debug-enabled modules
0142         debugModules = iPS.getUntrackedParameter<vString>("debugModules", empty_vString);
0143 
0144         // grab lists of suppressLEVEL modules
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 =  // change log 20
0154             iPS.getUntrackedParameter<vString>("suppressError", empty_vString);
0155       } catch (cms::Exception& e) {  // change log 13
0156       }
0157 
0158       // Use these lists to prepare a map to use in tracking suppression
0159 
0160       // Do suppressDebug first and suppressError last to get proper order
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();  // change log 20
0178            it != suppressError.end();
0179            ++it) {
0180         suppression_levels_[*it] = ELseverityLevel::ELsev_error;
0181       }
0182 
0183       // set up for tracking whether current module is debug-enabled
0184       // (and info-enabled and warning-enabled)
0185       if (debugModules.empty()) {
0186         anyDebugEnabled_ = true;
0187         everyDebugEnabled_ = true;
0188         MessageDrop::instance()->debugEnabled = true;
0189       } else {
0190         anyDebugEnabled_ = true;  // change log 11
0191         MessageDrop::instance()->debugEnabled = false;
0192         // this will be over-ridden when specific modules are entered
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       // change log 7
0205       std::string jm = edm::MessageDrop::jobMode;
0206       std::string* jm_p = new std::string(jm);
0207       MessageLoggerQ::MLqMOD(jm_p);  // change log 9
0208 
0209       MessageLoggerQ::MLqCFG(new ParameterSet(iPS));  // change log 9
0210 
0211       iRegistry.watchPreallocate([this](edm::service::SystemBounds const& iBounds) {
0212         //reserve the proper amount of space to record the transition info
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);  // change log 14
0228 
0229       iRegistry.watchPreModuleConstruction(this, &MessageLogger::preModuleConstruction);
0230       iRegistry.watchPostModuleConstruction(this, &MessageLogger::postModuleConstruction);
0231       // change log 3
0232 
0233       iRegistry.watchPreSourceConstruction(this, &MessageLogger::preSourceConstruction);
0234       iRegistry.watchPostSourceConstruction(this, &MessageLogger::postSourceConstruction);
0235       // change log 3
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       // change log 14:
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       // change log 13:
0259       // change log 15
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     }  // ctor
0339 
0340     void MessageLogger::setThreadContext(ModuleCallingContext const& iModContext) {
0341       //need to know if we are in a global or stream context
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     // Shared helper routines for establishing module name and enabling behavior
0378     //
0379 
0380     void MessageLogger::establishModule(ModuleDescription const& desc,
0381                                         const char* whichPhase)  // ChangeLog 13, 17
0382     {
0383       MessageDrop* messageDrop = MessageDrop::instance();
0384 
0385       // std::cerr << "establishModule( " << desc.moduleName() << ")\n";
0386       // Change Log 17
0387       messageDrop->setModuleWithPhase(desc.moduleName(), desc.moduleLabel(), desc.id(), whichPhase);
0388       // Removed caching per change 17 - caching is now done in MessageDrop.cc
0389       // in theContext() method, and only happens if a message is actually issued.
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     }  // establishModule
0413 
0414     void MessageLogger::establishModule(unsigned int transitionIndex,
0415                                         ModuleCallingContext const& mod,
0416                                         const char* whichPhase)  // ChangeLog 13, 17
0417     {
0418       MessageDrop* messageDrop = MessageDrop::instance();
0419 
0420       // std::cerr << "establishModule( " << desc.moduleName() << ")\n";
0421       // Change Log 17
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       // Removed caching per change 17 - caching is now done in MessageDrop.cc
0430       // in theContext() method, and only happens if a message is actually issued.
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     }  // establishModule
0454 
0455     void MessageLogger::unEstablishModule(ModuleDescription const& /*unused*/, const char* state) {
0456       // std::cerr << "unestablishModule( " << desc.moduleName() << ") "
0457       //           << "state = " << *state << "\n";
0458 
0459       MessageDrop* messageDrop = MessageDrop::instance();
0460       messageDrop->setSinglet(state);  // Change Log 17
0461       messageDrop->debugEnabled = nonModule_debugEnabled;
0462       messageDrop->infoEnabled = nonModule_infoEnabled;
0463       messageDrop->warningEnabled = nonModule_warningEnabled;
0464       messageDrop->errorEnabled = nonModule_errorEnabled;  // change log 20
0465     }
0466 
0467     void MessageLogger::unEstablishModule(ModuleCallingContext const& mod, const char* state) {
0468       //Need to reset to what was previously being used on this thread
0469       auto previous = mod.previousModuleOnThread();
0470       if (previous) {
0471         //need to know if we are in a global or stream context
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);  // Change Log 17
0509         messageDrop->debugEnabled = nonModule_debugEnabled;
0510         messageDrop->infoEnabled = nonModule_infoEnabled;
0511         messageDrop->warningEnabled = nonModule_warningEnabled;
0512         messageDrop->errorEnabled = nonModule_errorEnabled;  // change log 20
0513       }
0514 
0515       // std::cerr << "unestablishModule( " << desc.moduleName() << ") "
0516       //           << "state = " << *state << "\n";
0517     }
0518 
0519     void MessageLogger::establish(const char* state) {
0520       MessageDrop* messageDrop = MessageDrop::instance();
0521       messageDrop->setSinglet(state);  // Change Log 17
0522       if (!anyDebugEnabled_) {
0523         messageDrop->debugEnabled = false;
0524       } else if (everyDebugEnabled_) {
0525         messageDrop->debugEnabled = true;
0526       } else {
0527         messageDrop->debugEnabled = debugEnabledModules_.count(state);  // change log 8
0528       }
0529       std::map<const std::string, ELseverityLevel>::const_iterator it =
0530           suppression_levels_.find(state);  // change log 8
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);  // Change Log 17
0547     }
0548 
0549     //
0550     // callbacks that need to establish the module, and their counterparts
0551     //
0552 
0553     void MessageLogger::preModuleConstruction(const ModuleDescription& desc) {
0554       if (!messageServicePSetHasBeenValidated_) {  // change log 12
0555         if (!messageServicePSetValidatationResults_.empty()) {
0556           throw(edm::Exception(edm::errors::Configuration, messageServicePSetValidatationResults_));
0557         }
0558         messageServicePSetHasBeenValidated_ = true;
0559       }
0560       establishModule(desc, "@ctor");  // ChangeLog 16
0561     }
0562     //it is now guaranteed that this will be called even if the module throws
0563     void MessageLogger::postModuleConstruction(const ModuleDescription& iDescription) {
0564       unEstablishModule(iDescription, "AfterModConstruction");
0565     }
0566 
0567     void MessageLogger::preModuleDestruction(const ModuleDescription& desc) { establishModule(desc, "@dtor"); }
0568     //it is guaranteed that this will be called even if the module throws
0569     void MessageLogger::postModuleDestruction(const ModuleDescription& iDescription) {
0570       unEstablishModule(iDescription, "AfterModDestruction");
0571     }
0572 
0573     void MessageLogger::preModuleBeginJob(const ModuleDescription& desc) {
0574       establishModule(desc, "@beginJob");  // ChangeLog 13
0575     }
0576     void MessageLogger::postModuleBeginJob(const ModuleDescription& iDescription) {
0577       unEstablishModule(iDescription, "AfterModBeginJob");
0578     }
0579 
0580     void MessageLogger::preSourceConstruction(const ModuleDescription& desc) {
0581       if (!messageServicePSetHasBeenValidated_) {  // change log 12
0582         if (!messageServicePSetValidatationResults_.empty()) {
0583           throw(edm::Exception(edm::errors::Configuration, messageServicePSetValidatationResults_));
0584         }
0585         messageServicePSetHasBeenValidated_ = true;
0586       }
0587       establishModule(desc, "@sourceConstruction");  // ChangeLog 16
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");  // ChangeLog 13
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)]);  // ChangeLog 13
0651     }
0652     void MessageLogger::postModuleStreamEndRun(StreamContext const& stream, ModuleCallingContext const& mod) {
0653       unEstablishModule(mod, "AfterModStreamEndRun");
0654     }
0655 
0656     //Global
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)]);  // ChangeLog 13
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");  // ChangeLog 13
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");  // ChangeLog 13
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       // std::cerr << "establishModule( " << desc.moduleName() << ")\n";
0763       // Change Log 17
0764       auto label = &desc->label_;
0765       if (label->empty() or (*label)[0] == '\0') {
0766         label = &desc->type_;
0767       }
0768       //make sure ES module IDs do not conflict with ED module IDs
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");  // Change Log 17
0774     }
0775     //
0776     // callbacks that don't know about the module
0777     //
0778 
0779     void MessageLogger::postBeginJob() {
0780       MessageDrop::instance()->runEvent = "BeforeEvents";
0781       MessageDrop::instance()->setSinglet("AfterBeginJob");  // Change Log 17
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");  // changelog 17
0806           // Note - module name had not been set here  Similarly in other places where
0807           // RunEvent carries the new information; we add setSinglet for module name.
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)  // change log 14
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");  // changelog 17
0822     }
0823     void MessageLogger::postStreamBeginRun(StreamContext const&) {
0824       edm::MessageDrop::instance()->runEvent = "PostStreamBeginRun";
0825       edm::MessageDrop::instance()->setSinglet("PostStreamBeginRun");  // changelog 17
0826                                                                        // Note - module name had not been set here
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");  // changelog 17
0835     }
0836 
0837     void MessageLogger::postStreamEndRun(StreamContext const&) {
0838       edm::MessageDrop::instance()->runEvent = "PostStreamEndRun";
0839       edm::MessageDrop::instance()->setSinglet("PostStreaEndRun");  // changelog 17
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");  // changelog 17
0849     }
0850 
0851     void MessageLogger::postStreamBeginLumi(StreamContext const&) {
0852       edm::MessageDrop::instance()->runEvent = "PostStreamBeginLumi";
0853       edm::MessageDrop::instance()->setSinglet("PostStreamBeginLumi");  // changelog 17
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");  // changelog 17
0864     }
0865     void MessageLogger::postStreamEndLumi(StreamContext const&) {
0866       edm::MessageDrop::instance()->runEvent = "PostStreamEndLumi";
0867       edm::MessageDrop::instance()->setSinglet("PostStreamEndLumi");  // changelog 17
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)  // change log 14
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");  // changelog 17
0912     }
0913     void MessageLogger::postGlobalBeginRun(GlobalContext const&) {
0914       edm::MessageDrop::instance()->runEvent = "PostGlobalBeginRun";
0915       edm::MessageDrop::instance()->setSinglet("PostGlobalBeginRun");  // changelog 17
0916                                                                        // Note - module name had not been set here
0917     }
0918 
0919     void MessageLogger::prePathEvent(StreamContext const& stream, PathContext const& iPath)  // change log 14
0920     {
0921       auto messageDrop = edm::MessageDrop::instance();
0922       messageDrop->runEvent = transitionInfoCache_[stream.streamID().value()].begin();
0923       messageDrop->setPath("PreProcPath ", iPath.pathName());
0924       // change log 17
0925     }
0926 
0927     void MessageLogger::postPathEvent(StreamContext const&, PathContext const&, HLTPathStatus const&) {
0928       edm::MessageDrop::instance()->setSinglet("PostProcessPath");  // changelog 17
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");  // changelog 17
0936     }
0937 
0938     void MessageLogger::postGlobalEndRun(GlobalContext const&) {
0939       edm::MessageDrop::instance()->runEvent = "PostGlobalEndRun";
0940       edm::MessageDrop::instance()->setSinglet("PostGlobalEndRun");  // changelog 17
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");  // changelog 17
0949     }
0950 
0951     void MessageLogger::postGlobalBeginLumi(GlobalContext const&) {
0952       edm::MessageDrop::instance()->runEvent = "PostGlobalBeginLumi";
0953       edm::MessageDrop::instance()->setSinglet("PostGlobalBeginLumi");  // changelog 17
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");  // changelog 17
0962     }
0963     void MessageLogger::postGlobalEndLumi(GlobalContext const&) {
0964       edm::MessageDrop::instance()->runEvent = "PostGlobalEndLumi";
0965       edm::MessageDrop::instance()->setSinglet("PostGlobalEndLumi");  // changelog 17
0966     }
0967 
0968     void MessageLogger::preEndJob() {
0969       edm::MessageDrop::instance()->runEvent = "EndJob";
0970       edm::MessageDrop::instance()->setSinglet("EndJob");  // changelog
0971     }
0972 
0973     void MessageLogger::postEndJob() {
0974       summarizeInJobReport();    // Put summary info into Job Rep  // change log 10
0975       MessageLoggerQ::MLqSUM();  // trigger summary info.       // change log 9
0976     }
0977 
0978     void MessageLogger::jobFailure() {
0979       MessageDrop* messageDrop = MessageDrop::instance();
0980       messageDrop->setSinglet("jobFailure");
0981       summarizeInJobReport();    // Put summary info into Job Rep  // change log 10
0982       MessageLoggerQ::MLqSUM();  // trigger summary info.       // change log 9
0983     }
0984 
0985     //
0986     // Other methods
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   }  // end of namespace service
1000 }  // end of namespace edm
[ 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!