#include <EnableFloatingPointExceptions.h>

Public Types
typedef int	fpu_flags_type

Public Member Functions
	EnableFloatingPointExceptions (ParameterSet const &pset, ActivityRegistry &registry)

void	postEndJob ()

void	postModuleBeginJob (ModuleDescription const &)

void	postModuleBeginStream (StreamContext const &, ModuleCallingContext const &)

void	postModuleConstruction (ModuleDescription const &)

void	postModuleEndJob (ModuleDescription const &md)

void	postModuleEndStream (StreamContext const &, ModuleCallingContext const &)

void	postModuleEvent (StreamContext const &, ModuleCallingContext const &)

void	postModuleGlobalBeginLumi (GlobalContext const &, ModuleCallingContext const &)

void	postModuleGlobalBeginRun (GlobalContext const &, ModuleCallingContext const &)

void	postModuleGlobalEndLumi (GlobalContext const &, ModuleCallingContext const &)

void	postModuleGlobalEndRun (GlobalContext const &, ModuleCallingContext const &)

void	postModuleStreamBeginLumi (StreamContext const &, ModuleCallingContext const &)

void	postModuleStreamBeginRun (StreamContext const &, ModuleCallingContext const &)

void	postModuleStreamEndLumi (StreamContext const &, ModuleCallingContext const &)

void	postModuleStreamEndRun (StreamContext const &, ModuleCallingContext const &)

void	preModuleBeginJob (ModuleDescription const &)

void	preModuleBeginStream (StreamContext const &, ModuleCallingContext const &)

void	preModuleConstruction (ModuleDescription const &)

void	preModuleEndJob (ModuleDescription const &md)

void	preModuleEndStream (StreamContext const &, ModuleCallingContext const &)

void	preModuleEvent (StreamContext const &, ModuleCallingContext const &)

void	preModuleGlobalBeginLumi (GlobalContext const &, ModuleCallingContext const &)

void	preModuleGlobalBeginRun (GlobalContext const &, ModuleCallingContext const &)

void	preModuleGlobalEndLumi (GlobalContext const &, ModuleCallingContext const &)

void	preModuleGlobalEndRun (GlobalContext const &, ModuleCallingContext const &)

void	preModuleStreamBeginLumi (StreamContext const &, ModuleCallingContext const &)

void	preModuleStreamBeginRun (StreamContext const &, ModuleCallingContext const &)

void	preModuleStreamEndLumi (StreamContext const &, ModuleCallingContext const &)

void	preModuleStreamEndRun (StreamContext const &, ModuleCallingContext const &)

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

Private Member Functions
void	echoState () const

void	enableAndDisableExcept (fpu_flags_type target)

void	establishModuleEnvironments (ParameterSet const &)

void	postActions (ModuleDescription const &, char const *debugInfo)

void	postActions (ModuleCallingContext const &, char const *debugInfo)

void	preActions (ModuleDescription const &, char const *debugInfo)

void	preActions (ModuleCallingContext const &, char const *debugInfo)

void	setPrecision (bool precisionDouble)

Private Attributes
fpu_flags_type	defaultState_

bool	reportSettings_

std::map< std::string, fpu_flags_type >	stateMap_

Detailed Description

Description: This service gives cmsRun users the ability to configure the behavior of the Floating Point (FP) environment. There are two separate aspects of the FP environment this service can control:

1. floating-point exceptions (on a module by module basis if desired)
2. precision control on x87 FP processors (obsolete for 64 bit x86_64)

If you do not use the service at all, floating point exceptions will not be trapped anywhere (FP exceptions will not cause a crash). Add something like the following to the configuration file to enable to the exceptions:

process.EnableFloatingPointExceptions = cms.Service("EnableFloatingPointExceptions", moduleNames = cms.untracked.vstring( 'default', 'sendMessages1', 'sendMessages2' ), default = cms.untracked.PSet( enableOverFlowEx = cms.untracked.bool(False), enableDivByZeroEx = cms.untracked.bool(False), enableInvalidEx = cms.untracked.bool(False), enableUnderFlowEx = cms.untracked.bool(False) ), sendMessages1 = cms.untracked.PSet( enableOverFlowEx = cms.untracked.bool(False), enableDivByZeroEx = cms.untracked.bool(True), enableInvalidEx = cms.untracked.bool(False), enableUnderFlowEx = cms.untracked.bool(False) ), sendMessages2 = cms.untracked.PSet( enableOverFlowEx = cms.untracked.bool(False), enableDivByZeroEx = cms.untracked.bool(False), enableInvalidEx = cms.untracked.bool(True), enableUnderFlowEx = cms.untracked.bool(False) ) )

