Changeset 10539 for code/branches/core7/src/libraries/core/CoreStaticInitializationHandler.cc

Timestamp:

Jun 7, 2015, 12:10:24 PM (10 years ago)

Author:

landauf

Message:

destroy objects before deleting identifiers (when unloading a module)

File:

• code/branches/core7/src/libraries/core/CoreStaticInitializationHandler.cc (modified) (3 diffs)

code/branches/core7/src/libraries/core/CoreStaticInitializationHandler.cc

@@ -29 +29 @@
 #include "CoreStaticInitializationHandler.h"
 
+#include "CoreIncludes.h"
 #include "module/ModuleInstance.h"
 #include "class/IdentifierManager.h"
+#include "object/Iterator.h"
 
 namespace orxonox
@@ -53 +55 @@
     void CoreStaticInitializationHandler::loadInstances(ModuleInstance* module)
     {
-        // the order of initialization is important
+        // the order of initialization is important: handlers > identifiers > singletons > everything else
         module->loadAllStaticallyInitializedInstances(StaticInitialization::STATIC_INITIALIZATION_HANDLER);
         module->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
@@ -72 +74 @@
         module->unloadAllStaticallyInitializedInstances(StaticInitialization::COMMAND_LINE_ARGUMENT);
         module->unloadAllStaticallyInitializedInstances(StaticInitialization::SCOPED_SINGLETON_WRAPPER);
+
+        // until now every object (including singletons) of the unloaded identifiers should have been destroyed in a controlled manner.
+        // every remaining object is now destroyed in random order.
+        this->destroyObjects(module);
+
+        // all objects are gone now and we can unload identifiers
         module->unloadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
         module->unloadAllStaticallyInitializedInstances(StaticInitialization::STATIC_INITIALIZATION_HANDLER);
     }
+
+    void CoreStaticInitializationHandler::destroyObjects(ModuleInstance* module)
+    {
+        // collect all identifiers that are about to be unloaded
+        std::set<Identifier*> identifiers;
+        const std::set<StaticallyInitializedInstance*>& instances = module->getInstances(StaticInitialization::IDENTIFIER);
+        for (std::set<StaticallyInitializedInstance*>::const_iterator it = instances.begin(); it != instances.end(); ++it)
+            identifiers.insert(&static_cast<StaticallyInitializedIdentifier*>(*it)->getIdentifier());
+
+        // destroy objects. some objects may survive this at first because they still have smart pointers pointing at them. this is
+        // ok as long as those smart pointers are held by objects that are also about to be destroyed in the same loop. this means
+        // that objects within one module may reference each other by smart pointers. but it is not allowed that objects from another
+        // module (which is not unloaded) uses smart pointers to point at objects inside the unloaded module. this will lead to a crash.
+        for (std::set<Identifier*>::iterator it = identifiers.begin(); it != identifiers.end(); ++it)
+            (*it)->destroyObjects();
+
+        // check if all objects were really destroyed. this is not the case if an object is referenced by a smart pointer from another
+        // module (or if two objects inside this module reference each other). this will lead to a crash and must be fixed (e.g. by
+        // changing object dependencies; or by changing the logic that allows modules to be unloaded).
+        for (std::set<Identifier*>::iterator it = identifiers.begin(); it != identifiers.end(); ++it)
+        {
+            ObjectListBase* objectList = Context::getRootContext()->getObjectList(*it);
+            if (objectList->size() > 0)
+            {
+                orxout(internal_error) << "There are still " << objectList->size() << " objects of type " << (*it)->getName()
+                    << " after unloading the Identifier. This may lead to a crash" << endl;
+            }
+        }
+
+        // destroy object-lists in all contexts
+        for (std::set<Identifier*>::iterator it_identifier = identifiers.begin(); it_identifier != identifiers.end(); ++it_identifier)
+        {
+            // only do this if the Identifier is not a Context itself; otherwise we delete the list we're iterating over
+            if (!(*it_identifier)->isExactlyA(Class(Context)))
+            {
+                // iterate over all contexts
+                for (ObjectList<Context>::iterator it_context = ObjectList<Context>::begin(); it_context != ObjectList<Context>::end(); ++it_context)
+                    it_context->destroyObjectList((*it_identifier));
+            }
+        }
+    }
 }