AthenaSummarySvc Class Reference

#include <AthenaSummarySvc.h>

Inheritance diagram for AthenaSummarySvc:

Collaboration diagram for AthenaSummarySvc:

Public Member Functions
	AthenaSummarySvc (const std::string &name, ISvcLocator *svc)
virtual StatusCode	initialize () override
virtual StatusCode	reinitialize () override
virtual StatusCode	finalize () override
virtual StatusCode	createSummary () override
virtual void	setStatus (int s) override
virtual void	addListener (const std::string &incident_name) override
virtual void	addSummary (const std::string &dict_key, const std::string &data) override
virtual const std::string &	getOutputFile () const override

Private Member Functions
void	createDict (std::ofstream &)
void	createASCII (std::ofstream &)
virtual void	handle (const Incident &inc) override

Static Private Member Functions
static void	newHandler ()

Private Attributes
StringProperty	m_summaryFile
StringProperty	m_summaryFormat
StringArrayProperty	m_extraInc
StringArrayProperty	m_keywords
ServiceHandle< IIncidentSvc >	p_incSvc
ILoggedMessageSvc *	p_logMsg {nullptr}
std::list< std::string >	m_inputFilesRead
std::list< std::string >	m_outputFiles
std::list< std::string >	m_outputFilesError
std::map< std::string, std::map< std::string, int > >	m_extraIncidents
std::vector< std::pair< std::string, std::string > >	m_extraInfo
std::new_handler	m_new {nullptr}
int	m_status {0}
unsigned int	m_eventsRead {0}
unsigned int	m_eventsWritten {0}
unsigned int	m_eventsSkipped {0}
unsigned int	m_runs {0}

Static Private Attributes
static char *s_block	ATLAS_THREAD_SAFE
static bool s_badalloc	ATLAS_THREAD_SAFE

Detailed Description

Definition at line 36 of file AthenaSummarySvc.h.

Constructor & Destructor Documentation

AthenaSummarySvc()

AthenaSummarySvc::AthenaSummarySvc	(	const std::string &	name,
		ISvcLocator *	svc )

Definition at line 112 of file AthenaSummarySvc.cxx.

  : base_class( name, svc ),
    p_incSvc("IncidentSvc",name),
    m_new (std::set_new_handler( &AthenaSummarySvc::newHandler ))
{
}

Member Function Documentation

addListener()

void AthenaSummarySvc::addListener ( const std::string & incident_name )

overridevirtual

Definition at line 217 of file AthenaSummarySvc.cxx.

                                                    {
 
  ATH_MSG_DEBUG("now listening to incident {}", inc);
 
  if (m_extraIncidents.find( inc ) == m_extraIncidents.end()) {
    p_incSvc->addListener( this, inc, 100, true);
    m_extraIncidents[inc] = map<string,int>();
  } else {
    ATH_MSG_INFO("already listening to Incident {}", inc);
  }
 
}

addSummary()

void AthenaSummarySvc::addSummary ( const std::string & dict_key, const std::string & data )

overridevirtual

Definition at line 233 of file AthenaSummarySvc.cxx.

                                                                         {
 
  ATH_MSG_DEBUG("adding extra info: {}/{}", dict, info);
 
  m_extraInfo.push_back( make_pair(dict,info) );
 
}

createASCII()

void AthenaSummarySvc::createASCII ( std::ofstream & ofs )

private