In this example, the "Divide By Zero" exception is enabled only for the module with label "sendMessages1", the "Invalid" exception is enabled only for the module with label sendMessages2 and no floating point exceptions are otherwise enabled.

The defaults for these options are currently all false. (in an earlier version DivByZero, Invalid, and Overflow defaulted to true, we hope to return to those defaults someday when the frequency of such exceptions has decreased)

Enabling exceptions is very useful if you are trying to track down where a floating point value of 'nan' or 'inf' is being generated and is even better if the goal is to eliminate them.

Warning. The flags that control the behavior of floating point are globally available. Anything could potentially change them at any point in time, including the module itself and third party code that module calls. In a threading environment if the module waits in the middle of execution and others tasks run on the same thread, they could potentially change the behavior. Also if the module internally creates tasks that run on other threads those will run with whatever settings are on that thread unless special code has been written in the module to set the floating point exception control flags.

Note that we did tests to determine that the floating point exception control of feenableexcept was thread local and therefore could be use with the multithreaded framework. Although the functions in fenv.h that are part of the standard are required to be thread local, we were unable to find any documentation about this for feenableexcept which is an extension of the GCC compiler. Hopefully our test on one machine can be safely extrapolated to all machines ...

Precision control is obsolete in x86_64 architectures and other architectures CMS currently uses (maybe we should remove this part of the service). It has no effect. The x86_64 architecture uses SSE for floating point calculations, not x87. SSE always uses 64 bit precision. Precision control works for x87 floating point calculations as follows:

process.EnableFloatingPointExceptions = cms.Service("EnableFloatingPointExceptions", setPrecisionDouble = cms.untracked.bool(True) )

If set true (the default if the service is used), the floating precision in the x87 math processor will be set to round results of addition, subtraction, multiplication, division, and square root to 64 bits after each operation instead of the x87 default, which is 80 bits for values in registers (this is the default you get if this service is not used at all).

The precision control only affects Intel and AMD 32 bit CPUs under LINUX. We have not implemented precision control in the service for other CPUs. (most other CPUs round to 64 bits by default and/or do not allow control of the precision of floating point calculations).

Definition at line 120 of file EnableFloatingPointExceptions.h.

Member Typedef Documentation

typedef int edm::service::EnableFloatingPointExceptions::fpu_flags_type

Definition at line 123 of file EnableFloatingPointExceptions.h.

Constructor & Destructor Documentation

edm::service::EnableFloatingPointExceptions::EnableFloatingPointExceptions	(	ParameterSet const &	pset,
		ActivityRegistry &	registry
	)

