[core] Ensure registration of atexit function is done only once

vepadulano · vepadulano · commit 697a0b0f689b · 2022-06-14T15:38:49.000+02:00
Before this commit, the following triggered two calls to
TROOT::EndOfProcessCleanups:

python -c "import ROOT; ROOT.TH1F"

This happened because the TApplication constructor registered a
function that calls EndOfProcessCleanups with the C `atexit` and
PyROOT registered another similar function with the Python atexit
module in `__init__.py`. The Python atexit happened before the C
atexit.

This commit introduces a static function in TApplication that
registers the call to EndOfProcessCleanups with the C `atexit` and
this is guaranteed to be run only once through the use of
std::call_once. This new function can be called both from PyROOT
and the TApplication constructor, to make sure it will be
registered by either of them.

Furthermore, calling this from PyROOT means that now
EndOfProcessCleanups is always called at the very end of the
program, seemingly a more sensible choice.
diff --git a/bindings/pyroot/pythonizations/python/ROOT/__init__.py b/bindings/pyroot/pythonizations/python/ROOT/__init__.py
@@ -79,6 +79,7 @@ def cleanup():
             # Hard teardown: run part of the gROOT shutdown sequence.
             # Running it here ensures that it is done before any ROOT libraries
             # are off-loaded, with unspecified order of static object destruction.
-            backend.gROOT.EndOfProcessCleanups()
+            from ROOT import TApplication
+            TApplication.RegisterEndOfProcessCleanups()
 
 atexit.register(cleanup)
diff --git a/core/base/inc/TApplication.h b/core/base/inc/TApplication.h
@@ -158,6 +158,7 @@ class TApplication : public TObject, public TQObject {
    static TList   *GetApplications();
    static void     CreateApplication();
    static void     NeedGraphicsLibs();
+   static void     RegisterEndOfProcessCleanups();
 
    ClassDefOverride(TApplication,0)  //GUI application singleton
 };
diff --git a/core/base/src/TApplication.cxx b/core/base/src/TApplication.cxx
@@ -49,11 +49,13 @@ TApplication (see TRint).
 #include <cstdlib>
 #include <iostream>
 #include <fstream>
+#include <mutex>
 
 TApplication *gApplication = nullptr;
 Bool_t TApplication::fgGraphNeeded = kFALSE;
 Bool_t TApplication::fgGraphInit = kFALSE;
 TList *TApplication::fgApplications = nullptr;  // List of available applications
+std::once_flag gRegisterEndOfProcessCleanupsFlag;
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -91,6 +93,15 @@ static void CallEndOfProcessCleanups()
    }
 }
 
+////////////////////////////////////////////////////////////////////////////////
+/// Register an atexit function that calls TROOT::EndOfProcessCleanups.
+///
+/// The registration is done only once in the program by using an std::once_flag.
+void TApplication::RegisterEndOfProcessCleanups()
+{
+   std::call_once(gRegisterEndOfProcessCleanupsFlag, []{ std::atexit(CallEndOfProcessCleanups); });
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 /// Default ctor. Can be used by classes deriving from TApplication.
 
@@ -156,12 +167,8 @@ TApplication::TApplication(const char *appClassName, Int_t *argc, char **argv,
    if (!gSystem)
       ::Fatal("TApplication::TApplication", "gSystem not initialized");
 
-   static Bool_t hasRegisterAtExit(kFALSE);
-   if (!hasRegisterAtExit) {
-      // If we are the first TApplication register the atexit)
-      atexit(CallEndOfProcessCleanups);
-      hasRegisterAtExit = kTRUE;
-   }
+   TApplication::RegisterEndOfProcessCleanups();
+
    gROOT->SetName(appClassName);
 
    // copy command line arguments, can be later accessed via Argc() and Argv()
