improve benchmarks and websocket dispatch performance

Author: endel

benchmarks/BenchmarkNew/Assets/Benchmark/BenchmarkBatchRunner.cs

@@ -0,0 +1,79 @@
+using System;
+using UnityEngine;
+
+#if UNITY_EDITOR
+using UnityEditor;
+using UnityEditor.SceneManagement;
+
+public static class BenchmarkBatchRunner
+{
+    public static void RunSyncContextBenchmarks()
+    {
+        var scene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
+
+        var gameObject = new GameObject("BenchmarkRunner");
+        var runner = gameObject.AddComponent<BenchmarkRunner>();
+
+        runner.serverUrl = GetArg("-benchmarkServer", runner.serverUrl);
+        runner.implementationName = GetArg("-benchmarkImplementation", runner.implementationName);
+        runner.outputFileName = GetArg("-benchmarkOutput", runner.outputFileName);
+        runner.runLatency = false;
+        runner.runThroughput = true;
+        runner.runThroughputSend = false;
+        runner.runThroughputReceive = true;
+        runner.runThroughputBidirectional = false;
+        runner.runGCAlloc = false;
+        runner.runFrameTime = true;
+        runner.runBurst = true;
+        runner.throughputDurationSec = GetIntArg("-benchmarkThroughputDuration", 5);
+        runner.burstMessageCount = GetIntArg("-benchmarkBurstCount", runner.burstMessageCount);
+        runner.exitWhenDone = true;
+
+        string payloadSizesArg = GetArg("-benchmarkPayloadSizes", null);
+        if (!string.IsNullOrEmpty(payloadSizesArg))
+        {
+            string[] parts = payloadSizesArg.Split(',');
+            int[] payloadSizes = new int[parts.Length];
+            for (int i = 0; i < parts.Length; i++)
+            {
+                payloadSizes[i] = int.Parse(parts[i]);
+            }
+            runner.payloadSizes = payloadSizes;
+        }
+
+        EditorSceneManager.SaveScene(scene, "Assets/BenchmarkBatchScene.unity");
+        EditorApplication.EnterPlaymode();
+    }
+
+    private static string GetArg(string name, string fallback)
+    {
+        string[] args = Environment.GetCommandLineArgs();
+        for (int i = 0; i < args.Length - 1; i++)
+        {
+            if (args[i] == name)
+            {
+                return args[i + 1];
+            }
+        }
+
+        return fallback;
+    }
+
+    private static int GetIntArg(string name, int fallback)
+    {
+        string value = GetArg(name, null);
+        if (string.IsNullOrEmpty(value))
+        {
+            return fallback;
+        }
+
+        int parsed;
+        if (int.TryParse(value, out parsed))
+        {
+            return parsed;
+        }
+
+        return fallback;
+    }
+}
+#endif

benchmarks/BenchmarkNew/Assets/Benchmark/BenchmarkRunner.cs