Definition at line 79 of file EnableFloatingPointExceptions.cc.

                                                               :
       defaultState_(0),
       stateMap_(),
       reportSettings_(false) {
 
       reportSettings_ = pset.getUntrackedParameter<bool>("reportSettings", false);
       bool precisionDouble = pset.getUntrackedParameter<bool>("setPrecisionDouble", true);
 
       if(reportSettings_)  {
         LogVerbatim("FPE_Enable") << "\nSettings in EnableFloatingPointExceptions constructor";
         echoState();
       }
 
       establishModuleEnvironments(pset);
 
       enableAndDisableExcept(defaultState_);
 
       setPrecision(precisionDouble);
 
       // Note that we must watch all of the transitions even if there are no module specific settings.
       // This is because the floating point environment may be modified by code outside of this service.
       registry.watchPostEndJob(this, &EnableFloatingPointExceptions::postEndJob);
 
       registry.watchPreModuleBeginStream(this, &EnableFloatingPointExceptions::preModuleBeginStream);
       registry.watchPostModuleBeginStream(this, &EnableFloatingPointExceptions::postModuleBeginStream);
 
       registry.watchPreModuleEndStream(this, &EnableFloatingPointExceptions::preModuleEndStream);
       registry.watchPostModuleEndStream(this, &EnableFloatingPointExceptions::postModuleEndStream);
 
       registry.watchPreModuleConstruction(this, &EnableFloatingPointExceptions::preModuleConstruction);
       registry.watchPostModuleConstruction(this, &EnableFloatingPointExceptions::postModuleConstruction);
 
       registry.watchPreModuleBeginJob(this, &EnableFloatingPointExceptions::preModuleBeginJob);
       registry.watchPostModuleBeginJob(this, &EnableFloatingPointExceptions::postModuleBeginJob);
 
       registry.watchPreModuleEndJob(this, &EnableFloatingPointExceptions::preModuleEndJob);
       registry.watchPostModuleEndJob(this, &EnableFloatingPointExceptions::postModuleEndJob);
 
       registry.watchPreModuleEvent(this, &EnableFloatingPointExceptions::preModuleEvent);
       registry.watchPostModuleEvent(this, &EnableFloatingPointExceptions::postModuleEvent);
 
       registry.watchPreModuleStreamBeginRun(this, &EnableFloatingPointExceptions::preModuleStreamBeginRun);
       registry.watchPostModuleStreamBeginRun(this, &EnableFloatingPointExceptions::postModuleStreamBeginRun);
       registry.watchPreModuleStreamEndRun(this, &EnableFloatingPointExceptions::preModuleStreamEndRun);
       registry.watchPostModuleStreamEndRun(this, &EnableFloatingPointExceptions::postModuleStreamEndRun);
 
       registry.watchPreModuleStreamBeginLumi(this, &EnableFloatingPointExceptions::preModuleStreamBeginLumi);
       registry.watchPostModuleStreamBeginLumi(this, &EnableFloatingPointExceptions::postModuleStreamBeginLumi);
       registry.watchPreModuleStreamEndLumi(this, &EnableFloatingPointExceptions::preModuleStreamEndLumi);
       registry.watchPostModuleStreamEndLumi(this, &EnableFloatingPointExceptions::postModuleStreamEndLumi);
 
       registry.watchPreModuleGlobalBeginRun(this, &EnableFloatingPointExceptions::preModuleGlobalBeginRun);
       registry.watchPostModuleGlobalBeginRun(this, &EnableFloatingPointExceptions::postModuleGlobalBeginRun);
       registry.watchPreModuleGlobalEndRun(this, &EnableFloatingPointExceptions::preModuleGlobalEndRun);
       registry.watchPostModuleGlobalEndRun(this, &EnableFloatingPointExceptions::postModuleGlobalEndRun);
 
       registry.watchPreModuleGlobalBeginLumi(this, &EnableFloatingPointExceptions::preModuleGlobalBeginLumi);
       registry.watchPostModuleGlobalBeginLumi(this, &EnableFloatingPointExceptions::postModuleGlobalBeginLumi);
       registry.watchPreModuleGlobalEndLumi(this, &EnableFloatingPointExceptions::preModuleGlobalEndLumi);
       registry.watchPostModuleGlobalEndLumi(this, &EnableFloatingPointExceptions::postModuleGlobalEndLumi);
     }

Member Function Documentation

void edm::service::EnableFloatingPointExceptions::echoState ( ) const

private

Definition at line 580 of file EnableFloatingPointExceptions.cc.

Referenced by EnableFloatingPointExceptions(), establishModuleEnvironments(), postActions(), postEndJob(), and preActions().

                                                    {
       feclearexcept(FE_ALL_EXCEPT);
       fpu_flags_type femask = fegetexcept();
       LogVerbatim("FPE_Enable") << "Floating point exception mask is " 
                  << std::showbase << std::hex << femask;
  
       if(femask & FE_DIVBYZERO)
         LogVerbatim("FPE_Enable") << "\tDivByZero exception is on";
       else
         LogVerbatim("FPE_Enable") << "\tDivByZero exception is off";
   
       if(femask & FE_INVALID)
         LogVerbatim("FPE_Enable") << "\tInvalid exception is on";
       else
         LogVerbatim("FPE_Enable") << "\tInvalid exception is off";
  
       if(femask & FE_OVERFLOW)
         LogVerbatim("FPE_Enable") << "\tOverFlow exception is on";
       else
         LogVerbatim("FPE_Enable") << "\tOverflow exception is off";
   
       if(femask & FE_UNDERFLOW)
         LogVerbatim("FPE_Enable") << "\tUnderFlow exception is on";
       else
         LogVerbatim("FPE_Enable") << "\tUnderFlow exception is off";
     }

void edm::service::EnableFloatingPointExceptions::enableAndDisableExcept ( fpu_flags_type target )

private

Definition at line 532 of file EnableFloatingPointExceptions.cc.

