Inheritance diagram for edm::service::InitRootHandlers:

Classes
class	ThreadTracker

Public Member Functions
	InitRootHandlers (ParameterSet const &pset, ActivityRegistry &iReg)

	~InitRootHandlers () override

Public Member Functions inherited from edm::RootHandlers
template<typename F >
void	ignoreWarningsWhileDoing (F iFunc, SeverityLevel level=SeverityLevel::kWarning)

virtual	~RootHandlers ()

Static Public Member Functions
static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	stacktraceFromThread ()

static int	stackTracePause ()

static const ThreadTracker::Container_type &	threadIDs ()

Static Public Attributes
static std::atomic< std::size_t >	doneModules_

static std::vector< std::array< char, moduleBufferSize > >	moduleListBuffers_

static std::atomic< std::size_t >	nextModule_

Private Member Functions
void	cachePidInfo ()

void	enableWarnings_ () override

void	ignoreWarnings_ (edm::RootHandlers::SeverityLevel level) override

void	willBeUsingThreads () override

Static Private Member Functions
static char const	getPstackArgv ()

static void	stacktraceHelperThread ()

Private Attributes
bool	autoLibraryLoader_

bool	loadAllDictionaries_

bool	resetErrHandler_

std::shared_ptr< const void >	sigAbrtHandler_

std::shared_ptr< const void >	sigBusHandler_

std::shared_ptr< const void >	sigIllHandler_

std::shared_ptr< const void >	sigSegvHandler_

std::shared_ptr< const void >	sigTermHandler_

bool	unloadSigHandler_

Static Private Attributes
static int	childToParent_ [2] = {-1, -1}

static std::unique_ptr< std::thread >	helperThread_

static int	parentToChild_ [2] = {-1, -1}

static char	pidString_ [pidStringLength_] = {}

static const int	pidStringLength_ = 200

static char *const	pstackArgv_ [] = {pstackName, dashC, InitRootHandlers::pidString_, 0 }

static int	stackTracePause_ = 300

static ThreadTracker	threadTracker_

Friends
int	cmssw_stacktrace (void *)

Additional Inherited Members
Public Types inherited from edm::RootHandlers
enum	SeverityLevel { SeverityLevel::kInfo, SeverityLevel::kWarning, SeverityLevel::kError, SeverityLevel::kSysError, SeverityLevel::kFatal }

Detailed Description

Definition at line 68 of file InitRootHandlers.cc.

Constructor & Destructor Documentation

edm::service::InitRootHandlers::InitRootHandlers	(	ParameterSet const &	pset,
		ActivityRegistry &	iReg
	)

explicit

Definition at line 747 of file InitRootHandlers.cc.

