source が書き変わっちゃうことを認める代わりにアロケーション0のGroupBy

GroupByとかToLookupとかの GC コストが結構高くて困っており。
sourceが「直前で作ったばかりで、他に誰も使わず、書き換えても問題ない」みたいな状況が結構あったので、「書き換わる前提の Span 限定の GroupBy」を実装。
Sortして、連続して同じkeyが並んでる区間を列挙。

Author: ufcpp

Demo/2025/InPlaceGroupBy/.editorconfig

@@ -0,0 +1,5 @@
+[*]
+charset = utf-8
+end_of_line = lf
+
+csharp_style_namespace_declarations=file_scoped:suggestion

Demo/2025/InPlaceGroupBy/BenchmarkInPlaceGroupBy/BenchmarkInPlaceGroupBy.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net9.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="BenchmarkDotNet" Version="0.14.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\InPlaceGroupBy\InPlaceGroupBy.csproj" />
+  </ItemGroup>
+
+</Project>

Demo/2025/InPlaceGroupBy/BenchmarkInPlaceGroupBy/Program.cs

@@ -0,0 +1,64 @@
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Running;
+using InPlaceGroupBy;
+using System.Runtime.CompilerServices;
+
+BenchmarkRunner.Run<InPlaceGroupByBenchmark>();
+
+[MemoryDiagnoser]
+public class InPlaceGroupByBenchmark
+{
+    public static (string key, int value)[] Data =
+    [
+        ("a", 1), ("ab", 2), ("abc", 3), ("a", 4), ("ab", 5),
+        ("a", 6), ("a", 7), ("abc", 8), ("a", 9), ("a", 10),
+        ("a", 11), ("ab", 12), ("abc", 13), ("b", 14), ("ab", 15),
+        ("a", 16), ("a", 17), ("bc", 18), ("a", 19), ("b", 20),
+        ("a", 21), ("ab", 22), ("ac", 23), ("a", 24), ("ab", 25),
+        ("a", 26), ("d", 27), ("abc", 28), ("a", 29), ("ac", 30),
+    ];
+
+    [Benchmark]
+    public void Linq()
+    {
+        var values = (stackalloc int[30]);
+        var i = 0;
+
+        foreach (var g in Data.GroupBy(x => x.key))
+        {
+            values[i++] = g.Sum(x => x.value);
+        }
+    }
+
+    [InlineArray(32)]
+    private struct Buffer<T>
+    {
+        private T _value;
+    }
+
+    [Benchmark]
+    public void InPlaceSpan()
+    {
+        var buffer = new Buffer<(string key, int value)>();
+        Span<(string key, int value)> span = buffer;
+        Data.CopyTo(span); // needs copy
+
+        var values = (stackalloc int[30]);
+        var i = 0;
+
+        foreach (var g in span.GroupBy((x, y) => x.key.AsSpan().CompareTo(y.key, StringComparison.Ordinal)))
+        {
+            values[i++] = g.Sum(x => x.value);
+        }
+    }
+}
+
+file static class Ex
+{
+    public static int Sum<T>(this Span<T> span, Func<T, int> selector)
+    {
+        var sum = 0;
+        foreach (var item in span) sum += selector(item);
+        return sum;
+    }
+}

Demo/2025/InPlaceGroupBy/Directory.Build.props

@@ -0,0 +1,8 @@
+<Project>
+
+  <PropertyGroup>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+</Project>

Demo/2025/InPlaceGroupBy/InPlaceGroupBy.slnx

@@ -0,0 +1,5 @@
+<Solution>
+  <Project Path="BenchmarkInPlaceGroupBy/BenchmarkInPlaceGroupBy.csproj" Id="6964974f-b77a-42f7-8c80-5ad9a4595a43" />
+  <Project Path="InPlaceGroupBy/InPlaceGroupBy.csproj" Id="852225a0-e903-4d69-bec2-c9ea24607280" />
+  <Project Path="TestInPlaceGroupBy/TestInPlaceGroupBy.csproj" Id="cb9d56bd-0431-484e-9414-37bf232801f3" />
+</Solution>

Demo/2025/InPlaceGroupBy/InPlaceGroupBy/InPlaceGroupBy.csproj