References cond::rpcobimon::current, and filterCSVwithJSON::target.

Referenced by EnableFloatingPointExceptions(), establishModuleEnvironments(), postActions(), and preActions().

                                                                                {
       feclearexcept(FE_ALL_EXCEPT);
       fpu_flags_type current = fegetexcept();
       fpu_flags_type exceptionsToModify = current ^ target;
       fpu_flags_type exceptionsToEnable = 0;
       fpu_flags_type exceptionsToDisable = 0;
 
       if(exceptionsToModify & FE_DIVBYZERO) {
         if(target & FE_DIVBYZERO) {
           exceptionsToEnable |= FE_DIVBYZERO;
         }
         else {
           exceptionsToDisable |= FE_DIVBYZERO;
         }
       }
       if(exceptionsToModify & FE_INVALID) {
         if(target & FE_INVALID) {
           exceptionsToEnable |= FE_INVALID;
         }
         else {
           exceptionsToDisable |= FE_INVALID;
         }
       }
       if(exceptionsToModify & FE_OVERFLOW) {
         if(target & FE_OVERFLOW) {
           exceptionsToEnable |= FE_OVERFLOW;
         }
         else {
           exceptionsToDisable |= FE_OVERFLOW;
         }
       }
       if(exceptionsToModify & FE_UNDERFLOW) {
         if(target & FE_UNDERFLOW) {
           exceptionsToEnable |= FE_UNDERFLOW;
         }
         else {
           exceptionsToDisable |= FE_UNDERFLOW;
         }
       }
       if(exceptionsToEnable != 0) {
         feenableexcept(exceptionsToEnable);
       }
       if(exceptionsToDisable != 0) {
         fedisableexcept(exceptionsToDisable);
       }
     }

void edm::service::EnableFloatingPointExceptions::establishModuleEnvironments ( ParameterSet const & pset )

private

Definition at line 144 of file EnableFloatingPointExceptions.cc.

References assert(), def, defaultState_, echoState(), enableAndDisableExcept(), flags, edm::ParameterSet::getUntrackedParameter(), edm::ParameterSet::getUntrackedParameterSet(), reportSettings_, stateMap_, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by EnableFloatingPointExceptions().

                                                                                        {
 
       // Scan the module name list and set per-module values.  Be careful to treat
       // any user-specified default first.  If there is one, use it to override our default.
       // Then remove it from the list so we don't see it again while handling everything else.
 
       typedef std::vector<std::string> VString;
 
       std::string const def("default");
       ParameterSet const empty_PSet;
       VString const empty_VString;
       VString moduleNames = pset.getUntrackedParameter<VString>("moduleNames", empty_VString);
 
       for(VString::const_iterator it(moduleNames.begin()), itEnd = moduleNames.end(); it != itEnd; ++it) {
         ParameterSet const& modulePSet = pset.getUntrackedParameterSet(*it, empty_PSet);
         bool enableDivByZeroEx  = modulePSet.getUntrackedParameter<bool>("enableDivByZeroEx", false);
         bool enableInvalidEx    = modulePSet.getUntrackedParameter<bool>("enableInvalidEx",   false);
         bool enableOverFlowEx   = modulePSet.getUntrackedParameter<bool>("enableOverFlowEx",  false);
         bool enableUnderFlowEx  = modulePSet.getUntrackedParameter<bool>("enableUnderFlowEx", false);
 
         fpu_flags_type flags = 0;
         if(enableDivByZeroEx) flags |= FE_DIVBYZERO;
         if(enableInvalidEx)   flags |= FE_INVALID;
         if(enableOverFlowEx)  flags |= FE_OVERFLOW;
         if(enableUnderFlowEx) flags |= FE_UNDERFLOW;
         enableAndDisableExcept(flags);
 
         fpu_flags_type fpuState = fegetexcept();
         assert(flags == fpuState);
 
         if(reportSettings_) {
           LogVerbatim("FPE_Enable") << "\nSettings for module " << *it;
           echoState();
         }
         if(*it == def) {
           defaultState_ = fpuState;
         }
         else {
           stateMap_[*it] =  fpuState;
         }
       }
     }

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

static

