FPEAuditor Class Reference

#include <FPEAuditor.h>

Inheritance diagram for FPEAuditor:

Collaboration diagram for FPEAuditor:

Public Member Functions
	FPEAuditor (const std::string &name, ISvcLocator *pSvcLocator)
	Constructor.
virtual	~FPEAuditor ()
	Destructor.
virtual StatusCode	initialize () override
	Gaudi hooks.
virtual StatusCode	finalize () override
virtual void	before (const std::string &event, const std::string &name, const EventContext &ctx) override
	Auditor hooks.
virtual void	after (const std::string &event, const std::string &name, const EventContext &ctx, const StatusCode &sc) override
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Private Types
enum	{ FPEAUDITOR_OVERFLOW =0 , FPEAUDITOR_INVALID =1 , FPEAUDITOR_DIVBYZERO =2 , FPEAUDITOR_ARRAYSIZE =3 }

Private Member Functions
void	report_fpe (const std::string &step, const std::string &caller, const EventContext &ctx)
	report fpes which happened during step 'step' on behalf of 'caller'
void	add_fpe_node ()
	add an fpe node
void	pop_fpe_node ()
	pop an fpe node
void	InstallHandler ()
void	UninstallHandler ()

Private Attributes
std::atomic< unsigned int >	m_CountFPEs [FPEAUDITOR_ARRAYSIZE]
unsigned int	m_NstacktracesOnFPE =0
unsigned int	m_Nstacklines =100
fenv_t	m_env
	The FP environment before we initialize.
std::atomic< int >	m_nexceptions

Detailed Description

Definition at line 33 of file FPEAuditor.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

private

Enumerator
FPEAUDITOR_OVERFLOW
FPEAUDITOR_INVALID
FPEAUDITOR_DIVBYZERO
FPEAUDITOR_ARRAYSIZE

Definition at line 75 of file FPEAuditor.h.

{ FPEAUDITOR_OVERFLOW=0, FPEAUDITOR_INVALID=1, FPEAUDITOR_DIVBYZERO=2, FPEAUDITOR_ARRAYSIZE=3 };

Constructor & Destructor Documentation

FPEAuditor()

FPEAuditor::FPEAuditor	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Constructor.

Definition at line 60 of file FPEAuditor.cxx.

                                       :
  AthCommonMsg<Auditor>     ( name, pSvcLocator  ),
  m_CountFPEs(),
  m_env(),
  m_nexceptions(0)
{
  declareProperty("NStacktracesOnFPE", m_NstacktracesOnFPE,
                  "Flag to configure, how many stack traces in case of FPE are printed. "
                  "Default: Zero, just report that FPE has happened. "
                  "After collecting the stacktrace, the code has to modify the mcontext_t "
                  "struct to ignore FPEs for the rest of the processing of the algorithm/service "
                  "This part is highly non-portable!" );
 
  declareProperty("Nstacklines", m_Nstacklines,"Limit how deep we dive into the stack");
}

~FPEAuditor()

FPEAuditor::~FPEAuditor ( )

virtual

Destructor.

Definition at line 81 of file FPEAuditor.cxx.

{
  //m_msg << MSG::DEBUG << "Calling destructor" << endmsg;
}

Member Function Documentation

add_fpe_node()

void FPEAuditor::add_fpe_node ( )

private

add an fpe node

Definition at line 276 of file FPEAuditor.cxx.

{
  // clear FPE status word
  feclearexcept(FE_ALL_EXCEPT);
 
  if (FPEAudit::s_handlerDisabled) {
    // Make sure exceptions have been masked off if the handler has been
    // disabled.  Yes, this is already done in the signal handler.
    // But when TBB starts a new task, it resets the FPU control words
    // to values that were copied when the thread pool was initialized.
    // FIXME: Do it properly with TBB?  Not sure that the current
    // interfaces allow it.
    FPEAudit::mask_fpe();
  }
}

after()

void FPEAuditor::after ( const std::string & event, const std::string & name, const EventContext & ctx, const StatusCode & sc )

overridevirtual

Definition at line 176 of file FPEAuditor.cxx.

{
  report_fpe(event, name, ctx);
  pop_fpe_node();
 
  if ( event==IAuditor::Initialize ) {
    FPEAudit::lock_t lock (FPEAudit::s_mutex);
    // CoreDumpSvc can also install a FPE handler, grrr.
    if (name == "CoreDumpSvc") FPEAudit::s_handlerInstalled = false;
    if ( m_NstacktracesOnFPE && ! FPEAudit::s_handlerInstalled ) {
      InstallHandler();
      m_nexceptions = m_NstacktracesOnFPE;
    }
  }
}

before()

void FPEAuditor::before ( const std::string & event, const std::string & name, const EventContext & ctx )

