DRTVWR-418: Remove final shutdown cleanup as a cause of crashes.

The recent LLSingleton work added a hook that would run during the C++
runtime's final destruction of static objects. When the LAST LLSingleton in
any module was destroyed, its destructor would call
LLSingletonBase::deleteAll(). That mechanism was intended to permit an
application consuming LLSingletons to skip making an explicit deleteAll()
call, knowing that all instantiated LLSingleton instances would eventually be
cleaned up anyway.

However -- experience proves that kicking off deleteAll() processing during
the C++ runtime's final cleanup is too late. Too much has already been
destroyed. That call tends to cause more shutdown crashes than it resolves.

This commit deletes that whole mechanism. Going forward, if you want to clean
up LLSingleton instances, you must explicitly call
LLSingletonBase::deleteAll() during the application lifetime. If you don't,
LLSingleton instances will simply be leaked -- which might be okay,
considering the application is terminating anyway.

indra/llcommon/llsingleton.cpp

@@ -369,62 +369,20 @@ void LLSingletonBase::deleteAll()
     }
 }
 
-/*------------------------ Final cleanup management ------------------------*/
-class LLSingletonBase::MasterRefcount
-{
-public:
-    // store a POD int so it will be statically initialized to 0
-    int refcount;
-};
-static LLSingletonBase::MasterRefcount sMasterRefcount;
-
-LLSingletonBase::ref_ptr_t LLSingletonBase::get_master_refcount()
-{
-    // Calling this method constructs a new ref_ptr_t, which implicitly calls
-    // intrusive_ptr_add_ref(MasterRefcount*).
-    return &sMasterRefcount;
-}
-
-void intrusive_ptr_add_ref(LLSingletonBase::MasterRefcount* mrc)
-{
-    // Count outstanding SingletonLifetimeManager instances.
-    ++mrc->refcount;
-}
-
-void intrusive_ptr_release(LLSingletonBase::MasterRefcount* mrc)
-{
-    // Notice when each SingletonLifetimeManager instance is destroyed.
-    if (! --mrc->refcount)
-    {
-        // The last instance was destroyed. Time to kill any remaining
-        // LLSingletons -- but in dependency order.
-        LLSingletonBase::deleteAll();
-    }
-}
-
 /*---------------------------- Logging helpers -----------------------------*/
 namespace {
 bool oktolog()
 {
     // See comments in log() below.
-    return sMasterRefcount.refcount && LLError::is_available();
+    return LLError::is_available();
 }
 
 void log(LLError::ELevel level,
          const char* p1, const char* p2, const char* p3, const char* p4)
 {
-    // Check whether we're in the implicit final LLSingletonBase::deleteAll()
-    // call. We've carefully arranged for deleteAll() to be called when the
-    // last SingletonLifetimeManager instance is destroyed -- in other words,
-    // when the last translation unit containing an LLSingleton instance
-    // cleans up static data. That could happen after std::cerr is destroyed!
     // The is_available() test below ensures that we'll stop logging once
     // LLError has been cleaned up. If we had a similar portable test for
-    // std::cerr, this would be a good place to use it. As we do not, just
-    // don't log anything during implicit final deleteAll(). Detect that by
-    // the master refcount having gone to zero.
-    if (sMasterRefcount.refcount == 0)
-        return;
+    // std::cerr, this would be a good place to use it.
 
     // Check LLError::is_available() because some of LLError's infrastructure
     // is itself an LLSingleton. If that LLSingleton has not yet been

indra/llcommon/llsingleton.h

@@ -27,7 +27,6 @@
 
 #include <boost/noncopyable.hpp>
 #include <boost/unordered_set.hpp>
-#include <boost/intrusive_ptr.hpp>
 #include <list>
 #include <vector>
 #include <typeinfo>
@@ -36,8 +35,6 @@ class LLSingletonBase: private boost::noncopyable
 {
 public:
     class MasterList;
-    class MasterRefcount;
-    typedef boost::intrusive_ptr<MasterRefcount> ref_ptr_t;
 
 private:
     // All existing LLSingleton instances are tracked in this master list.
@@ -119,9 +116,6 @@ class LLSingletonBase: private boost::noncopyable
                          const char* p3="", const char* p4="");
     static std::string demangle(const char* mangled);
 
-    // obtain canonical ref_ptr_t
-    static ref_ptr_t get_master_refcount();
-
     // Default methods in case subclass doesn't declare them.
     virtual void initSingleton() {}
     virtual void cleanupSingleton() {}
@@ -175,10 +169,6 @@ class LLSingletonBase: private boost::noncopyable
     static void deleteAll();
 };
 
-// support ref_ptr_t
-void intrusive_ptr_add_ref(LLSingletonBase::MasterRefcount*);
-void intrusive_ptr_release(LLSingletonBase::MasterRefcount*);
-
 // Most of the time, we want LLSingleton_manage_master() to forward its
 // methods to real LLSingletonBase methods.
 template <class T>
@@ -298,8 +288,7 @@ class LLSingleton : public LLSingletonBase
     // stores pointer to singleton instance
     struct SingletonLifetimeManager
     {
-        SingletonLifetimeManager():
-            mMasterRefcount(LLSingletonBase::get_master_refcount())
+        SingletonLifetimeManager()
         {
             construct();
         }
@@ -317,17 +306,14 @@ class LLSingleton : public LLSingletonBase
             // of static-object destruction, mean that we DO NOT WANT this
             // destructor to delete this LLSingleton. This destructor will run
             // without regard to any other LLSingleton whose cleanup might
-            // depend on its existence. What we really want is to count the
-            // runtime's attempts to cleanup LLSingleton static data -- and on
-            // the very last one, call LLSingletonBase::deleteAll(). That
-            // method will properly honor cross-LLSingleton dependencies. This
-            // is why we store an intrusive_ptr to a MasterRefcount: our
-            // ref_ptr_t member counts SingletonLifetimeManager instances.
-            // Once the runtime destroys the last of these, THEN we can delete
-            // every remaining LLSingleton.
+            // depend on its existence. If you want to clean up LLSingletons,
+            // call LLSingletonBase::deleteAll() sometime before static-object
+            // destruction begins. That method will properly honor cross-
+            // LLSingleton dependencies. Otherwise we simply leak LLSingleton
+            // instances at shutdown. Since the whole process is terminating
+            // anyway, that's not necessarily a bad thing; it depends on what
+            // resources your LLSingleton instances are managing.
         }
-
-        LLSingletonBase::ref_ptr_t mMasterRefcount;
     };
 
 protected: