#include <InitRootHandlers.h>

Inheritance diagram for edm::service::InitRootHandlers:

Public Member Functions
	InitRootHandlers (ParameterSet const &pset)

virtual	~InitRootHandlers ()

Public Member Functions inherited from edm::RootHandlers
template<typename F >
void	ignoreWarningsWhileDoing (F iFunc)

	RootHandlers ()

virtual	~RootHandlers ()

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

Private Member Functions
virtual void	enableWarnings_ () override

virtual void	ignoreWarnings_ () override

virtual void	initializeThisThreadForUse () override

virtual void	willBeUsingThreads () override

Private Attributes
bool	autoLibraryLoader_

bool	loadAllDictionaries_

bool	resetErrHandler_

std::shared_ptr< const void >	sigBusHandler_

std::shared_ptr< const void >	sigIllHandler_

std::shared_ptr< const void >	sigSegvHandler_

bool	unloadSigHandler_

Detailed Description

Definition at line 12 of file InitRootHandlers.h.

Constructor & Destructor Documentation

edm::service::InitRootHandlers::InitRootHandlers ( ParameterSet const & pset )

explicit

Definition at line 219 of file InitRootHandlers.cc.

References autoLibraryLoader_, edm::dictionaryPlugInPrefix(), edm::RootAutoLibraryLoader::enable(), edmplugin::PluginCapabilities::get(), edm::ParameterSet::getUntrackedParameter(), edm::installCustomHandler(), edmplugin::PluginCapabilities::load(), edm::RootAutoLibraryLoader::loadAll(), loadAllDictionaries_, resetErrHandler_, edm::setRefCoreStreamer(), sigBusHandler_, sigIllHandler_, sigSegvHandler_, and unloadSigHandler_.

       : RootHandlers(),
         unloadSigHandler_(pset.getUntrackedParameter<bool> ("UnloadRootSigHandler")),
         resetErrHandler_(pset.getUntrackedParameter<bool> ("ResetRootErrHandler")),
         loadAllDictionaries_(pset.getUntrackedParameter<bool>("LoadAllDictionaries")),
         autoLibraryLoader_(loadAllDictionaries_ or pset.getUntrackedParameter<bool> ("AutoLibraryLoader"))
     {
       
       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")){
         //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);
         });
       }
 
       if(resetErrHandler_) {
 
       // Replace the Root error handler with one that uses the MessageLogger
         SetErrorHandler(RootErrorHandler);
       }
 
       // Enable automatic Root library loading.
       if(autoLibraryLoader_) {
         RootAutoLibraryLoader::enable();
         if(loadAllDictionaries_) {
           RootAutoLibraryLoader::loadAll();
         }
       }
 
       // Enable Cintex.
       ROOT::Cintex::Cintex::Enable();
 
       // Set ROOT parameters.
       TTree::SetMaxTreeSize(kMaxLong64);
       TH1::AddDirectory(kFALSE);
       G__SetCatchException(0);
 
       // Set custom streamers
       setRefCoreStreamer();
 
       // Load the library containing dictionaries for std:: classes, if not already loaded.
       if (!TypeWithDict(typeid(std::vector<std::vector<unsigned int> >)).hasDictionary()) {
          edmplugin::PluginCapabilities::get()->load(dictionaryPlugInPrefix() + "std::vector<std::vector<unsigned int> >");
       }
 
       int debugLevel = pset.getUntrackedParameter<int>("DebugLevel");
       if(debugLevel >0) {
     gDebug = debugLevel;
       }
     }

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

virtual

Definition at line 295 of file InitRootHandlers.cc.

References f, getDQMSummary::iter, and getGTfromDQMFile::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::enableWarnings_ ( )

overrideprivatevirtual

Implements edm::RootHandlers.

Definition at line 343 of file InitRootHandlers.cc.

                                       {
       s_ignoreWarnings =false;
     }

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

static

Definition at line 324 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>("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.");
       descriptions.add("InitRootHandlers", desc);
     }

void edm::service::InitRootHandlers::ignoreWarnings_ ( )

overrideprivatevirtual

Implements edm::RootHandlers.

Definition at line 348 of file InitRootHandlers.cc.

                                       {
       s_ignoreWarnings = true;
     }

void edm::service::InitRootHandlers::initializeThisThreadForUse ( )

overrideprivatevirtual

Implements edm::RootHandlers.

Definition at line 320 of file InitRootHandlers.cc.

                                                       {
       static thread_local TThread guard;
     }

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

overrideprivatevirtual

Implements edm::RootHandlers.

Definition at line 310 of file InitRootHandlers.cc.

                                               {
       //Tell Root we want to be multi-threaded
       TThread::Initialize();
       //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);
     }