Definition at line 366 of file AthenaSummarySvc.cxx.

                                                {
  
  ATH_MSG_DEBUG("createASCII");
 
  list<string>::const_iterator itr;
  
  std::println (ofs, "Files read: {}", m_inputFilesRead.size());
  for (itr=m_inputFilesRead.begin(); itr != m_inputFilesRead.end(); ++itr) {
    std::println (ofs, "  {}", *itr);
  }
  
  std::println (ofs, "Files written: {}", m_outputFiles.size());
  for (itr=m_outputFiles.begin(); itr != m_outputFiles.end(); ++itr) {
    std::println (ofs, "  {}", *itr);
  }
  
  std::println (ofs, "File Write Error: {}", m_outputFilesError.size());
  for (itr=m_outputFilesError.begin(); itr != m_outputFilesError.end(); ++itr) {
    std::println (ofs, "  {}", *itr);
  }
  
  std::println (ofs, "Events Read:    {}", m_eventsRead);
  std::println (ofs, "Events Written: {}", m_eventsWritten);
  std::println (ofs, "Events Skipped: {}", m_eventsSkipped);
 
  std::println (ofs, "Runs: {}", m_runs);
  
 
  std::println (ofs, "Message Count: ");
  std::println (ofs, " FATAL:   {}", msgSvc()->messageCount( MSG::FATAL ));
  std::println (ofs, " ERROR:   {}", msgSvc()->messageCount( MSG::ERROR ));
  std::println (ofs, " WARNING: {}", msgSvc()->messageCount( MSG::WARNING ));
  std::println (ofs, " INFO:    {}", msgSvc()->messageCount( MSG::INFO ));
 
  if (p_logMsg != nullptr) {
 
    IntegerProperty thresh("loggingLevel",MSG::VERBOSE);
    IProperty *ip = dynamic_cast<IProperty*>( p_logMsg );
    if (ip != nullptr) {
      if (ip->getProperty(&thresh).isFailure()) {
        ATH_MSG_ERROR("could not get loggingLevel property of LoggedMessageSvc");
      }
    } else {
      ATH_MSG_ERROR("could not dcast LoggedMessageSvc to IProperty");
    }
      
    
 
    std::println (ofs, "Message Log: ");
    vector<pair<string,string> > msgs;
    vector<pair<string,string> >::const_iterator mitr;
    for (unsigned int l=thresh.value(); l < MSG::ALWAYS; l++) {
      std::print (ofs, "  {}", levelNames[l]);
      msgs = p_logMsg->getMessages( MSG::Level(l) );
      std::println (ofs, "  {}", msgs.size());
      for (mitr=msgs.begin(); mitr != msgs.end(); ++mitr) {
        std::println (ofs, "      {} : {}", mitr->first, mitr->second);
      }
    }
 
    std::println (ofs, "Keyword tracked messages: ");
    for (const auto& msg : p_logMsg->getKeyMessages()) {
      std::println (ofs, "  {}  {}  {}",
                    levelNames[msg.level], msg.source, msg.message);
    }
    
  }
 
  if (m_extraInfo.size() > 0) {
    std::println (ofs, "Extra Summary Info:");
    vector<pair<string,string> >::const_iterator itr (m_extraInfo.begin() );
    for (; itr != m_extraInfo.end(); ++itr) {
      std::println (ofs, "      {} : {}", itr->first, itr->second);
    }
  }
  
  if (m_extraIncidents.size() > 0) {
    std::println (ofs, "Extra Incident Counts:");
    map<string, map<string,int> >::const_iterator itr(m_extraIncidents.begin());
    for (; itr != m_extraIncidents.end(); ++itr) {
      std::print (ofs, " {}", itr->first);
      if (itr->second.begin() == itr->second.end()) {
        std::println (ofs, " : 0");
      } else {
    for (map<string,int>::const_iterator it=itr->second.begin();
         it != itr->second.end(); ++it) {
          std::print (ofs, " ::  {}: {}", it->first, it->second);
    }
        std::println (ofs);
      }
    }
  }
 
  if (s_badalloc) {
    std::println (ofs, "std::bad_alloc caught: out of memory condition detected");
  }
 
  std::println (ofs, "Exit Status: {}", m_status);
 
 
}

createDict()

void AthenaSummarySvc::createDict ( std::ofstream & ofd )

private

