Ticket #3647: clone_commands_for_serializationtest_v1.patch

source/simulation2/Simulation2.cpp

@@ -330 +330 @@
 
     fixed turnLengthFixed = fixed::FromInt(turnLength) / 1000;
 
     /*
      * In serialization test mode, we save the original (primary) simulation state before each turn update.
      * We run the update, then load the saved state into a secondary context.
      * We serialize that again and compare to the original serialization (to check that
      * serialize->deserialize->serialize is equivalent to serialize).
      * Then we run the update on the secondary context, and check that its new serialized
      * state matches the primary context after the update (to check that the simulation doesn't depend
      * on anything that's not serialized).
      */
 
     const bool serializationTestDebugDump = false; // set true to save human-readable state dumps before an error is detected, for debugging (but slow)
     const bool serializationTestHash = true; // set true to save and compare hash of state
 
     SerializationTestState primaryStateBefore;
     ScriptInterface& scriptInterface = m_ComponentManager.GetScriptInterface();
 
+    // Initialise the secondary simulation
+    CTerrain secondaryTerrain;
+    CSimContext secondaryContext;
+    secondaryContext.m_Terrain = &secondaryTerrain;
+    CComponentManager secondaryComponentManager(secondaryContext, scriptInterface.GetRuntime());
+    std::vector<SimulationCommand> clonedCommands;
+    SerializationTestState secondaryStateBefore;
     if (m_EnableSerializationTest)
     {
         ENSURE(m_ComponentManager.SerializeState(primaryStateBefore.state));
         if (serializationTestDebugDump)
             ENSURE(m_ComponentManager.DumpDebugState(primaryStateBefore.debug, false));
         if (serializationTestHash)
             ENSURE(m_ComponentManager.ComputeStateHash(primaryStateBefore.hash, false));
-    }
-
-    UpdateComponents(m_SimContext, turnLengthFixed, commands);
 
-
-    if (m_EnableSerializationTest)
-    {
-        // Initialise the secondary simulation
-        CTerrain secondaryTerrain;
-        CSimContext secondaryContext;
-        secondaryContext.m_Terrain = &secondaryTerrain;
-        CComponentManager secondaryComponentManager(secondaryContext, scriptInterface.GetRuntime());
         secondaryComponentManager.LoadComponentTypes();
         std::set<VfsPath> secondaryLoadedScripts;
         ENSURE(LoadDefaultScripts(secondaryComponentManager, &secondaryLoadedScripts));
         ResetComponentState(secondaryComponentManager, false, false);
 
+        // Clone commands before UpdateComponents() might modify them in the primary simulation
+        clonedCommands = CloneCommandsFromOtherContext(scriptInterface, secondaryComponentManager.GetScriptInterface(), commands);
+
         // Load the trigger scripts after we have loaded the simulation.
         {
             JSContext* cx2 = secondaryComponentManager.GetScriptInterface().GetContext();
             JSAutoRequest rq2(cx2);
             JS::RootedValue mapSettingsCloned(cx2, 
                 secondaryComponentManager.GetScriptInterface().CloneValueFromOtherContext(
                     scriptInterface, m_MapSettings));
             ENSURE(LoadTriggerScripts(secondaryComponentManager, mapSettingsCloned, &secondaryLoadedScripts));
         }
 
         // Load the map into the secondary simulation
 
         LDR_BeginRegistering();
         CMapReader* mapReader = new CMapReader; // automatically deletes itself
             
         std::string mapType;
         scriptInterface.GetProperty(m_InitAttributes, "mapType", mapType);
         if (mapType == "random")
         {
             // TODO: support random map scripts
             debug_warn(L"Serialization test mode does not support random maps");
         }
         else
         {
             std::wstring mapFile;
             scriptInterface.GetProperty(m_InitAttributes, "map", mapFile);
 
             VfsPath mapfilename = VfsPath(mapFile).ChangeExtension(L".pmp");
             mapReader->LoadMap(mapfilename, scriptInterface.GetJSRuntime(), JS::UndefinedHandleValue,
                 &secondaryTerrain, NULL, NULL, NULL, NULL, NULL, NULL,
                 NULL, NULL, &secondaryContext, INVALID_PLAYER, true); // throws exception on failure
         }
 
         LDR_EndRegistering();
         ENSURE(LDR_NonprogressiveLoad() == INFO::OK);
 
         ENSURE(secondaryComponentManager.DeserializeState(primaryStateBefore.state));
 
-        SerializationTestState secondaryStateBefore;
         ENSURE(secondaryComponentManager.SerializeState(secondaryStateBefore.state));
         if (serializationTestDebugDump)
             ENSURE(secondaryComponentManager.DumpDebugState(secondaryStateBefore.debug, false));
         if (serializationTestHash)
             ENSURE(secondaryComponentManager.ComputeStateHash(secondaryStateBefore.hash, false));
 
         if (primaryStateBefore.state.str() != secondaryStateBefore.state.str() ||
             primaryStateBefore.hash != secondaryStateBefore.hash)
         {
             ReportSerializationFailure(&primaryStateBefore, NULL, &secondaryStateBefore, NULL);
         }
+    }
+
+    // Execute the commands of that turn in the primary simulation
+    UpdateComponents(m_SimContext, turnLengthFixed, commands);
 
+    // Execute the commands of that turn in the secondary simulation and compare hash values
+    if (m_EnableSerializationTest)
+    {
         SerializationTestState primaryStateAfter;
         ENSURE(m_ComponentManager.SerializeState(primaryStateAfter.state));
         if (serializationTestHash)
             ENSURE(m_ComponentManager.ComputeStateHash(primaryStateAfter.hash, false));
 
-        UpdateComponents(secondaryContext, turnLengthFixed,
-            CloneCommandsFromOtherContext(scriptInterface, secondaryComponentManager.GetScriptInterface(), commands));
+        UpdateComponents(secondaryContext, turnLengthFixed, clonedCommands);
         SerializationTestState secondaryStateAfter;
         ENSURE(secondaryComponentManager.SerializeState(secondaryStateAfter.state));
         if (serializationTestHash)
             ENSURE(secondaryComponentManager.ComputeStateHash(secondaryStateAfter.hash, false));
 
         if (primaryStateAfter.state.str() != secondaryStateAfter.state.str() ||
             primaryStateAfter.hash != secondaryStateAfter.hash)
         {
             // Only do the (slow) dumping now we know we're going to need to report it
             ENSURE(m_ComponentManager.DumpDebugState(primaryStateAfter.debug, false));
             ENSURE(secondaryComponentManager.DumpDebugState(secondaryStateAfter.debug, false));
 
             ReportSerializationFailure(&primaryStateBefore, &primaryStateAfter, &secondaryStateBefore, &secondaryStateAfter);
         }
     }
 
 //  if (m_TurnNumber == 0)
 //      m_ComponentManager.GetScriptInterface().DumpHeap();