ATLAS Offline Software
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
Athena Namespace Reference

Some weak symbol referencing magic... More...

Namespaces

 AlgorithmTimerHandler
 
 detail
 
 details
 
 DsoUtils
 
 Options
 
 Units
 

Classes

class  AlgorithmTimer
 Timer that invokes a user callback once the time is reached. More...
 
struct  BitTraits
 Describe the bit features of an integral type T. More...
 
class  Callback1
 
class  Callback1Rep
 
class  CallbackImpF11
 
class  Chrono
 Exception-safe IChronoSvc caller. More...
 
class  ConditionsCleanerSvc
 Facade class for conditions garbage collection. More...
 
class  CondObjDeleter
 Deletion object for conditions payloads. More...
 
class  DataBucketBranch
 
class  DBLock
 Common database lock. More...
 
class  DebugAids
 Utilities for debugging support. More...
 
class  DelayedConditionsCleanerSvc
 Clean conditions containers after a delay. More...
 
class  DelayedConditionsCleanerSvcProps
 
class  DvThinningHdlr
 Handle DataProxy holding DataVector. This class defines a (type-safe) protocol to pack and unpack thinned DataVector. More...
 
struct  get_thinning_handler
 metafunction to automagically dispatch on the type of a container and fetch the right thinning handler More...
 
class  IConditionsCleanerSvc
 Interface for doing garbage collection of conditions objects. More...
 
class  IdcThinningHdlr
 Handle DataProxy holding IdentifiableContainer This class defines a (type-safe) protocol to pack and unpack thinned IdentifiableContainer. More...
 
class  IInputRename
 Interface to retrieve input rename map. More...
 
class  IMessageSvcHolder
 get a IMessageSvc* on 1st use (if not set) and release it on ~ More...
 
class  IRCUObject
 Base object class for RCU-style synchronization for Athena. More...
 
class  IRCUSvc
 Interface for RCU service. More...
 
class  ISlimmingHdlr
 This class defines a protocol to slim objects (removing parts of that object) More...
 
class  IThinningHdlr
 This class defines a protocol to pack and unpack thinned collections. More...
 
class  LeafCnv
 
class  NtupleCnvSvc
 
class  RCUObject
 Wrapper object controlled by RCU synchonization. More...
 
class  RCURead
 Helper to read data from a RCUObject. More...
 
class  RCUReadQuiesce
 Helper to read data from a RCUObject. More...
 
class  RCUSvc
 Service to allow cleaning up RCU objects at the EndEvent. More...
 
class  RCUUpdate
 Helper to update data in a RCUObject. More...
 
class  RCUUpdater
 Implementation of Updater for RCUSvc. More...
 
class  RecyclableDataObject
 Helper for recycling objects from event to event. More...
 
class  RecyclableDataQueue
 Holder for recyclable objects. More...
 
class  RootAsciiDumperAlg
 
class  RootAsciiDumperAlgHandle
 
class  RootBranchAddress
 
class  RootCnv
 This class provides the abstract converter to translate an object to/from its persistent ROOT representation. More...
 
class  RootCnvSvc
 This class provides the interface between Athena and RootSvc. More...
 
class  RootConnection
 This class provides the implementation of Athena::RootConnection class, similar to Gaudi IDataConnection. More...
 
class  RootGlobalsRestore
 
class  RootNtupleEventContext
 
class  RootNtupleEventSelector
 Class implementing the GAUDI IEvtSelector interface using ROOT TTree as a backend. More...
 
class  RootNtupleOutputMetadataTool
 This is the AthenaRoot version of AthenaServices/AthenaOutputStreamTool. More...
 
class  RootNtupleOutputStream
 algorithm that marks for write data objects in SG More...
 
class  RootOutputStreamTool
 This is the AthenaRoot version of AthenaServices/AthenaOutputStreamTool. More...
 
class  RootSvc
 This class provides the interface to the ROOT software. More...
 
class  ScopedTimer
 Helper class to create a "scoped cook timer" without having to declare the CookTimer itself within the scope (see CookTimer documentation) More...
 
class  SharedLibrary
 Shared library services. More...
 
class  SharedLibraryError
 Error in a shared library operation. More...
 
class  Signal
 Utilities for handling signals and fatal errors. More...
 
struct  StatusCategory
 
class  StdThinningHdlr
 Handle DataProxy holding std::vector<T> This class defines a (type-safe) protocol to pack and unpack thinned DataVector. More...
 
class  ThinningCacheTool
 Create ThinningCache for a given stream. More...
 
class  Timeout
 Singleton to access the timeout flag. More...
 
class  TimeoutMaster
 Class to modify timeout flag. More...
 
class  ToolLock
 RAII helper for acquiring the lock of an ILockableTool. More...
 
struct  TPCnvType
 
struct  TPCnvVers
 
class  xAODBranchAddress
 
class  xAODCnv
 
class  xAODCnvSvc
 
class  xAODEventContext
 
class  xAODEventSelector
 Class implementing the GAUDI IEvtSelector interface using ROOT TTree as a backend. More...
 

Typedefs

typedef void(* DummyHandlerType) (int)
 Dummy handler type for standard signal() function. More...
 
typedef RootNtupleEventContext::FileNames_t FileNames_t
 

Enumerations

enum  Status : StatusCode::code_t { Status::TIMEOUT = 10, Status::MISSING_DATA = 11 }
 Athena specific StatusCode values. More...
 

Functions

IMessageSvc * getMessageSvc (bool quiet=false)
 
IMessageSvc * getMessageSvc (const Options::CreateOptions o, bool quiet=false)
 
void reportMessage (IMessageSvc *ims, const std::string &source, int type, const std::string &message)
 Wrappers for some of the IMessageSvc methods These can be used from libraries without explicit Gaudi dependency via weak linking. More...
 
int outputLevel (const IMessageSvc *ims, const std::string &source)
 
void setOutputLevel (IMessageSvc *ims, const std::string &source, int level)
 
int ubsan_boost_suppress ()
 
template<class T1 , class T2 >
Callback1Rep< T1 > * CreateCallback (void(*function)(T1, T2), const T2 &fill_2)
 
void DebugAids::stacktraceLine ATLAS_NOT_THREAD_SAFE (IOFD fd, unsigned long addr)
 Write out stack trace line to FD. More...
 
void DebugAids::setStackTraceAddr2Line ATLAS_NOT_THREAD_SAFE (const char *path)
 
void DebugAids::stacktrace ATLAS_NOT_THREAD_SAFE (IOFD fd)
 Produce a stack trace. More...
 
void SharedLibrary::path ATLAS_NOT_THREAD_SAFE (const std::string &path)
 
void Signal::handleQuit ATLAS_NOT_THREAD_SAFE (QuitHook hook)
 
void Signal::handleFatal ATLAS_NOT_THREAD_SAFE (const char *applicationName, IOFD fd, FatalHook hook, FatalReturn mainreturn, unsigned options)
 Install default handler for fatal signals. More...
 
