perf remove summer update delegate allocations

Author: KSemenenko

Directory.Build.props

@@ -24,8 +24,8 @@
         <RepositoryUrl>https://github.com/managedcode/TimeSeries</RepositoryUrl>
         <PackageProjectUrl>https://github.com/managedcode/TimeSeries</PackageProjectUrl>
         <Product>Managed Code - TimeSeries</Product>
-        <Version>10.0.2</Version>
-        <PackageVersion>10.0.2</PackageVersion>
+        <Version>10.0.3</Version>
+        <PackageVersion>10.0.3</PackageVersion>
 
     </PropertyGroup>
     <PropertyGroup Condition="'$(GITHUB_ACTIONS)' == 'true'">

ManagedCode.TimeSeries.Tests/ConcurrencyTests.cs

@@ -9,6 +9,32 @@ namespace ManagedCode.TimeSeries.Tests;
 
 public class ConcurrencyTests
 {
+    [Fact]
+    public async Task NumberSummer_ConcurrentSameBucketUpdatesPreserveExactTotalAndRange()
+    {
+        var series = new NumberTimeSeriesSummer<long>(TimeSpan.FromSeconds(1), 0, Strategy.Sum);
+        var bucket = series.Start;
+        const int writerCount = 8;
+        const int updatesPerWriter = 2000;
+
+        var writers = Enumerable.Range(0, writerCount).Select(_ => Task.Run(() =>
+        {
+            for (var i = 0; i < updatesPerWriter; i++)
+            {
+                series.AddNewData(bucket, 1L);
+            }
+        }));
+
+        await Task.WhenAll(writers);
+
+        var expectedTotal = (long)(writerCount * updatesPerWriter);
+        series.DataCount.ShouldBe((ulong)expectedTotal);
+        series.Samples.Count.ShouldBe(1);
+        series.Samples[bucket].ShouldBe(expectedTotal);
+        series.Start.ShouldBe(bucket);
+        series.End.ShouldBe(bucket);
+    }
+
     [Fact]
     public async Task Accumulator_ConcurrentWritesAndReads_AreSafe()
     {

ManagedCode.TimeSeries.Tests/SummersTests.cs

@@ -1,3 +1,4 @@
+using System.Numerics;
 using ManagedCode.TimeSeries.Abstractions;
 using ManagedCode.TimeSeries.Accumulators;
 using ManagedCode.TimeSeries.Summers;
@@ -303,6 +304,26 @@ public void NumberTimeSeriesSummerResamplePreservesTotals()
         summer.Sum().ShouldBe(12);
     }
 
+    [Fact]
+    public void NumberTimeSeriesSummerStrategiesCoverSupportedNumericTypes()
+    {
+        AssertStrategies<int>(2, 3, 4);
+        AssertStrategies<long>(2, 3, 4);
+        AssertStrategies<float>(2, 3, 4);
+        AssertStrategies<double>(2, 3, 4);
+        AssertStrategies<decimal>(2, 3, 4);
+    }
+
+    [Fact]
+    public void NumberTimeSeriesSummerMergeAndResamplePreserveStrategiesAcrossNumericTypes()
+    {
+        AssertMergeAndResample<int>();
+        AssertMergeAndResample<long>();
+        AssertMergeAndResample<float>();
+        AssertMergeAndResample<double>();
+        AssertMergeAndResample<decimal>();
+    }
+
     [Fact]
     public void DoubleTimeSeriesSummerConstructorsRespectStrategy()
     {
@@ -330,6 +351,90 @@ public void FloatTimeSeriesSummerAggregatesValues()
         summer.Max().ShouldNotBeNull();
     }
 
+    private static void AssertStrategies<TNumber>(TNumber first, TNumber second, TNumber newBucketValue)
+        where TNumber : struct, INumber<TNumber>
+    {
+        foreach (var strategy in Enum.GetValues<Strategy>())
+        {
+            var summer = new NumberTimeSeriesSummer<TNumber>(TimeSpan.FromSeconds(1), 0, strategy);
+            var start = summer.Start;
+            summer.AddNewData(start, first);
+            summer.AddNewData(start, second);
+            summer.Samples[start].ShouldBe(strategy switch
+            {
+                Strategy.Sum => first + second,
+                Strategy.Min => TNumber.Min(first, second),
+                Strategy.Max => TNumber.Max(first, second),
+                Strategy.Replace => second,
+                _ => throw new InvalidOperationException("Unsupported strategy.")
+            });
+
+            var next = start.AddSeconds(1);
+            summer.AddNewData(next, newBucketValue);
+            summer.Samples[next].ShouldBe(newBucketValue);
+            summer.DataCount.ShouldBe(3ul);
+            summer.Start.ShouldBe(start);
+            summer.End.ShouldBe(next);
+        }
+    }
+
+    private static void AssertMergeAndResample<TNumber>()
+        where TNumber : struct, INumber<TNumber>
+    {
+        foreach (var strategy in Enum.GetValues<Strategy>())
+        {
+            var summer = new NumberTimeSeriesSummer<TNumber>(TimeSpan.FromSeconds(1), 0, strategy);
+            var incoming = new NumberTimeSeriesSummer<TNumber>(TimeSpan.FromSeconds(1), 0, strategy);
+            var interval = TimeSpan.FromSeconds(3);
+            var currentStartTicks = summer.Start.UtcDateTime.Ticks;
+            var alignedStartTicks = currentStartTicks - currentStartTicks % interval.Ticks;
+            var start = new DateTimeOffset(alignedStartTicks, TimeSpan.Zero);
+            var first = TNumber.CreateChecked(2);
+            var second = TNumber.CreateChecked(10);
+            var merged = TNumber.CreateChecked(3);
+            var newBucket = TNumber.CreateChecked(20);
+
+            summer.AddNewData(start, first);
+            summer.AddNewData(start.AddSeconds(1), second);
+            incoming.AddNewData(start, merged);
+            incoming.AddNewData(start.AddSeconds(3), newBucket);
+
+            summer.Merge(incoming);
+            summer.DataCount.ShouldBe(4ul);
+            summer.Start.ShouldBe(start);
+            summer.End.ShouldBe(start.AddSeconds(3));
+            summer.Samples[start].ShouldBe(strategy switch
+            {
+                Strategy.Sum => first + merged,
+                Strategy.Min => TNumber.Min(first, merged),
+                Strategy.Max => TNumber.Max(first, merged),
+                Strategy.Replace => merged,
+                _ => throw new InvalidOperationException("Unsupported strategy.")
+            });
+
+            summer.Resample(interval, 0);
+
+            if (strategy == Strategy.Replace)
+            {
+                // The source snapshot is unordered, so Replace keeps one of these inputs.
+                new[] { merged, second }.ShouldContain(summer.Samples[start]);
+            }
+            else
+            {
+                summer.Samples[start].ShouldBe(strategy switch
+                {
+                    Strategy.Sum => first + merged + second,
+                    Strategy.Min => TNumber.Min(TNumber.Min(first, merged), second),
+                    Strategy.Max => TNumber.Max(TNumber.Max(first, merged), second),
+                    _ => throw new InvalidOperationException("Unsupported strategy.")
+                });
+            }
+
+            summer.Samples[start.AddSeconds(3)].ShouldBe(newBucket);
+            summer.DataCount.ShouldBe(4ul);
+        }
+    }
+
     // [Fact]
     // public async Task SummerGroup()
     // {

ManagedCode.TimeSeries/Abstractions/BaseNumberTimeSeriesSummer.cs

@@ -17,9 +17,12 @@ public abstract class BaseNumberTimeSeriesSummer<TNumber, TSelf>(TimeSpan sample
 
     protected override void AddData(DateTimeOffset date, TNumber data)
     {
-        AddOrUpdateSample(date,
-            () => data,
-            current => Update(current, data));
+        var state = (Owner: this, Value: data);
+        AddOrUpdateSample(
+            date,
+            state,
+            static context => context.Value,
+            static (current, context) => context.Owner.Update(current, context.Value));
     }
 
     /// <inheritdoc />
@@ -38,9 +41,12 @@ public override void Merge(TSelf accumulator)
 
         foreach (var sample in accumulator.Samples)
         {
-            AddOrUpdateSample(sample.Key,
-                () => sample.Value,
-                current => Update(current, sample.Value));
+            var state = (Owner: this, Value: sample.Value);
+            AddOrUpdateSample(
+                sample.Key,
+                state,
+                static context => context.Value,
+                static (current, context) => context.Owner.Update(current, context.Value));
         }
     }
 
@@ -67,9 +73,12 @@ public override void Resample(TimeSpan sampleInterval, int samplesCount)
         foreach (var (key, value) in snapshot)
         {
             var roundedKey = key.RoundUtc(SampleInterval);
-            AddOrUpdateSample(roundedKey,
-                () => value,
-                current => Update(current, value));
+            var state = (Owner: this, Value: value);
+            AddOrUpdateSample(
+                roundedKey,
+                state,
+                static context => context.Value,
+                static (current, context) => context.Owner.Update(current, context.Value));
 
             if (!lastObservedSample.HasValue || roundedKey > lastObservedSample.Value)
             {

ManagedCode.TimeSeries/Abstractions/BaseTimeSeries.cs

@@ -381,12 +381,26 @@ protected TSample GetOrCreateSample(DateTimeOffset key, Func<TSample> factory)
     }
 
     protected TSample AddOrUpdateSample(DateTimeOffset key, Func<TSample> addFactory, Func<TSample, TSample> updateFactory)
+    {
+        var factories = (Add: addFactory, Update: updateFactory);
+        return AddOrUpdateSample(
+            key,
+            factories,
+            static state => state.Add(),
+            static (current, state) => state.Update(current));
+    }
+
+    protected TSample AddOrUpdateSample<TArg>(
+        DateTimeOffset key,
+        TArg argument,
+        Func<TArg, TSample> addFactory,
+        Func<TSample, TArg, TSample> updateFactory)
     {
         while (true)
         {
             if (_samples.TryGetValue(key, out var existing))
             {
-                var updated = updateFactory(existing);
+                var updated = updateFactory(existing, argument);
                 if (_samples.TryUpdate(key, updated, existing))
                 {
                     UpdateRange(key);
@@ -396,7 +410,7 @@ protected TSample AddOrUpdateSample(DateTimeOffset key, Func<TSample> addFactory
                 continue;
             }
 
-            var created = addFactory();
+            var created = addFactory(argument);
             if (_samples.TryAdd(key, created))
             {
                 UpdateOnAdd(key);

docs/ADR/0002-performance-and-temporal-arithmetic.md

@@ -1,6 +1,6 @@
 # ADR-0002: measured ingestion and exact temporal arithmetic
 
-Status: Accepted; runtime evidence and patch delivery pending.
+Status: Accepted; temporal arithmetic and release workflow repair are released in v10.0.2 with exact-source tests, coverage, native profiles, package signatures and feed payloads verified. The selected summer allocation candidate for v10.0.3 awaits exact-source correctness and repeated performance qualification.
 
 ## Decision
 

docs/Features/performance-and-temporal-arithmetic.md

@@ -1,6 +1,6 @@
 # Performance and temporal arithmetic
 
-Status: source contract accepted; implementation and current-source GitHub evidence pending.
+Status: temporal arithmetic is released in v10.0.1 and its native regression suite passes; release publication integrity is repaired and qualified in v10.0.2. The approved summer allocation candidate is prepared for v10.0.3 and awaits exact-source correctness, coverage and repeated performance qualification. This slice remains in progress until the selected summer change passes all gates and the owning release/feed proof is complete.
 
 ## Requirements and acceptance
 
@@ -122,3 +122,25 @@ another allocation hotspot, but its concurrent trimming semantics remain under
 review. The current work does not change `EnsureCapacity` or its range logic.
 Any later capacity implementation needs its own bounded concurrency contract,
 late-arrival and multi-writer regressions, and source review before profiling.
+
+### Exact-source execution record (2026-10-03)
+
+- `43a142759d3b9fa65d10a58559def98ab0020b75` delivered the temporal arithmetic
+  repair as v10.0.1; its exact-source Release job passed. The later v10.0.1
+  duplicate-run asset overwrite is retained as a delivery defect and was repaired
+  by the v10.0.2 release workflow contract.
+- `64cba752e366fec74f8a09c0450ce724d483012e` made the capacity fixture start
+  deterministic. Its full performance workflow later passed, including all
+  repeated normal/scalar measurements; the earlier failed IsFull timing fixture
+  is retained in the plan history.
+- `2c9118b6fbd45a5170682d345d66cba4ad6e8f2d` delivered v10.0.2. Its Release
+  workflow passed build and 1104/1104 xUnit tests; line coverage was Core 668/710
+  (94.08%) and Orleans 205/212 (96.70%). Both packages were freshly published,
+  signed feed contents matched the package payloads, and a same-source duplicate
+  dispatch skipped release mutation with unchanged asset hashes. Its native
+  performance run passed all four repeated 16-case normal/scalar profiles and is
+  the exact pre-summer baseline at `/private/tmp/timeseries-run-2c9118b/`.
+- The current generic-state summer candidate retains the original protected
+  callback API and one CAS loop. Its source/test diff is under root review; no
+  10.0.3 performance or release claim is made until a fresh exact-source GitHub
+  run passes all correctness, coverage, profile and feed gates.