Definition at line 470 of file AthenaSummarySvc.cxx.

                                              {
 
  ATH_MSG_DEBUG("createDict");
 
  list<string>::const_iterator itr;
 
  PD p;
 
  PD files;
  string f;
  for (itr=m_inputFilesRead.begin(); itr != m_inputFilesRead.end(); ++itr) {
    if (f.length() > 0) { f += ","; }
    f += *itr;
  }
  files.add("read",f);
 
  f.clear();
  for (itr=m_outputFiles.begin(); itr != m_outputFiles.end(); ++itr) {
    if (f.length() > 0) { f += ","; }
    f += *itr;    
  }
  files.add("write",f);
  
  f.clear();
  for (itr=m_outputFilesError.begin(); itr != m_outputFilesError.end(); ++itr) {
    if (f.length() > 0) { f += ","; }
    f += *itr;    
  }
  files.add("write error",f);
  
  p.add("files",files);
 
  PD events;
  events.add("read",m_eventsRead);
  events.add("write",m_eventsWritten);
  events.add("skip",m_eventsSkipped);
 
  p.add("events",events);
 
  p.add("runs",m_runs);
 
  PD msg;
  msg.add("FATAL",msgSvc()->messageCount( MSG::FATAL ));
  msg.add("ERROR",msgSvc()->messageCount( MSG::ERROR ));
  msg.add("WARNING",msgSvc()->messageCount( MSG::WARNING ));
  msg.add("INFO",msgSvc()->messageCount( MSG::INFO ));
 
  p.add("message count",msg);
 
  if (p_logMsg != nullptr) {
 
    IntegerProperty thresh("loggingLevel",MSG::VERBOSE);
    IProperty *ip = dynamic_cast<IProperty*>( p_logMsg );
    if (ip != nullptr) {
      if (ip->getProperty(&thresh).isFailure()) {
        ATH_MSG_ERROR("could not get loggingLevel property of LoggedMessageSvc");
      }
    } else {
      ATH_MSG_ERROR("could not dcast LoggedMessageSvc to IProperty");
    }
    
    PD mlog;
    vector<pair<string,string> > msgs;
    vector<pair<string,string> >::const_iterator mitr;
    for (unsigned int l=thresh.value(); l < MSG::ALWAYS; l++) {
      PD slog;
      msgs = p_logMsg->getMessages( MSG::Level(l) );
      for (mitr=msgs.begin(); mitr != msgs.end(); ++mitr) {
    slog.add(mitr->first, mitr->second);
      }
      mlog.add(levelNames[l],slog);      
    }
 
    p.add("messages",mlog);
    
  }
 
  if (m_extraInfo.size() > 0) {    
    PD user;
    vector<pair<string,string> >::const_iterator itr (m_extraInfo.begin() );
    for (; itr != m_extraInfo.end(); ++itr) {
      string dat = itr->second;
      while( dat.find("\n") != string::npos) {
    dat.erase(dat.find("\n"),1);    
      }
      user.add(itr->first, dat);
    }
    p.add("user data",user);
  }
  
  if (m_extraIncidents.size() > 0) {
    PD inc;
    map<string, map<string,int> >::const_iterator itr(m_extraIncidents.begin());
    for (; itr != m_extraIncidents.end(); ++itr) {
      if (itr->second.begin() == itr->second.end()) {
    inc.add(itr->first,0);
      } else {
    PD inc2;
    for (map<string,int>::const_iterator it=itr->second.begin();
         it != itr->second.end(); ++it) {
      inc2.add(it->first, it->second);
    }
    inc.add(itr->first, inc2);
      }
    }
 
//     PD inc;
//     map<string, int>::const_iterator itr(m_extraIncidents.begin());
//     for (; itr != m_extraIncidents.end(); ++itr) {
//       inc.add(itr->first, itr->second);
//     }
 
    p.add("extra incidents",inc);
  }
 
  p.add("exit",m_status);
  p.add("bad_alloc",s_badalloc);
 
  std::println (ofd, "{}", p.dump());
}

createSummary()

StatusCode AthenaSummarySvc::createSummary ( )

overridevirtual

