Merge pull request #9 from esnya/feature/improve-runtime-performance

zap: ⚡️ Improve runtime performance and serialized outputs

Author: esnya

ResoniteMetricsCounter/Metrics/Metric.cs

@@ -1,119 +1,67 @@
 using FrooxEngine;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Converters;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Text;
+using System.Runtime.CompilerServices;
+using System.Text.Json.Serialization;
 
 namespace ResoniteMetricsCounter.Metrics;
 
-internal enum MetricType
+/// <summary>
+/// Represents a metric that is associated with a specific target element.
+/// </summary>
+/// <typeparam name="T">The type of the target element, which must implement <see cref="IWorldElement"/>.</typeparam>
+public class Metric<T> where T : IWorldElement
 {
-    PhysicsMoved,
-    PhysicsUpdate,
-    Updates,
-    ProtoFluxContinuousChanges,
-    ProtoFluxUpdates,
-    Changes,
-    Connectors,
-}
-
-
-#pragma warning disable CA1812
-internal sealed class SlotHierarchyConverter : JsonConverter<Slot>
-{
-    private readonly Dictionary<Slot, string> cache = new();
-
-    public override Slot ReadJson(JsonReader reader, Type objectType, Slot? existingValue, bool hasExistingValue, JsonSerializer serializer)
+    /// <summary>
+    /// Target element of the metric.
+    /// </summary>
+    [JsonInclude] public T Target { get; private set; }
+
+    /// <summary>
+    /// Ticks of the metric.
+    /// </summary>
+    [JsonInclude] public long Ticks { get; private set; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="Metric{T}"/> class.
+    /// </summary>
+    /// <param name="target">The target element of the metric.</param>
+    /// <param name="ticks">The initial number of ticks. Default is 0.</param>
+    public Metric(T target, long ticks = 0)
     {
-        throw new NotImplementedException();
+        Target = target;
+        Ticks = ticks;
     }
 
-    public override void WriteJson(JsonWriter writer, Slot? value, JsonSerializer serializer)
+    /// <summary>
+    /// Adds the specified number of ticks to the metric.
+    /// </summary>
+    /// <param name="ticks">The number of ticks to add.</param>
+    /// <throws><see cref="OverflowException"/> if the result is greater than <see cref="long.MaxValue"/>.</throws>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Add(long ticks)
     {
-        if (value is null)
-        {
-            writer.WriteNull();
-            return;
-        }
-
-        if (cache.TryGetValue(value, out var cached))
-        {
-            writer.WriteValue(cached);
-            return;
-        }
-
-        var stringBuilder = new StringBuilder();
-
-        for (var s = value; s != null; s = s.Parent)
-        {
-            stringBuilder.Insert(0, s.Name);
-            stringBuilder.Insert(0, "/");
-        }
-
-        writer.WriteValue(cache[value] = stringBuilder.ToString());
+        Ticks += ticks;
     }
 }
-#pragma warning restore CA1812
 
-internal struct Metric
+/// <summary>
+/// Represents a metric that is associated with a specific world refresh stage.
+/// </summary>
+/// <typeparam name="T">The type of the target element, which must implement <see cref="IWorldElement"/>.</typeparam>
+public sealed class StageMetric<T> : Metric<T> where T : IWorldElement
 {
-    [JsonConverter(typeof(SlotHierarchyConverter))]
-    public Slot Slot;
-
-    public string Name;
-
-    [JsonConverter(typeof(StringEnumConverter))]
-    public MetricType Type;
-
-    public long Ticks;
-
-    public static long Frequency => Stopwatch.Frequency;
-
-
-    [JsonConverter(typeof(SlotHierarchyConverter))]
-    public readonly Slot? ObjectRoot
-    {
-        get
-        {
-            return Slot.Parent?.GetObjectRoot();
-        }
-    }
-
-    public readonly string Label
-    {
-        get
-        {
-            var parent = Slot.Parent;
-            var root = parent?.GetObjectRoot();
-
-            if (parent is null)
-            {
-                return $"{Slot.Name}.{Name}[{Type}]";
-            }
-            else if (root is null || root == parent)
-            {
-                return $"{parent.Name}/{Slot.Name}.{Name}[{Type}]";
-            }
-
-            return $"{root.Name}/../{parent.Name}/{Slot.Name}.{Name}[{Type}]";
-        }
-    }
-
-    public override readonly int GetHashCode()
-    {
-        return Slot.ReferenceID.GetHashCode() ^ Name.GetHashCode() ^ Type.GetHashCode();
-    }
-
-    public static Metric operator +(Metric a, Metric b)
+    /// <summary>
+    /// World reflesh stage of the metric.
+    /// </summary>
+    [JsonInclude] public World.RefreshStage Stage { get; private set; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="StageMetric{T}"/> class.
+    /// </summary>
+    /// <param name="stage">The world refresh stage of the metric.</param>
+    /// <param name="target">The target element of the metric.</param>
+    /// <param name="ticks">The initial number of ticks. Default is 0.</param>
+    public StageMetric(World.RefreshStage stage, T target, long ticks = 0) : base(target, ticks)
     {
-        return new Metric
-        {
-            Slot = a.Slot,
-            Name = a.Name,
-            Type = a.Type,
-            Ticks = a.Ticks + b.Ticks,
-        };
+        Stage = stage;
     }
 }

ResoniteMetricsCounter/Metrics/MetricsCounter.cs

@@ -1,104 +1,124 @@
 using Elements.Core;
 using FrooxEngine;
-using Newtonsoft.Json;
+using FrooxEngine.ProtoFlux;
+using ResoniteMetricsCounter.Serialization;
+using ResoniteMetricsCounter.Utils;
+using ResoniteModLoader;
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using System.Text.Json;
+using System.Text.Json.Serialization;
 
 namespace ResoniteMetricsCounter.Metrics;
 
-internal sealed class MetricsCounter : IDisposable
+
+public sealed class MetricsCounter : IDisposable
 {
-    internal Dictionary<int, Metric> Metrics = new();
-    private readonly string filename;
-    private HashSet<string> blackList;
-    private Slot? ignoredHierarchy;
-    internal long TotalTicks
+    private readonly CachedElementValue<IWorldElement, bool> shouldSkip;
+
+    [JsonInclude] public Slot? IgnoredHierarchy { get; private set; }
+    internal bool IsDisposed { get; private set; }
+
+    [JsonInclude] public string Filename { get; private set; }
+    [JsonInclude] public VersionNumber EngineVersion { get; private set; }
+    [JsonInclude] public HashSet<string> BlackList { get; private set; }
+
+    [JsonInclude] public MetricsByStageStorage<IWorldElement> ByElement { get; private set; } = new();
+    [JsonInclude] public MetricsStorage<Slot> ByObjectRoot { get; private set; } = new();
+
+    public MetricsCounter(IEnumerable<string> blackList)
     {
-        get;
-        private set;
+        shouldSkip = new(ShouldSkipImpl);
+
+        EngineVersion = Engine.Version;
+        Filename = UniLog.GenerateLogName(EngineVersion.ToString(), "-trace").Replace(".log", ".json");
+        BlackList = blackList.ToHashSet();
     }
-    internal long MaxTicks
+
+    private bool ShouldSkipImpl(IWorldElement element)
     {
-        get;
-        private set;
+        if (element.World.Focus != World.WorldFocus.Focused) return true;
+        if (element.IsLocalElement || element.IsRemoved || BlackList.Contains(element.GetNameFast())) return true;
+
+        var slot = element.GetSlotFast();
+        if (slot is null || IgnoredHierarchy is null) return false;
+        return IgnoredHierarchy.IsChildOf(slot, includeSelf: true);
     }
 
-    public MetricsCounter(IEnumerable<string> blackList)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void AddForCurrentStage(object? obj, long ticks)
     {
-        filename = UniLog.GenerateLogName(Engine.VersionNumber, "-trace").Replace(".log", ".json");
-        this.blackList = blackList.ToHashSet();
+        if (obj is IWorldElement element) AddForCurrentStage(element, ticks);
+        else if (obj is ProtoFluxNodeGroup group) AddForCurrentStage(group, ticks);
+        else if (ResoniteMod.IsDebugEnabled()) ResoniteMod.Debug($"Unknown object type: {obj?.GetType()}");
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void Add(string name, Slot slot, long ticks, MetricType type)
+    private void AddForCurrentStage(ProtoFluxNodeGroup group, long ticks)
     {
-        Add(new Metric()
-        {
-            Slot = slot,
-            Name = name,
-            Ticks = ticks,
-            Type = type
-        });
+        var world = group.World;
+        if (world.Focus != World.WorldFocus.Focused) return;
+
+        var node = group.Nodes.FirstOrDefault();
+        if (node is null) return;
+
+        AddForCurrentStage(node, ticks);
     }
 
-    public void Add(in Metric metric)
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private void AddForCurrentStage(IWorldElement element, long ticks)
     {
-        if (metric.Ticks == 0 || blackList.Contains(metric.Name) || (ignoredHierarchy is not null && metric.Slot.IsChildOf(ignoredHierarchy, includeSelf: true))) return;
+        if (shouldSkip.GetOrCache(element)) return;
 
-        TotalTicks += metric.Ticks;
+        ByElement.Add(element, ticks);
 
-        var id = metric.GetHashCode();
-        if (Metrics.TryGetValue(id, out var prevValue))
-        {
-            Metrics[id] = prevValue + metric;
-        }
-        else
-        {
-            Metrics[id] = metric;
-        }
+        var objectRoot = element.GetExactObjectRootOrWorldRootFast();
+        if (objectRoot is null) return;
 
-        var ticks = Metrics[id].Ticks;
-        if (ticks > MaxTicks)
-        {
-            MaxTicks = ticks;
-        }
+        ByObjectRoot.Add(objectRoot, ticks);
     }
 
+    private static readonly JsonSerializerOptions jsonSerializerOptions = new()
+    {
+        WriteIndented = true,
+        IgnoreReadOnlyFields = false,
+        IgnoreReadOnlyProperties = false,
+        Converters = { new IWorldElementConverter(), new JsonStringEnumConverter<World.RefreshStage>() },
+    };
+
     public void Flush()
     {
-        var serializer = new JsonSerializer();
-        var streamWriter = new StreamWriter(filename, append: true);
-        serializer.Serialize(streamWriter, Metrics);
-        streamWriter.Close();
+        ResoniteMod.DebugFunc(() => $"Writing metrics to {Filename}");
+        using (var writer = new FileStream(Filename, FileMode.Create))
+        {
+            JsonSerializer.Serialize(writer, this, jsonSerializerOptions);
+        }
     }
 
     public void Dispose()
     {
+        IsDisposed = true;
         Flush();
     }
 
     internal void UpdateBlacklist(IEnumerable<string> blackList)
     {
-        this.blackList = blackList.ToHashSet();
-        foreach (var metric in Metrics.Values)
-        {
-            if (this.blackList.Contains(metric.Name))
-            {
-                Metrics.Remove(metric.GetHashCode());
-            }
-        }
+        shouldSkip.Clear();
+        BlackList = blackList.ToHashSet();
+        ByElement.RemoveWhere(m => BlackList.Contains(m.Target.GetNameFast()));
+        ByObjectRoot.RemoveWhere(m => BlackList.Contains(m.Target.GetNameFast()));
     }
 
-    internal void Remove(in Metric metric)
+    internal void Remove(Slot slot)
     {
-        Metrics.Remove(metric.GetHashCode());
+        ByObjectRoot.Remove(slot);
     }
 
     internal void IgnoreHierarchy(Slot slot)
     {
-        ignoredHierarchy = slot;
+        IgnoredHierarchy = slot;
     }
 }