com.wallstop-studios.dxmessaging 2.0.0-rc13 → 2.0.0-rc15

package/Runtime/Core/MessagingDebug.cs

@@ -14,10 +14,12 @@
     }
 
     /// <summary>
-    /// Debug functionality for all of the Messaging Components.
+    /// Debug functionality for all the Messaging Components.
     /// </summary>
     public static class MessagingDebug
     {
+        public static bool enabled = false;
+
         /// <summary>
         /// Custom log function to use.
         /// </summary>
@@ -27,7 +29,7 @@
         public static Action<LogLevel, string> LogFunction = null;
 
         /// <summary>
-        /// Logs a message to the debug log function, if it's not null.
+        /// Logs a message to the debug log function if it's not null.
         /// </summary>
         /// <param name="logLevel">Severity of the message.</param>
         /// <param name="message">Message to log.</param>
@@ -47,6 +49,11 @@
         /// <param name="args">Args to populate format string with.</param>
         public static void Log(LogLevel logLevel, string message, params object[] args)
         {
+            if (!enabled)
+            {
+                return;
+            }
+
             Action<LogLevel, string> logFunction = LogFunction;
             /*
                 We can potentially avoid an unnecessary string.Format call if the LogFunction is null,

package/Tests/Runtime/Benchmarks/PerformanceTests.cs

@@ -6,59 +6,30 @@
     using DxMessaging.Core;
     using DxMessaging.Core.Extensions;
     using global::Unity.PerformanceTesting;
-    using global::Unity.Profiling;
     using NUnit.Framework;
     using Scripts.Components;
     using Scripts.Messages;
     using UnityEngine;
-    using UnityEngine.Profiling;
+    using UnityEngine.TestTools.Constraints;
     using Debug = UnityEngine.Debug;
+    using Is = NUnit.Framework.Is;
     using Object = UnityEngine.Object;
 
     public sealed class PerformanceTests : MessagingTestBase
     {
-        internal static string FormatBytes(long bytes)
-        {
-            if (bytes < 1024)
-            {
-                return $"{bytes} B";
-            }
-
-            string[] sizes = { "KB", "MB", "GB", "TB", "PB", "EB" };
-            double len = bytes;
-            int order = 0;
-
-            while (1024 <= len && order < sizes.Length - 1)
-            {
-                len /= 1024;
-                order++;
-            }
-
-            return $"{len:0.##} {sizes[order]}";
-        }
-
-        [SetUp]
-        public override void Setup()
-        {
-            base.Setup();
-            MessagingDebug.LogFunction = (_, _) => { };
-        }
+        protected override bool MessagingDebugEnabled => false;
 
         [Test]
         public void Benchmark()
         {
             TimeSpan timeout = TimeSpan.FromSeconds(2);
 
-            Debug.Log("| Message Tech | Operations / Second | Memory Allocated |");
-            Debug.Log("| ------------ | ------------------- | --------------- |");
+            Debug.Log("| Message Tech | Operations / Second | Allocations? |");
+            Debug.Log("| ------------ | ------------------- | ------------ | ");
 
             ComplexTargetedMessage message = new(Guid.NewGuid());
             Stopwatch timer = Stopwatch.StartNew();
-            ProfilerRecorder recorder = ProfilerRecorder.StartNew(
-                ProfilerCategory.Memory,
-                "GC.Alloc"
-            );
-            recorder.Stop();
+
             RunTest(component => Unity(timer, timeout, component.gameObject, message));
             RunTest(component => NormalGameObject(timer, timeout, component, message));
             RunTest(component => NormalComponent(timer, timeout, component, message));
@@ -77,16 +48,19 @@
             MessageRegistrationToken token = GetToken(
                 go.GetComponent<EmptyMessageAwareComponent>()
             );
+            // ReSharper disable once NotAccessedVariable
             int count = 0;
             token.RegisterGameObjectBroadcast<SimpleBroadcastMessage>(go, Handle);
 
             SimpleBroadcastMessage message = new();
+            SampleGroup time = new("Time", SampleUnit.Nanosecond);
 
             Measure
                 .Method(() => message.EmitGameObjectBroadcast(go))
+                .SampleGroup(time)
                 .WarmupCount(10)
-                .IterationsPerMeasurement(10)
-                .MeasurementCount(1_000)
+                .IterationsPerMeasurement(1)
+                .MeasurementCount(10_000)
                 .Run();
             return;
 
@@ -104,16 +78,19 @@
             MessageRegistrationToken token = GetToken(
                 go.GetComponent<EmptyMessageAwareComponent>()
             );
+            // ReSharper disable once NotAccessedVariable
             int count = 0;
             token.RegisterGameObjectTargeted<SimpleTargetedMessage>(go, Handle);
 
             SimpleTargetedMessage message = new();
+            SampleGroup time = new("Time", SampleUnit.Nanosecond);
 
             Measure
                 .Method(() => message.EmitGameObjectTargeted(go))
+                .SampleGroup(time)
                 .WarmupCount(10)
-                .IterationsPerMeasurement(10)
-                .MeasurementCount(1_000)
+                .IterationsPerMeasurement(1)
+                .MeasurementCount(10_000)
                 .Run();
             return;
 
@@ -131,16 +108,19 @@
             MessageRegistrationToken token = GetToken(
                 go.GetComponent<EmptyMessageAwareComponent>()
             );
+            // ReSharper disable once NotAccessedVariable
             int count = 0;
             token.RegisterUntargeted<SimpleUntargetedMessage>(Handle);
 
             SimpleUntargetedMessage message = new();
+            SampleGroup time = new("Time", SampleUnit.Nanosecond);
 
             Measure
                 .Method(() => message.EmitUntargeted())
+                .SampleGroup(time)
                 .WarmupCount(10)
-                .IterationsPerMeasurement(10)
-                .MeasurementCount(1_000)
+                .IterationsPerMeasurement(1)
+                .MeasurementCount(10_000)
                 .Run();
             return;
 
@@ -169,11 +149,11 @@
             string testName,
             int count,
             TimeSpan timeout,
-            long memoryUsed
+            bool allocating
         )
         {
             Debug.Log(
-                $"| {testName} | {Math.Floor(count / timeout.TotalSeconds):N0} | {FormatBytes(Math.Max(memoryUsed, 0))} |"
+                $"| {testName} | {Math.Floor(count / timeout.TotalSeconds):N0} | {(allocating ? "Yes" : "No")} |"
             );
         }
 
@@ -201,10 +181,12 @@
             int count = 0;
             var component = target.AddComponent<SimpleMessageAwareComponent>();
             component.slowComplexTargetedHandler = () => ++count;
-            ProfilerRecorder recorder = ProfilerRecorder.StartNew(
-                ProfilerCategory.Memory,
-                "GC.Alloc"
+            // Pre-warm
+            target.SendMessage(
+                nameof(SimpleMessageAwareComponent.HandleSlowComplexTargetedMessage),
+                message
             );
+
             timer.Restart();
             do
             {
@@ -213,8 +195,25 @@
                     message
                 );
             } while (timer.Elapsed < timeout);
-            recorder.Stop();
-            DisplayCount("Unity", count, timeout, recorder.LastValue);
+
+            bool allocating;
+            try
+            {
+                Assert.That(
+                    () =>
+                        target.SendMessage(
+                            nameof(SimpleMessageAwareComponent.HandleSlowComplexTargetedMessage),
+                            message
+                        ),
+                    Is.Not.AllocatingGCMemory()
+                );
+                allocating = false;
+            }
+            catch
+            {
+                allocating = true;
+            }
+            DisplayCount("Unity", count, timeout, allocating);
         }
 
         private void NormalGameObject(
@@ -229,18 +228,26 @@
 
             GameObject go = component.gameObject;
             token.RegisterGameObjectTargeted<ComplexTargetedMessage>(go, Handle);
-            ProfilerRecorder recorder = ProfilerRecorder.StartNew(
-                ProfilerCategory.Memory,
-                "GC.Alloc"
-            );
+            // Pre-warm
+            message.EmitGameObjectTargeted(go);
+
             timer.Restart();
             do
             {
                 message.EmitGameObjectTargeted(go);
             } while (timer.Elapsed < timeout);
+            bool allocating;
+            try
+            {
+                Assert.That(() => message.EmitGameObjectTargeted(go), Is.Not.AllocatingGCMemory());
+                allocating = false;
+            }
+            catch
+            {
+                allocating = true;
+            }
 
-            recorder.Stop();
-            DisplayCount("DxMessaging (GameObject) - Normal", count, timeout, recorder.LastValue);
+            DisplayCount("DxMessaging (GameObject) - Normal", count, timeout, allocating);
             return;
 
             void Handle(ComplexTargetedMessage _)
@@ -260,17 +267,29 @@
             var token = GetToken(component);
 
             token.RegisterComponentTargeted<ComplexTargetedMessage>(component, Handle);
-            ProfilerRecorder recorder = ProfilerRecorder.StartNew(
-                ProfilerCategory.Memory,
-                "GC.Alloc"
-            );
+            // Pre-warm
+            message.EmitComponentTargeted(component);
+
             timer.Restart();
             do
             {
                 message.EmitComponentTargeted(component);
             } while (timer.Elapsed < timeout);
-            recorder.Stop();
-            DisplayCount("DxMessaging (Component) - Normal", count, timeout, recorder.LastValue);
+
+            bool allocating;
+            try
+            {
+                Assert.That(
+                    () => message.EmitComponentTargeted(component),
+                    Is.Not.AllocatingGCMemory()
+                );
+                allocating = false;
+            }
+            catch
+            {
+                allocating = true;
+            }
+            DisplayCount("DxMessaging (Component) - Normal", count, timeout, allocating);
             return;
 
             void Handle(ComplexTargetedMessage _)
@@ -291,17 +310,28 @@
 
             GameObject go = component.gameObject;
             token.RegisterGameObjectTargeted<ComplexTargetedMessage>(go, Handle);
-            ProfilerRecorder recorder = ProfilerRecorder.StartNew(
-                ProfilerCategory.Memory,
-                "GC.Alloc"
-            );
+            // Pre-warm
+            message.EmitGameObjectTargeted(component.gameObject);
+
             timer.Restart();
             do
             {
                 message.EmitGameObjectTargeted(component.gameObject);
             } while (timer.Elapsed < timeout);
-            recorder.Stop();
-            DisplayCount("DxMessaging (GameObject) - No-Copy", count, timeout, recorder.LastValue);
+            bool allocating;
+            try
+            {
+                Assert.That(
+                    () => message.EmitGameObjectTargeted(component.gameObject),
+                    Is.Not.AllocatingGCMemory()
+                );
+                allocating = false;
+            }
+            catch
+            {
+                allocating = true;
+            }
+            DisplayCount("DxMessaging (GameObject) - No-Copy", count, timeout, allocating);
             return;
 
             void Handle(ref ComplexTargetedMessage _)
@@ -321,17 +351,29 @@
             var token = GetToken(component);
 
             token.RegisterComponentTargeted<ComplexTargetedMessage>(component, Handle);
-            ProfilerRecorder recorder = ProfilerRecorder.StartNew(
-                ProfilerCategory.Memory,
-                "GC.Alloc"
-            );
+            // Pre-warm
+            message.EmitComponentTargeted(component);
+
             timer.Restart();
             do
             {
                 message.EmitComponentTargeted(component);
             } while (timer.Elapsed < timeout);
-            recorder.Stop();
-            DisplayCount("DxMessaging (Component) - No-Copy", count, timeout, recorder.LastValue);
+
+            bool allocating;
+            try
+            {
+                Assert.That(
+                    () => message.EmitComponentTargeted(component),
+                    Is.Not.AllocatingGCMemory()
+                );
+                allocating = false;
+            }
+            catch
+            {
+                allocating = true;
+            }
+            DisplayCount("DxMessaging (Component) - No-Copy", count, timeout, allocating);
             return;
 
             void Handle(ref ComplexTargetedMessage _)
@@ -351,17 +393,26 @@
             var token = GetToken(component);
 
             token.RegisterUntargeted<SimpleUntargetedMessage>(Handle);
-            ProfilerRecorder recorder = ProfilerRecorder.StartNew(
-                ProfilerCategory.Memory,
-                "GC.Alloc"
-            );
+            // Pre-warm
+            message.EmitUntargeted();
+
             timer.Restart();
             do
             {
                 message.EmitUntargeted();
             } while (timer.Elapsed < timeout);
-            recorder.Stop();
-            DisplayCount("DxMessaging (Untargeted) - No-Copy", count, timeout, recorder.LastValue);
+
+            bool allocating;
+            try
+            {
+                Assert.That(() => message.EmitUntargeted(), Is.Not.AllocatingGCMemory());
+                allocating = false;
+            }
+            catch
+            {
+                allocating = true;
+            }
+            DisplayCount("DxMessaging (Untargeted) - No-Copy", count, timeout, allocating);
             return;
 
             void Handle(ref SimpleUntargetedMessage _)

package/Tests/Runtime/Core/MessagingTestBase.cs

@@ -22,9 +22,12 @@
         protected readonly List<GameObject> _spawned = new();
         protected readonly Random _random = new();
 
+        protected virtual bool MessagingDebugEnabled => true;
+
         [SetUp]
         public virtual void Setup()
         {
+            MessagingDebug.enabled = MessagingDebugEnabled;
             MessagingDebug.LogFunction = (level, message) =>
             {
                 switch (level)
@@ -45,6 +48,18 @@
             Assert.IsNotNull(messageBus);
             messageBus.Log.Enabled = true;
             _numRegistrations = 150;
+
+            LogMessageBusStatus();
+        }
+
+        protected void LogMessageBusStatus()
+        {
+            MessageBus messageBus = MessageHandler.MessageBus;
+            Debug.Log(
+                $"Untargeted registrations: {messageBus.RegisteredUntargeted}, "
+                    + $"targeted registrations: {messageBus.RegisteredTargeted}, "
+                    + $"broadcast registrations: {messageBus.RegisteredBroadcast}."
+            );
         }
 
         [TearDown]
@@ -154,20 +169,12 @@
 
         protected IEnumerator WaitUntilMessageHandlerIsFresh()
         {
-            Setup();
             MessageBus messageBus = MessageHandler.MessageBus;
             Assert.IsNotNull(messageBus);
 
             Stopwatch timer = Stopwatch.StartNew();
 
-            bool IsStale()
-            {
-                return messageBus.RegisteredUntargeted != 0
-                    || messageBus.RegisteredTargeted != 0
-                    || messageBus.RegisteredBroadcast != 0;
-            }
-
-            while (IsStale() && timer.Elapsed < TimeSpan.FromSeconds(2.5))
+            while (IsStale() && timer.Elapsed < TimeSpan.FromSeconds(1.25))
             {
                 yield return null;
             }
@@ -180,6 +187,14 @@
                 messageBus.RegisteredBroadcast,
                 messageBus.Log
             );
+            yield break;
+
+            bool IsStale()
+            {
+                return messageBus.RegisteredUntargeted != 0
+                    || messageBus.RegisteredTargeted != 0
+                    || messageBus.RegisteredBroadcast != 0;
+            }
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.wallstop-studios.dxmessaging",
-  "version": "2.0.0-rc13",
+  "version": "2.0.0-rc15",
   "displayName": "DxMessaging",
   "description": "Synchronous Event Bus for Unity",
   "unity": "2021.3",