Definition at line 366 of file EnableFloatingPointExceptions.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::addNode(), edm::ParameterSetDescription::addUntracked(), python.Node::node, edm::ConfigurationDescriptions::setComment(), edm::ParameterSetDescription::setComment(), and edm::ParameterDescriptionNode::setComment().

                                                                {
       ParameterSetDescription desc;
 
       desc.addUntracked<bool>("reportSettings", false)->setComment(
         "Log FPE settings at different phases of the job.");
       desc.addUntracked<bool>("setPrecisionDouble", true)->setComment(
         "Set the FPU to use double precision");
 
       ParameterSetDescription validator;
       validator.setComment("FPU exceptions to enable/disable for the requested module");
       validator.addUntracked<bool>("enableDivByZeroEx", false)->setComment(
         "Enable/disable exception for 'divide by zero'");
       validator.addUntracked<bool>("enableInvalidEx",   false)->setComment(
         "Enable/disable exception for 'invalid' math operations (e.g. sqrt(-1))");
       validator.addUntracked<bool>("enableOverFlowEx",  false)->setComment(
         "Enable/disable exception for numeric 'overflow' (value to big for type)");
       validator.addUntracked<bool>("enableUnderFlowEx", false)->setComment(
         "Enable/disable exception for numeric 'underflow' (value to small to be represented accurately)");
 
       AllowedLabelsDescription<ParameterSetDescription> node("moduleNames", validator, false);
       node.setComment("Contains the names for PSets where the PSet name matches the label of a module for which you want to modify the FPE");
       desc.addNode(node);
 
       descriptions.add("EnableFloatingPointExceptions", desc);
       descriptions.setComment("This service allows you to control the FPU and its exceptions on a per module basis.");
     }

void edm::service::EnableFloatingPointExceptions::postActions	(	ModuleDescription const &	description,
		char const *	debugInfo
	)

private

Definition at line 421 of file EnableFloatingPointExceptions.cc.

References defaultState_, echoState(), enableAndDisableExcept(), edm::ModuleDescription::moduleLabel(), and reportSettings_.

Referenced by postModuleBeginJob(), postModuleBeginStream(), postModuleConstruction(), postModuleEndJob(), postModuleEndStream(), postModuleEvent(), postModuleGlobalBeginLumi(), postModuleGlobalBeginRun(), postModuleGlobalEndLumi(), postModuleGlobalEndRun(), postModuleStreamBeginLumi(), postModuleStreamBeginRun(), postModuleStreamEndLumi(), and postModuleStreamEndRun().

                                                                              {
 
       enableAndDisableExcept(defaultState_);
 
       if(reportSettings_) {
         LogVerbatim("FPE_Enable")
           << "\nSettings for module label \""
           << description.moduleLabel()
           << "\" after "
           << debugInfo;
         echoState();
       }
     }

void edm::service::EnableFloatingPointExceptions::postActions	(	ModuleCallingContext const &	mcc,
		char const *	debugInfo
	)

private

Definition at line 462 of file EnableFloatingPointExceptions.cc.

References defaultState_, echoState(), enableAndDisableExcept(), edm::ModuleCallingContext::moduleDescription(), edm::ModuleDescription::moduleLabel(), edm::ModuleCallingContext::previousModuleOnThread(), reportSettings_, and stateMap_.

                                                                         {
 
       fpu_flags_type fpuState = defaultState_;
 
       edm::ModuleCallingContext const* previous_mcc = mcc.previousModuleOnThread();
       if(previous_mcc) {
         std::map<std::string, fpu_flags_type>::const_iterator iModule = stateMap_.find(previous_mcc->moduleDescription()->moduleLabel());
         if(iModule != stateMap_.end())  {
           fpuState = iModule->second;
         }
       }
       enableAndDisableExcept(fpuState);
 
       if(reportSettings_) {
         LogVerbatim("FPE_Enable")
           << "\nSettings for module label \""
           << mcc.moduleDescription()->moduleLabel()
           << "\" after "
           << debugInfo;
         echoState();
       }
     }

void edm::service::EnableFloatingPointExceptions::postEndJob ( )

Definition at line 188 of file EnableFloatingPointExceptions.cc.

References echoState(), and reportSettings_.

Referenced by EnableFloatingPointExceptions().

                                               {
 
       if(reportSettings_) {
         LogVerbatim("FPE_Enable") << "\nSettings after endJob ";
         echoState();
       }
     }

void edm::service::EnableFloatingPointExceptions::postModuleBeginJob ( ModuleDescription const & md )

Definition at line 216 of file EnableFloatingPointExceptions.cc.

References postActions().

Referenced by EnableFloatingPointExceptions().

                                                     {
       postActions(md, "beginJob");
     }

