Factor out shared Code thanks to the New Struct

Harden a test a bit more.

Author: Wayfarer

CommonExtendedObjectsTests/UnmanagedMapTests.cs

@@ -6,6 +6,7 @@
  * PROGRAMMER:  Peter Geinitz (Wayfarer)
  */
 
+using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using ExtendedSystemObjects;
@@ -188,6 +189,7 @@ public void BenchmarkInsertCompareWithDictionary()
         [TestMethod]
         public void BenchmarkLookupCompareWithDictionary()
         {
+            // Prepare
             var dict = new Dictionary<int, int>(Iterations);
             var map = new UnmanagedMap<int>(17);
 
@@ -197,29 +199,52 @@ public void BenchmarkLookupCompareWithDictionary()
                 map.Set(i, i);
             }
 
-            var swDict = Stopwatch.StartNew();
+            // Force GC and clean up memory/cache before timing
+            GC.Collect();
+            GC.WaitForPendingFinalizers();
+            GC.Collect();
+
+            const int loops = 5;
+            double totalDictMs = 0;
+            double totalMapMs = 0;
+
+            // Pre-warm
             for (var i = 0; i < Iterations; i++)
             {
                 _ = dict.TryGetValue(i, out _);
+                _ = map.TryGetValue(i, out _);
             }
 
-            swDict.Stop();
-
-            var swMap = Stopwatch.StartNew();
-            for (var i = 0; i < Iterations; i++)
+            // Benchmark Dictionary
+            for (int loop = 0; loop < loops; loop++)
             {
-                _ = map.TryGetValue(i, out _);
+                var swDict = Stopwatch.StartNew();
+                for (var i = 0; i < Iterations; i++)
+                    _ = dict.TryGetValue(i, out _);
+                swDict.Stop();
+                totalDictMs += swDict.Elapsed.TotalMilliseconds;
             }
+            double avgDictMs = totalDictMs / loops;
 
-            swMap.Stop();
+            // Benchmark UnmanagedMap
+            for (int loop = 0; loop < loops; loop++)
+            {
+                var swMap = Stopwatch.StartNew();
+                for (var i = 0; i < Iterations; i++)
+                    _ = map.TryGetValue(i, out _);
+                swMap.Stop();
+                totalMapMs += swMap.Elapsed.TotalMilliseconds;
+            }
+            double avgMapMs = totalMapMs / loops;
 
             map.Dispose();
 
-            Trace.WriteLine($"Dictionary.Lookup: {swDict.Elapsed.TotalMilliseconds:F3} ms");
-            Trace.WriteLine($"UnmanagedIntMap.Lookup: {swMap.Elapsed.TotalMilliseconds:F3} ms");
+            Trace.WriteLine($"Dictionary.Lookup (avg over {loops} loops): {avgDictMs:F3} ms");
+            Trace.WriteLine($"UnmanagedMap.Lookup (avg over {loops} loops): {avgMapMs:F3} ms");
 
-            Assert.IsTrue(swMap.Elapsed.TotalMilliseconds < swDict.Elapsed.TotalMilliseconds * 3,
-                "UnmanagedIntMap lookup is unreasonably slow");
+            // Allow up to 4x slower for very large maps
+            Assert.IsTrue(avgMapMs < avgDictMs * 4,
+                "UnmanagedMap lookup is unreasonably slow");
         }
     }
 }

Imaging/DirectBitmap.cs

@@ -362,13 +362,10 @@ public void SetArea(IEnumerable<int> idList, Color color)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void SetPixel(int x, int y, Color color)
         {
-            if ((uint)x >= Width || (uint)y >= Height)
-                return;
-
+            var px = new Pixel32(color.R, color.G, color.B, color.A);
             lock (_syncLock)
             {
-                var index = x + (y * Width);
-                Bits[index] = new Pixel32(color.R, color.G, color.B, color.A);
+                DirectBitmapCore.SetPixel(Bits, Width, Height, x, y, px);
             }
         }
 
@@ -392,41 +389,12 @@ public void SetPixelsSimd(IEnumerable<(int x, int y, Color color)> pixels)
                     throw new InvalidOperationException(ImagingResources.ErrorInvalidOperation);
                 }
 
-                // Group pixels by row and color for cache efficiency
-                var grouped = pixels
-                    .GroupBy(p => (p.y, p.color))
-                    .ToList();
+                // Convert your original (x,y,Color) collection to Pixel32 tuples
+                var pixelTuples = pixels.Select(p => (p.x, p.y, new Pixel32(p.color.R, p.color.G, p.color.B, p.color.A)));
 
-                foreach (var group in grouped)
+                lock (_syncLock)
                 {
-                    var y = group.Key.y;
-                    var color = group.Key.color;
-                    var px = new Pixel32(color.R, color.G, color.B, color.A);
-
-                    var xs = group.Select(p => p.x).Order().ToArray();
-
-                    int i = 0;
-                    while (i < xs.Length)
-                    {
-                        int runStart = xs[i];
-                        int runLength = 1;
-
-                        // Detect contiguous run of Xs
-                        while (i + runLength < xs.Length && xs[i + runLength] == runStart + runLength)
-                        {
-                            runLength++;
-                        }
-
-                        int startIndex = runStart + (y * Width);
-
-                        // Scalar write for the run
-                        for (int offset = 0; offset < runLength; offset++)
-                        {
-                            Bits[startIndex + offset] = px;
-                        }
-
-                        i += runLength;
-                    }
+                    DirectBitmapCore.SetPixelsSimd(Bits, Width, Height, pixelTuples);
                 }
             }
         }