@@ -0,0 +1,7 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+  </PropertyGroup>
+
+</Project>

Demo/2025/InPlaceGroupBy/InPlaceGroupBy/InPlaceSpanExtensions.cs

@@ -0,0 +1,10 @@
+namespace InPlaceGroupBy;
+
+public static class InPlaceSpanExtensions
+{
+    public static SortedSpanGrouping<T> GroupBy<T>(this Span<T> span, Comparison<T> comparison)
+    {
+        span.Sort(comparison);
+        return new(span, comparison);
+    }
+}

Demo/2025/InPlaceGroupBy/InPlaceGroupBy/SortedSpanGrouping.cs

@@ -0,0 +1,32 @@
+namespace InPlaceGroupBy;
+
+public readonly ref struct SortedSpanGrouping<T>(Span<T> span, Comparison<T> comparison)
+{
+    private readonly Span<T> _span = span;
+    private readonly Comparison<T> _comparison = comparison;
+
+    public Enumerator GetEnumerator() => new(this);
+
+    public ref struct Enumerator(SortedSpanGrouping<T> source)
+    {
+        private readonly SortedSpanGrouping<T> _source = source;
+        private int _start;
+        private int _end;
+
+        public bool MoveNext()
+        {
+            if (_end >= _source._span.Length) return false;
+
+            var first = _source._span[_end];
+            _start = _end;
+            while (true)
+            {
+                ++_end;
+                if (_end >= _source._span.Length
+                    || _source._comparison(first, _source._span[_end]) != 0) return true;
+            }
+        }
+
+        public readonly Span<T> Current => _source._span[_start.._end];
+    }
+}

Demo/2025/InPlaceGroupBy/TestInPlaceGroupBy/Common.cs

@@ -0,0 +1,18 @@
+namespace TestInPlaceGroupBy;
+
+class Common
+{
+    public static (string key, int value)[] Data = [
+        ("a", 1), ("ab", 2), ("abc", 3), ("a", 4), ("ab", 5),
+        ("a", 6), ("a", 7), ("abc", 8), ("a", 9), ("a", 10),
+        ("a", 11), ("ab", 12), ("abc", 13), ("b", 14), ("ab", 15),
+        ("a", 16), ("a", 17), ("bc", 18), ("a", 19), ("b", 20),
+        ("a", 21), ("ab", 22), ("ac", 23), ("a", 24), ("ab", 25),
+        ("a", 26), ("d", 27), ("abc", 28), ("a", 29), ("ac", 30),
+    ];
+
+    public static int Compare((string key, int value) x, (string key, int value) y)
+    {
+        return x.key.AsSpan().CompareTo(y.key, StringComparison.Ordinal);
+    }
+}

Demo/2025/InPlaceGroupBy/TestInPlaceGroupBy/InPlaceGroupBy.cs

@@ -0,0 +1,45 @@
+using InPlaceGroupBy;
+
+namespace TestInPlaceGroupBy;
+
+using static Common;
+
+public class InPlaceGroupByTest
+{
+    [Fact]
+    public void EquivalentToLinq()
+    {
+        var g1 = Data.GroupBy(x => x.key);
+
+        var data = Data.ToArray().AsSpan();
+        var g2 = data.GroupBy(Compare);
+
+        Equals(g1, g2);
+    }
+
+    private static void Equals(IEnumerable<IGrouping<string, (string key, int value)>> g1, SortedSpanGrouping<(string key, int value)> g2)
+    {
+        // Same count
+        var count = 0;
+        {
+            var e = g2.GetEnumerator();
+            while (e.MoveNext()) count++;
+        }
+        Assert.Equal(g1.Count(), count);
+
+        var d = g1.ToDictionary(x => x.Key);
+
+        foreach (var g in g2)
+        {
+            var key = g[0].key;
+
+            // Same keys
+            Assert.True(d.TryGetValue(key, out var g1Item));
+
+            // Same values but order is not guaranteed
+            Assert.Equal(
+                g1Item.Select(x => x.value).Order(),
+                g.ToArray().Select(x => x.value).Order());
+        }
+    }
+}