test(math): implement diagnostic benchmark for deterministic math parity

- Add RUN_MATH_BENCHMARK_REPLAY400_FLAG to SimulationMathCrc.h
- Implement 10000-iteration dual-path benchmark in SimulationMathCrc.cpp
- Inject benchmark trigger into GameLogic::update at replay frame 400
- Benchmark measures CRT vs WWMath precision and performance

Author: Okladnoj

Core/GameEngine/Include/Common/Diagnostic/SimulationMathCrc.h

@@ -18,8 +18,12 @@
 
 #pragma once
 
+// Flags for diagnostic math benchmarks
+// #define RUN_MATH_BENCHMARK_REPLAY400_FLAG
+
 class SimulationMathCrc
 {
 public:
 	static UnsignedInt calculate();
+	static void runBenchmark(int iterations = 10000);
 };

Core/GameEngine/Source/Common/Diagnostic/SimulationMathCrc.cpp

@@ -25,8 +25,10 @@
 #include "GameLogic/FPUControl.h"
 
 #include <math.h>
+#include <stdio.h>
+#include <time.h>
 
-static void appendSimulationMathCrc(XferCRC &xfer)
+static void appendSimulationMathCrc_Deterministic(XferCRC &xfer)
 {
     Matrix3D matrix;
     Matrix3D factorsMatrix;
@@ -37,8 +39,8 @@ static void appendSimulationMathCrc(XferCRC &xfer)
         0.9f, 1.0f, 2.1f, 1.2f);
 
     factorsMatrix.Set(
-        WWMath::Sin(0.7f) * log10f(2.3f),
-        WWMath::Cos(1.1f) * powf(1.1f, 2.0f),
+        WWMath::Sin(0.7f) * WWMath::Log10fOrigin(2.3f),
+        WWMath::Cos(1.1f) * WWMath::PowfOrigin(1.1f, 2.0f),
         WWMath::TanfOrigin(0.3f),
         WWMath::ASinfOrigin(0.967302263f),
         WWMath::ACosfOrigin(0.967302263f),
@@ -56,18 +58,88 @@ static void appendSimulationMathCrc(XferCRC &xfer)
     xfer.xferMatrix3D(&matrix);
 }
 
+static void appendSimulationMathCrc_Native(XferCRC &xfer)
+{
+    Matrix3D matrix;
+    Matrix3D factorsMatrix;
+
+    matrix.Set(
+        4.1f, 1.2f, 0.3f, 0.4f,
+        0.5f, 3.6f, 0.7f, 0.8f,
+        0.9f, 1.0f, 2.1f, 1.2f);
+
+    factorsMatrix.Set(
+        (float)(::sin(0.7) * ::log10(2.3)),
+        (float)(::cos(1.1) * ::pow(1.1, 2.0)),
+        (float)::tan(0.3),
+        (float)::asin(0.967302263),
+        (float)::acos(0.967302263),
+        (float)(::atan(0.967302263) * ::pow(1.1, 2.0)),
+        (float)::atan2(0.4, 1.3),
+        (float)::sinh(0.2),
+        (float)(::cosh(0.4) * ::tanh(0.5)),
+        (float)::sqrt(55788.84375),
+        (float)(::exp(0.1) * ::log10(2.3)),
+        (float)::log(1.4));
+
+    Matrix3D::Multiply(matrix, factorsMatrix, &matrix);
+    matrix.Get_Inverse(matrix);
+
+    xfer.xferMatrix3D(&matrix);
+}
+
 UnsignedInt SimulationMathCrc::calculate()
 {
     XferCRC xfer;
     xfer.open("SimulationMathCrc");
 
     setFPMode();
 
-    appendSimulationMathCrc(xfer);
+    appendSimulationMathCrc_Deterministic(xfer);
 
     _fpreset();
 
     xfer.close();
 
     return xfer.getCRC();
 }
+
+void SimulationMathCrc::runBenchmark(int iterations)
+{
+    clock_t startDet = clock();
+    UnsignedInt crcDet = 0;
+    
+    setFPMode();
+    for (int i = 0; i < iterations; ++i)
+    {
+        XferCRC xfer;
+        xfer.open("SimMathDet");
+        appendSimulationMathCrc_Deterministic(xfer);
+        xfer.close();
+        if (i == 0) crcDet = xfer.getCRC();
+    }
+    _fpreset();
+    clock_t endDet = clock();
+    double timeDetMs = (double)(endDet - startDet) / CLOCKS_PER_SEC * 1000.0;
+
+    clock_t startNat = clock();
+    UnsignedInt crcNat = 0;
+    
+    setFPMode();
+    for (int i = 0; i < iterations; ++i)
+    {
+        XferCRC xfer;
+        xfer.open("SimMathNat");
+        appendSimulationMathCrc_Native(xfer);
+        xfer.close();
+        if (i == 0) crcNat = xfer.getCRC();
+    }
+    _fpreset();
+    clock_t endNat = clock();
+    double timeNatMs = (double)(endNat - startNat) / CLOCKS_PER_SEC * 1000.0;
+
+    printf("\n================ MATH BENCHMARK (%d iters) ================\n", iterations);
+    printf("Deterministic (WWMath): CRC = %08X, Time = %.2f ms\n", crcDet, timeDetMs);
+    printf("Native (system math):   CRC = %08X, Time = %.2f ms\n", crcNat, timeNatMs);
+    printf("===========================================================\n\n");
+}

GeneralsMD/Code/GameEngine/Source/GameLogic/System/GameLogic.cpp

@@ -33,6 +33,7 @@
 #include "Common/AudioHandleSpecialValues.h"
 #include "Common/BuildAssistant.h"
 #include "Common/CRCDebug.h"
+#include "Common/Diagnostic/SimulationMathCrc.h"
 #include "Common/FramePacer.h"
 #include "Common/GameAudio.h"
 #include "Common/GameEngine.h"
@@ -3738,6 +3739,22 @@ void GameLogic::update()
 		TheTerrainLogic->UPDATE();
 	}
 
+#ifdef RUN_MATH_BENCHMARK_REPLAY400_FLAG
+	static int s_replayStartFrame = -1;
+	static bool s_benchmarkRun = false;
+
+	if (!s_benchmarkRun && TheRecorder && TheRecorder->isPlaybackMode())
+	{
+		if (s_replayStartFrame == -1) {
+			s_replayStartFrame = m_frame;
+		}
+		else if (m_frame == s_replayStartFrame + 400) {
+			SimulationMathCrc::runBenchmark(10000);
+			s_benchmarkRun = true;
+		}
+	}
+#endif
+
 	// force CRC calculation, so we can keep a cache of the last N CRCs.  We do this right where the recorder
 	// would be getting the CRC anyway, so replays can get the CRCs from the exact instant in time as the original.
 	Bool isMPGameOrReplay = (TheRecorder && TheRecorder->isMultiplayer() && getGameMode() != GAME_SHELL && getGameMode() != GAME_NONE);