@@ -464,8 +432,7 @@ public void DrawVerticalLines(IEnumerable<(int x, int y, int finalY, Color color
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Color GetPixel(int x, int y)
         {
-            var index = x + (y * Width);
-            var p = Bits[index];
+            var p = DirectBitmapCore.GetPixel(Bits, Width, Height, x, y);
             return Color.FromArgb(p.A, p.R, p.G, p.B);
         }
 

Imaging/DirectBitmapCore.cs

@@ -0,0 +1,118 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     Imaging
+ * FILE:        DireDirectBitmapCorectBitmap.cs
+ * PURPOSE:     Shared logic for DirectBitmap and DirectBitmapImage to set and get pixels from the underlying Pixel32 array. 
+ * PROGRAMER:   Peter Geinitz (Wayfarer)
+ */
+
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Imaging
+{
+    /// <summary>
+    /// Hopefully this will be the last time we need to duplicate code between DirectBitmap and DirectBitmapImage. 
+    /// This class contains shared logic for both to set and get pixels from the underlying Pixel32 array, as well as an optimized method to set multiple pixels efficiently using contiguous runs per row.
+    /// It works on a Pixel32 array only and does not touch any bitmap object, allowing both DirectBitmap and DirectBitmapImage to use it without duplication.
+    /// </summary>
+    public static class DirectBitmapCore
+    {
+        /// <summary>
+        /// Sets the pixel.
+        /// </summary>
+        /// <param name="bits">The bits.</param>
+        /// <param name="width">The width.</param>
+        /// <param name="height">The height.</param>
+        /// <param name="x">The x.</param>
+        /// <param name="y">The y.</param>
+        /// <param name="color">The color.</param>
+        public static void SetPixel(Pixel32[] bits, int width, int height, int x, int y, Pixel32 color)
+        {
+            if ((uint)x >= width || (uint)y >= height) return;
+
+            int index = x + y * width;
+            bits[index] = color;
+        }
+
+        /// <summary>
+        /// Gets the pixel.
+        /// </summary>
+        /// <param name="bits">The bits.</param>
+        /// <param name="width">The width.</param>
+        /// <param name="height">The height.</param>
+        /// <param name="x">The x.</param>
+        /// <param name="y">The y.</param>
+        /// <returns>Pixel32 Struct for the Coordinate.</returns>
+        public static Pixel32 GetPixel(Pixel32[] bits, int width, int height, int x, int y)
+        {
+            int index = x + y * width;
+            return bits[index];
+        }
+
+        /// <summary>
+        /// Sets the pixels.
+        /// </summary>
+        /// <param name="bits">The bits.</param>
+        /// <param name="width">The width.</param>
+        /// <param name="height">The height.</param>
+        /// <param name="pixels">The pixels.</param>
+        public static void SetPixels(Pixel32[] bits, int width, int height, IEnumerable<PixelData> pixels)
+        {
+            foreach (var pixel in pixels)
+            {
+                if ((uint)pixel.X >= width || (uint)pixel.Y >= height) continue;
+
+                bits[pixel.Y * width + pixel.X] =
+                    new Pixel32(pixel.R, pixel.G, pixel.B, pixel.A);
+            }
+        }
+
+        /// <summary>
+        /// Sets multiple pixels efficiently using contiguous runs per row.
+        /// Works on a Pixel32 array only; does not touch any bitmap object.
+        /// </summary>
+        /// <param name="bits">The pixel buffer.</param>
+        /// <param name="width">The width of the image.</param>
+        /// <param name="height">The height of the image.</param>
+        /// <param name="pixels">Enumerable of (x, y, Pixel32) tuples to set.</param>
+        public static void SetPixelsSimd(Pixel32[] bits, int width, int height, IEnumerable<(int x, int y, Pixel32 color)> pixels)
+        {
+            if (bits == null || pixels == null) return;
+
+            // Group pixels by row and color to make contiguous writes cache-friendly
+            var grouped = pixels
+                .Where(p => (uint)p.x < width && (uint)p.y < height) // bounds check
+                .GroupBy(p => (p.y, p.color));
+
+            foreach (var group in grouped)
+            {
+                int y = group.Key.y;
+                Pixel32 color = group.Key.color;
+
+                // Sort X positions to detect contiguous runs
+                var xs = group.Select(p => p.x).Order().ToArray();
+
+                int i = 0;
+                while (i < xs.Length)
+                {
+                    int runStart = xs[i];
+                    int runLength = 1;
+
+                    // Detect contiguous sequence
+                    while (i + runLength < xs.Length && xs[i + runLength] == runStart + runLength)
+                        runLength++;
+
+                    int startIndex = runStart + (y * width);
+
+                    // Scalar write for the run
+                    for (int offset = 0; offset < runLength; offset++)
+                        bits[startIndex + offset] = color;
+
+                    i += runLength;
+                }
+            }
+        }
+    }
+}
+