References autoLibraryLoader_, edm::TypeWithDict::byName(), cachePidInfo(), UEAnalysisJets_cfi::debugLevel, edm::ParameterSet::getUntrackedParameter(), edm::hasDictionary(), edm::installCustomHandler(), edm::service::SystemBounds::maxNumberOfThreads(), moduleListBuffers_, resetErrHandler_, edm::setRefCoreStreamerInTClass(), sigAbrtHandler_, sigBusHandler_, sigIllHandler_, sigSegvHandler_, sigTermHandler_, stackTracePause_, unloadSigHandler_, and edm::ActivityRegistry::watchPreallocate().

         : RootHandlers(),
           unloadSigHandler_(pset.getUntrackedParameter<bool>("UnloadRootSigHandler")),
           resetErrHandler_(pset.getUntrackedParameter<bool>("ResetRootErrHandler")),
           loadAllDictionaries_(pset.getUntrackedParameter<bool>("LoadAllDictionaries")),
           autoLibraryLoader_(loadAllDictionaries_ or pset.getUntrackedParameter<bool>("AutoLibraryLoader")) {
       stackTracePause_ = pset.getUntrackedParameter<int>("StackTracePauseTime");
 
       if (unloadSigHandler_) {
         // Deactivate all the Root signal handlers and restore the system defaults
         gSystem->ResetSignal(kSigChild);
         gSystem->ResetSignal(kSigBus);
         gSystem->ResetSignal(kSigSegmentationViolation);
         gSystem->ResetSignal(kSigIllegalInstruction);
         gSystem->ResetSignal(kSigSystem);
         gSystem->ResetSignal(kSigPipe);
         gSystem->ResetSignal(kSigAlarm);
         gSystem->ResetSignal(kSigUrgent);
         gSystem->ResetSignal(kSigFloatingException);
         gSystem->ResetSignal(kSigWindowChanged);
       } else if (pset.getUntrackedParameter<bool>("AbortOnSignal")) {
         cachePidInfo();
 
         //NOTE: ROOT can also be told to abort on these kinds of problems BUT
         // it requires an TApplication to be instantiated which causes problems
         gSystem->ResetSignal(kSigBus);
         gSystem->ResetSignal(kSigSegmentationViolation);
         gSystem->ResetSignal(kSigIllegalInstruction);
         installCustomHandler(SIGBUS, sig_dostack_then_abort);
         sigBusHandler_ = std::shared_ptr<const void>(nullptr, [](void*) { installCustomHandler(SIGBUS, sig_abort); });
         installCustomHandler(SIGSEGV, sig_dostack_then_abort);
         sigSegvHandler_ = std::shared_ptr<const void>(nullptr, [](void*) { installCustomHandler(SIGSEGV, sig_abort); });
         installCustomHandler(SIGILL, sig_dostack_then_abort);
         sigIllHandler_ = std::shared_ptr<const void>(nullptr, [](void*) { installCustomHandler(SIGILL, sig_abort); });
         installCustomHandler(SIGTERM, sig_dostack_then_abort);
         sigTermHandler_ = std::shared_ptr<const void>(nullptr, [](void*) { installCustomHandler(SIGTERM, sig_abort); });
         installCustomHandler(SIGABRT, sig_dostack_then_abort);
         sigAbrtHandler_ = std::shared_ptr<const void>(nullptr, [](void*) {
           signal(SIGABRT, SIG_DFL);  // release SIGABRT to default
         });
       }
 
       iReg.watchPreallocate([](edm::service::SystemBounds const& iBounds) {
         if (iBounds.maxNumberOfThreads() > moduleListBuffers_.size()) {
           moduleListBuffers_.resize(iBounds.maxNumberOfThreads());
         }
       });
 
       if (resetErrHandler_) {
         // Replace the Root error handler with one that uses the MessageLogger
         SetErrorHandler(RootErrorHandler);
       }
 
       // Enable automatic Root library loading.
       if (autoLibraryLoader_) {
         gInterpreter->SetClassAutoloading(1);
       }
 
       // Set ROOT parameters.
       TTree::SetMaxTreeSize(kMaxLong64);
       TH1::AddDirectory(kFALSE);
       //G__SetCatchException(0);
 
       // Set custom streamers
       setRefCoreStreamerInTClass();
 
       // Load the library containing dictionaries for std:: classes, if not already loaded.
       if (!hasDictionary(typeid(std::vector<std::vector<unsigned int>>))) {
         TypeWithDict::byName("std::vector<std::vector<unsigned int> >");
       }
 
       int debugLevel = pset.getUntrackedParameter<int>("DebugLevel");
       if (debugLevel > 0) {
         gDebug = debugLevel;
       }
 
       // Enable Root implicit multi-threading
       bool imt = pset.getUntrackedParameter<bool>("EnableIMT");
       if (imt && not ROOT::IsImplicitMTEnabled()) {
         ROOT::EnableImplicitMT();
       }
     }

edm::service::InitRootHandlers::~InitRootHandlers ( )

override

Definition at line 830 of file InitRootHandlers.cc.

References f, and haddnano::obj.

                                         {
       // close all open ROOT files
       TIter iter(gROOT->GetListOfFiles());
       TObject* obj = nullptr;
       while (nullptr != (obj = iter.Next())) {
         TFile* f = dynamic_cast<TFile*>(obj);
         if (f) {
           // We get a new iterator each time,
           // because closing a file can invalidate the iterator
           f->Close();
           iter = TIter(gROOT->GetListOfFiles());
         }
       }
     }

Member Function Documentation

void edm::service::InitRootHandlers::cachePidInfo ( )

private

Definition at line 884 of file InitRootHandlers.cc.

References childToParent_, helperThread_, edm::errors::OtherCMS, parentToChild_, pidString_, pidStringLength_, and stacktraceHelperThread().