void Signal::quit ATLAS_NOT_THREAD_SAFE (int sig, siginfo_t *info, void *x)
 The quit signal handler. More...
 
bool Signal::fatalDump ATLAS_NOT_THREAD_SAFE (int sig, siginfo_t *info, void *extra, IOFD fd, unsigned options)
 
IOFD Signal::handleFatalFd ATLAS_NOT_THREAD_SAFE (void)
 Return the file descriptor #fataldump() uses for output. More...
 

Variables

std::atomic< bool > getMessageSvcQuiet
 Set this to force off the warning messages from getMessageSvc (in unit tests, for example). More...
 
int ubsan_boost_suppress_ = ubsan_boost_suppress()
 

Detailed Description

Some weak symbol referencing magic...

These are declared in AthenaKernel/getMessageSvc.h and will be non-nullptr in case the GaudiSvc/AthenaKernel shared libraries have been loaded.

Typedef Documentation

◆ DummyHandlerType

typedef void(* Athena::DummyHandlerType) (int)

Dummy handler type for standard signal() function.


Definition at line 109 of file SealSignal.cxx.

◆ FileNames_t

Definition at line 213 of file RootNtupleEventSelector.cxx.

Enumeration Type Documentation

◆ Status

enum Athena::Status : StatusCode::code_t
strong

Athena specific StatusCode values.

These can be used in place of Gaudi's StatusCode::XYZ if additional information should be returned. Some of these codes will result in special treatment of the event (e.g. sending them to the debug stream in the HLT).

Only generic return codes should be defined here. Algorithm-specific return values should be encoded in separate enums in the respective packages.

Enumerator
TIMEOUT 

Timeout during event processing.

MISSING_DATA 

Missing/corrupted input data.

Definition at line 22 of file AthStatusCode.h.

22  : StatusCode::code_t {
23  TIMEOUT = 10,
24  MISSING_DATA = 11
25 };

Function Documentation

◆ ATLAS_NOT_THREAD_SAFE() [1/9]

void Signal::handleFatal Athena::ATLAS_NOT_THREAD_SAFE ( const char *  applicationName,
IOFD  fd,
FatalHook  hook,
FatalReturn  mainreturn,
unsigned  options 
)

Install default handler for fatal signals.

This method installs a handler for fatal signals such as floating point exceptions, illegal instructions, and memory violations. The behaviour is more precisely determined by options, a bitwise or of the option constants defined in the class declaration.

applicationName sets the application name to be used to report the signal in #fatalDump(). fd sets the file descriptor to which the fatal signal message is written; by default this will be the standard error output. hook sets the pre-exit application hook to invoke, mainreturn sets the hook to return to back to the application "main loop" (i.e. ignore the signal by jumping out of the signal back to the somewhere higher up in the application).

Options left to default values will not change the current state. This allows one to re-install signal handlers without disturbing already registered information. Use this to restore handlers after some other library has meddled with the handlers.

This installs #fatal() as the handler for fatal signals and on Windows for otherwise unhandled fatal structured exceptions. If #FATAL_ON_QUIT is included in options, quitting related signals (see #quit()) are also considered fatal. If #FATAL_ON_INT is set, SIGINT is considered fatal—but see also #fatal() documentation. If #USR1_DUMP_CORE is set, #DebugAids::coredump is registered as a handler for SIGUSR1 (please note the security risks of this option in its documentation).