void edm::service::EnableFloatingPointExceptions::postModuleBeginStream	(	StreamContext const &	,
		ModuleCallingContext const &	mcc
	)

Definition at line 240 of file EnableFloatingPointExceptions.cc.

References postActions().

Referenced by EnableFloatingPointExceptions().

                                                                                  {
       postActions(mcc, "beginStream");
     }

void edm::service::EnableFloatingPointExceptions::postModuleConstruction ( ModuleDescription const & md )

Definition at line 204 of file EnableFloatingPointExceptions.cc.

References postActions().

Referenced by EnableFloatingPointExceptions().

                                                         {
       postActions(md, "construction");
     }

void edm::service::EnableFloatingPointExceptions::postModuleEndJob ( ModuleDescription const & md )

Definition at line 228 of file EnableFloatingPointExceptions.cc.

References postActions().

Referenced by EnableFloatingPointExceptions().

                                                   {
       postActions(md, "endJob");
     }

void edm::service::EnableFloatingPointExceptions::postModuleEndStream	(	StreamContext const &	,
		ModuleCallingContext const &	mcc
	)

Definition at line 252 of file EnableFloatingPointExceptions.cc.

References postActions().

Referenced by EnableFloatingPointExceptions().

                                                                                {
       postActions(mcc, "endStream");
     }

void edm::service::EnableFloatingPointExceptions::postModuleEvent	(	StreamContext const &	,
		ModuleCallingContext const &	mcc
	)

Definition at line 360 of file EnableFloatingPointExceptions.cc.

References postActions().

Referenced by EnableFloatingPointExceptions().

                                                                            {
       postActions(mcc, "event");
     }

void edm::service::EnableFloatingPointExceptions::postModuleGlobalBeginLumi	(	GlobalContext const &	,
		ModuleCallingContext const &	mcc
	)

Definition at line 288 of file EnableFloatingPointExceptions.cc.

References postActions().

Referenced by EnableFloatingPointExceptions().

                                                                                      {
       postActions(mcc, "globalBeginLumi");
     }

void edm::service::EnableFloatingPointExceptions::postModuleGlobalBeginRun	(	GlobalContext const &	,
		ModuleCallingContext const &	mcc
	)

Definition at line 264 of file EnableFloatingPointExceptions.cc.

References postActions().

Referenced by EnableFloatingPointExceptions().

                                                                                     {
       postActions(mcc, "globalBeginRun");
     }

void edm::service::EnableFloatingPointExceptions::postModuleGlobalEndLumi	(	GlobalContext const &	,
		ModuleCallingContext const &	mcc
	)

Definition at line 300 of file EnableFloatingPointExceptions.cc.

References postActions().

Referenced by EnableFloatingPointExceptions().

                                                                                    {
       postActions(mcc, "globalEndLumi");
     }

void edm::service::EnableFloatingPointExceptions::postModuleGlobalEndRun	(	GlobalContext const &	,
		ModuleCallingContext const &	mcc
	)

Definition at line 276 of file EnableFloatingPointExceptions.cc.

References postActions().

Referenced by EnableFloatingPointExceptions().

                                                                                   {
       postActions(mcc, "globalEndRun");
     }

void edm::service::EnableFloatingPointExceptions::postModuleStreamBeginLumi	(	StreamContext const &	,
		ModuleCallingContext const &	mcc
	)

Definition at line 336 of file EnableFloatingPointExceptions.cc.

References postActions().

Referenced by EnableFloatingPointExceptions().

                                                                                      {
       postActions(mcc, "streamBeginLumi");
     }

void edm::service::EnableFloatingPointExceptions::postModuleStreamBeginRun	(	StreamContext const &	,
		ModuleCallingContext const &	mcc
	)

Definition at line 312 of file EnableFloatingPointExceptions.cc.

References postActions().

Referenced by EnableFloatingPointExceptions().

                                                                                     {
       postActions(mcc, "streamBeginRun");
     }

void edm::service::EnableFloatingPointExceptions::postModuleStreamEndLumi	(	StreamContext const &	,
		ModuleCallingContext const &	mcc
	)

Definition at line 348 of file EnableFloatingPointExceptions.cc.

References postActions().

Referenced by EnableFloatingPointExceptions().

                                                                                    {
       postActions(mcc, "streamEndLumi");
     }