Referenced by InitRootHandlers().

                                         {
       if (helperThread_) {
         //Another InitRootHandlers was initialized in this job, possibly
         // because multiple EventProcessors are being used.
         //In that case, we are already all setup
         return;
       }
       if (snprintf(pidString_,
                    pidStringLength_ - 1,
                    "date; gdb -quiet -p %d 2>&1 <<EOF |\n"
                    "set width 0\n"
                    "set height 0\n"
                    "set pagination no\n"
                    "thread apply all bt\n"
                    "EOF\n"
                    "/bin/sed -n -e 's/^\\((gdb) \\)*//' -e '/^#/p' -e '/^Thread/p'",
                    getpid()) >= pidStringLength_) {
         std::ostringstream sstr;
         sstr << "Unable to pre-allocate stacktrace handler information";
         edm::Exception except(edm::errors::OtherCMS, sstr.str());
         throw except;
       }
 
       // These are initialized to -1; harmless to close an invalid FD.
       // If this is called post-fork, we don't want to be communicating on
       // these FDs as they are used internally by the parent.
       close(childToParent_[0]);
       close(childToParent_[1]);
       childToParent_[0] = -1;
       childToParent_[1] = -1;
       close(parentToChild_[0]);
       close(parentToChild_[1]);
       parentToChild_[0] = -1;
       parentToChild_[1] = -1;
 
       if (-1 == pipe2(childToParent_, O_CLOEXEC)) {
         std::ostringstream sstr;
         sstr << "Failed to create child-to-parent pipes (errno=" << errno << "): " << strerror(errno);
         edm::Exception except(edm::errors::OtherCMS, sstr.str());
         throw except;
       }
 
       if (-1 == pipe2(parentToChild_, O_CLOEXEC)) {
         close(childToParent_[0]);
         close(childToParent_[1]);
         childToParent_[0] = -1;
         childToParent_[1] = -1;
         std::ostringstream sstr;
         sstr << "Failed to create child-to-parent pipes (errno=" << errno << "): " << strerror(errno);
         edm::Exception except(edm::errors::OtherCMS, sstr.str());
         throw except;
       }
 
       helperThread_.reset(new std::thread(stacktraceHelperThread));
       helperThread_->detach();
     }

void edm::service::InitRootHandlers::enableWarnings_ ( )

overrideprivatevirtual

Implements edm::RootHandlers.

Definition at line 880 of file InitRootHandlers.cc.

References edm::RootHandlers::kInfo.

880 { s_ignoreWarnings = edm::RootHandlers::SeverityLevel::kInfo; }

edm::RootHandlers::SeverityLevel::kInfo

void edm::service::InitRootHandlers::fillDescriptions ( ConfigurationDescriptions & descriptions )

static

Definition at line 856 of file InitRootHandlers.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::addUntracked(), and edm::ParameterSetDescription::setComment().

                                                                                    {
       ParameterSetDescription desc;
       desc.setComment("Centralized interface to ROOT.");
       desc.addUntracked<bool>("UnloadRootSigHandler", false)
           ->setComment("If True, signals are handled by this service, rather than by ROOT.");
       desc.addUntracked<bool>("ResetRootErrHandler", true)
           ->setComment(
               "If True, ROOT messages (e.g. errors, warnings) are handled by this service, rather than by ROOT.");
       desc.addUntracked<bool>("AutoLibraryLoader", true)
           ->setComment("If True, enables automatic loading of data dictionaries.");
       desc.addUntracked<bool>("LoadAllDictionaries", false)->setComment("If True, loads all ROOT dictionaries.");
       desc.addUntracked<bool>("EnableIMT", true)->setComment("If True, calls ROOT::EnableImplicitMT().");
       desc.addUntracked<bool>("AbortOnSignal", true)
           ->setComment(
               "If True, do an abort when a signal occurs that causes a crash. If False, ROOT will do an exit which "
               "attempts to do a clean shutdown.");
       desc.addUntracked<int>("DebugLevel", 0)->setComment("Sets ROOT's gDebug value.");
       desc.addUntracked<int>("StackTracePauseTime", 300)
           ->setComment("Seconds to pause other threads during stack trace.");
       descriptions.add("InitRootHandlers", desc);
     }

char *const * edm::service::InitRootHandlers::getPstackArgv ( )

staticprivate

Definition at line 878 of file InitRootHandlers.cc.

References pstackArgv_.

Referenced by edm::service::cmssw_stacktrace().

878 { return pstackArgv_; }

edm::service::InitRootHandlers::pstackArgv_

static char *const pstackArgv_[]

Definition: InitRootHandlers.cc:114

void edm::service::InitRootHandlers::ignoreWarnings_ ( edm::RootHandlers::SeverityLevel level )

overrideprivatevirtual

Implements edm::RootHandlers.

Definition at line 882 of file InitRootHandlers.cc.

References hcalDigis_cfi::level.

882 { s_ignoreWarnings = level; }

hcalDigis_cfi.level

level

Definition: hcalDigis_cfi.py:18

void edm::service::InitRootHandlers::stacktraceFromThread ( )

static

Definition at line 666 of file InitRootHandlers.cc.

References childToParent_, parentToChild_, and mps_fire::result.

