Ticket #4242: rejointest_v2.patch

binaries/system/readme.txt

@@ -56 +56 @@
                     files created in sim_log within the game's log folder. NOTE: game will
                     run much slower with this option!
 -serializationtest  checks simulation state each turn for serialization errors; on test
                     failure, error is displayed and logs created in oos_log within the
                     game's log folder. NOTE: game will run much slower with this option!
+-rejointest=N       simulates a rejoin and checks simulation state each turn for serialization
+                    errors; this is similar to a serialization test but much faster and
+                    less complete. It should be enough for debugging most rejoin OOSes.
 
 Windows-specific:
 -wQpcTscSafe        allow timing via QueryPerformanceCounter despite the fact
                     that it's using TSC and it may be unsafe. has no effect if
                     a better timer (i.e. the HPET) is available.

source/main.cpp

@@ -469 +469 @@
         MountMods(paths, GetMods(args, INIT_MODS));
 
         {
             CReplayPlayer replay;
             replay.Load(replayFile);
-            replay.Replay(args.Has("serializationtest"), args.Has("ooslog"));
+            replay.Replay(
+                args.Has("serializationtest"),
+                args.Has("rejointest") ? args.Get("rejointest").ToInt() : -1,
+                args.Has("ooslog"));
         }
 
         g_VFS.reset();
 
         CXeromyces::Terminate();

source/ps/GameSetup/Config.cpp

@@ -167 +167 @@
     if (args.Has("ooslog"))
         g_ConfigDB.SetValueString(CFG_COMMAND, "ooslog", "true");
 
     if (args.Has("serializationtest"))
         g_ConfigDB.SetValueString(CFG_COMMAND, "serializationtest", "true");
+
+    if (args.Has("rejointest"))
+        g_ConfigDB.SetValueString(CFG_COMMAND, "rejointest", args.Get("rejointest"));
 }
 
 
 void CONFIG_Init(const CmdLineArgs& args)
 {

source/ps/Replay.cpp

@@ -112 +112 @@
 
     m_Stream = new std::ifstream(path.c_str());
     ENSURE(m_Stream->good());
 }
 
-void CReplayPlayer::Replay(bool serializationtest, bool ooslog)
+void CReplayPlayer::Replay(bool serializationtest, int rejointestturn, bool ooslog)
 {
     ENSURE(m_Stream);
 
     new CProfileViewer;
     new CProfileManager;
@@ -128 +128 @@
     g_ScriptRuntime = ScriptInterface::CreateRuntime(shared_ptr<ScriptRuntime>(), runtimeSize, heapGrowthBytesGCTrigger);
 
     g_Game = new CGame(true, false);
     if (serializationtest)
         g_Game->GetSimulation2()->EnableSerializationTest();
+    if (rejointestturn > 0)
+        g_Game->GetSimulation2()->EnableRejoinTest(rejointestturn);
     if (ooslog)
         g_Game->GetSimulation2()->EnableOOSLog();
 
     // Need some stuff for terrain movement costs:
     // (TODO: this ought to be independent of any graphics code)

source/ps/Replay.h

@@ -1 @@
-/* Copyright (C) 2015 Wildfire Games.
+/* Copyright (C) 2016 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
@@ -95 +95 @@
 public:
     CReplayPlayer();
     ~CReplayPlayer();
 
     void Load(const std::string& path);
-    void Replay(bool serializationtest, bool ooslog);
+    void Replay(bool serializationtest, int rejointestturn, bool ooslog);
 
 private:
     std::istream* m_Stream;
 };
 

source/simulation2/Simulation2.cpp

@@ -49 +49 @@
 class CSimulation2Impl
 {
 public:
     CSimulation2Impl(CUnitManager* unitManager, shared_ptr<ScriptRuntime> rt, CTerrain* terrain) :
         m_SimContext(), m_ComponentManager(m_SimContext, rt),
-        m_EnableOOSLog(false), m_EnableSerializationTest(false),
+        m_EnableOOSLog(false), m_EnableSerializationTest(false), m_RejoinTestTurn(-1), m_TestingRejoin(false),
+        m_SecondaryTerrain(nullptr), m_SecondaryContext(nullptr), m_SecondaryComponentManager(nullptr), m_SecondaryLoadedScripts(nullptr),
         m_MapSettings(rt->m_rt), m_InitAttributes(rt->m_rt)
     {
         m_SimContext.m_UnitManager = unitManager;
         m_SimContext.m_Terrain = terrain;
         m_ComponentManager.LoadComponentTypes();
@@ -63 +64 @@
         // Tests won't have config initialised
         if (CConfigDB::IsInitialised())
         {
             CFG_GET_VAL("ooslog", m_EnableOOSLog);
             CFG_GET_VAL("serializationtest", m_EnableSerializationTest);
+            CFG_GET_VAL("rejointest", m_RejoinTestTurn);
+            if (m_RejoinTestTurn <= 0) // Handle bogus values of the arg
+                m_RejoinTestTurn = -1;
         }
 
         if (m_EnableOOSLog)
         {
             m_OOSLogPath = createDateIndexSubdirectory(psLogDir() / "oos_logs");
@@ -74 +78 @@
         }
     }
 
     ~CSimulation2Impl()
     {
+        delete m_SecondaryTerrain;
+        delete m_SecondaryContext;
+        delete m_SecondaryComponentManager;
+        delete m_SecondaryLoadedScripts;
+
         UnregisterFileReloadFunc(ReloadChangedFileCB, this);
     }
 
     void ResetState(bool skipScriptedComponents, bool skipAI)
     {
@@ -128 +137 @@
     OsPath m_OOSLogPath;
 
     // Functions and data for the serialization test mode: (see Update() for relevant comments)
 
     bool m_EnableSerializationTest;
+    int m_RejoinTestTurn;
+    bool m_TestingRejoin;
+
+    // Secondary simulation
+    CTerrain* m_SecondaryTerrain;
+    CSimContext* m_SecondaryContext;
+    CComponentManager* m_SecondaryComponentManager;
+    std::set<VfsPath>* m_SecondaryLoadedScripts;
 
     struct SerializationTestState
     {
         std::stringstream state;
         std::stringstream debug;
@@ -330 +347 @@
      * 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).
+     *
+     * In rejoin test mode, the secondary simulation is initialized from serialized data at turn N, then both
+     * simulations run independantly while comparing their states each turn. This is way faster than a
+     * complete serialization test and allows us to reproduce OOSes on rejoin.
      */
 
     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();
 
-    if (m_EnableSerializationTest)
+    if (m_RejoinTestTurn == m_TurnNumber)
+        m_TestingRejoin = true;
+
+    if (m_EnableSerializationTest || m_TestingRejoin)
     {
         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)
+    if (m_EnableSerializationTest || m_RejoinTestTurn == m_TurnNumber)
     {
-        // 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);
+        // Initialize the secondary simulation
+        delete m_SecondaryTerrain;
+        m_SecondaryTerrain = new CTerrain();
+
+        delete m_SecondaryContext;
+        m_SecondaryContext = new CSimContext();
+        m_SecondaryContext->m_Terrain = m_SecondaryTerrain;
+
+        delete m_SecondaryComponentManager;
+        m_SecondaryComponentManager = new CComponentManager(*m_SecondaryContext, scriptInterface.GetRuntime());
+        m_SecondaryComponentManager->LoadComponentTypes();
+
+        delete m_SecondaryLoadedScripts;
+        m_SecondaryLoadedScripts = new std::set<VfsPath>();
+        ENSURE(LoadDefaultScripts(*m_SecondaryComponentManager, m_SecondaryLoadedScripts));
+        ResetComponentState(*m_SecondaryComponentManager, false, false);
 
         // Load the trigger scripts after we have loaded the simulation.
         {
-            JSContext* cx2 = secondaryComponentManager.GetScriptInterface().GetContext();
+            JSContext* cx2 = m_SecondaryComponentManager->GetScriptInterface().GetContext();
             JSAutoRequest rq2(cx2);
             JS::RootedValue mapSettingsCloned(cx2,
-                secondaryComponentManager.GetScriptInterface().CloneValueFromOtherContext(
+                m_SecondaryComponentManager->GetScriptInterface().CloneValueFromOtherContext(
                     scriptInterface, m_MapSettings));
-            ENSURE(LoadTriggerScripts(secondaryComponentManager, mapSettingsCloned, &secondaryLoadedScripts));
+            ENSURE(LoadTriggerScripts(*m_SecondaryComponentManager, mapSettingsCloned, m_SecondaryLoadedScripts));
         }
 
         // Load the map into the secondary simulation
 
         LDR_BeginRegistering();
@@ -391 +421 @@
             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
+                m_SecondaryTerrain, NULL, NULL, NULL, NULL, NULL, NULL,
+                NULL, NULL, m_SecondaryContext, INVALID_PLAYER, true); // throws exception on failure
         }
 
         LDR_EndRegistering();
         ENSURE(LDR_NonprogressiveLoad() == INFO::OK);
+        ENSURE(m_SecondaryComponentManager->DeserializeState(primaryStateBefore.state));
+    }
 