void edm::service::EnableFloatingPointExceptions::postModuleStreamEndRun	(	StreamContext const &	,
		ModuleCallingContext const &	mcc
	)

Definition at line 324 of file EnableFloatingPointExceptions.cc.

References postActions().

Referenced by EnableFloatingPointExceptions().

                                                                                   {
       postActions(mcc, "streamEndRun");
     }

void edm::service::EnableFloatingPointExceptions::preActions	(	ModuleDescription const &	description,
		char const *	debugInfo
	)

private

Definition at line 396 of file EnableFloatingPointExceptions.cc.

References defaultState_, echoState(), enableAndDisableExcept(), edm::ModuleDescription::moduleLabel(), reportSettings_, stateMap_, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by preModuleBeginJob(), preModuleBeginStream(), preModuleConstruction(), preModuleEndJob(), preModuleEndStream(), preModuleEvent(), preModuleGlobalBeginLumi(), preModuleGlobalBeginRun(), preModuleGlobalEndLumi(), preModuleGlobalEndRun(), preModuleStreamBeginLumi(), preModuleStreamBeginRun(), preModuleStreamEndLumi(), and preModuleStreamEndRun().

                                       {
 
       std::string const& moduleLabel = description.moduleLabel();
       std::map<std::string, fpu_flags_type>::const_iterator iModule = stateMap_.find(moduleLabel);
 
       fpu_flags_type fpuState = defaultState_;
 
       if(iModule != stateMap_.end())  {
         fpuState = iModule->second;
       }
       enableAndDisableExcept(fpuState);
 
       if(reportSettings_) {
         LogVerbatim("FPE_Enable")
           << "\nSettings for module label \""
           << moduleLabel
           << "\" before "
           << debugInfo;
         echoState();
       }
     }

void edm::service::EnableFloatingPointExceptions::preActions	(	ModuleCallingContext const &	mcc,
		char const *	debugInfo
	)

private

Definition at line 437 of file EnableFloatingPointExceptions.cc.

References defaultState_, echoState(), enableAndDisableExcept(), edm::ModuleCallingContext::moduleDescription(), edm::ModuleDescription::moduleLabel(), reportSettings_, stateMap_, and AlCaHLTBitMon_QueryRunRegistry::string.

                                       {
 
       std::string const& moduleLabel = mcc.moduleDescription()->moduleLabel();
       std::map<std::string, fpu_flags_type>::const_iterator iModule = stateMap_.find(moduleLabel);
 
       fpu_flags_type fpuState = defaultState_;
 
       if(iModule != stateMap_.end())  {
         fpuState = iModule->second;
       }
       enableAndDisableExcept(fpuState);
 
       if(reportSettings_) {
         LogVerbatim("FPE_Enable")
           << "\nSettings for module label \""
           << moduleLabel
           << "\" before "
           << debugInfo;
         echoState();
       }
     }

void edm::service::EnableFloatingPointExceptions::preModuleBeginJob ( ModuleDescription const & md )

Definition at line 210 of file EnableFloatingPointExceptions.cc.

References preActions().

Referenced by EnableFloatingPointExceptions().

                                                    {
       preActions(md, "beginJob");
     }

void edm::service::EnableFloatingPointExceptions::preModuleBeginStream	(	StreamContext const &	,
		ModuleCallingContext const &	mcc
	)

Definition at line 234 of file EnableFloatingPointExceptions.cc.

References preActions().

Referenced by EnableFloatingPointExceptions().

                                                                                 {
       preActions(mcc, "beginStream");
     }

void edm::service::EnableFloatingPointExceptions::preModuleConstruction ( ModuleDescription const & md )

Definition at line 198 of file EnableFloatingPointExceptions.cc.

References preActions().

Referenced by EnableFloatingPointExceptions().

                                                        {
       preActions(md, "construction");
     }

void edm::service::EnableFloatingPointExceptions::preModuleEndJob ( ModuleDescription const & md )

Definition at line 222 of file EnableFloatingPointExceptions.cc.

References preActions().

Referenced by EnableFloatingPointExceptions().

                                                  {
       preActions(md, "endJob");
     }

void edm::service::EnableFloatingPointExceptions::preModuleEndStream	(	StreamContext const &	,
		ModuleCallingContext const &	mcc
	)

Definition at line 246 of file EnableFloatingPointExceptions.cc.

References preActions().

Referenced by EnableFloatingPointExceptions().

                                                                               {
       preActions(mcc, "endStream");
     }