overridevirtual

Auditor hooks.

Definition at line 160 of file FPEAuditor.cxx.

{
  add_fpe_node();
 
  if ( event==IAuditor::Execute ) {
    if ( m_NstacktracesOnFPE && ! FPEAudit::s_handlerInstalled ) {
      FPEAudit::lock_t lock (FPEAudit::s_mutex);
      if ( m_NstacktracesOnFPE && ! FPEAudit::s_handlerInstalled ) {
        InstallHandler();
        m_nexceptions = m_NstacktracesOnFPE;
      }
    }
  }
}

finalize()

StatusCode FPEAuditor::finalize ( )

overridevirtual

Definition at line 98 of file FPEAuditor.cxx.

{
  ATH_MSG_INFO("FPE summary for this job");
  ATH_MSG_INFO(" FPE OVERFLOWs  : " << m_CountFPEs[FPEAUDITOR_OVERFLOW] );
  ATH_MSG_INFO(" FPE INVALIDs   : " << m_CountFPEs[FPEAUDITOR_INVALID]);
  ATH_MSG_INFO(" FPE DIVBYZEROs : " << m_CountFPEs[FPEAUDITOR_DIVBYZERO]);
 
  {
    FPEAudit::lock_t lock (FPEAudit::s_mutex);
    if ( FPEAudit::s_handlerInstalled && !FPEAudit::s_handlerDisabled )
      UninstallHandler();
  }
 
  return StatusCode::SUCCESS;
}

initialize()

StatusCode FPEAuditor::initialize ( )

overridevirtual

Gaudi hooks.

Definition at line 86 of file FPEAuditor.cxx.

{
  for ( unsigned int i(0); i<FPEAUDITOR_ARRAYSIZE; ++i )
    m_CountFPEs[i]=0;
  //ATH_MSG_INFO("==> initialize");
  // add a fake node here because we may come alive while the AuditorSvc is
  // still initializing (so one edge is left orphaned)
  add_fpe_node();
 
  return StatusCode::SUCCESS;
}

InstallHandler()

void FPEAuditor::InstallHandler ( )

private

Definition at line 114 of file FPEAuditor.cxx.

{
  // Save the current FP environment.
  fegetenv (&m_env);
 
#ifdef __aarch64__
  ATH_MSG_WARNING("Collecting stack traces for FPES is not supported on aarch64");
  m_NstacktracesOnFPE = 0;
  FPEAudit::s_handlerDisabled = true;
  FPEAudit::s_handlerInstalled = true;
#else
  struct sigaction act;
  memset(&act, 0, sizeof act);
  act.sa_sigaction = FPEAudit::fpe_sig_action;
  act.sa_flags = SA_SIGINFO;
  if ( sigaction(SIGFPE, &act, &FPEAudit::s_oldactHandler) != 0 )
    {
      ATH_MSG_WARNING ("Printing stacktraces on FPE requested, but unable to install signal handler ! Switched off !");
      m_NstacktracesOnFPE=0;
    }
  if ( m_NstacktracesOnFPE )
    {
      ATH_MSG_INFO ("Installed Signalhandler !");
      FPEAudit::unmask_fpe();
    }
  FPEAudit::s_tlsdata.s_array_O[0]=NULL;
  FPEAudit::s_tlsdata.s_array_I[0]=NULL;
  FPEAudit::s_tlsdata.s_array_D[0]=NULL;
 
  FPEAudit::s_handlerInstalled = true;
#endif
}

msg()

MsgStream & AthCommonMsg< Gaudi::Auditor >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Gaudi::Auditor >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

pop_fpe_node()

void FPEAuditor::pop_fpe_node ( )

private

pop an fpe node

Definition at line 293 of file FPEAuditor.cxx.

{
  if ( FPEAudit::s_handlerInstalled && !FPEAudit::s_handlerDisabled) {
    FPEAudit::unmask_fpe();
  }
}

report_fpe()

void FPEAuditor::report_fpe ( const std::string & step, const std::string & caller, const EventContext & ctx )

private

report fpes which happened during step 'step' on behalf of 'caller'

Definition at line 196 of file FPEAuditor.cxx.