Definition at line 334 of file AthenaSummarySvc.cxx.

                                {
 
  ATH_MSG_DEBUG("createSummary");
 
  std::ofstream ofs;
  ofs.open(m_summaryFile.value().c_str());
  if (!ofs) {
    ATH_MSG_ERROR("Unable to open output file \"{}\"",
                  m_summaryFile.value());
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_DEBUG("Writing to \"{}\"", m_summaryFile.value());
 
  if (m_summaryFormat.value() == "ascii" || m_summaryFormat.value() == "both") {
    createASCII(ofs);
  }
 
  if (m_summaryFormat.value() == "python" || m_summaryFormat.value() == "both") {
    createDict(ofs);
  }
 
  ofs.close();
 
  return StatusCode::SUCCESS;
 
 
}

finalize()

StatusCode AthenaSummarySvc::finalize ( )

overridevirtual

Definition at line 203 of file AthenaSummarySvc.cxx.

                                      {
 
  createSummary().ignore();
 
  // cleanup
  delete[] s_block; s_block = nullptr;
  std::set_new_handler( m_new );
 
  return StatusCode::SUCCESS;
}

getOutputFile()

virtual const std::string & AthenaSummarySvc::getOutputFile ( ) const

inlineoverridevirtual

Definition at line 51 of file AthenaSummarySvc.h.

{ return m_summaryFile; }

handle()

void AthenaSummarySvc::handle ( const Incident & inc )

overrideprivatevirtual

Definition at line 283 of file AthenaSummarySvc.cxx.

                                            {
 
  ATH_MSG_DEBUG("handle incident: {} {}", inc.type(), inc.source());
 
  string fileName;
 
  const FileIncident *fi = dynamic_cast<const FileIncident*>( &inc );
  if (fi != nullptr) {
    // FIXME!!! waiting on AthenaPoolKernel-00-00-07
    ATH_MSG_INFO(" -> file incident: {} [GUID: {}]",
                 fi->fileName(), fi->fileGuid());
    fileName = fi->fileName();
  } else {
    fileName = inc.source();
  }
 
  if (inc.type() == "BeginInputFile" ) {
    m_inputFilesRead.emplace_back( std::move(fileName) );
  } else if (inc.type() == "BeginOutputFile") {
    m_outputFiles.emplace_back( std::move(fileName) );
  } else if (inc.type() == "FailOutputFile") {
    m_outputFilesError.push_back( std::move(fileName) );
  } else if (inc.type() == "BeginEvent") {
    m_eventsRead ++;
  } else if (inc.type() == "SkipEvent") {
    m_eventsSkipped ++;
  } else if (inc.type() == "WriteEvent") {
    m_eventsWritten ++;
  } else if (inc.type() == "BeginRun") {
    m_runs ++;
  } else if (inc.type() == "EndRun") {
  }
 
  map<std::string, map<string,int> >::iterator itr 
    ( m_extraIncidents.find(inc.type()) );
 
  if (itr != m_extraIncidents.end()) {
    map<string,int>::iterator it = itr->second.find(inc.source());
    if (it != itr->second.end()) {
      m_extraIncidents[inc.type()][inc.source()]++;
    } else {
      m_extraIncidents[inc.type()][inc.source()] = 1;
    }
  }
 
}

initialize()

StatusCode AthenaSummarySvc::initialize ( )

overridevirtual

Definition at line 121 of file AthenaSummarySvc.cxx.

                                        {
 
  ATH_MSG_DEBUG("Initializing AthenaSummarySvc");
 
  int pri=100;
  p_incSvc->addListener( this, "BeginInputFile", pri, true);
  p_incSvc->addListener( this, "EndInputFile", pri, true);
  p_incSvc->addListener( this, "BeginOutputFile", pri, true);
  p_incSvc->addListener( this, "FailOutputFile", pri, true);
  p_incSvc->addListener( this, "WroteToOutputFile", pri, true);
  p_incSvc->addListener( this, "EndOutputFile", pri, true);
 
  p_incSvc->addListener( this, "AbortEvent", pri, true);
 
  p_incSvc->addListener( this, "BeginEvent", pri, true);
  p_incSvc->addListener( this, "EndEvent", pri, true);
  p_incSvc->addListener( this, "BeginRun", pri, true);
  p_incSvc->addListener( this, "EndRun", pri, true);
 
  p_incSvc->addListener( this, "FirstInputFile", pri, true );
 
  vector<string>::const_iterator itr;
  for (itr=m_extraInc.value().begin(); itr != m_extraInc.value().end(); ++itr) {
    ATH_MSG_DEBUG("Tracking incident \"{}\"", *itr);
    addListener(*itr);
  }
 
  p_logMsg = dynamic_cast< ILoggedMessageSvc* > ( msgSvc().get() );
  if (p_logMsg == nullptr) {
    ATH_MSG_INFO("unable dcast IMessageSvc to ILoggedMessageSvc: "
                 "not scanning for keywords in logs, or printing logged messages");
      } else {
 
    if (m_keywords.value().size() > 0) {
      IProperty *ip = dynamic_cast<IProperty*>( p_logMsg );
      if (ip != nullptr) {
        if (ip->setProperty(m_keywords).isFailure()) {
          ATH_MSG_ERROR("could not set keywords property of LoggedMessageSvc");
        } else {
          ATH_MSG_INFO("Scanning log for keyword \"{}\". CAVEAT EMPTOR - THIS IS VERY SLOW!!",
                       m_keywords);
        }
      } else {
        ATH_MSG_ERROR("could not dcast LoggedMessageSvc to IProperty");
      }
    }
  }
 
  std::string fmt = m_summaryFormat.value();
  tolower(fmt);
  m_summaryFormat = fmt;
 
  // save some space for the summary output if we run out of memory
  ATH_MSG_DEBUG("allocating block of 100 pages");
  const long pageSize = sysconf( _SC_PAGESIZE );
  if (pageSize < 1 || pageSize > 1024*1024*1024) {
    ATH_MSG_FATAL ("Bad page size from sysconf");
    return StatusCode::FAILURE;
  }
  s_block = new char[ pageSize * 100 ];
 
 
  return StatusCode(s_block!=nullptr);
 
}

newHandler()

void AthenaSummarySvc::newHandler ( )

staticprivate

Definition at line 245 of file AthenaSummarySvc.cxx.

                             {
 
  s_badalloc = true;
 
  if ( ! s_block )
    throw std::bad_alloc();   // default behavior (no print-out)
 
  // release our block to create working space for finalize()
  delete[] s_block; s_block = nullptr;
  
  // print onto std::cerr rather than MsgStream, as it's more innocuous
  std::println (std::cerr, "AthenaSummarySvc     FATAL out of memory: saving summary ...");
 
  SmartIF<IAthenaSummarySvc> ipa(Gaudi::svcLocator()->service("AthenaSummarySvc"));
 
  if (ipa) {
    std::string btrace;
    if ( System::backTrace(btrace,5,3) ) {
      ipa->addSummary("badalloc backtrace",btrace);
    }
 
    ipa->setStatus(99);
    ipa->createSummary().ignore();
  } else {
    std::println (std::cerr, "AthenaSummarySvc    ERROR unable to get hold of myself and print summary");
  }
 
    
  // in order to abort the job, throw a bad_alloc, which should make its way
  // through to python, even if the ExceptionSvc is used, and that will shutdown
  // (finalize/terminate) the application on exit
  throw std::bad_alloc();
 
}

reinitialize()

StatusCode AthenaSummarySvc::reinitialize ( )

overridevirtual

Definition at line 189 of file AthenaSummarySvc.cxx.

                                          {
 
  delete[] s_block; s_block = nullptr;
  long pageSize = sysconf( _SC_PAGESIZE );
  if (pageSize < 1 || pageSize > 1024*1024*1024) {
    ATH_MSG_FATAL ("Bad page size from sysconf");
    return StatusCode::FAILURE;
  }
  s_block = new char[ pageSize * 100 ];
  return s_block ? StatusCode::SUCCESS : StatusCode::FAILURE;
 
}

setStatus()

virtual void AthenaSummarySvc::setStatus ( int s )

inlineoverridevirtual

Definition at line 48 of file AthenaSummarySvc.h.

{m_status = s;}

Member Data Documentation

ATLAS_THREAD_SAFE [1/2]

bool s_badalloc AthenaSummarySvc::ATLAS_THREAD_SAFE

staticprivate

Definition at line 75 of file AthenaSummarySvc.h.

ATLAS_THREAD_SAFE [2/2]

char* s_block AthenaSummarySvc::ATLAS_THREAD_SAFE

staticprivate

Definition at line 74 of file AthenaSummarySvc.h.

m_eventsRead

unsigned int AthenaSummarySvc::m_eventsRead {0}

private

Definition at line 86 of file AthenaSummarySvc.h.

{0};

m_eventsSkipped

unsigned int AthenaSummarySvc::m_eventsSkipped {0}

private

Definition at line 88 of file AthenaSummarySvc.h.

{0};

m_eventsWritten

unsigned int AthenaSummarySvc::m_eventsWritten {0}

private

Definition at line 87 of file AthenaSummarySvc.h.

{0};

m_extraInc

StringArrayProperty AthenaSummarySvc::m_extraInc

private

Initial value:

{this, "ExtraIncidents", {},
                                 "user incidets to monitor"}

Definition at line 65 of file AthenaSummarySvc.h.

                                {this, "ExtraIncidents", {},
                                 "user incidets to monitor"};

m_extraIncidents

std::map< std::string, std::map<std::string, int> > AthenaSummarySvc::m_extraIncidents

private

Definition at line 81 of file AthenaSummarySvc.h.

m_extraInfo

std::vector< std::pair<std::string, std::string> > AthenaSummarySvc::m_extraInfo

private

Definition at line 82 of file AthenaSummarySvc.h.

m_inputFilesRead

std::list<std::string> AthenaSummarySvc::m_inputFilesRead

private

Definition at line 77 of file AthenaSummarySvc.h.

m_keywords

StringArrayProperty AthenaSummarySvc::m_keywords

private

Initial value:

{this, "keywords", {},
                                 "kewords to scan for in MessageSvc. WARNING: THIS IS VERY SLOW!!!"}

Definition at line 67 of file AthenaSummarySvc.h.

                                {this, "keywords", {},
                                 "kewords to scan for in MessageSvc. WARNING: THIS IS VERY SLOW!!!"};

m_new

std::new_handler AthenaSummarySvc::m_new {nullptr}

private

Definition at line 84 of file AthenaSummarySvc.h.

{nullptr};

m_outputFiles

std::list<std::string> AthenaSummarySvc::m_outputFiles

private

Definition at line 78 of file AthenaSummarySvc.h.

m_outputFilesError

std::list<std::string> AthenaSummarySvc::m_outputFilesError

private

Definition at line 79 of file AthenaSummarySvc.h.

m_runs

unsigned int AthenaSummarySvc::m_runs {0}

private

Definition at line 89 of file AthenaSummarySvc.h.

{0};

m_status

int AthenaSummarySvc::m_status {0}

private

Definition at line 85 of file AthenaSummarySvc.h.

{0};

m_summaryFile

StringProperty AthenaSummarySvc::m_summaryFile

private

Initial value:

{this, "SummaryFile", "AthSummary.txt",
                               "Output File"}

Definition at line 61 of file AthenaSummarySvc.h.

                              {this, "SummaryFile", "AthSummary.txt",
                               "Output File"};

m_summaryFormat

StringProperty AthenaSummarySvc::m_summaryFormat

private

Initial value:

{this, "SummaryFileFormat", "both",
                                 "output format: one of 'ascii', 'python', 'both'"}

Definition at line 63 of file AthenaSummarySvc.h.

                                {this, "SummaryFileFormat", "both",
                                 "output format: one of 'ascii', 'python', 'both'"};

p_incSvc

ServiceHandle<IIncidentSvc> AthenaSummarySvc::p_incSvc

private

Definition at line 71 of file AthenaSummarySvc.h.

p_logMsg

ILoggedMessageSvc* AthenaSummarySvc::p_logMsg {nullptr}

private

Definition at line 72 of file AthenaSummarySvc.h.

{nullptr};

---

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

• AthenaSummarySvc.h
• AthenaSummarySvc.cxx