void edm::service::EnableFloatingPointExceptions::preModuleEvent	(	StreamContext const &	,
		ModuleCallingContext const &	mcc
	)

Definition at line 354 of file EnableFloatingPointExceptions.cc.

References preActions().

Referenced by EnableFloatingPointExceptions().

                                                                           {
       preActions(mcc, "event");
     }

void edm::service::EnableFloatingPointExceptions::preModuleGlobalBeginLumi	(	GlobalContext const &	,
		ModuleCallingContext const &	mcc
	)

Definition at line 282 of file EnableFloatingPointExceptions.cc.

References preActions().

Referenced by EnableFloatingPointExceptions().

                                                                                     {
       preActions(mcc, "globalBeginLumi");
     }

void edm::service::EnableFloatingPointExceptions::preModuleGlobalBeginRun	(	GlobalContext const &	,
		ModuleCallingContext const &	mcc
	)

Definition at line 258 of file EnableFloatingPointExceptions.cc.

References preActions().

Referenced by EnableFloatingPointExceptions().

                                                                                    {
       preActions(mcc, "globalBeginRun");
     }

void edm::service::EnableFloatingPointExceptions::preModuleGlobalEndLumi	(	GlobalContext const &	,
		ModuleCallingContext const &	mcc
	)

Definition at line 294 of file EnableFloatingPointExceptions.cc.

References preActions().

Referenced by EnableFloatingPointExceptions().

                                                                                   {
       preActions(mcc, "globalEndLumi");
     }

void edm::service::EnableFloatingPointExceptions::preModuleGlobalEndRun	(	GlobalContext const &	,
		ModuleCallingContext const &	mcc
	)

Definition at line 270 of file EnableFloatingPointExceptions.cc.

References preActions().

Referenced by EnableFloatingPointExceptions().

                                                                                  {
       preActions(mcc, "globalEndRun");
     }

void edm::service::EnableFloatingPointExceptions::preModuleStreamBeginLumi	(	StreamContext const &	,
		ModuleCallingContext const &	mcc
	)

Definition at line 330 of file EnableFloatingPointExceptions.cc.

References preActions().

Referenced by EnableFloatingPointExceptions().

                                                                                     {
       preActions(mcc, "streamBeginLumi");
     }

void edm::service::EnableFloatingPointExceptions::preModuleStreamBeginRun	(	StreamContext const &	,
		ModuleCallingContext const &	mcc
	)

Definition at line 306 of file EnableFloatingPointExceptions.cc.

References preActions().

Referenced by EnableFloatingPointExceptions().

                                                                                    {
       preActions(mcc, "streamBeginRun");
     }

void edm::service::EnableFloatingPointExceptions::preModuleStreamEndLumi	(	StreamContext const &	,
		ModuleCallingContext const &	mcc
	)

Definition at line 342 of file EnableFloatingPointExceptions.cc.

References preActions().

Referenced by EnableFloatingPointExceptions().

                                                                                   {
       preActions(mcc, "streamEndLumi");
     }

void edm::service::EnableFloatingPointExceptions::preModuleStreamEndRun	(	StreamContext const &	,
		ModuleCallingContext const &	mcc
	)

Definition at line 318 of file EnableFloatingPointExceptions.cc.

References preActions().

Referenced by EnableFloatingPointExceptions().

                                                                                  {
       preActions(mcc, "streamEndRun");
     }

void edm::service::EnableFloatingPointExceptions::setPrecision ( bool precisionDouble )

private

Definition at line 527 of file EnableFloatingPointExceptions.cc.

Referenced by EnableFloatingPointExceptions().

527 {

528 }

Member Data Documentation

fpu_flags_type edm::service::EnableFloatingPointExceptions::defaultState_

private

Definition at line 191 of file EnableFloatingPointExceptions.h.

Referenced by EnableFloatingPointExceptions(), establishModuleEnvironments(), postActions(), and preActions().

bool edm::service::EnableFloatingPointExceptions::reportSettings_

private

Definition at line 193 of file EnableFloatingPointExceptions.h.

Referenced by EnableFloatingPointExceptions(), establishModuleEnvironments(), postActions(), postEndJob(), and preActions().

std::map<std::string, fpu_flags_type> edm::service::EnableFloatingPointExceptions::stateMap_

private

Definition at line 192 of file EnableFloatingPointExceptions.h.

Referenced by establishModuleEnvironments(), postActions(), and preActions().

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation