Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2024-04-06 12:12:45 

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_ = false;                       // change log 11
0187         MessageDrop::instance()->debugEnabled = false;  // change log 1
0188       } else {
0189         anyDebugEnabled_ = true;  // change log 11
0190         MessageDrop::instance()->debugEnabled = false;
0191         // this will be over-ridden when specific modules are entered
0192       }
0193 
0194       // if ( debugModules.empty()) anyDebugEnabled_ = true; // wrong; change log 11
0195       for (vString::const_iterator it = debugModules.begin(); it != debugModules.end(); ++it) {
0196         if (*it == "*") {
0197           everyDebugEnabled_ = true;
0198         } else {
0199           debugEnabledModules_.insert(*it);
0200         }
0201       }
0202 
0203       // change log 7
0204       std::string jm = edm::MessageDrop::jobMode;
0205       std::string* jm_p = new std::string(jm);
0206       MessageLoggerQ::MLqMOD(jm_p);  // change log 9
0207 
0208       MessageLoggerQ::MLqCFG(new ParameterSet(iPS));  // change log 9
0209 
0210       iRegistry.watchPreallocate([this](edm::service::SystemBounds const& iBounds) {
0211         //reserve the proper amount of space to record the transition info
0212         constexpr unsigned int maxNumberOfConcurrentProcessBlocks = 1;
0213         this->transitionInfoCache_.resize(iBounds.maxNumberOfStreams() +
0214                                           iBounds.maxNumberOfConcurrentLuminosityBlocks() +
0215                                           iBounds.maxNumberOfConcurrentRuns() + maxNumberOfConcurrentProcessBlocks);
0216         lumiInfoBegin_ = iBounds.maxNumberOfStreams();
0217         runInfoBegin_ = lumiInfoBegin_ + iBounds.maxNumberOfConcurrentLuminosityBlocks();
0218         processBlockInfoBegin_ = runInfoBegin_ + iBounds.maxNumberOfConcurrentRuns();
0219 
0220         setMaxLoggedErrorsSummaryIndicies(iBounds.maxNumberOfStreams());
0221       });
0222 
0223       iRegistry.watchPostBeginJob(this, &MessageLogger::postBeginJob);
0224       iRegistry.watchPreEndJob(this, &MessageLogger::preEndJob);
0225       iRegistry.watchPostEndJob(this, &MessageLogger::postEndJob);
0226       iRegistry.watchJobFailure(this, &MessageLogger::jobFailure);  // change log 14
0227 
0228       iRegistry.watchPreModuleConstruction(this, &MessageLogger::preModuleConstruction);
0229       iRegistry.watchPostModuleConstruction(this, &MessageLogger::postModuleConstruction);
0230       // change log 3
0231 
0232       iRegistry.watchPreSourceConstruction(this, &MessageLogger::preSourceConstruction);
0233       iRegistry.watchPostSourceConstruction(this, &MessageLogger::postSourceConstruction);
0234       // change log 3
0235 
0236       iRegistry.watchPreModuleDestruction(this, &MessageLogger::preModuleDestruction);
0237       iRegistry.watchPostModuleDestruction(this, &MessageLogger::postModuleDestruction);
0238 
0239       iRegistry.watchPreModuleEvent(this, &MessageLogger::preModuleEvent);
0240       iRegistry.watchPostModuleEvent(this, &MessageLogger::postModuleEvent);
0241 
0242       iRegistry.watchPreModuleEventAcquire(this, &MessageLogger::preModuleEventAcquire);
0243       iRegistry.watchPostModuleEventAcquire(this, &MessageLogger::postModuleEventAcquire);
0244 
0245       iRegistry.watchPreSourceEvent(this, &MessageLogger::preSourceEvent);
0246       iRegistry.watchPostSourceEvent(this, &MessageLogger::postSourceEvent);
0247       // change log 14:
0248       iRegistry.watchPreSourceRun([this](RunIndex) { preSourceRunLumi(); });
0249       iRegistry.watchPostSourceRun([this](RunIndex) { postSourceRunLumi(); });
0250       iRegistry.watchPreSourceLumi([this](LuminosityBlockIndex) { preSourceRunLumi(); });
0251       iRegistry.watchPostSourceLumi([this](LuminosityBlockIndex) { postSourceRunLumi(); });
0252       iRegistry.watchPreOpenFile(this, &MessageLogger::preFile);
0253       iRegistry.watchPostOpenFile(this, &MessageLogger::postFile);
0254       iRegistry.watchPreCloseFile(this, &MessageLogger::preFileClose);
0255       iRegistry.watchPostCloseFile(this, &MessageLogger::postFile);
0256 
0257       // change log 13:
0258       // change log 15
0259       iRegistry.watchPreModuleBeginJob(this, &MessageLogger::preModuleBeginJob);
0260       iRegistry.watchPostModuleBeginJob(this, &MessageLogger::postModuleBeginJob);
0261       iRegistry.watchPreModuleEndJob(this, &MessageLogger::preModuleEndJob);
0262       iRegistry.watchPostModuleEndJob(this, &MessageLogger::postModuleEndJob);
0263 
0264       iRegistry.watchPreModuleBeginStream(this, &MessageLogger::preModuleBeginStream);
0265       iRegistry.watchPostModuleBeginStream(this, &MessageLogger::postModuleBeginStream);
0266       iRegistry.watchPreModuleEndStream(this, &MessageLogger::preModuleEndStream);
0267       iRegistry.watchPostModuleEndStream(this, &MessageLogger::postModuleEndStream);
0268 
0269       iRegistry.watchPreModuleStreamBeginRun(this, &MessageLogger::preModuleStreamBeginRun);
0270       iRegistry.watchPostModuleStreamBeginRun(this, &MessageLogger::postModuleStreamBeginRun);
0271       iRegistry.watchPreModuleStreamEndRun(this, &MessageLogger::preModuleStreamEndRun);
0272       iRegistry.watchPostModuleStreamEndRun(this, &MessageLogger::postModuleStreamEndRun);
0273       iRegistry.watchPreModuleStreamBeginLumi(this, &MessageLogger::preModuleStreamBeginLumi);
0274       iRegistry.watchPostModuleStreamBeginLumi(this, &MessageLogger::postModuleStreamBeginLumi);
0275       iRegistry.watchPreModuleStreamEndLumi(this, &MessageLogger::preModuleStreamEndLumi);
0276       iRegistry.watchPostModuleStreamEndLumi(this, &MessageLogger::postModuleStreamEndLumi);
0277 
0278       iRegistry.watchPreModuleBeginProcessBlock(this, &MessageLogger::preModuleBeginProcessBlock);
0279       iRegistry.watchPostModuleBeginProcessBlock(this, &MessageLogger::postModuleBeginProcessBlock);
0280       iRegistry.watchPreModuleAccessInputProcessBlock(this, &MessageLogger::preModuleAccessInputProcessBlock);
0281       iRegistry.watchPostModuleAccessInputProcessBlock(this, &MessageLogger::postModuleAccessInputProcessBlock);
0282       iRegistry.watchPreModuleEndProcessBlock(this, &MessageLogger::preModuleEndProcessBlock);
0283       iRegistry.watchPostModuleEndProcessBlock(this, &MessageLogger::postModuleEndProcessBlock);
0284 
0285       iRegistry.watchPreModuleGlobalBeginRun(this, &MessageLogger::preModuleGlobalBeginRun);
0286       iRegistry.watchPostModuleGlobalBeginRun(this, &MessageLogger::postModuleGlobalBeginRun);
0287       iRegistry.watchPreModuleGlobalEndRun(this, &MessageLogger::preModuleGlobalEndRun);
0288       iRegistry.watchPostModuleGlobalEndRun(this, &MessageLogger::postModuleGlobalEndRun);
0289       iRegistry.watchPreModuleWriteRun(this, &MessageLogger::preModuleWriteRun);
0290       iRegistry.watchPostModuleWriteRun(this, &MessageLogger::postModuleWriteRun);
0291       iRegistry.watchPreModuleGlobalBeginLumi(this, &MessageLogger::preModuleGlobalBeginLumi);
0292       iRegistry.watchPostModuleGlobalBeginLumi(this, &MessageLogger::postModuleGlobalBeginLumi);
0293       iRegistry.watchPreModuleGlobalEndLumi(this, &MessageLogger::preModuleGlobalEndLumi);
0294       iRegistry.watchPostModuleGlobalEndLumi(this, &MessageLogger::postModuleGlobalEndLumi);
0295       iRegistry.watchPreModuleWriteLumi(this, &MessageLogger::preModuleWriteLumi);
0296       iRegistry.watchPostModuleWriteLumi(this, &MessageLogger::postModuleWriteLumi);
0297 
0298       iRegistry.watchPreEvent(this, &MessageLogger::preEvent);
0299       iRegistry.watchPostEvent(this, &MessageLogger::postEvent);
0300 
0301       iRegistry.watchPreStreamBeginRun(this, &MessageLogger::preStreamBeginRun);
0302       iRegistry.watchPostStreamBeginRun(this, &MessageLogger::postStreamBeginRun);
0303       iRegistry.watchPreStreamEndRun(this, &MessageLogger::preStreamEndRun);
0304       iRegistry.watchPostStreamEndRun(this, &MessageLogger::postStreamEndRun);
0305       iRegistry.watchPreStreamBeginLumi(this, &MessageLogger::preStreamBeginLumi);
0306       iRegistry.watchPostStreamBeginLumi(this, &MessageLogger::postStreamBeginLumi);
0307       iRegistry.watchPreStreamEndLumi(this, &MessageLogger::preStreamEndLumi);
0308       iRegistry.watchPostStreamEndLumi(this, &MessageLogger::postStreamEndLumi);
0309 
0310       iRegistry.watchPreBeginProcessBlock(this, &MessageLogger::preBeginProcessBlock);
0311       iRegistry.watchPostBeginProcessBlock(this, &MessageLogger::postBeginProcessBlock);
0312       iRegistry.watchPreAccessInputProcessBlock(this, &MessageLogger::preAccessInputProcessBlock);
0313       iRegistry.watchPostAccessInputProcessBlock(this, &MessageLogger::postAccessInputProcessBlock);
0314       iRegistry.watchPreEndProcessBlock(this, &MessageLogger::preEndProcessBlock);
0315       iRegistry.watchPostEndProcessBlock(this, &MessageLogger::postEndProcessBlock);
0316 
0317       iRegistry.watchPreGlobalBeginRun(this, &MessageLogger::preGlobalBeginRun);
0318       iRegistry.watchPostGlobalBeginRun(this, &MessageLogger::postGlobalBeginRun);
0319       iRegistry.watchPreGlobalEndRun(this, &MessageLogger::preGlobalEndRun);
0320       iRegistry.watchPostGlobalEndRun(this, &MessageLogger::postGlobalEndRun);
0321       iRegistry.watchPreGlobalBeginLumi(this, &MessageLogger::preGlobalBeginLumi);
0322       iRegistry.watchPostGlobalBeginLumi(this, &MessageLogger::postGlobalBeginLumi);
0323       iRegistry.watchPreGlobalEndLumi(this, &MessageLogger::preGlobalEndLumi);
0324       iRegistry.watchPostGlobalEndLumi(this, &MessageLogger::postGlobalEndLumi);
0325 
0326       iRegistry.watchPrePathEvent(this, &MessageLogger::prePathEvent);
0327       iRegistry.watchPostPathEvent(this, &MessageLogger::postPathEvent);
0328 
0329       iRegistry.watchPreESModule(this, &MessageLogger::preESModule);
0330       iRegistry.watchPostESModule(this, &MessageLogger::postESModule);
0331 
0332       MessageDrop* messageDrop = MessageDrop::instance();
0333       nonModule_debugEnabled = messageDrop->debugEnabled;
0334       nonModule_infoEnabled = messageDrop->infoEnabled;
0335       nonModule_warningEnabled = messageDrop->warningEnabled;
0336       nonModule_errorEnabled = messageDrop->errorEnabled;
0337     }  // ctor
0338 
0339     void MessageLogger::setThreadContext(ModuleCallingContext const& iModContext) {
0340       //need to know if we are in a global or stream context
0341       auto top = iModContext.getTopModuleCallingContext();
0342       assert(nullptr != top);
0343       if (ParentContext::Type::kGlobal == top->type()) {
0344         auto globalContext = iModContext.getGlobalContext();
0345         auto tran = globalContext->transition();
0346         if (tran == GlobalContext::Transition::kBeginLuminosityBlock or
0347             tran == GlobalContext::Transition::kEndLuminosityBlock) {
0348           establishModule(lumiInfoBegin_ + globalContext->luminosityBlockIndex(),
0349                           iModContext,
0350                           s_globalTransitionNames[static_cast<int>(tran)]);
0351         } else if (tran == GlobalContext::Transition::kBeginRun or tran == GlobalContext::Transition::kEndRun) {
0352           establishModule(
0353               runInfoBegin_ + globalContext->runIndex(), iModContext, s_globalTransitionNames[static_cast<int>(tran)]);
0354         } else if (tran == GlobalContext::Transition::kBeginProcessBlock ||
0355                    tran == GlobalContext::Transition::kAccessInputProcessBlock ||
0356                    tran == GlobalContext::Transition::kEndProcessBlock) {
0357           establishModule(processBlockInfoBegin_, iModContext, s_globalTransitionNames[static_cast<int>(tran)]);
0358         } else {
0359           MessageDrop* messageDrop = MessageDrop::instance();
0360           messageDrop->streamID = std::numeric_limits<unsigned int>::max();
0361           messageDrop->setSinglet("unknown context");
0362           MessageDrop::instance()->runEvent = "";
0363           messageDrop->debugEnabled = nonModule_debugEnabled;
0364           messageDrop->infoEnabled = nonModule_infoEnabled;
0365           messageDrop->warningEnabled = nonModule_warningEnabled;
0366           messageDrop->errorEnabled = nonModule_errorEnabled;
0367         }
0368       } else {
0369         auto stream = iModContext.getStreamContext();
0370         establishModule(
0371             stream->streamID().value(), iModContext, s_streamTransitionNames[static_cast<int>(stream->transition())]);
0372       }
0373     }
0374 
0375     //
0376     // Shared helper routines for establishing module name and enabling behavior
0377     //
0378 
0379     void MessageLogger::establishModule(ModuleDescription const& desc,
0380                                         const char* whichPhase)  // ChangeLog 13, 17
0381     {
0382       MessageDrop* messageDrop = MessageDrop::instance();
0383 
0384       // std::cerr << "establishModule( " << desc.moduleName() << ")\n";
0385       // Change Log 17
0386       messageDrop->setModuleWithPhase(desc.moduleName(), desc.moduleLabel(), desc.id(), whichPhase);
0387       // Removed caching per change 17 - caching is now done in MessageDrop.cc
0388       // in theContext() method, and only happens if a message is actually issued.
0389 
0390       if (!anyDebugEnabled_) {
0391         messageDrop->debugEnabled = false;
0392       } else if (everyDebugEnabled_) {
0393         messageDrop->debugEnabled = true;
0394       } else {
0395         messageDrop->debugEnabled = debugEnabledModules_.count(desc.moduleLabel());
0396       }
0397 
0398       auto it = suppression_levels_.find(desc.moduleLabel());
0399       if (it != suppression_levels_.end()) {
0400         messageDrop->debugEnabled = messageDrop->debugEnabled && (it->second < ELseverityLevel::ELsev_success);
0401         messageDrop->infoEnabled = (it->second < ELseverityLevel::ELsev_info);
0402         messageDrop->fwkInfoEnabled = (it->second < ELseverityLevel::ELsev_fwkInfo);
0403         messageDrop->warningEnabled = (it->second < ELseverityLevel::ELsev_warning);
0404         messageDrop->errorEnabled = (it->second < ELseverityLevel::ELsev_error);
0405       } else {
0406         messageDrop->infoEnabled = true;
0407         messageDrop->fwkInfoEnabled = true;
0408         messageDrop->warningEnabled = true;
0409         messageDrop->errorEnabled = true;
0410       }
0411     }  // establishModule
0412 
0413     void MessageLogger::establishModule(unsigned int transitionIndex,
0414                                         ModuleCallingContext const& mod,
0415                                         const char* whichPhase)  // ChangeLog 13, 17
0416     {
0417       MessageDrop* messageDrop = MessageDrop::instance();
0418 
0419       // std::cerr << "establishModule( " << desc.moduleName() << ")\n";
0420       // Change Log 17
0421       auto const desc = mod.moduleDescription();
0422       messageDrop->runEvent = transitionInfoCache_[transitionIndex].begin();
0423       messageDrop->setModuleWithPhase(desc->moduleName(), desc->moduleLabel(), desc->id(), whichPhase);
0424       messageDrop->streamID = transitionIndex;
0425       if (transitionIndex >= lumiInfoBegin_) {
0426         messageDrop->streamID = std::numeric_limits<unsigned int>::max();
0427       }
0428       // Removed caching per change 17 - caching is now done in MessageDrop.cc
0429       // in theContext() method, and only happens if a message is actually issued.
0430 
0431       if (!anyDebugEnabled_) {
0432         messageDrop->debugEnabled = false;
0433       } else if (everyDebugEnabled_) {
0434         messageDrop->debugEnabled = true;
0435       } else {
0436         messageDrop->debugEnabled = debugEnabledModules_.count(desc->moduleLabel());
0437       }
0438 
0439       auto it = suppression_levels_.find(desc->moduleLabel());
0440       if (it != suppression_levels_.end()) {
0441         messageDrop->debugEnabled = messageDrop->debugEnabled && (it->second < ELseverityLevel::ELsev_success);
0442         messageDrop->infoEnabled = (it->second < ELseverityLevel::ELsev_info);
0443         messageDrop->fwkInfoEnabled = (it->second < ELseverityLevel::ELsev_fwkInfo);
0444         messageDrop->warningEnabled = (it->second < ELseverityLevel::ELsev_warning);
0445         messageDrop->errorEnabled = (it->second < ELseverityLevel::ELsev_error);
0446       } else {
0447         messageDrop->infoEnabled = true;
0448         messageDrop->fwkInfoEnabled = true;
0449         messageDrop->warningEnabled = true;
0450         messageDrop->errorEnabled = true;
0451       }
0452     }  // establishModule
0453 
0454     void MessageLogger::unEstablishModule(ModuleDescription const& /*unused*/, const char* state) {
0455       // std::cerr << "unestablishModule( " << desc.moduleName() << ") "
0456       //           << "state = " << *state << "\n";
0457 
0458       MessageDrop* messageDrop = MessageDrop::instance();
0459       messageDrop->setSinglet(state);  // Change Log 17
0460       messageDrop->debugEnabled = nonModule_debugEnabled;
0461       messageDrop->infoEnabled = nonModule_infoEnabled;
0462       messageDrop->warningEnabled = nonModule_warningEnabled;
0463       messageDrop->errorEnabled = nonModule_errorEnabled;  // change log 20
0464     }
0465 
0466     void MessageLogger::unEstablishModule(ModuleCallingContext const& mod, const char* state) {
0467       //Need to reset to what was previously being used on this thread
0468       auto previous = mod.previousModuleOnThread();
0469       if (previous) {
0470         //need to know if we are in a global or stream context
0471         auto top = previous->getTopModuleCallingContext();
0472         assert(nullptr != top);
0473         if (ParentContext::Type::kGlobal == top->type()) {
0474           auto globalContext = top->globalContext();
0475           assert(nullptr != globalContext);
0476           auto tran = globalContext->transition();
0477           if (tran == GlobalContext::Transition::kBeginLuminosityBlock or
0478               tran == GlobalContext::Transition::kEndLuminosityBlock) {
0479             establishModule(lumiInfoBegin_ + globalContext->luminosityBlockIndex(),
0480                             *previous,
0481                             s_globalTransitionNames[static_cast<int>(tran)]);
0482           } else if (tran == GlobalContext::Transition::kBeginRun or tran == GlobalContext::Transition::kEndRun) {
0483             establishModule(
0484                 runInfoBegin_ + globalContext->runIndex(), *previous, s_globalTransitionNames[static_cast<int>(tran)]);
0485           } else if (tran == GlobalContext::Transition::kBeginProcessBlock ||
0486                      tran == GlobalContext::Transition::kAccessInputProcessBlock ||
0487                      tran == GlobalContext::Transition::kEndProcessBlock) {
0488             establishModule(processBlockInfoBegin_, *previous, s_globalTransitionNames[static_cast<int>(tran)]);
0489           } else {
0490             MessageDrop* messageDrop = MessageDrop::instance();
0491             messageDrop->streamID = std::numeric_limits<unsigned int>::max();
0492             messageDrop->setSinglet("unknown context");
0493             MessageDrop::instance()->runEvent = "";
0494             messageDrop->debugEnabled = nonModule_debugEnabled;
0495             messageDrop->infoEnabled = nonModule_infoEnabled;
0496             messageDrop->warningEnabled = nonModule_warningEnabled;
0497             messageDrop->errorEnabled = nonModule_errorEnabled;
0498           }
0499         } else {
0500           auto stream = previous->getStreamContext();
0501           establishModule(
0502               stream->streamID().value(), *previous, s_streamTransitionNames[static_cast<int>(stream->transition())]);
0503         }
0504       } else {
0505         MessageDrop* messageDrop = MessageDrop::instance();
0506         messageDrop->streamID = std::numeric_limits<unsigned int>::max();
0507         messageDrop->setSinglet(state);  // Change Log 17
0508         messageDrop->debugEnabled = nonModule_debugEnabled;
0509         messageDrop->infoEnabled = nonModule_infoEnabled;
0510         messageDrop->warningEnabled = nonModule_warningEnabled;
0511         messageDrop->errorEnabled = nonModule_errorEnabled;  // change log 20
0512       }
0513 
0514       // std::cerr << "unestablishModule( " << desc.moduleName() << ") "
0515       //           << "state = " << *state << "\n";
0516     }
0517 
0518     void MessageLogger::establish(const char* state) {
0519       MessageDrop* messageDrop = MessageDrop::instance();
0520       messageDrop->setSinglet(state);  // Change Log 17
0521       if (!anyDebugEnabled_) {
0522         messageDrop->debugEnabled = false;
0523       } else if (everyDebugEnabled_) {
0524         messageDrop->debugEnabled = true;
0525       } else {
0526         messageDrop->debugEnabled = debugEnabledModules_.count(state);  // change log 8
0527       }
0528       std::map<const std::string, ELseverityLevel>::const_iterator it =
0529           suppression_levels_.find(state);  // change log 8
0530       if (it != suppression_levels_.end()) {
0531         messageDrop->debugEnabled = messageDrop->debugEnabled && (it->second < ELseverityLevel::ELsev_success);
0532         messageDrop->infoEnabled = (it->second < ELseverityLevel::ELsev_info);
0533         messageDrop->fwkInfoEnabled = (it->second < ELseverityLevel::ELsev_fwkInfo);
0534         messageDrop->warningEnabled = (it->second < ELseverityLevel::ELsev_warning);
0535         messageDrop->errorEnabled = (it->second < ELseverityLevel::ELsev_error);
0536       } else {
0537         messageDrop->infoEnabled = true;
0538         messageDrop->fwkInfoEnabled = true;
0539         messageDrop->warningEnabled = true;
0540         messageDrop->errorEnabled = true;
0541       }
0542     }
0543 
0544     void MessageLogger::unEstablish(const char* state) {
0545       MessageDrop::instance()->setSinglet(state);  // Change Log 17
0546     }
0547 
0548     //
0549     // callbacks that need to establish the module, and their counterparts
0550     //
0551 
0552     void MessageLogger::preModuleConstruction(const ModuleDescription& desc) {
0553       if (!messageServicePSetHasBeenValidated_) {  // change log 12
0554         if (!messageServicePSetValidatationResults_.empty()) {
0555           throw(edm::Exception(edm::errors::Configuration, messageServicePSetValidatationResults_));
0556         }
0557         messageServicePSetHasBeenValidated_ = true;
0558       }
0559       establishModule(desc, "@ctor");  // ChangeLog 16
0560     }
0561     //it is now guaranteed that this will be called even if the module throws
0562     void MessageLogger::postModuleConstruction(const ModuleDescription& iDescription) {
0563       unEstablishModule(iDescription, "AfterModConstruction");
0564     }
0565 
0566     void MessageLogger::preModuleDestruction(const ModuleDescription& desc) { establishModule(desc, "@dtor"); }
0567     //it is guaranteed that this will be called even if the module throws
0568     void MessageLogger::postModuleDestruction(const ModuleDescription& iDescription) {
0569       unEstablishModule(iDescription, "AfterModDestruction");
0570     }
0571 
0572     void MessageLogger::preModuleBeginJob(const ModuleDescription& desc) {
0573       establishModule(desc, "@beginJob");  // ChangeLog 13
0574     }
0575     void MessageLogger::postModuleBeginJob(const ModuleDescription& iDescription) {
0576       unEstablishModule(iDescription, "AfterModBeginJob");
0577     }
0578 
0579     void MessageLogger::preSourceConstruction(const ModuleDescription& desc) {
0580       if (!messageServicePSetHasBeenValidated_) {  // change log 12
0581         if (!messageServicePSetValidatationResults_.empty()) {
0582           throw(edm::Exception(edm::errors::Configuration, messageServicePSetValidatationResults_));
0583         }
0584         messageServicePSetHasBeenValidated_ = true;
0585       }
0586       establishModule(desc, "@sourceConstruction");  // ChangeLog 16
0587     }
0588     void MessageLogger::postSourceConstruction(const ModuleDescription& iDescription) {
0589       unEstablishModule(iDescription, "AfterSourceConstruction");
0590     }
0591 
0592     void MessageLogger::preModuleBeginStream(StreamContext const& stream, ModuleCallingContext const& mcc) {
0593       ModuleDescription const& desc = *mcc.moduleDescription();
0594       establishModule(desc, "@beginStream");  // ChangeLog 13
0595     }
0596     void MessageLogger::postModuleBeginStream(StreamContext const& stream, ModuleCallingContext const& mcc) {
0597       ModuleDescription const& desc = *mcc.moduleDescription();
0598       unEstablishModule(desc, "AfterModBeginStream");
0599     }
0600 
0601     void MessageLogger::preModuleStreamBeginRun(StreamContext const& stream, ModuleCallingContext const& mod) {
0602       establishModule(stream.streamID().value(),
0603                       mod,
0604                       s_streamTransitionNames[static_cast<int>(StreamContext::Transition::kBeginRun)]);
0605     }
0606     void MessageLogger::postModuleStreamBeginRun(StreamContext const& stream, ModuleCallingContext const& mod) {
0607       unEstablishModule(mod, "AfterModStreamBeginRun");
0608     }
0609 
0610     void MessageLogger::preModuleStreamBeginLumi(StreamContext const& stream, ModuleCallingContext const& mod) {
0611       establishModule(stream.streamID().value(),
0612                       mod,
0613                       s_streamTransitionNames[static_cast<int>(StreamContext::Transition::kBeginLuminosityBlock)]);
0614     }
0615     void MessageLogger::postModuleStreamBeginLumi(StreamContext const& stream, ModuleCallingContext const& mod) {
0616       unEstablishModule(mod, "AfterModStreamBeginLumi");
0617     }
0618 
0619     void MessageLogger::preModuleEvent(StreamContext const& stream, ModuleCallingContext const& mod) {
0620       establishModule(
0621           stream.streamID().value(), mod, s_streamTransitionNames[static_cast<int>(StreamContext::Transition::kEvent)]);
0622     }
0623 
0624     void MessageLogger::postModuleEvent(StreamContext const& stream, ModuleCallingContext const& mod) {
0625       unEstablishModule(mod, "PostModuleEvent");
0626     }
0627 
0628     void MessageLogger::preModuleEventAcquire(StreamContext const& stream, ModuleCallingContext const& mod) {
0629       establishModule(
0630           stream.streamID().value(), mod, s_streamTransitionNames[static_cast<int>(StreamContext::Transition::kEvent)]);
0631     }
0632 
0633     void MessageLogger::postModuleEventAcquire(StreamContext const& stream, ModuleCallingContext const& mod) {
0634       unEstablishModule(mod, "PostModuleEventAcquire");
0635     }
0636 
0637     void MessageLogger::preModuleStreamEndLumi(StreamContext const& stream, ModuleCallingContext const& mod) {
0638       establishModule(stream.streamID().value(),
0639                       mod,
0640                       s_streamTransitionNames[static_cast<int>(StreamContext::Transition::kEndLuminosityBlock)]);
0641     }
0642     void MessageLogger::postModuleStreamEndLumi(StreamContext const& stream, ModuleCallingContext const& mod) {
0643       unEstablishModule(mod, "AfterModStreamEndLumi");
0644     }
0645 
0646     void MessageLogger::preModuleStreamEndRun(StreamContext const& stream, ModuleCallingContext const& mod) {
0647       establishModule(stream.streamID().value(),
0648                       mod,
0649                       s_streamTransitionNames[static_cast<int>(StreamContext::Transition::kEndRun)]);  // ChangeLog 13
0650     }
0651     void MessageLogger::postModuleStreamEndRun(StreamContext const& stream, ModuleCallingContext const& mod) {
0652       unEstablishModule(mod, "AfterModStreamEndRun");
0653     }
0654 
0655     //Global
0656 
0657     void MessageLogger::preModuleBeginProcessBlock(GlobalContext const&, ModuleCallingContext const& mod) {
0658       establishModule(processBlockInfoBegin_,
0659                       mod,
0660                       s_globalTransitionNames[static_cast<int>(GlobalContext::Transition::kBeginProcessBlock)]);
0661     }
0662 
0663     void MessageLogger::postModuleBeginProcessBlock(GlobalContext const&, ModuleCallingContext const& mod) {
0664       unEstablishModule(mod, "AfterModBeginProcessBlock");
0665     }
0666 
0667     void MessageLogger::preModuleAccessInputProcessBlock(GlobalContext const&, ModuleCallingContext const& mod) {
0668       establishModule(processBlockInfoBegin_,
0669                       mod,
0670                       s_globalTransitionNames[static_cast<int>(GlobalContext::Transition::kAccessInputProcessBlock)]);
0671     }
0672 
0673     void MessageLogger::postModuleAccessInputProcessBlock(GlobalContext const&, ModuleCallingContext const& mod) {
0674       unEstablishModule(mod, "AfterModAccessInputProcessBlock");
0675     }
0676 
0677     void MessageLogger::preModuleEndProcessBlock(GlobalContext const&, ModuleCallingContext const& mod) {
0678       establishModule(processBlockInfoBegin_,
0679                       mod,
0680                       s_globalTransitionNames[static_cast<int>(GlobalContext::Transition::kEndProcessBlock)]);
0681     }
0682 
0683     void MessageLogger::postModuleEndProcessBlock(GlobalContext const&, ModuleCallingContext const& mod) {
0684       unEstablishModule(mod, "AfterModEndProcessBlock");
0685     }
0686 
0687     void MessageLogger::preModuleGlobalBeginRun(GlobalContext const& context, ModuleCallingContext const& mod) {
0688       establishModule(runInfoBegin_ + context.runIndex().value(),
0689                       mod,
0690                       s_globalTransitionNames[static_cast<int>(GlobalContext::Transition::kBeginRun)]);
0691     }
0692     void MessageLogger::postModuleGlobalBeginRun(GlobalContext const& context, ModuleCallingContext const& mod) {
0693       unEstablishModule(mod, "AfterModGlobalBeginRun");
0694     }
0695 
0696     void MessageLogger::preModuleGlobalBeginLumi(GlobalContext const& context, ModuleCallingContext const& mod) {
0697       establishModule(lumiInfoBegin_ + context.luminosityBlockIndex().value(),
0698                       mod,
0699                       s_globalTransitionNames[static_cast<int>(GlobalContext::Transition::kBeginLuminosityBlock)]);
0700     }
0701     void MessageLogger::postModuleGlobalBeginLumi(GlobalContext const& stream, ModuleCallingContext const& mod) {
0702       unEstablishModule(mod, "AfterModGlobalBeginLumi");
0703     }
0704 
0705     void MessageLogger::preModuleGlobalEndLumi(GlobalContext const& context, ModuleCallingContext const& mod) {
0706       establishModule(lumiInfoBegin_ + context.luminosityBlockIndex().value(),
0707                       mod,
0708                       s_globalTransitionNames[static_cast<int>(GlobalContext::Transition::kEndLuminosityBlock)]);
0709     }
0710     void MessageLogger::postModuleGlobalEndLumi(GlobalContext const& stream, ModuleCallingContext const& mod) {
0711       unEstablishModule(mod, "AfterModGlobalEndLumi");
0712     }
0713 
0714     void MessageLogger::preModuleWriteLumi(GlobalContext const& context, ModuleCallingContext const& mod) {
0715       establishModule(lumiInfoBegin_ + context.luminosityBlockIndex().value(),
0716                       mod,
0717                       s_globalTransitionNames[static_cast<int>(GlobalContext::Transition::kWriteLuminosityBlock)]);
0718     }
0719     void MessageLogger::postModuleWriteLumi(GlobalContext const& stream, ModuleCallingContext const& mod) {
0720       unEstablishModule(mod, "AfterModWriteLumi");
0721     }
0722 
0723     void MessageLogger::preModuleGlobalEndRun(GlobalContext const& context, ModuleCallingContext const& mod) {
0724       establishModule(runInfoBegin_ + context.runIndex().value(),
0725                       mod,
0726                       s_globalTransitionNames[static_cast<int>(GlobalContext::Transition::kEndRun)]);  // ChangeLog 13
0727     }
0728     void MessageLogger::postModuleGlobalEndRun(GlobalContext const& stream, ModuleCallingContext const& mod) {
0729       unEstablishModule(mod, "AfterModGlobalEndRun");
0730     }
0731 
0732     void MessageLogger::preModuleWriteRun(GlobalContext const& context, ModuleCallingContext const& mod) {
0733       establishModule(runInfoBegin_ + context.runIndex().value(),
0734                       mod,
0735                       s_globalTransitionNames[static_cast<int>(GlobalContext::Transition::kWriteRun)]);
0736     }
0737     void MessageLogger::postModuleWriteRun(GlobalContext const& stream, ModuleCallingContext const& mod) {
0738       unEstablishModule(mod, "AfterModWriteRun");
0739     }
0740 
0741     void MessageLogger::preModuleEndStream(StreamContext const&, ModuleCallingContext const& mcc) {
0742       ModuleDescription const& desc = *mcc.moduleDescription();
0743       establishModule(desc, "@endStream");  // ChangeLog 13
0744     }
0745 
0746     void MessageLogger::postModuleEndStream(StreamContext const&, ModuleCallingContext const& mcc) {
0747       ModuleDescription const& desc = *mcc.moduleDescription();
0748       unEstablishModule(desc, "AfterModEndStream");
0749     }
0750 
0751     void MessageLogger::preModuleEndJob(const ModuleDescription& desc) {
0752       establishModule(desc, "@endJob");  // ChangeLog 13
0753     }
0754     void MessageLogger::postModuleEndJob(const ModuleDescription& iDescription) {
0755       unEstablishModule(iDescription, "AfterModEndJob");
0756     }
0757 
0758     void MessageLogger::preESModule(eventsetup::EventSetupRecordKey const&, ESModuleCallingContext const& context) {
0759       MessageDrop* messageDrop = MessageDrop::instance();
0760       auto desc = context.componentDescription();
0761       // std::cerr << "establishModule( " << desc.moduleName() << ")\n";
0762       // Change Log 17
0763       auto label = &desc->label_;
0764       if (label->empty() or (*label)[0] == '\0') {
0765         label = &desc->type_;
0766       }
0767       //make sure ES module IDs do not conflict with ED module IDs
0768       messageDrop->setModuleWithPhase(desc->type_, *label, 1000000 + desc->id_, "@callESModule");
0769     }
0770     void MessageLogger::postESModule(eventsetup::EventSetupRecordKey const&, ESModuleCallingContext const&) {
0771       MessageDrop* messageDrop = MessageDrop::instance();
0772       messageDrop->setSinglet("@finishedCallESModule");  // Change Log 17
0773     }
0774     //
0775     // callbacks that don't know about the module
0776     //
0777 
0778     void MessageLogger::postBeginJob() {
0779       MessageDrop::instance()->runEvent = "BeforeEvents";
0780       MessageDrop::instance()->setSinglet("AfterBeginJob");  // Change Log 17
0781     }
0782 
0783     void MessageLogger::preSourceEvent(StreamID) {
0784       establish("source");
0785       MessageDrop::instance()->runEvent = "PreSource";
0786     }
0787     void MessageLogger::postSourceEvent(StreamID) {
0788       unEstablish("AfterSource");
0789       MessageDrop::instance()->runEvent = "AfterSource";
0790     }
0791     void MessageLogger::preSourceRunLumi() { establish("source"); }
0792     void MessageLogger::postSourceRunLumi() { unEstablish("AfterSource"); }
0793 
0794     void MessageLogger::preFile(std::string const&) { establish("file_open"); }
0795     void MessageLogger::preFileClose(std::string const&) { establish("file_close"); }
0796     void MessageLogger::postFile(std::string const&) { unEstablish("AfterFile"); }
0797 
0798     void MessageLogger::preEvent(StreamContext const& iContext) {
0799       assert(iContext.streamID().value() < transitionInfoCache_.size());
0800       auto& buffer = transitionInfoCache_[iContext.streamID().value()];
0801       auto const& id = iContext.eventID();
0802       auto v = fill_buffer(buffer, "Run: ", id.run(), " Event: ", id.event());
0803       edm::MessageDrop::instance()->runEvent = v;
0804       edm::MessageDrop::instance()->setSinglet("PreEventProcessing");  // changelog 17
0805           // Note - module name had not been set here  Similarly in other places where
0806           // RunEvent carries the new information; we add setSinglet for module name.
0807     }
0808 
0809     void MessageLogger::postEvent(StreamContext const& iContext) {
0810       edm::MessageDrop::instance()->runEvent = "PostProcessEvent";
0811       edm::clearLoggedErrorsSummary(iContext.streamID().value());
0812     }
0813 
0814     void MessageLogger::preStreamBeginRun(StreamContext const& iContext)  // change log 14
0815     {
0816       auto& buffer = transitionInfoCache_[iContext.streamID().value()];
0817       auto v = fill_buffer(buffer, "Run: ", iContext.eventID().run(), " Stream: ", iContext.streamID().value());
0818 
0819       edm::MessageDrop::instance()->runEvent = v;
0820       edm::MessageDrop::instance()->setSinglet("PreStreamBeginRun");  // changelog 17
0821     }
0822     void MessageLogger::postStreamBeginRun(StreamContext const&) {
0823       edm::MessageDrop::instance()->runEvent = "PostStreamBeginRun";
0824       edm::MessageDrop::instance()->setSinglet("PostStreamBeginRun");  // changelog 17
0825                                                                        // Note - module name had not been set here
0826     }
0827 
0828     void MessageLogger::preStreamEndRun(StreamContext const& iContext) {
0829       auto& buffer = transitionInfoCache_[iContext.streamID().value()];
0830       auto v = fill_buffer(buffer, "End Run: ", iContext.eventID().run(), " Stream: ", iContext.streamID().value());
0831 
0832       edm::MessageDrop::instance()->runEvent = v;
0833       edm::MessageDrop::instance()->setSinglet("PreStreamEndRun");  // changelog 17
0834     }
0835 
0836     void MessageLogger::postStreamEndRun(StreamContext const&) {
0837       edm::MessageDrop::instance()->runEvent = "PostStreamEndRun";
0838       edm::MessageDrop::instance()->setSinglet("PostStreaEndRun");  // changelog 17
0839     }
0840 
0841     void MessageLogger::preStreamBeginLumi(StreamContext const& iContext) {
0842       auto& buffer = transitionInfoCache_[iContext.streamID().value()];
0843       auto const& id = iContext.eventID();
0844       auto v = fill_buffer(
0845           buffer, "Run: ", id.run(), " Lumi: ", id.luminosityBlock(), " Stream: ", iContext.streamID().value());
0846       edm::MessageDrop::instance()->runEvent = v;
0847       edm::MessageDrop::instance()->setSinglet("PreStreamBeginLumi");  // changelog 17
0848     }
0849 
0850     void MessageLogger::postStreamBeginLumi(StreamContext const&) {
0851       edm::MessageDrop::instance()->runEvent = "PostStreamBeginLumi";
0852       edm::MessageDrop::instance()->setSinglet("PostStreamBeginLumi");  // changelog 17
0853     }
0854 
0855     void MessageLogger::preStreamEndLumi(StreamContext const& iContext) {
0856       auto& buffer = transitionInfoCache_[iContext.streamID().value()];
0857       auto const& id = iContext.eventID();
0858       auto v = fill_buffer(
0859           buffer, "Run: ", id.run(), " Lumi: ", id.luminosityBlock(), " Stream: ", iContext.streamID().value());
0860 
0861       edm::MessageDrop::instance()->runEvent = v;
0862       edm::MessageDrop::instance()->setSinglet("PreStreamEndLumi");  // changelog 17
0863     }
0864     void MessageLogger::postStreamEndLumi(StreamContext const&) {
0865       edm::MessageDrop::instance()->runEvent = "PostStreamEndLumi";
0866       edm::MessageDrop::instance()->setSinglet("PostStreamEndLumi");  // changelog 17
0867     }
0868 
0869     void MessageLogger::preBeginProcessBlock(GlobalContext const& gc) {
0870       auto& buffer = transitionInfoCache_[processBlockInfoBegin_];
0871       auto v = fill_buffer(buffer, "pre-events");
0872       edm::MessageDrop::instance()->runEvent = v;
0873       edm::MessageDrop::instance()->setSinglet("PreBeginProcessBlock");
0874     }
0875 
0876     void MessageLogger::postBeginProcessBlock(GlobalContext const& gc) {
0877       edm::MessageDrop::instance()->runEvent = "PostBeginProcessBlock";
0878       edm::MessageDrop::instance()->setSinglet("PostBeginProcessBlock");
0879     }
0880 
0881     void MessageLogger::preAccessInputProcessBlock(GlobalContext const& gc) {
0882       auto& buffer = transitionInfoCache_[processBlockInfoBegin_];
0883       auto v = fill_buffer(buffer, "pre-events");
0884       edm::MessageDrop::instance()->runEvent = v;
0885       edm::MessageDrop::instance()->setSinglet("PreAccessInputProcessBlock");
0886     }
0887 
0888     void MessageLogger::postAccessInputProcessBlock(GlobalContext const& gc) {
0889       edm::MessageDrop::instance()->runEvent = "PostAccessInputProcessBlock";
0890       edm::MessageDrop::instance()->setSinglet("PostAccessInputProcessBlock");
0891     }
0892 
0893     void MessageLogger::preEndProcessBlock(GlobalContext const& gc) {
0894       auto& buffer = transitionInfoCache_[processBlockInfoBegin_];
0895       auto v = fill_buffer(buffer, "post-events");
0896       edm::MessageDrop::instance()->runEvent = v;
0897       edm::MessageDrop::instance()->setSinglet("PreEndProcessBlock");
0898     }
0899 
0900     void MessageLogger::postEndProcessBlock(GlobalContext const& gc) {
0901       edm::MessageDrop::instance()->runEvent = "PostEndProcessBlock";
0902       edm::MessageDrop::instance()->setSinglet("PostEndProcessBlock");
0903     }
0904 
0905     void MessageLogger::preGlobalBeginRun(GlobalContext const& iContext)  // change log 14
0906     {
0907       auto& buffer = transitionInfoCache_[runInfoBegin_ + iContext.runIndex()];
0908       auto v = fill_buffer(buffer, "Run: ", iContext.luminosityBlockID().run());
0909       edm::MessageDrop::instance()->runEvent = v;
0910       edm::MessageDrop::instance()->setSinglet("PreGlobalBeginRun");  // changelog 17
0911     }
0912     void MessageLogger::postGlobalBeginRun(GlobalContext const&) {
0913       edm::MessageDrop::instance()->runEvent = "PostGlobalBeginRun";
0914       edm::MessageDrop::instance()->setSinglet("PostGlobalBeginRun");  // changelog 17
0915                                                                        // Note - module name had not been set here
0916     }
0917 
0918     void MessageLogger::prePathEvent(StreamContext const& stream, PathContext const& iPath)  // change log 14
0919     {
0920       auto messageDrop = edm::MessageDrop::instance();
0921       messageDrop->runEvent = transitionInfoCache_[stream.streamID().value()].begin();
0922       messageDrop->setPath("PreProcPath ", iPath.pathName());
0923       // change log 17
0924     }
0925 
0926     void MessageLogger::postPathEvent(StreamContext const&, PathContext const&, HLTPathStatus const&) {
0927       edm::MessageDrop::instance()->setSinglet("PostProcessPath");  // changelog 17
0928     }
0929 
0930     void MessageLogger::preGlobalEndRun(GlobalContext const& iContext) {
0931       auto& buffer = transitionInfoCache_[runInfoBegin_ + iContext.runIndex()];
0932       auto v = fill_buffer(buffer, "End Run: ", iContext.luminosityBlockID().run());
0933       edm::MessageDrop::instance()->runEvent = v;
0934       edm::MessageDrop::instance()->setSinglet("PreGlobalEndRun");  // changelog 17
0935     }
0936 
0937     void MessageLogger::postGlobalEndRun(GlobalContext const&) {
0938       edm::MessageDrop::instance()->runEvent = "PostGlobalEndRun";
0939       edm::MessageDrop::instance()->setSinglet("PostGlobalEndRun");  // changelog 17
0940     }
0941 
0942     void MessageLogger::preGlobalBeginLumi(GlobalContext const& iContext) {
0943       auto& buffer = transitionInfoCache_[lumiInfoBegin_ + iContext.luminosityBlockIndex()];
0944       auto const& id = iContext.luminosityBlockID();
0945       auto v = fill_buffer(buffer, "Run: ", id.run(), " Lumi: ", id.luminosityBlock());
0946       edm::MessageDrop::instance()->runEvent = v;
0947       edm::MessageDrop::instance()->setSinglet("PreGlobalBeginLumi");  // changelog 17
0948     }
0949 
0950     void MessageLogger::postGlobalBeginLumi(GlobalContext const&) {
0951       edm::MessageDrop::instance()->runEvent = "PostGlobalBeginLumi";
0952       edm::MessageDrop::instance()->setSinglet("PostGlobalBeginLumi");  // changelog 17
0953     }
0954 
0955     void MessageLogger::preGlobalEndLumi(GlobalContext const& iContext) {
0956       auto& buffer = transitionInfoCache_[lumiInfoBegin_ + iContext.luminosityBlockIndex()];
0957       auto const& id = iContext.luminosityBlockID();
0958       auto v = fill_buffer(buffer, "Run: ", id.run(), " Lumi: ", id.luminosityBlock());
0959       edm::MessageDrop::instance()->runEvent = v;
0960       edm::MessageDrop::instance()->setSinglet("PreGlobalEndLumi");  // changelog 17
0961     }
0962     void MessageLogger::postGlobalEndLumi(GlobalContext const&) {
0963       edm::MessageDrop::instance()->runEvent = "PostGlobalEndLumi";
0964       edm::MessageDrop::instance()->setSinglet("PostGlobalEndLumi");  // changelog 17
0965     }
0966 
0967     void MessageLogger::preEndJob() {
0968       edm::MessageDrop::instance()->runEvent = "EndJob";
0969       edm::MessageDrop::instance()->setSinglet("EndJob");  // changelog
0970     }
0971 
0972     void MessageLogger::postEndJob() {
0973       summarizeInJobReport();    // Put summary info into Job Rep  // change log 10
0974       MessageLoggerQ::MLqSUM();  // trigger summary info.       // change log 9
0975     }
0976 
0977     void MessageLogger::jobFailure() {
0978       MessageDrop* messageDrop = MessageDrop::instance();
0979       messageDrop->setSinglet("jobFailure");
0980       summarizeInJobReport();    // Put summary info into Job Rep  // change log 10
0981       MessageLoggerQ::MLqSUM();  // trigger summary info.       // change log 9
0982     }
0983 
0984     //
0985     // Other methods
0986     //
0987 
0988     void MessageLogger::summarizeInJobReport() {
0989       if (fjrSummaryRequested_) {
0990         std::map<std::string, double>* smp = new std::map<std::string, double>();
0991         MessageLoggerQ::MLqJRS(smp);
0992         Service<JobReport> reportSvc;
0993         reportSvc->reportMessageInfo(*smp);
0994         delete smp;
0995       }
0996     }
0997 
0998   }  // end of namespace service
0999 }  // 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!