{
  // store current list of FPE flags which were raised before
  int raised = fetestexcept(FE_OVERFLOW | FE_INVALID | FE_DIVBYZERO);
  if (raised) {
    std::stringstream evStr;
    if (ctx.valid()) {
      evStr << " on event " << ctx.eventID().event_number();
    }
 
    if (raised & FE_OVERFLOW) {
      ATH_MSG_WARNING("FPE OVERFLOW in [" << step << "] of [" << caller << "]" << evStr.str() <<
                      " " << m_NstacktracesOnFPE << " " << FPEAudit::s_tlsdata.s_array_O[0]
                      );
      ++m_CountFPEs[FPEAUDITOR_OVERFLOW];
      if ( m_NstacktracesOnFPE && FPEAudit::s_tlsdata.s_array_O[0] != NULL )
    {
      for (unsigned int j = 0; j < m_Nstacklines; j++)
        {
              FPEAudit::lock_t lock (FPEAudit::s_mutex);
          if (FPEAudit::s_tlsdata.s_array_O[j]==NULL) break;
          this->msg(MSG::INFO) << "FPE stacktrace " << j << " :\n";
          FPEAudit::resolve(FPEAudit::s_tlsdata.s_array_O[j],this->msg());
          FPEAudit::s_tlsdata.s_array_O[j]=NULL;
          this->msg(MSG::INFO) << endmsg;
        }
    }
    }
    if (raised & FE_INVALID) {
      ATH_MSG_WARNING("FPE INVALID in [" << step << "] of [" << caller << "]" << evStr.str()
                      << " " << m_NstacktracesOnFPE << " " << FPEAudit::s_tlsdata.s_array_I[0]
                      );
      ++m_CountFPEs[FPEAUDITOR_INVALID];
    }
    if ( m_NstacktracesOnFPE && FPEAudit::s_tlsdata.s_array_I[0] != NULL )
      {
    for (unsigned int j = 0; j < m_Nstacklines; j++)
      {
            FPEAudit::lock_t lock (FPEAudit::s_mutex);
            if (FPEAudit::s_tlsdata.s_array_I[j]==NULL) break;
        this->msg(MSG::INFO) << "FPE stacktrace " << j << " :\n";
        FPEAudit::resolve(FPEAudit::s_tlsdata.s_array_I[j],this->msg());
        FPEAudit::s_tlsdata.s_array_I[j]=NULL;
        this->msg(MSG::INFO) << endmsg;
      }
      }
    if (raised & FE_DIVBYZERO) {
      ATH_MSG_WARNING("FPE DIVBYZERO in [" << step << "] of [" << caller << "]" << evStr.str()
                      << " " << m_NstacktracesOnFPE << " " << FPEAudit::s_tlsdata.s_array_D[0]
                      );
      ++m_CountFPEs[FPEAUDITOR_DIVBYZERO];
      if ( m_NstacktracesOnFPE && FPEAudit::s_tlsdata.s_array_D[0] != NULL )
    {
          FPEAudit::lock_t lock (FPEAudit::s_mutex);
      for (unsigned int j = 0; j < m_Nstacklines; j++)
        {
          if (FPEAudit::s_tlsdata.s_array_D[j]==NULL) break;
          this->msg(MSG::INFO) << "FPE stacktrace " << j << " :\n";
          FPEAudit::resolve(FPEAudit::s_tlsdata.s_array_D[j],this->msg());
          FPEAudit::s_tlsdata.s_array_D[j]=NULL;
          this->msg(MSG::INFO) << endmsg;
        }
    }
    }
 
 
    FPEAudit::lock_t lock (FPEAudit::s_mutex);
    if ( --m_nexceptions == 0
         && FPEAudit::s_handlerInstalled &&
         !FPEAudit::s_handlerDisabled )
    {
      fprintf(stderr, "too many SIGFPE detected, will be uninstalling signal handler\n");
      UninstallHandler();
    }
  }
}

UninstallHandler()

void FPEAuditor::UninstallHandler ( )

private

Definition at line 147 of file FPEAuditor.cxx.

{
  ATH_MSG_INFO("uninstalling SignalHandler");
  FPEAudit::s_handlerDisabled = true;
 
  feclearexcept(FE_ALL_EXCEPT);
  fesetenv (&m_env);
  FPEAudit::mask_fpe();
 
  // feenableexcept (0);
  // fedisableexcept (FE_ALL_EXCEPT);
}

Member Data Documentation

m_CountFPEs

std::atomic<unsigned int> FPEAuditor::m_CountFPEs[FPEAUDITOR_ARRAYSIZE]

private

Definition at line 77 of file FPEAuditor.h.

m_env

fenv_t FPEAuditor::m_env

private

The FP environment before we initialize.

Definition at line 90 of file FPEAuditor.h.

m_nexceptions

std::atomic<int> FPEAuditor::m_nexceptions

private

Definition at line 92 of file FPEAuditor.h.

m_Nstacklines

unsigned int FPEAuditor::m_Nstacklines =100

private

Definition at line 81 of file FPEAuditor.h.

m_NstacktracesOnFPE

unsigned int FPEAuditor::m_NstacktracesOnFPE =0

private

Definition at line 79 of file FPEAuditor.h.

---

The documentation for this class was generated from the following files:

• FPEAuditor.h
• FPEAuditor.cxx