@@ -0,0 +1,116 @@
+using System.Collections;
+using System.IO;
+using UnityEngine;
+
+public class BenchmarkRunner : MonoBehaviour
+{
+    [Header("Server")]
+    public string serverUrl = "ws://localhost:3000";
+
+    [Header("Implementation")]
+    public string implementationName = "new";
+
+    [Header("Output")]
+    public string outputFileName = "benchmark_results.csv";
+
+    [Header("Benchmarks to Run")]
+    public bool runLatency = true;
+    public bool runThroughput = true;
+    public bool runThroughputSend = true;
+    public bool runThroughputReceive = true;
+    public bool runThroughputBidirectional = true;
+    public bool runGCAlloc = true;
+    public bool runFrameTime = true;
+    public bool runBurst = true;
+
+    [Header("Automation")]
+    public bool exitWhenDone = false;
+
+    [Header("Parameters")]
+    public int latencyIterations = 1000;
+    public int throughputDurationSec = 10;
+    public int burstMessageCount = 100;
+    public int[] payloadSizes = new int[] { 32, 256, 1024, 8192, 65536 };
+
+    private BenchmarkLogger logger;
+
+    void Start()
+    {
+        string outputPath = Path.Combine(Application.persistentDataPath, outputFileName);
+        logger = new BenchmarkLogger(implementationName, outputPath);
+        Debug.Log("Results will be written to: " + outputPath);
+        StartCoroutine(RunAllBenchmarks());
+    }
+
+    IEnumerator RunAllBenchmarks()
+    {
+        Debug.Log(string.Format("=== Starting benchmarks for [{0}] ===", implementationName));
+        yield return new WaitForSeconds(1f);
+
+        if (runLatency)
+        {
+            var bench = new LatencyBench();
+            foreach (int size in payloadSizes)
+            {
+                Debug.Log(string.Format("--- Latency benchmark (payload={0}B) ---", size));
+                yield return StartCoroutine(bench.Run(serverUrl, latencyIterations, size, logger));
+                yield return new WaitForSeconds(1f);
+            }
+        }
+
+        if (runThroughput)
+        {
+            var bench = new ThroughputBench();
+            foreach (int size in payloadSizes)
+            {
+                Debug.Log(string.Format("--- Throughput benchmark (payload={0}B) ---", size));
+                yield return StartCoroutine(bench.Run(
+                    serverUrl,
+                    throughputDurationSec,
+                    size,
+                    logger,
+                    runThroughputSend,
+                    runThroughputReceive,
+                    runThroughputBidirectional));
+                yield return new WaitForSeconds(1f);
+            }
+        }
+
+        if (runGCAlloc)
+        {
+            var bench = new GCAllocBench();
+            foreach (int size in payloadSizes)
+            {
+                Debug.Log(string.Format("--- GC Allocation benchmark (payload={0}B) ---", size));
+                yield return StartCoroutine(bench.Run(serverUrl, size, logger));
+                yield return new WaitForSeconds(1f);
+            }
+        }
+
+        if (runFrameTime)
+        {
+            var bench = new FrameTimeBench();
+            Debug.Log("--- Frame Time benchmark ---");
+            yield return StartCoroutine(bench.Run(serverUrl, logger));
+            yield return new WaitForSeconds(1f);
+        }
+
+        if (runBurst)
+        {
+            var bench = new BurstBench();
+            Debug.Log(string.Format("--- Burst benchmark (count={0}) ---", burstMessageCount));
+            yield return StartCoroutine(bench.Run(serverUrl, burstMessageCount, logger));
+            yield return new WaitForSeconds(1f);
+        }
+
+        Debug.Log(string.Format("=== All benchmarks complete for [{0}] ===", implementationName));
+        logger.Close();
+
+#if UNITY_EDITOR
+        if (exitWhenDone && Application.isBatchMode)
+        {
+            UnityEditor.EditorApplication.delayCall += () => UnityEditor.EditorApplication.Exit(0);
+        }
+#endif
+    }
+}

benchmarks/BenchmarkNew/Assets/Benchmark/FrameTimeBench.cs