-        ENSURE(secondaryComponentManager.DeserializeState(primaryStateBefore.state));
-
+    if (m_EnableSerializationTest || m_TestingRejoin)
+    {
         SerializationTestState secondaryStateBefore;
-        ENSURE(secondaryComponentManager.SerializeState(secondaryStateBefore.state));
+        ENSURE(m_SecondaryComponentManager->SerializeState(secondaryStateBefore.state));
         if (serializationTestDebugDump)
-            ENSURE(secondaryComponentManager.DumpDebugState(secondaryStateBefore.debug, false));
+            ENSURE(m_SecondaryComponentManager->DumpDebugState(secondaryStateBefore.debug, false));
         if (serializationTestHash)
-            ENSURE(secondaryComponentManager.ComputeStateHash(secondaryStateBefore.hash, false));
+            ENSURE(m_SecondaryComponentManager->ComputeStateHash(secondaryStateBefore.hash, false));
 
         if (primaryStateBefore.state.str() != secondaryStateBefore.state.str() ||
             primaryStateBefore.hash != secondaryStateBefore.hash)
         {
             ReportSerializationFailure(&primaryStateBefore, NULL, &secondaryStateBefore, NULL);
@@ -418 +450 @@
         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(*m_SecondaryContext, turnLengthFixed,
+            CloneCommandsFromOtherContext(scriptInterface, m_SecondaryComponentManager->GetScriptInterface(), commands));
         SerializationTestState secondaryStateAfter;
-        ENSURE(secondaryComponentManager.SerializeState(secondaryStateAfter.state));
+        ENSURE(m_SecondaryComponentManager->SerializeState(secondaryStateAfter.state));
         if (serializationTestHash)
-            ENSURE(secondaryComponentManager.ComputeStateHash(secondaryStateAfter.hash, false));
+            ENSURE(m_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));
+            ENSURE(m_SecondaryComponentManager->DumpDebugState(secondaryStateAfter.debug, false));
 
             ReportSerializationFailure(&primaryStateBefore, &primaryStateAfter, &secondaryStateBefore, &secondaryStateAfter);
         }
     }
 
@@ -586 +618 @@
     delete m;
 }
 
 // Forward all method calls to the appropriate CSimulation2Impl/CComponentManager methods:
 
+void CSimulation2::EnableSerializationTest()
+{
+    m->m_EnableSerializationTest = true;
+}
+
+void CSimulation2::EnableRejoinTest(int rejoinTestTurn)
+{
+    m->m_RejoinTestTurn = rejoinTestTurn;
+}
+
 void CSimulation2::EnableOOSLog()
 {
     if (m->m_EnableOOSLog)
         return;
 
@@ -597 +639 @@
     m->m_OOSLogPath = createDateIndexSubdirectory(psLogDir() / "oos_logs");
 
     debug_printf("Writing ooslogs to %s\n", m->m_OOSLogPath.string8().c_str());
 }
 
-void CSimulation2::EnableSerializationTest()
-{
-    m->m_EnableSerializationTest = true;
-}
-
 entity_id_t CSimulation2::AddEntity(const std::wstring& templateName)
 {
     return m->m_ComponentManager.AddEntity(templateName, m->m_ComponentManager.AllocateNewEntity());
 }
 

source/simulation2/Simulation2.h

@@ -52 +52 @@
     // TODO: CUnitManager should probably be handled automatically by this
     // module, but for now we'll have it passed in externally instead
     CSimulation2(CUnitManager* unitManager, shared_ptr<ScriptRuntime> rt, CTerrain* terrain);
     ~CSimulation2();
 
-    void EnableOOSLog();
     void EnableSerializationTest();
+    void EnableRejoinTest(int rejoinTestTurn);
+    void EnableOOSLog();
 
     /**
      * Load all scripts in the specified directory (non-recursively),
      * so they can register new component types and functions. This
      * should be called immediately after constructing the CSimulation2 object.