using System; using System.Collections.Generic; using System.IO; using System.Reflection; using System.Reflection.Emit; using System.Runtime.CompilerServices; using System.Threading; using HarmonyLib; using Newtonsoft.Json; using Newtonsoft.Json.Linq; using Sandbox; using Sandbox.Engine.Physics; using Sandbox.Engine.Utils; using Sandbox.Game.Entities; using Sandbox.Game.GameSystems; using Sandbox.Game.Multiplayer; using Sandbox.Game.World; using VRage; using VRage.Library.Utils; using VRageRender.ExternalApp; namespace XFE.SeAgent.Plugin.Performance { /// Reversible, opt-in engine tuning. No simulation step or ship content is changed. internal sealed class PerformanceTuning : IDisposable { private const string PatchId = "studio.xfe.seagent.performance"; private readonly Harmony harmony = new Harmony(PatchId); private readonly Action log; private readonly string path; private readonly int gameThread; private readonly CacheCoreAffinity cacheCoreAffinity = new CacheCoreAffinity(); private readonly GcLatencyTuning gcLatency = new GcLatencyTuning(); private static PerformanceTuning current; private ConditionalWeakTable stamps = new ConditionalWeakTable(); private readonly List cacheMethods = new List(); private WaitForTargetFrameRate renderWaiter; private MyRenderThread affinityRenderThread; private bool originalRenderMaxSpeed; private bool uncapped, cacheEnabled, validate, disableVsync, actorBatching, lockFreeLoops, idleRotation, texturePriority, hierarchyUpdates; private readonly bool originalLockFreeLoops = ParallelTasks.Parallel.IsMutexSlow; private MethodBase presentMethod; private MethodBase actorUpdateMethod; private MethodBase entityUpdateMethod; private bool entityBatching; private MethodBase rotationMethod; private MethodBase texturePriorityMethod; private MethodBase hierarchyMethod; private int physicsWorkers; private long generation, lookups, hits, validations, mismatches; private string patchError; private static readonly FieldInfo RenderWaiter = AccessTools.Field(typeof(MyRenderThread), "m_waiter"); public PerformanceTuning(Action logger) { log = logger; gameThread = Thread.CurrentThread.ManagedThreadId; current = this; ActorBatching.Affinity=cacheCoreAffinity; path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "XFE", "SpaceEngineersAgent", "performance.json"); // This is the engine's supported pool sizing input; never replace a live native pool. try { var platformGetter = AccessTools.PropertyGetter(MyVRage.Platform.System.GetType(), "OptimalHavokThreadCount"); if (platformGetter == null) throw new MissingMemberException("OptimalHavokThreadCount"); harmony.Patch(platformGetter, postfix: new HarmonyMethod(typeof(PerformanceTuning), nameof(PhysicsWorkersPostfix))); } catch { Dispose(); throw; } if (File.Exists(path)) { try { if (new FileInfo(path).Length > 16384) throw new InvalidDataException("Performance configuration exceeds 16 KiB."); Configure(JObject.Parse(File.ReadAllText(path)), false); } catch (Exception error) { patchError = error.Message; log("Performance configuration not fully applied: " + error.Message); } } } public JObject Configure(JObject args, bool mayPersist = true) { bool nextUncapped = Boolean(args, "renderUncapped", uncapped), nextCache = Boolean(args, "terminalAccessCache", cacheEnabled); bool nextValidate = Boolean(args, "validateCache", validate); bool nextDisableVsync = Boolean(args, "disableVsync", disableVsync); bool nextActorBatching = Boolean(args, "actorBatching", actorBatching); bool nextEntityBatching = Boolean(args, "entityBatching", entityBatching); int nextEntityChunk = Integer(args, "entityBatchSize", EntityBatching.ChunkSize, 1, 128); bool nextLockFreeLoops = Boolean(args, "lockFreeParallelLoops", lockFreeLoops); bool nextCacheCores = Boolean(args, "preferLargestL3", cacheCoreAffinity.Enabled); bool nextMainThreadOnly = Boolean(args, "mainThreadL3", cacheCoreAffinity.MainThreadOnly); bool nextRenderAffinity = Boolean(args, "pinRenderWorkers", cacheCoreAffinity.PinRenderWorkers); bool nextIdleRotation = Boolean(args, "idleRotation", idleRotation); bool nextTexturePriority = Boolean(args, "texturePriority", texturePriority); bool nextHierarchy = Boolean(args, "hierarchyUpdates", hierarchyUpdates); bool nextLowLatency = Boolean(args, "lowLatencyGc", gcLatency.Enabled); int nextChunk = Integer(args, "actorBatchSize", ActorBatching.ChunkSize, 16, 1024); int nextActorWorkers = Integer(args, "actorWorkers", ActorBatching.Workers, 0, Environment.ProcessorCount); int nextWorkers = physicsWorkers; if (args["physicsWorkers"] != null) { if (args["physicsWorkers"].Type != JTokenType.Integer) throw new ArgumentException("physicsWorkers must be an integer."); nextWorkers = (int)args["physicsWorkers"]; if (nextWorkers != 0 && (nextWorkers < 2 || nextWorkers > Math.Min(64, Environment.ProcessorCount))) throw new ArgumentException("physicsWorkers must be 0 (game default), or 2..logicalProcessors (maximum 64)."); } bool persist = Boolean(args, "persist", false); if (nextCache != cacheEnabled) SetCache(nextCache); if (nextDisableVsync != disableVsync) SetVsyncOverride(nextDisableVsync); if (nextActorBatching != actorBatching) SetActorBatching(nextActorBatching); if (nextEntityBatching != entityBatching) SetEntityBatching(nextEntityBatching); EntityBatching.ChunkSize = nextEntityChunk; if (nextIdleRotation != idleRotation) SetIdleRotation(nextIdleRotation); if (nextTexturePriority != texturePriority) SetTexturePriority(nextTexturePriority); if (nextHierarchy != hierarchyUpdates) SetHierarchyUpdates(nextHierarchy); ActorBatching.ChunkSize = nextChunk; ActorBatching.Workers = nextActorWorkers; gcLatency.Set(nextLowLatency); cacheCoreAffinity.Set(nextCacheCores,nextMainThreadOnly,nextRenderAffinity); lockFreeLoops = nextLockFreeLoops; ParallelTasks.Parallel.IsMutexSlow = lockFreeLoops || originalLockFreeLoops; uncapped = nextUncapped; physicsWorkers = nextWorkers; validate = nextValidate; UpdateRenderLimit(); if (persist && mayPersist) { var settings = new JObject { ["renderUncapped"] = uncapped, ["disableVsync"] = disableVsync, ["terminalAccessCache"] = cacheEnabled, ["actorBatching"] = actorBatching, ["lockFreeParallelLoops"] = lockFreeLoops, ["entityBatching"] = entityBatching, ["entityBatchSize"] = EntityBatching.ChunkSize, ["idleRotation"] = idleRotation, ["actorBatchSize"] = ActorBatching.ChunkSize, ["actorWorkers"] = ActorBatching.Workers, ["texturePriority"] = texturePriority, ["hierarchyUpdates"] = hierarchyUpdates, ["lowLatencyGc"] = gcLatency.Enabled, ["preferLargestL3"] = cacheCoreAffinity.Enabled, ["physicsWorkers"] = physicsWorkers }; settings["mainThreadL3"]=cacheCoreAffinity.MainThreadOnly; settings["pinRenderWorkers"]=cacheCoreAffinity.PinRenderWorkers; Directory.CreateDirectory(Path.GetDirectoryName(path)); File.WriteAllText(path + ".tmp", settings.ToString(Formatting.Indented)); if (File.Exists(path)) File.Replace(path + ".tmp", path, path + ".bak"); else File.Move(path + ".tmp", path); } log("Performance tuning: " + Status().ToString(Formatting.None)); return Status(); } private static bool Boolean(JObject args, string name, bool fallback) { if (args[name] == null) return fallback; if (args[name].Type != JTokenType.Boolean) throw new ArgumentException(name + " must be boolean."); return (bool)args[name]; } private static int Integer(JObject args, string name, int fallback, int min, int max) { if (args[name] == null) return fallback; if (args[name].Type != JTokenType.Integer || (long)args[name] < min || (long)args[name] > max) throw new ArgumentException(name + " must be an integer in " + min + ".." + max + "."); return (int)args[name]; } public void UpdateRenderLimit() { gcLatency.Update(MySession.Static != null && MySandboxGame.IsGameReady && !MySandboxGame.IsPaused); var thread = MySandboxGame.Static?.GameRenderComponent?.RenderThread; if(!ReferenceEquals(thread,affinityRenderThread)) { if(affinityRenderThread!=null) affinityRenderThread.BeforeDraw-=cacheCoreAffinity.MarkRenderThread; affinityRenderThread=thread; if(thread!=null) thread.BeforeDraw+=cacheCoreAffinity.MarkRenderThread; } var waiter = thread == null ? null : RenderWaiter?.GetValue(thread) as WaitForTargetFrameRate; if (!ReferenceEquals(waiter, renderWaiter)) { if (renderWaiter != null) Volatile.Write(ref renderWaiter.EnableMaxSpeed, originalRenderMaxSpeed); renderWaiter = waiter; if (waiter != null) originalRenderMaxSpeed = waiter.EnableMaxSpeed; } if (waiter != null) Volatile.Write(ref waiter.EnableMaxSpeed, uncapped || originalRenderMaxSpeed); } public JObject Status() => new JObject { ["renderUncapped"] = uncapped, ["renderLimitApplied"] = renderWaiter != null && renderWaiter.EnableMaxSpeed, ["disableVsync"] = disableVsync, ["actorBatching"] = actorBatching, ["lockFreeParallelLoops"] = lockFreeLoops, ["entityBatching"] = entityBatching, ["entityBatchSize"] = EntityBatching.ChunkSize, ["entityBatchesDispatched"] = EntityBatching.Dispatches, ["entityItemsProcessed"] = EntityBatching.ItemsProcessed, ["idleRotation"] = idleRotation, ["idleRotationsSkipped"] = IdleRotation.Skipped, ["texturePriority"] = texturePriority, ["hierarchyUpdates"] = hierarchyUpdates, ["lowLatencyGc"] = gcLatency.Enabled, ["lowLatencyGcApplied"] = gcLatency.Applied, ["lowLatencyGcReason"] = gcLatency.Reason, ["availablePhysicalBytes"] = gcLatency.AvailableBytes, ["actorBatchSize"] = ActorBatching.ChunkSize, ["actorWorkers"] = ActorBatching.Workers, ["preferLargestL3"] = cacheCoreAffinity.Enabled, ["processorAffinityHex"] = cacheCoreAffinity.CurrentMask, ["mainThreadL3"] = cacheCoreAffinity.MainThreadOnly, ["pinRenderWorkers"] = cacheCoreAffinity.PinRenderWorkers,["pinnedRenderThreads"] = cacheCoreAffinity.PinnedRenderThreads,["threadAffinityError"] = cacheCoreAffinity.ThreadError, ["selectedL3Bytes"] = cacheCoreAffinity.SelectedCacheBytes, ["actorBatchesDispatched"] = Interlocked.Read(ref ActorBatching.Dispatches), ["actorComponentsProcessed"] = Interlocked.Read(ref ActorBatching.ItemsProcessed), ["terminalAccessCache"] = cacheEnabled, ["validateCache"] = validate, ["physicsWorkersRequested"] = physicsWorkers, ["physicsWorkersApply"] = "next world load; 0 uses game default; native Havok may cap the request", ["havokMultithreading"] = MyFakes.ENABLE_HAVOK_MULTITHREADING, ["havokParallelScheduling"] = MyFakes.ENABLE_HAVOK_PARALLEL_SCHEDULING, ["cacheLookups"] = lookups, ["cacheHits"] = hits, ["cacheValidations"] = validations, ["cacheMismatches"] = mismatches, ["patchError"] = patchError }; private static void PhysicsWorkersPostfix(ref int? __result) { if (current != null && current.physicsWorkers > 0) __result = current.physicsWorkers; } private void SetVsyncOverride(bool enabled) { if (presentMethod != null) harmony.Unpatch(presentMethod, HarmonyPatchType.Transpiler, PatchId); presentMethod = null; disableVsync = false; if (!enabled) return; var type = AccessTools.TypeByName("VRageRender.MyRender11"); var method = type == null ? null : AccessTools.Method(type, "Present"); if (method == null) throw new MissingMethodException("MyRender11.Present"); harmony.Patch(method, transpiler: new HarmonyMethod(typeof(PerformanceTuning), nameof(PresentWithoutVsync))); presentMethod = method; disableVsync = true; } private void SetActorBatching(bool enabled) { if (actorUpdateMethod != null) harmony.Unpatch(actorUpdateMethod, HarmonyPatchType.Transpiler, PatchId); actorUpdateMethod = null; actorBatching = false; if (!enabled) return; var method = AccessTools.Method(typeof(VRage.Render.Scene.MyActorUpdater), "Update"); harmony.Patch(method, transpiler: new HarmonyMethod(typeof(ActorBatching), nameof(ActorBatching.ReplaceLoop))); actorUpdateMethod = method; actorBatching = true; } private void SetEntityBatching(bool enabled) { if (entityUpdateMethod != null) harmony.Unpatch(entityUpdateMethod, HarmonyPatchType.Transpiler, PatchId); entityUpdateMethod = null; entityBatching = false; if (!enabled) return; var type = AccessTools.TypeByName("Sandbox.Game.Entities.MyParallelEntityUpdateOrchestrator"); var method = type == null ? null : AccessTools.DeclaredMethod(type, "PerformParallelUpdate"); if (method == null) throw new MissingMethodException("PerformParallelUpdate"); harmony.Patch(method, transpiler: new HarmonyMethod(typeof(EntityBatching), nameof(EntityBatching.ReplaceLoop))); entityUpdateMethod = method; entityBatching = true; } private void SetIdleRotation(bool enabled) { if (rotationMethod != null) harmony.Unpatch(rotationMethod, HarmonyPatchType.Prefix, PatchId); rotationMethod = null; idleRotation = false; if (!enabled) return; IdleRotation.ValidateEngine(); var method = AccessTools.Method(typeof(Sandbox.RenderDirect.ActorComponents.MyRotationAnimator), "OnUpdateBeforeDraw"); harmony.Patch(method, prefix: new HarmonyMethod(typeof(IdleRotation), nameof(IdleRotation.Prefix))); rotationMethod = method; idleRotation = true; } private void SetTexturePriority(bool enabled) { if (texturePriorityMethod != null) harmony.Unpatch(texturePriorityMethod, HarmonyPatchType.Transpiler, PatchId); texturePriorityMethod = null; texturePriority = false; if (!enabled) return; var type = AccessTools.TypeByName("VRage.Render11.Resources.Textures.MyTextureStreamingManager+CompiledBatch"); var method = type == null ? null : AccessTools.Method(type, "UpdateScenePriority"); if (method == null) throw new MissingMethodException("CompiledBatch.UpdateScenePriority"); harmony.Patch(method, transpiler: new HarmonyMethod(typeof(TexturePriorityUpdates), nameof(TexturePriorityUpdates.ReplaceMaximum))); texturePriorityMethod = method; texturePriority = true; } private void SetHierarchyUpdates(bool enabled) { if (hierarchyMethod != null) harmony.Unpatch(hierarchyMethod, HarmonyPatchType.Prefix, PatchId); hierarchyMethod = null; hierarchyUpdates = false; if (!enabled) return; HierarchyUpdates.ValidateEngine(); var method = AccessTools.DeclaredMethod(typeof(VRage.Game.Components.MyPositionComponent), "UpdateChildren"); harmony.Patch(method, prefix: new HarmonyMethod(typeof(HierarchyUpdates), nameof(HierarchyUpdates.Prefix))); hierarchyMethod = method; hierarchyUpdates = true; } private static IEnumerable PresentWithoutVsync(IEnumerable instructions) { var result = new List(); int matches = 0; foreach (var instruction in instructions) { result.Add(instruction); bool setting = instruction.opcode == OpCodes.Ldfld && instruction.operand is FieldInfo field && field.Name == "VSync" && field.FieldType == typeof(int); bool dynamicSetting = instruction.opcode == OpCodes.Call && instruction.operand is MethodInfo method && method.Name == "GetDeviceVSyncMode" && method.ReturnType == typeof(int); if (!setting && !dynamicSetting) continue; // Change only DXGI's sync interval. Do not change swap-chain size, graphics quality or simulation cadence. result.Add(new CodeInstruction(OpCodes.Pop)); result.Add(new CodeInstruction(OpCodes.Ldc_I4_0)); matches++; } if (matches != 2) throw new InvalidOperationException("Unsupported Present method: expected two verified VSync interval sites."); return result; } private void SetCache(bool enabled) { foreach (var method in cacheMethods) harmony.Unpatch(method, HarmonyPatchType.All, PatchId); cacheMethods.Clear(); cacheEnabled = false; stamps = new ConditionalWeakTable(); if (!enabled) return; try { PatchInvalidation(typeof(MyGridTerminalSystem), "Add", "Remove"); PatchInvalidation(typeof(MyCubeGrid), "NotifyBlockOwnershipChange", "ChangeGridOwnership"); PatchInvalidation(typeof(MyFactionCollection), "ApplyFactionStateChange", "AddPlayerToFactionInternal", "ClearPlayersFactionMapping", "ChangeFactionRelation", "ChangeRelationWithPlayer", "ChangeReputationWithPlayer", "RemoveRelation", "DeleteFactionRelations", "DeletePlayerRelations"); var walk = AccessTools.Method(typeof(MyGridTerminalSystem), "UpdateGridBlocksOwnership", new[] { typeof(long) }); if (walk == null) throw new MissingMethodException("UpdateGridBlocksOwnership"); harmony.Patch(walk, prefix: new HarmonyMethod(typeof(PerformanceTuning), nameof(AccessPrefix)), postfix: new HarmonyMethod(typeof(PerformanceTuning), nameof(AccessPostfix))); cacheMethods.Add(walk); cacheEnabled = true; patchError = null; } catch (Exception error) { foreach (var method in cacheMethods) harmony.Unpatch(method, HarmonyPatchType.All, PatchId); cacheMethods.Clear(); patchError = error.Message; throw new InvalidOperationException("Access cache remains disabled; engine patch verification failed.", error); } } private void PatchInvalidation(Type type, params string[] names) { foreach (string name in names) { var method = AccessTools.Method(type, name); if (method == null) throw new MissingMethodException(type.FullName, name); harmony.Patch(method, prefix: new HarmonyMethod(typeof(PerformanceTuning), nameof(Invalidate))); cacheMethods.Add(method); } } private static void Invalidate() { if (current != null) Interlocked.Increment(ref current.generation); } private sealed class AccessCall { public AccessStamp Stamp; public long Owner, Generation, Frame; public bool Admin, Factions; } private static bool AccessPrefix(MyGridTerminalSystem __instance, long ownerID, ref AccessCall __state) { var self = current; var session = MySession.Static; // The stock scripts run on the game thread. Do not interfere with another plugin's parallel runner. if (self == null || !self.cacheEnabled || session == null || Thread.CurrentThread.ManagedThreadId != self.gameThread) return true; self.lookups++; var stamp = self.stamps.GetValue(__instance, _ => new AccessStamp()); bool admin = false; foreach (var block in __instance.Blocks) { admin = block.HasAdminUseTerminals(ownerID); break; } long gen = Interlocked.Read(ref self.generation), frame = session.GameplayFrameCounter; bool factions = MyFakes.SHOW_FACTIONS_GUI; if (stamp.Matches(ownerID, gen, frame, admin, factions)) { if (self.validate) { self.validations++; foreach (var block in __instance.Blocks) { if (block.IsAccessibleForProgrammableBlock == block.HasPlayerAccessWithNobodyCheck(ownerID, true)) continue; self.mismatches++; self.cacheEnabled = false; self.log("Access cache disabled: validation mismatch on block " + block.EntityId); return true; } } self.hits++; return false; } __state = new AccessCall { Stamp = stamp, Owner = ownerID, Generation = gen, Frame = frame, Admin = admin, Factions = factions }; return true; } private static void AccessPostfix(AccessCall __state) { if (__state != null) __state.Stamp.Record(__state.Owner, __state.Generation, __state.Frame, __state.Admin, __state.Factions); } public void Dispose() { if(affinityRenderThread!=null) affinityRenderThread.BeforeDraw-=cacheCoreAffinity.MarkRenderThread; if(ReferenceEquals(ActorBatching.Affinity,cacheCoreAffinity)) ActorBatching.Affinity=null; try { gcLatency.Dispose(); cacheCoreAffinity.Dispose(); } finally { ParallelTasks.Parallel.IsMutexSlow = originalLockFreeLoops; if (renderWaiter != null) Volatile.Write(ref renderWaiter.EnableMaxSpeed, originalRenderMaxSpeed); harmony.UnpatchAll(PatchId); if (ReferenceEquals(current, this)) current = null; } } } }