A multi-threaded application should call this method in each thread. (FIXME: Calling this in one thread and blocking signals in others won't work on Linux, and in any case will probably produce nonsense stack traces (unless stacktrace can be fixed to dump the stacks of all the threads). Since the handler is always the same, I am not sure it will make the slightest difference which thread catches the signals, and on the other hand, it is best to dump the problems in the faulting thread if possible.)

Definition at line 646 of file SealSignal.cxx.

651 {
652  // FIXME: Provide means to install handlers for fatal signals that
653  // an application has requested and app was supposed to register a
654  // handler before making the request? (So that if the app handler
655  // is not installed for some reason, an internal error hook can
656  // run?) Such fatal signals include:
657  // - SIGPIPE: read or write to broken pipe; child died
658  // (read or write to socket with ASYNC io?)
659  // - SIGLOST: lost a resource (e.g., lock on nfs server reboot)
660  // - SIGALRM: interval timer elapsed
661  // - SIGUSR1, SIGUSR2
662  // - SIGPOLL: pollable streams device events
663  // - SIGIO: i/o possible (from async i/o)
664  // - SIGVTALRM: virtual timer expired
665  // - SIGPROF: profiling timer expired
666  // - SIGRTMIN - SIGRTMAX: POSIX real-time signals
667  //
668  // Some of these the application should probably just #block()
669  // (e.g. SIGPIPE). Some of them the app should block and then
670  // wait or poll for events (SIGPOLL, SIGIO, possibly SIGALRM, the
671  // real-time signals if they are used).
672 
673  static const int hups [] = {
674 #ifdef SIGHUP
675  SIGHUP, // hang up (lost terminal or process group leader)
676 #endif
677 #ifdef SIGTERM
678  SIGTERM, // terminate (e.g. system going down)
679 #endif
680 #ifdef SIGQUIT
681  SIGQUIT, /* user request to quit and leave debuggable
682  state (from quit key on controlling
683  terminal) */
684 
685 #endif
686  -1
687  };
688 
689  static int fatals [] = {
690 #ifdef SIGFPE
691  SIGFPE, // arithmetic exception
692 #endif
693 #ifdef SIGILL
694  SIGILL, // illegal instruction
695 #endif
696 #ifdef SIGSEGV
697  SIGSEGV, // illegal address
698 #endif
699 #ifdef SIGBUS
700  SIGBUS, // hardware exception
701 #endif
702 #ifdef SIGIOT
703  SIGIOT, /* IOT trap. Before SIGABRT so that if SIGIOT
704  == SIGABRT then SIGABRT overrides SIGIOT;
705  SIGABRT is in ISO C and POSIX.1, SIGIOT is
706  not. */
707 #endif
708 #ifdef SIGABRT
709  SIGABRT, // abort
710 
711 #endif
712 #ifdef SIGTRAP
713  SIGTRAP, // trace/breakpoint reached
714 #endif
715 #ifdef SIGEMT
716  SIGEMT, // emulation trap (may be used by profiler?)
717 #endif
718 #ifdef SIGSYS
719  SIGSYS, // invalid system call
720 #endif
721 #ifdef SIGXCPU
722  SIGXCPU, // cpu time limit exceeded
723 #endif
724 #ifdef SIGXFSZ
725  SIGXFSZ, // file size limit exceeded
726 #endif
727  -1
728  };
729 
730  // Make sure `strsignal' is properly initialised.
731  name (1);
732 
733  // Remember app name if specified
734  if (applicationName && *applicationName)
735  s_applicationName = applicationName;
736 
737  // Automatically initialise s_fatalFd on first access
738  if (s_fatalFd == IOFD_INVALID)
739  s_fatalFd = STDERR_HANDLE;
740 
741  // Remember the fatal output fd if defined
742  if (fd != IOFD_INVALID)
743  s_fatalFd = fd;
744 
745  // Now that we know the fd, setup a callback for dumping shared
746  // libraries via #SignalDumpLibs. This avoids having to allocate
747  // memory for the callback implementation in the middle of a fatal
748  // signal, and on the other hand avoids a global object which
749  // might not be initialised yet.
750  delete SignalDumpCallback;
751  SignalDumpCallback = new SharedLibrary::InfoHandler
752  (CreateCallback (&SignalDumpLibs, s_fatalFd));
753 
754  // Remember the hooks if specified
755  if (hook)
756  s_fatalHook = hook;
757 
758  if (mainreturn)
759  s_fatalReturn = mainreturn;
760 
761  // Remember the new options
762  s_fatalOptions = options;
763 
764  // Signal::fatal() requires this, otherwise weird things can happen.
765  // Programs not wanting to return to main should set FATAL_AUTO_EXIT.
766  assert (s_fatalReturn || (s_fatalOptions & FATAL_AUTO_EXIT));
767 
768  // Install signal handlers.
769  if (options & FATAL_ON_QUIT)
770  for (unsigned sig = 0; hups [sig] != -1; ++sig)
771  handle (hups [sig], fatal);
772 
773  for (unsigned sig = 0; fatals [sig] != -1; ++sig)
774  handle (fatals [sig], fatal);
775 
776 #ifdef SIGINT
777  // interrupt key from controlling terminal
778  if (options & FATAL_ON_INT)
779  handle (SIGINT, fatal);
780 #endif
781 
782 #ifdef SIGUSR1
783  // program-defined signals SIGUSR1 and SIGUSR2
784  if (options & USR1_DUMP_CORE)
785  handle (SIGUSR1, (HandlerType) DebugAids::coredump);
786 #endif
787 
788 #ifdef _WIN32
789  SetUnhandledExceptionFilter (&SEHFatal);
790 #endif
791 }

◆ ATLAS_NOT_THREAD_SAFE() [2/9]

void DebugAids::setStackTraceAddr2Line Athena::ATLAS_NOT_THREAD_SAFE ( const char *  path)

Definition at line 579 of file SealDebug.cxx.

580 {
581  addr2LinePath = path;
582 }

◆ ATLAS_NOT_THREAD_SAFE() [3/9]

void SharedLibrary::path Athena::ATLAS_NOT_THREAD_SAFE ( const std::string &  path)

Definition at line 164 of file SealSharedLib.cxx.

165 {
166  /* Do not free `var'; most implementations of `putenv' use the
167  string without copying it. On systems where `putenv' copies,
168  you'll see leaks from this routine. It would be possible to
169  check for this, but only by killing cross-compilation.
170 
171  NB: `HAVE_COPYING_PUTENV' will never be set as we are not
172  checking for it :-) */
173 
174  const char *pathvar = PATH;
175  if (pathvar) {
176  const int path_size = strlen(pathvar) + 1 + path.length () + 1;
177  char *var = (char *) malloc (path_size);
178  snprintf (var, path_size, "%s=%s", pathvar, path.c_str ());
179  putenv (var);
180 #if HAVE_COPYING_PUTENV
181  free (var);
182 #endif
183  }
184 }

◆ ATLAS_NOT_THREAD_SAFE() [4/9]

bool Signal::fatalDump Athena::ATLAS_NOT_THREAD_SAFE ( int  sig,
siginfo_t info,
void *  extra,
IOFD  fd,
unsigned  options 
)

Definition at line 1515 of file SealSignal.cxx.

1518 {
1519  const unsigned int buf_size = sizeof (buf);
1520  bool haveCore = false;
1521  if (sig < 0)
1522  {
1523  sig = -sig;
1524  haveCore = true;
1525  }
1526 
1527  if (options & FATAL_DUMP_SIG)
1528  {
1529  MYWRITE (fd, "\n", 1);
1530  if (s_applicationName)
1531  {
1532  MYWRITE (fd, s_applicationName,
1533  STDC::strlen (s_applicationName));
1534  MYWRITE (fd, " ", 1);
1535  }
1536 
1537  MYWRITE (fd, buf,
1538  snprintf (buf, SIGNAL_MESSAGE_BUFSIZE, "(pid=%ld ppid=%ld) received fatal signal %d"
1539  " (%.100s)%s\n",
1540  (long) ProcessInfo__pid (), (long) ProcessInfo__ppid (), // wlav :: -> __ (x2)
1541  sig, name (sig), haveCore ? " (core dumped)" : ""));
1542 
1543  MYWRITE (fd, buf, snprintf(buf, buf_size, "signal context:\n"));
1544  dumpInfo (fd, buf, buf_size, sig, info);
1545  }
1546 
1547  unsigned long sp = 0;
1548  if (options & FATAL_DUMP_CONTEXT)
1549  sp = dumpContext (fd, buf, buf_size, extra);
1550 
1551  if (options & FATAL_DUMP_STACK)
1552  {
1553  MYWRITE (fd, buf, snprintf(buf, buf_size, "\nstack trace:\n"));
1554  if (s_lastSP) {
1555  MYWRITE (fd, buf, snprintf(buf, buf_size, "\n(backtrace failed; raw dump follows)\n"));
1556  MYWRITE (fd, buf, snprintf(buf, buf_size, "%016lx:", s_lastSP.load()));
1557  dumpMemory (fd, buf, buf_size, reinterpret_cast<void*>(s_lastSP.load()), 1024);
1558  MYWRITE (fd, buf, snprintf(buf, buf_size, "\n\n"));
1559  }
1560  else {
1561  s_lastSP = sp;
1562  DebugAids::stacktrace (fd);
1563  }
1564  s_lastSP = 0;
1565  }
1566 
1567  if (options & FATAL_DUMP_LIBS)
1568  {
1569  MYWRITE (fd, buf, snprintf(buf, buf_size, "\nshared libraries present:\n"));
1570  try { SharedLibrary::loaded (*SignalDumpCallback); }
1571  catch (...) { ; }
1572  }
1573 
1574  return true;
1575 }

◆ ATLAS_NOT_THREAD_SAFE() [5/9]

bool Signal::fatalDump Athena::ATLAS_NOT_THREAD_SAFE ( int  sig,
siginfo_t info,
void *  x 
)

The quit signal handler.

The fatal signal handler.

This is the handler installed by #handleQuit(). Please use #handleQuit() and this method instead of installing your own handlers with #handle().

This handler first invokes the application hook if one was given to #handleQuit(). If the hook returns true, the signal handler for this signal (number sig) is reset to its default handler, and the signal is re-raised. This causes the program to exit via the signal and have a the correct exit status.

The application should do whatever is necessary for a graceful shutdown. Note however that this signal may arrive asynchronously at any time, hence it probably isn't safe to allocate memory, use the standard output streams, and so forth. What you can do is to set a flag, return false to return back to your application, detect the flag setting and drain your current event loop, and then quit. But do note that if #FATAL_AUTO_EXIT was set in call to #handleFatal(), #fatal() will call #quit() which in turn calls the application hook. Thus the hook should make sure it returns true if the application has crashed as noted in the documentation for <<QuitHook>>.

This is the handler installed by #handleFatal(). Please use #handleFatal() and this method instead of installing your handlers with #handle(). You should be able use the handler options to specify all the control you need.

The first thing this handler does is to reinstall itself for the benefit of platforms with single-delivery signals. Immediately after that it unblocks the delivery of that signal again, in case the signal handler itself gets in trouble. The next step is to check if the current crash level (the recursion of calls to #fatal(), see #fatalLevel()) exceeds the predefined limit of 4; if so, we give up and let the application die with this this signal. The handler then determines whether the signal is fatal: everything except SIGINT is, and SIGINT is fatal if #FATAL_ON_INT was set. If the signal is fatal, crash indicator is set (see #crashed()).

If this is not a nested fatal signal, the signal is fatal, and #FATAL_DUMP_CORE is set, the handler tries dump a core file. Then the handler will either attempt to quit or to return to the main program depending on #FATAL_AUTO_EXIT option setting. If it is set or this is a nested fatal signal, the handler will attempt to exit as follows: the application hook (or #fatalDump() in its absence) is invoked. If the hook returns true, #quit() is called; otherwise the signal handler will return (and crash or get an infinite sequence of fatal signals). Note that if an application hook is registered, #fataldump() is not called by default; the application hook must invoke it itself to get the dump.

If #FATAL_AUTO_EXIT is not set, the application must have registered a main return hook, which will be invoked. The hook must not return, but do a siglongjmp back to the main program (it should not throw unless all code is built with options that allow exceptions to be thrown from signal handlers). Note that the fatal signal may be asynchronous and may have arisen in code left in unsafe state, so returning back to the main program may not buy you much. It may make sense for a few things like rogue null pointer dereferences or floating point exceptions.

An interactive application using a main return hook should do something like this when the sigsetjmp in the main loop returns:

  • disable "main loop entered" status
  • inform the user about the fatal error (e.g. with a popup); the popup window should be precreated for best stability
  • reset any locks the application holds, especially for user interface, including status bars, wait icons etc.
  • suggest to run a debugger against the program right there
  • in a windowing system ungrab pointer, keyboard and the server
  • unblock the signal via #block(sig, false) as the operating system may think the signal is still being processed
  • add an idle processor to re-return the "main loop entered" once all pending event queue events have been drained
  • go onto processing gui events

Using a main return will most likely leak memory like a sieve, but in balance, the application just got a fatal signal and the leak is unlikely to be the greatest concern.

Definition at line 817 of file SealSignal.cxx.

818 {
819  // Quit if no hook has been registered: we are coming in via
820  // FATAL_AUTO_EXIT in fatal and the application did not call
821  // handleQuit.
822  if (! s_quitHook || (*s_quitHook) (sig, info, x))
823  {
824  // Reactivate the default signal handling behaviour for this
825  // signal, which is to terminate the application one way or
826  // the other. Then exit through the signal. This makes the
827  // process exit status correct.
828  revert (sig);
829  raise (sig);
830  }
831 }

◆ ATLAS_NOT_THREAD_SAFE() [6/9]

void DebugAids::stacktrace Athena::ATLAS_NOT_THREAD_SAFE ( IOFD  fd)

Produce a stack trace.

Prints the current stack trace to file descriptor fd or if the default invalid descriptor, the currently registered stack trace descriptor as registered with #stacktraceFd(). Avoids unnecessary memory allocation so it should be safe to call this function even in dire situations. On some systems the implementation always outputs to the standard error and has no means for redirection. On these systems an attempt is made to redirect standard error momentarily elsewhere and then redirect standard error to the desired file descriptor, invoke the output, and redirect standard error back to its original location. If the redirection fails or the system has no stack tracing support, no stack trace is produced.

Definition at line 634 of file SealDebug.cxx.

635 {
636  if (fd == IOFD_INVALID)
637  fd = stacktraceFd();
638 
639  std::cerr.flush ();
640  fflush (stderr);
641 
642 #ifdef _WIN32
643  // FIXME: Autoload all these functions so users don't need to
644  // link in imagehlp.dll.
645  if (! SymInitialize (GetCurrentProcess (), NULL, TRUE))
646  {
647  MYWRITELIT (fd, ("failed to dump stack trace:"
648  " cannot get symbolic information\n"));
649  return;
650  }
651 
652  union SYMBUFFER {
653  IMAGEHLP_SYMBOL sym;
654  BYTE buffer [ sizeof (IMAGEHLP_SYMBOL) + 512 ];
655  };
656 
657  unsigned level = 0;
658  CONTEXT context;
659  STACKFRAME frame;
660  SYMBUFFER symbol;
661  IMAGEHLP_MODULE module;
662  char modulename [MAX_PATH];
663  DWORD section;
664  DWORD offset;
665  const int buf_size = 2*40+6; // ample for two 128+ bit numbers
666  char buf [buf_size];
667  // DWORD exceptargs [] = { (DWORD) &context };
668 
669  // FIXME: XP 64-bit adds: RtlCaptureContext (&context);
670  // This is documented to *not* work, but apparently it does.
671  context.ContextFlags = CONTEXT_FULL;
672  if (! GetThreadContext (GetCurrentThread (), &context))
673  return;
674 
675  // LPTOP_LEVEL_EXCEPTION_FILTER oldseh
676  // = SetUnhandledExceptionFilter (&GrabExceptionContext);
677  // RaiseException (0, 0, 1, exceptargs);
678  // SetUnhandledExceptionFilter (oldseh);
679 
680  memset (&module, 0, sizeof (module));
681  memset (&frame, 0, sizeof (frame));
682 
683  module.SizeOfStruct = sizeof (module);
684 
685  frame.AddrPC.Offset = context.Eip;
686  frame.AddrPC.Mode = AddrModeFlat;
687  frame.AddrStack.Offset = context.Esp;
688  frame.AddrStack.Mode = AddrModeFlat;
689  frame.AddrFrame.Offset = context.Ebp;
690  frame.AddrFrame.Mode = AddrModeFlat;
691 
692  while (true)
693  {
694  if (! StackWalk (IMAGE_FILE_MACHINE_I386,
695  GetCurrentProcess (),
696  GetCurrentThread (),
697  &frame,
698  &context,
699  NULL,
700  SymFunctionTableAccess,
701  SymGetModuleBase,
702  NULL)
703  || frame.AddrFrame.Offset == 0)
704  break;
705 
706  // FIXME: Throw away everything above stacktrace? Keep looping
707  // below until the name includes something we understand?
708 
709  // Print stack frame too? If we know how many arguments there
710  // are (from demangling function name -- see below, could count
711  // commas), args are: *((ULONG *)frame.AddrFrame.Offset+2+ARG).
712  MYWRITE (fd, buf, snprintf (buf, buf_size, "(%2u) 0x%08lx 0x%08lx ",
713  level, frame.AddrPC.Offset,
714  frame.AddrFrame.Offset));
715 
716  memset (&symbol, 0, sizeof (symbol));
717  symbol.sym.SizeOfStruct = sizeof (symbol);
718  symbol.sym.MaxNameLength = sizeof (symbol) - sizeof (symbol.sym);
719 
720  offset = 0;
721  if (SymGetSymFromAddr (GetCurrentProcess (), frame.AddrPC.Offset,
722  &offset, &symbol.sym))
723  {
724  // FIXME: Demangle name with:
725  // UnDecorateSymbolName (name, undecname, sizeof (undecname),
726  // UNDNAME_COMPLETE
727  // | UNDNAME_NO_THISTYPE
728  // | UNDNAME_NO_SPECIAL_SYMS
729  // | UNDNAME_NO_MEMBER_TYPE
730  // | UNDNAME_NO_MS_KEYWORDS
731  // | UNDNAME_NO_ACCESS_SPECIFIERS);
732  MYWRITE (fd, symbol.sym.Name, STDC::strlen (symbol.sym.Name));
733  MYWRITE (fd, buf, snprintf (buf, buf_size, " + %lx", offset));
734 
735  if (SymGetModuleInfo (GetCurrentProcess(), frame.AddrPC.Offset,
736  &module))
737  {
738  MYWRITELIT (fd, " [");
739  MYWRITE (fd, module.ImageName,
740  STDC::strlen (module.ImageName));
741  MYWRITELIT (fd, "]");
742  }
743  }
744  else
745  {
746  GetLogicalAddress ((PVOID) frame.AddrPC.Offset,
747  modulename, sizeof (modulename),
748  section, offset);
749  MYWRITE (fd, buf, snprintf (buf, buf_size, "%04lx:%08lx [", section, offset));
750  MYWRITE (fd, modulename, STDC::strlen (modulename));
751  MYWRITELIT (fd, "]");
752  }
753  MYWRITELIT (fd, "\n");
754  ++level;
755  }
756  SymCleanup (GetCurrentProcess ());
757 
758 #elif (HAVE_U_STACK_TRACE || HAVE_XL_TRBK) // hp-ux, aix
759  // FIXME: deal with inability to duplicate the file handle
760  int stderrfd = dup (STDERR_FILENO);
761  if (stderrfd == -1)
762  return;
763 
764  int newfd = dup2 (fd, STDERR_FILENO);
765  if (newfd == -1)
766  {
767  close (stderrfd);
768  return;
769  }
770 
771 # if HAVE_U_STACK_TRACE // hp-ux
772  U_STACK_TRACE ();
773 # elif HAVE_XL_TRBK // aix
774  xl__trbk ();
775 # else
776 # error "oops, you shouldn't have gotten here!"
777 # endif
778 
779  fflush (stderr);
780  dup2 (stderrfd, STDERR_FILENO);
781  close (newfd);
782 #elif HAVE_LINUX_UNWIND_BACKTRACE
783  CxxUtils::backtraceByUnwind (stacktraceLine, fd);
784 
785 #elif HAVE_BACKTRACE_SYMBOLS_FD && HAVE_DLADDR // linux
786  // we could have used backtrace_symbols_fd, except its output
787  // format is pretty bad, so recode that here :-(
788  void *trace [MAX_BACKTRACE_DEPTH];
789  int depth = backtrace (trace, MAX_BACKTRACE_DEPTH);
790 
791  for (int n = 0; n < depth; ++n/*, nbufs = 0*/)
792  {
793  unsigned long addr = (unsigned long) trace [n];
794  stacktraceLine (fd, addr);
795  }
796 
797 #elif HAVE_EXCPT_H && HAVE_PDSC_H && HAVE_RLD_INTERFACE_H // tru64
798  // Tru64 stack walk. Uses the exception handling library and the
799  // run-time linker's core functions (loader(5)). FIXME: Tru64
800  // should have _RLD_DLADDR like IRIX below. Verify and update.
801 
802  const int buffer_size = 100 + BitTraits<unsigned long>::HexDigits * 2 + 11;
803  char buffer [buffer_size];
804  sigcontext context;
805  int rc = 0;
806 
807  exc_capture_context (&context);
808  while (!rc && context.sc_pc)
809  {
810  // FIXME: Elf32?
811  pdsc_crd *func, *base, *crd
812  = exc_remote_lookup_function_entry(0, 0, context.sc_pc, 0, &func, &base);
813  Elf32_Addr addr = PDSC_CRD_BEGIN_ADDRESS(base, func);
814  // const char *name = _rld_address_to_name(addr);
815  const char *name = "<unknown function>";
816  snprintf (buffer, buffer_size, " 0x%012lx %.100s + 0x%lx\n",
817  context.sc_pc, name, context.sc_pc - addr);
818  write (fd, buffer, STDC::strlen(buffer));
819  rc = exc_virtual_unwind(0, &context);
820  }
821 
822 #elif HAVE_EXCEPTION_H && defined __sgi // irix
823  // IRIX stack walk -- like Tru64 but with a little different names.
824  // NB: The guard above is to protect against unrelated <exception.h>
825  // provided by some compilers (e.g. KCC 4.0f).
826  // NB: libexc.h has trace_back_stack and trace_back_stack_and_print
827  // but their output isn't pretty and nowhere as complete as ours.
828  char buffer [340];
829  sigcontext context;
830 
831  exc_setjmp (&context);
832  while (context.sc_pc >= 4)
833  {
834  // Do two lookups, one using exception handling tables and
835  // another using _RLD_DLADDR, and use the one with a smaller
836  // offset. For signal handlers we seem to get things wrong:
837  // _sigtramp's exception range is huge while based on Dl_info
838  // the offset is small -- but both supposedly describe the
839  // same thing. Go figure.
840  char *name = 0;
841  const char *libname = 0;
842  const char *symname = 0;
843  Elf32_Addr offset = ~0L;
844 
845  // Do the exception/dwarf lookup
846  Elf32_Addr pc = context.sc_pc;
847  Dwarf_Fde fde = find_fde_name (&pc, &name);
848  Dwarf_Addr low_pc = context.sc_pc;
849  Dwarf_Unsigned udummy;
850  Dwarf_Signed sdummy;
851  Dwarf_Ptr pdummy;
852  Dwarf_Off odummy;
853  Dwarf_Error err;
854 
855  symname = name;
856 
857  // Determine offset using exception descriptor range information.
858  if (dwarf_get_fde_range (fde, &low_pc, &udummy, &pdummy, &udummy,
859  &odummy, &sdummy, &odummy, &err) == DW_DLV_OK)
860  offset = context.sc_pc - low_pc;
861 
862  // Now do a dladdr() lookup. If the found symbol has the same
863  // address, trust the more accurate offset from dladdr();
864  // ignore the looked up mangled symbol name and prefer the
865  // demangled name produced by find_fde_name(). If we find a
866  // smaller offset, trust the dynamic symbol as well. Always
867  // trust the library name even if we can't match it with an
868  // exact symbol.
869  Elf32_Addr addr = context.sc_pc;
870  Dl_info info;
871 
872  if (_rld_new_interface (_RLD_DLADDR, addr, &info))
873  {
874  if (info.dli_fname && info.dli_fname [0])
875  libname = info.dli_fname;
876 
877  Elf32_Addr symaddr = (Elf32_Addr) info.dli_saddr;
878  if (symaddr == low_pc)
879  offset = addr - symaddr;
880  else if (info.dli_sname
881  && info.dli_sname [0]
882  && addr - symaddr < offset)
883  {
884  offset = addr - symaddr;
885  symname = info.dli_sname;
886  }
887  }
888 
889  // Print out the result
890  if (libname && symname)
891  write (fd, buffer, snprintf
892  (buffer, buffer_size, " 0x%012lx %.100s + 0x%lx [%.200s]\n",
893  addr, symname, offset, libname));
894  else if (symname)
895  write (fd, buffer, snprintf
896  (buffer, buffer_size, " 0x%012lx %.100s + 0x%lx\n",
897  addr, symname, offset));
898  else
899  write (fd, buffer, snprintf
900  (buffer, buffer_size, " 0x%012lx <unknown function>\n", addr));
901 
902  // Free name from find_fde_name().
903  free (name);
904 
905  // Check for termination. exc_unwind() sets context.sc_pc to
906  // 0 or an error (< 4). However it seems we can't unwind
907  // through signal stack frames though this is not mentioned in
908  // the docs; it seems that for those we need to check for
909  // changed pc after find_fde_name(). That seems to indicate
910  // end of the post-signal stack frame. (FIXME: Figure out how
911  // to unwind through signal stack frame, e.g. perhaps using
912  // sigcontext_t's old pc? Or perhaps we can keep on going
913  // down without doing the symbol lookup?)
914  if (pc != context.sc_pc)
915  break;
916 
917  exc_unwind (&context, fde);
918  }
919 
920 #elif defined PROG_PSTACK // solaris
921 # ifdef PROG_CXXFILT
922 # define CXXFILTER " | " PROG_CXXFILT
923 # else
924 # define CXXFILTER
925 # endif
926  // 64 should more than plenty for a space and a pid.
927  const int buffer_size = sizeof(PROG_PSTACK) + 1 + BitTraits<unsigned long>::Digits
928  + 3 + sizeof(PROG_CXXFILT) + BitTraits<int>::Digits + 1;
929  char buffer [buffer_size];
930  snprintf (buffer, buffer_size, "%s %lu%s 1>&%d", PROG_PSTACK, (unsigned long) getpid (),
931  "" CXXFILTER, fd);
932  system (buffer);
933 # undef CXXFILTER
934 
935 #elif __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
936  // FIXME: Check for _Unwind*, compilers other than GCC support this API
937  _Unwind_Backtrace (unwindWalkStack, &fd);
938 #endif
939 
940  // FIXME: mpatrol has some generic unix unwind code.
941  // FIXME: from unix faq: ask debugger to dump stack trace
942  // with something like:
943  // - gdb: echo "thread apply all where\nwhere\ndetach" | gdb $prog $pid
944  // - dbx: echo "where\ndetach" | dbx -a $program_path $pid
945  // - dbx (aix): echo "where\ndetach" | dbx -p $program_path $pid
946 }

◆ ATLAS_NOT_THREAD_SAFE() [7/9]

void DebugAids::stacktraceLine Athena::ATLAS_NOT_THREAD_SAFE ( IOFD  fd,
unsigned long  addr 
)

Write out stack trace line to FD.

IP is the instruction pointer. (sss)

Definition at line 328 of file SealDebug.cxx.

330 {
331  iovec bufs [7];
332  int nbufs = 0;
333  const int addrbuf_size = 5 + BitTraits<unsigned long>::HexDigits;
334  char addrbuf [addrbuf_size];
335 
336 #if HAVE_BACKTRACE_SYMBOLS_FD && HAVE_DLADDR
337  const int diffbuf_size = 15 + BitTraits<unsigned long>::HexDigits;
338  char diffbuf [diffbuf_size];
339  static const char trailer [] = "]\n";
340  Dl_info info;
341 
342  char dembuf[ LINE_MAX ];
343  char line[ LINE_MAX ];
344 
345  if (dladdr ((void*)addr, &info) && info.dli_fname && info.dli_fname[0])
346  {
347  const char *libname = info.dli_fname;
348 
349  unsigned long symaddr = (unsigned long) info.dli_saddr;
350  bool gte = (addr >= symaddr);
351  unsigned long diff = (gte ? addr - symaddr : symaddr - addr);
352 
353  // RS start
354  int length = 0;
355 
356  const int relbuf_size = 7 + BitTraits<unsigned long>::HexDigits;
357  char relbuf [relbuf_size];
358 
359  // difference of two pointers
360  unsigned long libaddr = (unsigned long) info.dli_fbase;
361  unsigned long relative_address = (addr >= libaddr) ? addr - libaddr : libaddr - addr;
362  // ELF executables are usually not relocatable, and on 64-bit platforms
363  // are usually loaded starting at 0x400000. In that case, we should _not_
364  // subtract the base address. But clang15 by default appears to produce
365  // position-independent executables (PIE) by default. In that case,
366  // we do need to subtract the offset.
367  // I'm not sure how to reliably tell the difference short of parsing
368  // the object headers. For now, just assume that something
369  // that doesn't have .so in the name and is loaded at 0x400000
370  // is not relocatable. This is not really portable, though.
371  if (strstr (info.dli_fname, ".so") == 0 && libaddr == 0x400000)
372  relative_address = addr;
373 
374  // need popen for addr2line ...
375  int pfd;
376  pid_t child_pid;
377  const char* symname = dembuf;
378  size_t demlen = 0;
379 
380  // did we find valid entry ?
381  size_t len = strlen(info.dli_fname);
382  if ( len > 0 && len + 80 < LINE_MAX)
383  {
384  if (getenv ("LD_PRELOAD"))
385  unsetenv ("LD_PRELOAD");
386 
387  if ( addr2LinePath == "/usr/bin/eu-addr2line" )
388  {
389  snprintf (line, LINE_MAX, "%s -f -e %s %p | /usr/bin/c++filt | /usr/bin/tr \\\\012 \\\\040 ",
390  addr2LinePath.c_str(),
391  info.dli_fname,
392  (void*)relative_address);
393  }
394  else
395  {
396  snprintf (line, LINE_MAX, "%s -f -C -e %s %p",
397  addr2LinePath.c_str(),
398  info.dli_fname,
399  (void*)relative_address);
400  }
401 
402  pfd = stacktracePopenFD( line, child_pid );
403 
404  length = 1;
405  line[0] = ' ';
406 
407  // did we succeed to open the pipe?
408  if ( pfd >= 0 )
409  {
410  demlen = stacktraceReadline (pfd, dembuf, sizeof(dembuf));
411 
412  length = stacktraceReadline (pfd, line+1, sizeof(line)-1);
413  if (length >= 0) ++length;
414 
415  int stat = stacktracePcloseFD (pfd, child_pid);
416 
417  // don't print anything, if nothing is found
418  if ( stat || line[1] == '?' || length < 0)
419  {
420  line[1] = '\0';
421  length = 0;
422  }
423 
424  if ( stat || demlen <= 0 || dembuf[0] == '?') {
425  symname = info.dli_sname;
426  if (!symname) symname = "???";
427  demlen = strlen (symname);
428  }
429 
430  }
431  }
432  // RS end
433 
434  bufs [nbufs].iov_base = addrbuf;
435  bufs [nbufs].iov_len = snprintf (addrbuf, addrbuf_size, " 0x%08lx ", addr);
436  ++nbufs;
437 
438  bufs [nbufs].iov_base = (void *) symname; // discard const
439  bufs [nbufs].iov_len = demlen;
440  ++nbufs;
441 
442  // RS start
443  bufs [nbufs].iov_base = line;
444  bufs [nbufs].iov_len = length;
445  ++nbufs;
446  // RS end
447 
448  bufs [nbufs].iov_base = diffbuf;
449  bufs [nbufs].iov_len = snprintf (diffbuf, diffbuf_size, " %c 0x%lx [",
450  gte ? '+' : '-', diff);
451  ++nbufs;
452 
453  bufs [nbufs].iov_base = (void *) libname; // discard const
454  bufs [nbufs].iov_len = strlen (libname);
455  ++nbufs;
456 
457  // RS start
458  bufs [nbufs].iov_base = relbuf;
459  bufs [nbufs].iov_len = snprintf( relbuf, relbuf_size, " D[%p]", (void*)relative_address );
460  ++nbufs;
461  // RS end
462 
463  bufs [nbufs].iov_base = (void *) trailer; // discard const
464  bufs [nbufs].iov_len = 2;
465  ++nbufs;
466 
467  }
468  else
469 #endif
470  {
471  bufs [nbufs].iov_base = addrbuf;
472  bufs [nbufs].iov_len = snprintf (addrbuf, addrbuf_size, " 0x%08lx ", addr);
473  ++nbufs;
474 
475  bufs [nbufs].iov_base = (void *) "<unknown function>\n"; //no const
476  bufs [nbufs].iov_len = 19;
477  ++nbufs;
478  }
479 
480  writev (fd, bufs, nbufs);
481 }

◆ ATLAS_NOT_THREAD_SAFE() [8/9]

void Signal::handleQuit Athena::ATLAS_NOT_THREAD_SAFE ( QuitHook  hook)

Definition at line 581 of file SealSignal.cxx.

582 {
583  static int hups [] = {
584 #ifdef SIGHUP
585  // hang up (lost terminal or process group leader)
586  SIGHUP,
587 #endif
588 #ifdef SIGTERM
589  // terminate (e.g. system going down)
590  SIGTERM,
591 #endif
592 #ifdef SIGQUIT
593  // user request to quit and leave debuggable state (from quit
594  // key on controlling terminal)
595  SIGQUIT,
596 #endif
597  -1
598  };
599 
600  if (hook)
601  s_quitHook = hook;
602 
603  for (unsigned sig = 0; hups [sig] != -1; ++sig)
604  handle (hups [sig], quit);
605 }

◆ ATLAS_NOT_THREAD_SAFE() [9/9]

bool Signal::crashed Athena::ATLAS_NOT_THREAD_SAFE ( void  )

Return the file descriptor #fataldump() uses for output.

Return the crash status indicator: true if a fatal signal has been received since the program started.

Return the depth to which #fatal() is currently recursively entered, or zero if #fatal() is not currently active.

Return the current application quit signal hook.

Return the current fatal signal handling options.

Return the application fatal signal return hook.

Return the application fatal signal hook.

Registered through #handleFatal().

Registered through #handleFatal().

See also
#fatal()

Registered through #handleFatal().

See also
#fatal().

Set on invocation to #handleFatal().

Registered through #handleQuit().

Use this method in application fatal hook to decide which operations are safe to perform. For example, if the attempts to notify the user result in further signals, it is best to avoid such attempts at deeper recursion levels. Currently #fatal() ceases to call the application's hooks and forces termination if the nesting level reaches 4.

Set if #fatal() is entered with a fatal signal.

Definition at line 1580 of file SealSignal.cxx.

1581 {
1582  // Automatically initialise on first access.
1583  if (s_fatalFd == IOFD_INVALID)
1584  s_fatalFd = STDERR_HANDLE;
1585 
1586  return s_fatalFd;
1587 }

◆ CreateCallback()

template<class T1 , class T2 >
Callback1Rep<T1>* Athena::CreateCallback ( void(*)(T1, T2)  function,
const T2 &  fill_2 
)
inline

Definition at line 136 of file SealSharedLib.h.

138 { return new CallbackImpF11<T1,T2> (function, fill_2); }

◆ getMessageSvc() [1/2]

IMessageSvc * Athena::getMessageSvc ( bool  quiet = false)

Definition at line 20 of file getMessageSvc.cxx.

20 { return getMessageSvc( Options::Lazy, quiet ); }

◆ getMessageSvc() [2/2]

IMessageSvc * Athena::getMessageSvc ( const Options::CreateOptions  o,
bool  quiet = false 
)

Definition at line 21 of file getMessageSvc.cxx.

21  {
22 
23  // We cache the MessageSvc, but only once it has been found. This ensures that an
24  // early call to this method (before MessageSvc is available) does not prevent
25  // from finding it in subsequent calls. The limited use of ServiceHandle for this
26  // purpose should be thread-safe:
27  static ServiceHandle<IMessageSvc> msgSvc ATLAS_THREAD_SAFE ("MessageSvc", "getMessageSvc");
28 
29  if (msgSvc.get()) {
30  msgSvc->addRef(); // even if cached, maintain correct ref-count
31  }
32  else {
33  const bool warn = !(quiet || Athena::getMessageSvcQuiet);
34  if ( ((opt==Athena::Options::Lazy && !Gaudi::svcLocator()->existsService("MessageSvc")) ||
35  msgSvc.retrieve().isFailure()) && warn ) {
36  std::cerr << "Athena::getMessageSvc: WARNING MessageSvc not found, will use std::cout" << std::endl;
37  }
38  }
39 
40  return msgSvc.get();
41 }

◆ outputLevel()

int Athena::outputLevel ( const IMessageSvc *  ims,
const std::string &  source 
)

Definition at line 47 of file getMessageSvc.cxx.

47  {
48  if (ims) return ims->outputLevel(source);
49  else return MSG::INFO;
50 }

◆ reportMessage()

void Athena::reportMessage ( IMessageSvc *  ims,
const std::string &  source,
int  type,
const std::string &  message 
)

Wrappers for some of the IMessageSvc methods These can be used from libraries without explicit Gaudi dependency via weak linking.

(see e.g. TrigConf::MsgStream in TrigConfBase)

DO NOT MODIFY THE SIGNATURE OF THESE METHODS WITHOUT UPDATING THE TRIGCONF SIDE !!!

Definition at line 43 of file getMessageSvc.cxx.

43  {
44  if (ims) ims->reportMessage(source, type, message);
45 }

◆ setOutputLevel()

void Athena::setOutputLevel ( IMessageSvc *  ims,
const std::string &  source,
int  level 
)

Definition at line 52 of file getMessageSvc.cxx.

52  {
53  if(ims) ims->setOutputLevel(source, level);
54 }

◆ ubsan_boost_suppress()

int Athena::ubsan_boost_suppress ( )

Definition at line 21 of file ubsan_boost_suppress.cxx.

22 {
23  // See <https://svn.boost.org/trac/boost/ticket/11632>
24  CxxUtils::ubsan_suppress ([]() { boost::format("%1%") % "asd"; });
25  return 0;
26 }

Variable Documentation

◆ getMessageSvcQuiet

std::atomic< bool > Athena::getMessageSvcQuiet

Set this to force off the warning messages from getMessageSvc (in unit tests, for example).

Definition at line 18 of file getMessageSvc.cxx.

◆ ubsan_boost_suppress_

int Athena::ubsan_boost_suppress_ = ubsan_boost_suppress()

Definition at line 29 of file ubsan_boost_suppress.cxx.

grepfile.info
info
Definition: grepfile.py:38
Athena::Options::Lazy
@ Lazy
Definition: getMessageSvc.h:23
pid_t
int32_t pid_t
Definition: FPGATrackSimTypes.h:19
base
std::string base
Definition: hcg.cxx:78
beamspotnt.var
var
Definition: bin/beamspotnt.py:1394
checkFileSG.line
line
Definition: checkFileSG.py:75
egammaParameters::depth
@ depth
pointing depth of the shower as calculated in egammaqgcld
Definition: egammaParamDefs.h:276
athena.path
path
python interpreter configuration --------------------------------------—
Definition: athena.py:128
vtune_athena.format
format
Definition: vtune_athena.py:14
Athena::getMessageSvcQuiet
std::atomic< bool > getMessageSvcQuiet
Set this to force off the warning messages from getMessageSvc (in unit tests, for example).
Definition: getMessageSvc.cxx:18
make_coralServer_rep.opt
opt
Definition: make_coralServer_rep.py:19
quiet
bool quiet
Definition: TrigGlobEffCorrValidation.cxx:190
mc.diff
diff
Definition: mc.SFGenPy8_MuMu_DD.py:14
get_generator_info.stderr
stderr
Definition: get_generator_info.py:40
x
#define x
ReweightUtils.message
message
Definition: ReweightUtils.py:15
Athena::getMessageSvc
IMessageSvc * getMessageSvc(bool quiet=false)
Definition: getMessageSvc.cxx:20
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
Athena::Status::MISSING_DATA
@ MISSING_DATA
Missing/corrupted input data.
python.PyAthena.module
module
Definition: PyAthena.py:131
PlotCalibFromCool.modulename
modulename
Definition: PlotCalibFromCool.py:81
createCoolChannelIdFile.buffer
buffer
Definition: createCoolChannelIdFile.py:12
dqt_zlumi_pandas.err
err
Definition: dqt_zlumi_pandas.py:182
StdJOSetup.msgSvc
msgSvc
Provide convenience handles for various services.
Definition: StdJOSetup.py:36
python.DecayParser.buf
buf
print ("=> [%s]"cmd)
Definition: DecayParser.py:27
beamspotman.n
n
Definition: beamspotman.py:731
python.ByteStreamConfig.write
def write
Definition: Event/ByteStreamCnvSvc/python/ByteStreamConfig.py:247
python.BuildSignatureFlags.sig
sig
Definition: BuildSignatureFlags.py:218
python.Constants.TRUE
bool TRUE
for job options legacy (TODO: get rid of these!) ----------------------—
Definition: Control/AthenaCommon/python/Constants.py:22
TrigInDetValidation_Base.malloc
malloc
Definition: TrigInDetValidation_Base.py:132
python.AtlRunQueryLib.options
options
Definition: AtlRunQueryLib.py:379
beamspotman.stat
stat
Definition: beamspotman.py:266
python.handimod.extra
int extra
Definition: handimod.py:522
ReadFromCoolCompare.fd
fd
Definition: ReadFromCoolCompare.py:196
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:225
IOFD_INVALID
#define IOFD_INVALID
Invalid channel descriptor constant.
Definition: SealCommon.h:20
ReadBadBitsFromCool.warn
warn
Definition: ReadBadBitsFromCool.py:43
Athena::Status::TIMEOUT
@ TIMEOUT
Timeout during event processing.
SCT_ConditionsAlgorithms::CoveritySafe::getenv
std::string getenv(const std::string &variableName)
get an environment variable
Definition: SCT_ConditionsUtilities.cxx:17
MYWRITE
#define MYWRITE(fd, data, n)
Definition: SealDebug.cxx:93
PATH
TString PATH
Definition: run_EoverP.cxx:91
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
if
if(febId1==febId2)
Definition: LArRodBlockPhysicsV0.cxx:567
convertTimingResiduals.offset
offset
Definition: convertTimingResiduals.py:71
copySelective.source
string source
Definition: copySelective.py:32
ATLAS_THREAD_SAFE
#define ATLAS_THREAD_SAFE
Definition: checker_macros.h:211
section
void section(const std::string &sec)
Definition: TestTriggerMenuAccess.cxx:22
MYWRITELIT
#define MYWRITELIT(fd, str)
Definition: SealDebug.cxx:97
CxxUtils::ubsan_suppress
void ubsan_suppress(void(*func)())
Helper for suppressing ubsan warnings.
Definition: ubsan_suppress.cxx:69
check_log.backtrace
backtrace
Definition: check_log.py:58
length
double length(const pvec &v)
Definition: FPGATrackSimLLPDoubletHoughTransformTool.cxx:26
python.SystemOfUnits.pc
float pc
Definition: SystemOfUnits.py:99
Athena::CreateCallback
Callback1Rep< T1 > * CreateCallback(void(*function)(T1, T2), const T2 &fill_2)
Definition: SealSharedLib.h:136
STDERR_HANDLE
#define STDERR_HANDLE
Definition: SealDebug.h:34
python.trfValidateRootFile.rc
rc
Definition: trfValidateRootFile.py:350
MYWRITE
#define MYWRITE(fd, data, n)
Definition: SealDebug.h:44
ServiceHandle< IMessageSvc >