Enhance memory management and performance benchmarks

Added a new configuration setting in `.editorconfig` to sort system directives last and increased the maximum line length to 400 characters. Added a new static class `MathUtilities` in `MathUtilities.cs` with a method `CeilPow2` for computing powers of two. Added a new benchmark class `CollectionBenchmark` in `CollectionBenchmark.cs` to measure performance of standard versus unsafe arrays. Added a new benchmark class `HashCodeBenchmark` in `HashCodeBenchmark.cs` to evaluate hash code generation performance. Added new utility methods in `UnsafeUtilities.cs` for memory allocation and deallocation, including `Malloc`, `AlignedAlloc`, `Realloc`, and `Free`. Added a new `AllocationType` enum in `AllocationType.cs` to specify memory allocation types. Changed the project file `Misaki.HighPerformance.Mathematics.csproj` to target .NET 9.0 and enable implicit usings and nullable reference types. Changed the `ParallelNoiseBenchmark` class in `ParallelNoiseBenchmark.cs` to improve memory allocation strategies and performance. Changed memory management in `Arena.cs` and `DynamicArena.cs` to use custom `Malloc` and `Free` functions. Changed the `IUnsafeCollection` interface in `IUnsafeCollection.cs` to include new methods for resizing collections and obtaining unsafe pointers. Changed the `UnsafeArray.cs` to improve management of unsafe arrays, including constructor and method updates. Changed the `UnsafeHashMap` and `UnsafeHashSet` classes to enhance performance and memory management. Changed the `UnsafeCollectionExtensions` class to provide additional methods for copying elements and converting collections. Changed the `ObjectPool` class in `ObjectPool.cs` to simplify cleanup and remove auto-cleanup functionality. Changed job scheduling and worker classes in `JobExtensions.cs` and `JobWorker.cs` to improve job scheduling in a thread pool. Removed commented-out code in `Program.cs` related to previous testing methods. Removed auto-cleanup functionality from the `ObjectPool` class.
2025-04-03 09:13:07 +09:00
parent 060b4c9477
commit 48f2dce778
27 changed files with 1557 additions and 228 deletions
--- a/Misaki.HighPerformance.Test/HashCodeBenchmark.cs
+++ b/Misaki.HighPerformance.Test/HashCodeBenchmark.cs
@@ -0,0 +1,95 @@
+using BenchmarkDotNet.Attributes;
+using System.Numerics;
+
+namespace Misaki.HighPerformance.Test;
+
+public class HashCodeBenchmark
+{
+    private struct Component
+    {
+        public int Value;
+        public int Value2;
+        public float Value3;
+        public Guid Value4;
+        public Matrix4x4 Value5;
+        public Vector4 Value6;
+    }
+
+    [Params(100, 1000, 10000)]
+    public int count;
+
+    private Component _component = new Component()
+    {
+        Value = 0,
+        Value2 = 1,
+        Value3 = 2,
+        Value4 = Guid.NewGuid(),
+        Value5 = Matrix4x4.Identity,
+        Value6 = Vector4.One
+    };
+
+    private Dictionary<Type, int> _hashCache = new();
+    //private UnsafeHashMap<Guid, int> _hashMap = new(16);
+
+    private bool _disposed;
+
+    //~HashCodeBenchmark()
+    //{
+    //    Dispose();
+    //}
+
+    [Benchmark]
+    public void Hash()
+    {
+        for (var i = 0; i < count; i++)
+        {
+            _ = _component.GetHashCode();
+        }
+    }
+
+    [Benchmark]
+    public void HashWithCache()
+    {
+        for (var i = 0; i < count; i++)
+        {
+            var type = typeof(Component);
+            if (!_hashCache.TryGetValue(type, out var hash))
+            {
+                hash = type.GetHashCode();
+                _hashCache[type] = hash;
+            }
+
+            _ = hash;
+        }
+    }
+
+    //[Benchmark]
+    //public void HashWithUnsafeHashMap()
+    //{
+    //    for (var i = 0; i < count; i++)
+    //    {
+    //        var type = _component.GetType();
+    //        var guid = type.GUID;
+    //        if (!_hashMap.TryGetValue(guid, out var hash))
+    //        {
+    //            hash = type.GetHashCode();
+    //            _hashMap.Add(guid, hash);
+    //            _hashMap.Test(ref _hashMap._hashMap);
+    //        }
+
+    //        _ = hash;
+    //    }
+    //}
+
+    //public void Dispose()
+    //{
+    //    if (_disposed)
+    //    {
+    //        return;
+    //    }
+
+    //    _hashMap.Dispose();
+
+    //    GC.SuppressFinalize(this);
+    //}
+}