Referenced by edm::service::isProcessWideService().

                                                 {
       int result = full_write(parentToChild_[1], "1");
       if (result < 0) {
         full_cerr_write("\n\nAttempt to request stacktrace failed: ");
         full_cerr_write(strerror(-result));
         full_cerr_write("\n");
         return;
       }
       char buf[2];
       buf[1] = '\0';
       if ((result = full_read(childToParent_[0], buf, 1, 5 * 60)) < 0) {
         full_cerr_write("\n\nWaiting for stacktrace completion failed: ");
         if (result == -ETIMEDOUT) {
           full_cerr_write("timed out waiting for GDB to complete.");
         } else {
           full_cerr_write(strerror(-result));
         }
         full_cerr_write("\n");
         return;
       }
     }

void edm::service::InitRootHandlers::stacktraceHelperThread ( )

staticprivate

Definition at line 623 of file InitRootHandlers.cc.

References childToParent_, edm::service::cmssw_stacktrace_fork(), parentToChild_, and mps_fire::result.

Referenced by cachePidInfo().

                                                   {
       int toParent = childToParent_[1];
       int fromParent = parentToChild_[0];
       char buf[2];
       buf[1] = '\0';
 
       while (true) {
         int result = full_read(fromParent, buf, 1);
         if (result < 0) {
           // To avoid a deadlock (this function is NOT re-entrant), reset signals
           // We never set them back to the CMSSW handler because we assume the parent
           // thread will abort for us.
           set_default_signals();
           close(toParent);
           full_cerr_write("\n\nTraceback helper thread failed to read from parent: ");
           full_cerr_write(strerror(-result));
           full_cerr_write("\n");
           ::abort();
         }
         if (buf[0] == '1') {
           set_default_signals();
           cmssw_stacktrace_fork();
           full_write(toParent, buf);
         } else if (buf[0] == '2') {
           // We have just finished forking.  Reload the file descriptors for thread
           // communication.
           close(toParent);
           close(fromParent);
           toParent = childToParent_[1];
           fromParent = parentToChild_[0];
         } else if (buf[0] == '3') {
           break;
         } else {
           set_default_signals();
           close(toParent);
           full_cerr_write("\n\nTraceback helper thread got unknown command from parent: ");
           full_cerr_write(buf);
           full_cerr_write("\n");
           ::abort();
         }
       }
     }

static int edm::service::InitRootHandlers::stackTracePause ( )

inlinestatic

Definition at line 98 of file InitRootHandlers.cc.

References stackTracePause_.

Referenced by edm::service::isProcessWideService().

98 { return stackTracePause_; }

edm::service::InitRootHandlers::stackTracePause_

static int stackTracePause_

Definition: InitRootHandlers.cc:119

static const ThreadTracker::Container_type& edm::service::InitRootHandlers::threadIDs ( )

inlinestatic

Definition at line 97 of file InitRootHandlers.cc.

References edm::service::InitRootHandlers::ThreadTracker::IDs(), and threadTracker_.

Referenced by edm::service::isProcessWideService().

97 { return threadTracker_.IDs(); }

edm::service::InitRootHandlers::threadTracker_

static ThreadTracker threadTracker_

Definition: InitRootHandlers.cc:118

edm::service::InitRootHandlers::ThreadTracker::IDs

const Container_type & IDs()

Definition: InitRootHandlers.cc:86

void edm::service::InitRootHandlers::willBeUsingThreads ( )

overrideprivatevirtual

Implements edm::RootHandlers.

Definition at line 845 of file InitRootHandlers.cc.

                                               {
       //Tell Root we want to be multi-threaded
       ROOT::EnableThreadSafety();
 
       //When threading, also have to keep ROOT from logging all TObjects into a list
       TObject::SetObjectStat(false);
 
       //Have to avoid having Streamers modify themselves after they have been used
       TVirtualStreamerInfo::Optimize(false);
     }

Friends And Related Function Documentation

int cmssw_stacktrace ( void * )

friend

Definition at line 719 of file InitRootHandlers.cc.

Referenced by edm::service::isProcessWideService().

                                   {
       set_default_signals();
 
       char* const* argv = edm::service::InitRootHandlers::getPstackArgv();
       // NOTE: this is NOT async-signal-safe at CERN's lxplus service.
       // CERN uses LD_PRELOAD to replace execv with a function from libsnoopy which
       // calls dlsym.
 #ifdef __linux__
       syscall(SYS_execve, "/bin/sh", argv, __environ);
 #else
       execv("/bin/sh", argv);
 #endif
       ::abort();
       return 1;
     }