@@ -0,0 +1,151 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Text;
+using UnityEngine;
+using NativeWebSocket;
+
+public class FrameTimeBench
+{
+    public IEnumerator Run(string serverUrl, BenchmarkLogger logger)
+    {
+        var ws = new WebSocket(serverUrl);
+        bool connected = false;
+        bool closed = false;
+        bool floodStopped = false;
+
+        ws.OnOpen += () => connected = true;
+        ws.OnMessage += (data) =>
+        {
+            if (IsExactTextMessage(data, "flood_stopped"))
+            {
+                floodStopped = true;
+            }
+        };
+        ws.OnClose += (code) => closed = true;
+
+        _ = ws.Connect();
+
+        float timeout = 0;
+        while (!connected && !closed && timeout < 10f)
+        {
+            ws.DispatchMessageQueue();
+            timeout += Time.unscaledDeltaTime;
+            yield return null;
+        }
+        if (!connected) yield break;
+
+        int payloadSize = 256;
+        var sw = new Stopwatch();
+
+        // --- Baseline: dispatch time with no pending messages ---
+        var baselineTimes = new List<double>();
+        for (int i = 0; i < 300; i++)
+        {
+            sw.Restart();
+            ws.DispatchMessageQueue();
+            sw.Stop();
+            baselineTimes.Add(sw.Elapsed.TotalMilliseconds);
+            yield return null;
+        }
+
+        // --- Under load: sustained flood + measure dispatch time ---
+        _ = ws.SendText(string.Format("flood_continuous:{0}", payloadSize));
+
+        float warmup = 0f;
+        while (warmup < 0.2f)
+        {
+            ws.DispatchMessageQueue();
+            warmup += Time.unscaledDeltaTime;
+            yield return null;
+        }
+
+        var dispatchTimes = new List<double>();
+        var frameTimes = new List<double>();
+        var frameSw = new Stopwatch();
+
+        for (int i = 0; i < 600; i++)
+        {
+            frameSw.Restart();
+
+            sw.Restart();
+            ws.DispatchMessageQueue();
+            sw.Stop();
+            dispatchTimes.Add(sw.Elapsed.TotalMilliseconds);
+
+            frameSw.Stop();
+            frameTimes.Add(frameSw.Elapsed.TotalMilliseconds);
+            yield return null;
+        }
+
+        _ = ws.SendText("flood_stop");
+        timeout = 0;
+        while (!floodStopped && timeout < 1f)
+        {
+            ws.DispatchMessageQueue();
+            timeout += Time.unscaledDeltaTime;
+            yield return null;
+        }
+
+        // Log baseline
+        var baselineStats = new BenchmarkStats(baselineTimes);
+        logger.LogResult("FrameTime_Baseline", 0, "avg_ms", baselineStats.Average);
+        logger.LogResult("FrameTime_Baseline", 0, "p99_ms", baselineStats.P99);
+        logger.LogResult("FrameTime_Baseline", 0, "max_ms", baselineStats.Max);
+        logger.LogResult("FrameTime_Baseline", 0, "jitter_stddev_ms", baselineStats.StdDev);
+
+        // Log dispatch under load
+        var dispatchStats = new BenchmarkStats(dispatchTimes);
+        logger.LogResult("FrameTime_Dispatch", payloadSize, "avg_ms", dispatchStats.Average);
+        logger.LogResult("FrameTime_Dispatch", payloadSize, "median_ms", dispatchStats.Median);
+        logger.LogResult("FrameTime_Dispatch", payloadSize, "p95_ms", dispatchStats.P95);
+        logger.LogResult("FrameTime_Dispatch", payloadSize, "p99_ms", dispatchStats.P99);
+        logger.LogResult("FrameTime_Dispatch", payloadSize, "max_ms", dispatchStats.Max);
+        logger.LogResult("FrameTime_Dispatch", payloadSize, "jitter_stddev_ms", dispatchStats.StdDev);
+        logger.LogSummary("FrameTime_Dispatch", payloadSize, dispatchStats);
+
+        // Log total frame time under load
+        var frameStats = new BenchmarkStats(frameTimes);
+        logger.LogResult("FrameTime_UnderLoad", payloadSize, "avg_ms", frameStats.Average);
+        logger.LogResult("FrameTime_UnderLoad", payloadSize, "p99_ms", frameStats.P99);
+        logger.LogResult("FrameTime_UnderLoad", payloadSize, "max_ms", frameStats.Max);
+        logger.LogResult("FrameTime_UnderLoad", payloadSize, "jitter_stddev_ms", frameStats.StdDev);
+
+        UnityEngine.Debug.Log(string.Format(
+            "Frame time: baseline avg={0:F3}ms, dispatch under load avg={1:F3}ms p99={2:F3}ms",
+            baselineStats.Average, dispatchStats.Average, dispatchStats.P99));
+
+        closed = false;
+        _ = ws.Close();
+        timeout = 0;
+        while (!closed && timeout < 5f)
+        {
+            ws.DispatchMessageQueue();
+            timeout += Time.unscaledDeltaTime;
+            yield return null;
+        }
+    }
+
+    private static bool IsExactTextMessage(byte[] data, string expected)
+    {
+        if (data == null || expected == null)
+        {
+            return false;
+        }
+
+        if (data.Length != Encoding.UTF8.GetByteCount(expected))
+        {
+            return false;
+        }
+
+        try
+        {
+            return Encoding.UTF8.GetString(data) == expected;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+}