Merge pull request #168 from mlemanczyk/codex/remove-redundant-wrapper-methods-in-mersenne-path

Eliminate IDisposable dependencies

AGENTS.md

@@ -106,16 +106,11 @@ There is only one agents file - this one. Don't search for another one.
 
 Always use indentation with four space characters in source code files, even if a file currently uses tabs or appears to rely on eight-space indentation. Increase indentation level by exactly one indentation unit (four spaces) per nested block. When parameters or long expressions wrap, indent the continuation with two indentation units for clarity.
 Explicitly prefer reusing existing variables once their previous values are no longer required instead of declaring new locals of the same type. Call out the variable reuse in comments when its meaning changes so the intent stays clear and register pressure remains minimal.
-Do not introduce try/finally blocks solely to release pooled resources. Restructure the code so that every return path releases the resources without relying on finally unless the control flow would become unclear or unmaintainable.
 
 Keep the divisor cycle cache limited to a single block in memory (only the on-disk snapshot). When a lookup misses, compute the required cycle on the configured device and discard the transient result instead of scheduling background generation or caching additional blocks.
 
 All code, comments, commit messages, branch names and PR descriptions must be written in American English.
 
-- When modifying existing files, preserve all relevant TODO notes and explanatory comments unless they are no longer valid.
-- Prefer defining data holders as structs or classes with public fields over auto-properties when performance on the hot path is a concern.
-- Do not add or keep methods that simply wrap another method call without adding any logic; inline those calls or extend the wrapper with meaningful work.
-
 ## Performance implementation checklist
 
 - Prefer dedicated kernels over flag-controlled or parameterized kernels. Avoid conditional branches in kernels and tight loops by creating separate kernels when necessary.

EvenPerfectBitScanner.Benchmarks/EvenPerfectBitScanner.Benchmarks.csproj

@@ -15,4 +15,7 @@
     <PackageReference Include="BenchmarkDotNet" Version="0.13.12" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Compile Remove=".temp.cs" />
+  </ItemGroup>
 </Project>

EvenPerfectBitScanner.Benchmarks/GpuPow2ModBenchmarks.cs

@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;
 using PerfectNumbers.Core.Gpu;

EvenPerfectBitScanner.Benchmarks/GpuUInt128AddBenchmarks.cs

@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;

EvenPerfectBitScanner.Benchmarks/GpuUInt128Montgomery64Benchmarks.cs

@@ -1,3 +1,5 @@
+using System;
+using System.Collections.Generic;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;
 using PerfectNumbers.Core.Gpu;

EvenPerfectBitScanner.Benchmarks/GpuUInt128Mul64Benchmarks.cs

@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;

EvenPerfectBitScanner.Benchmarks/GpuUInt128MulModBenchmarks.cs

@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;

EvenPerfectBitScanner.Benchmarks/GpuUInt128MulModByLimbBenchmarks.cs

@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;
 using PerfectNumbers.Core.Gpu;

EvenPerfectBitScanner.Benchmarks/GpuUInt128NativeModuloBenchmarks.cs

@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;
 using PerfectNumbers.Core.Gpu;

EvenPerfectBitScanner.Benchmarks/GpuUInt128ScalarMulModBenchmarks.cs

@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;
 using PerfectNumbers.Core.Gpu;

EvenPerfectBitScanner.Benchmarks/GpuUInt128SubModScalarBenchmarks.cs

@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;
 using PerfectNumbers.Core.Gpu;

EvenPerfectBitScanner.Benchmarks/HeuristicMultiplyShiftBenchmarks.cs

@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;
 using PerfectNumbers.Core;

EvenPerfectBitScanner.Benchmarks/MersenneDivisorCycleLengthGpuBenchmarks.cs

@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;

EvenPerfectBitScanner.Benchmarks/Mod11ULongBenchmarks.cs

@@ -1,6 +1,7 @@
 using System.Runtime.CompilerServices;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;
+using PerfectNumbers.Core;
 
 namespace EvenPerfectBitScanner.Benchmarks;
 

EvenPerfectBitScanner.Benchmarks/Mul64Benchmarks.cs

@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using BenchmarkDotNet.Attributes;

EvenPerfectBitScanner.Benchmarks/MulHighBenchmarks.cs

@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using BenchmarkDotNet.Attributes;

EvenPerfectBitScanner.Benchmarks/MulMod64Benchmarks.cs

@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;
@@ -157,36 +158,16 @@ public class MulMod64Benchmarks
     }
 
     /// <summary>
-    /// Uses the GPU-friendly <see cref="ULongExtensions.MulMod64GpuCompatible(ulong, ulong, ulong)"/> helper; dense inputs now
-    /// cost 24.4–61.9 ns, while NearFullRange and SparseOperands finish near 7.27 ns and ZeroOperands stay baseline-fast at
-    /// 3.59 ns.
+    /// Uses the production <see cref="ULongExtensions.MulMod64(ulong, ulong, ulong)"/> helper shared by CPU and GPU callers.
     /// </summary>
     /// <remarks>
-    /// Observed means: CrossWordBlend 24.422 ns (6.86×), MixedBitPattern 61.850 ns, NearFullRange 7.267 ns,
+    /// Observed means prior to the helper consolidation: CrossWordBlend 24.422 ns, MixedBitPattern 61.850 ns, NearFullRange 7.267 ns,
     /// PrimeSizedModulus 55.114 ns, SparseOperands 7.261 ns, ZeroOperands 3.587 ns.
     /// </remarks>
     [Benchmark]
-    public ulong GpuCompatibleBaseline()
+    public ulong UnifiedMulMod()
     {
-        // TODO: Callers in production should migrate to ULongExtensions.MulMod64 where GPU parity
-        // is not required; that baseline stayed 6–17× faster for dense 64-bit operands.
-        return Input.Left.MulMod64GpuCompatible(Input.Right, Input.Modulus);
-    }
-
-    /// <summary>
-    /// Uses the deferred native-modulo helper <see cref="ULongExtensions.MulMod64GpuCompatibleDeferred(ulong, ulong, ulong)"/>;
-    /// excels when operands are tiny (2.01 ns on ZeroOperands) yet remains the slowest choice on dense data at 146–295 ns.
-    /// </summary>
-    /// <remarks>
-    /// Observed means: CrossWordBlend 146.559 ns (40.63×), MixedBitPattern 255.555 ns, NearFullRange 21.390 ns,
-    /// PrimeSizedModulus 294.486 ns, SparseOperands 18.182 ns, ZeroOperands 2.009 ns.
-    /// </remarks>
-    [Benchmark]
-    public ulong GpuCompatibleDeferred()
-    {
-        // TODO: Retire the deferred GPU shim from runtime paths and keep it only for benchmarks;
-        // ULongExtensions.MulMod64 avoids the 6×–82× slowdown on real-world operand mixes.
-        return Input.Left.MulMod64GpuCompatibleDeferred(Input.Right, Input.Modulus);
+        return Input.Left.MulMod64(Input.Right, Input.Modulus);
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]

EvenPerfectBitScanner.Benchmarks/MutableUInt128AddBenchmarks.cs

@@ -0,0 +1,75 @@
+using System.Runtime.CompilerServices;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+using PerfectNumbers.Core;
+
+namespace EvenPerfectBitScanner.Benchmarks;
+
+[ShortRunJob(RuntimeMoniker.Net80)]
+[MemoryDiagnoser]
+public class MutableUInt128AddBenchmarks
+{
+	private static readonly BenchmarkInput[] Inputs =
+	[
+		new(Create(0UL, 0x0000_0000_0000_0007UL), Create(0, 0x3UL), "TinyOperands"),
+		new(Create(0x1234_5678_9ABC_DEF0UL, 0x0FED_CBA9_8765_4321UL), Create(0xFFFF_FFFF, 0x0000_0001UL), "MixedOperands"),
+		new(Create(0xFFFF_FFFF_FFFF_FFFFUL, 0xFFFF_FFFF_FFFF_FFFFUL), Create(0xFFFF_FFFF,  0xFFFF_FFFBUL), "NearMaxOperands"),
+    ];
+
+    [ParamsSource(nameof(GetInputs))]
+    public BenchmarkInput Input { get; set; }
+
+    public static IEnumerable<BenchmarkInput> GetInputs() => Inputs;
+
+	private static MutableUInt128 Create(ulong high, ulong low) => new(high, low);
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	private static void StandardInternal(ref MutableUInt128 source, MutableUInt128 value)
+	{
+        ulong temp = source.Low + value.Low;
+        source.Low = temp;
+        temp = temp < source.Low ? 1UL : 0UL;
+		temp += source.High;
+		temp += value.High;
+        source.High = temp;
+	}
+
+	/// <summary>
+	/// Baseline MultiplyAdd implementation that chains Multiply and Add; measured 3.370 ns with mixed operands,
+	/// 3.361 ns when both limbs and inputs are near their maxima, and 3.368 ns with tiny operands.
+	/// </summary>
+	/// <remarks>
+	/// Observed means: MixedOperands 3.370 ns, NearMaxOperands 3.361 ns, TinyOperands 3.368 ns.
+	/// </remarks>
+	[Benchmark(Baseline = true)]
+	public MutableUInt128 Standard()
+	{
+		MutableUInt128 value = Input.InitialValue;
+		StandardInternal(ref value, Input.Addend);
+		return value;
+	}
+
+    /// <summary>
+    /// Fully inlined MultiplyAdd implementation that kept all arithmetic inside the method; landed at 3.175 ns on mixed operands,
+    /// 3.177 ns on near-max inputs, and 3.178 ns on tiny operands.
+    /// </summary>
+    /// <remarks>
+    /// Observed means: MixedOperands 3.175 ns, NearMaxOperands 3.177 ns, TinyOperands 3.178 ns.
+	/// Status: Implemented
+    /// </remarks>
+    [Benchmark]
+    public MutableUInt128 Optimized()
+    {
+        MutableUInt128 value = Input.InitialValue;
+        value.Add(Input.Addend);
+        return value;
+    }
+
+    public readonly record struct BenchmarkInput(MutableUInt128 InitialValue, MutableUInt128 Addend, string Name)
+    {
+        public override string ToString()
+        {
+            return Name;
+        }
+    }
+}

EvenPerfectBitScanner.Benchmarks/MutableUInt128Mul64Benchmarks.cs

@@ -0,0 +1,100 @@
+using System.Runtime.CompilerServices;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+using PerfectNumbers.Core;
+
+namespace EvenPerfectBitScanner.Benchmarks;
+
+[ShortRunJob(RuntimeMoniker.Net80)]
+[MemoryDiagnoser]
+public class MutableUInt128Mul64Benchmarks
+{
+	private static readonly BenchmarkInput[] Inputs =
+	[
+		new(Create(0UL, 0x0000_0000_0000_0007UL), 0x3UL, "TinyOperands"),
+		new(Create(0x1234_5678_9ABC_DEF0UL, 0x0FED_CBA9_8765_4321UL), 0xFFFF_FFFF_0000_0001UL, "MixedOperands"),
+		new(Create(0xFFFF_FFFF_FFFF_FFFFUL, 0xFFFF_FFFF_FFFF_FFFFUL), 0xFFFF_FFFF_FFFF_FFFBUL, "NearMaxOperands"),
+    ];
+
+    [ParamsSource(nameof(GetInputs))]
+    public BenchmarkInput Input { get; set; }
+
+    public static IEnumerable<BenchmarkInput> GetInputs() => Inputs;
+
+	private static MutableUInt128 Create(ulong high, ulong low) => new(high, low);
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static ulong Mul64(ulong left, ulong right, out ulong low)
+    {
+        const ulong Mask32 = 0xFFFF_FFFFUL;
+
+        ulong leftLow = left & Mask32;
+        ulong leftHigh = left >> 32;
+        ulong rightLow = right & Mask32;
+        ulong rightHigh = right >> 32;
+
+        ulong lowLow = leftLow * rightLow;
+        ulong lowHigh = leftLow * rightHigh;
+        ulong highLow = leftHigh * rightLow;
+        ulong highHigh = leftHigh * rightHigh;
+
+        ulong carry = (lowLow >> 32) + (lowHigh & Mask32) + (highLow & Mask32);
+        ulong high = highHigh + (lowHigh >> 32) + (highLow >> 32) + (carry >> 32);
+
+        low = ((carry & Mask32) << 32) | (lowLow & Mask32);
+        return high;
+    }
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	private static void StandardInternal(ref MutableUInt128 source, ulong value)
+	{
+        ulong currentHigh = source.High;
+        ulong currentLow = source.Low;
+
+        ulong carry = Mul64(currentLow, value, out ulong newLow);
+        Mul64(currentHigh, value, out ulong shiftedHigh);
+        ulong newHigh = shiftedHigh + carry;
+
+        source.Low = newLow;
+        source.High = newHigh;
+	}
+
+	/// <summary>
+	/// Baseline MultiplyAdd implementation that chains Multiply and Add; measured 3.113 ns with mixed operands,
+	/// 3.128 ns when both limbs and inputs are near their maxima, and 3.131 ns with tiny operands.
+	/// </summary>
+	/// <remarks>
+	/// Observed means: MixedOperands 3.113 ns, NearMaxOperands 3.128 ns, TinyOperands 3.131 ns.
+	/// </remarks>
+	[Benchmark(Baseline = true)]
+	public MutableUInt128 Standard()
+	{
+		MutableUInt128 value = Input.InitialValue;
+		StandardInternal(ref value, Input.Addend);
+		return value;
+	}
+
+    /// <summary>
+    /// Fully inlined MultiplyAdd implementation that kept all arithmetic inside the method; landed at 2.969 ns on mixed operands,
+    /// 2.912 ns on near-max inputs, and 2.935 ns on tiny operands.
+    /// </summary>
+    /// <remarks>
+    /// Observed means: MixedOperands 2.969 ns, NearMaxOperands 2.912 ns, TinyOperands 2.935 ns.
+	/// Status: Implemented
+    /// </remarks>
+    [Benchmark]
+    public MutableUInt128 Optimized()
+    {
+        MutableUInt128 value = Input.InitialValue;
+        value.Mul(Input.Addend);
+        return value;
+    }
+
+    public readonly record struct BenchmarkInput(MutableUInt128 InitialValue, ulong Addend, string Name)
+    {
+        public override string ToString()
+        {
+            return Name;
+        }
+    }
+}

EvenPerfectBitScanner.Benchmarks/MutableUInt128MultiplyAddBenchmarks.cs

@@ -0,0 +1,76 @@
+using System.Collections.Generic;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+using PerfectNumbers.Core;
+
+namespace EvenPerfectBitScanner.Benchmarks;
+
+[ShortRunJob(RuntimeMoniker.Net80)]
+[MemoryDiagnoser]
+public class MutableUInt128MultiplyAddBenchmarks
+{
+    private static readonly MultiplyAddInput[] Inputs =
+    [
+        new(Create(0UL, 0x0000_0000_0000_0007UL), 0x3UL, 0x5UL, "TinyOperands"),
+        new(Create(0x1234_5678_9ABC_DEF0UL, 0x0FED_CBA9_8765_4321UL), 0xFFFF_FFFF_0000_0001UL, 0x1357_9BDF_2468_ACEEUL, "MixedOperands"),
+        new(Create(0xFFFF_FFFF_FFFF_FFFFUL, 0xFFFF_FFFF_FFFF_FFFFUL), 0xFFFF_FFFF_FFFF_FFFBUL, 0xFFFF_FFFF_FFFF_FFF7UL, "NearMaxOperands"),
+    ];
+
+    [ParamsSource(nameof(GetInputs))]
+    public MultiplyAddInput Input { get; set; }
+
+    public static IEnumerable<MultiplyAddInput> GetInputs() => Inputs;
+
+    private static UInt128 Create(ulong high, ulong low)
+    {
+        return ((UInt128)high << 64) | low;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+	private static void MultiplyAdd(ref MutableUInt128 source, ulong multiplier, ulong addend)
+	{
+		source.Mul(multiplier);
+		source.Add(addend);
+	}
+
+	/// <summary>
+	/// Baseline MultiplyAdd implementation that chains Multiply and Add; measured 3.370 ns with mixed operands,
+	/// 3.361 ns when both limbs and inputs are near their maxima, and 3.368 ns with tiny operands.
+	/// </summary>
+	/// <remarks>
+	/// Observed means: MixedOperands 3.370 ns, NearMaxOperands 3.361 ns, TinyOperands 3.368 ns.
+	/// </remarks>
+	[Benchmark(Baseline = true)]
+	public MutableUInt128 MultiplyAddChained()
+	{
+		MutableUInt128 value = new(Input.InitialValue);
+		MultiplyAdd(ref value, Input.Multiplier, Input.Addend);
+		return value;
+	}
+
+    /// <summary>
+    /// Fully inlined MultiplyAdd implementation that kept all arithmetic inside the method; landed at 3.175 ns on mixed operands,
+    /// 3.177 ns on near-max inputs, and 3.178 ns on tiny operands.
+    /// </summary>
+    /// <remarks>
+    /// Observed means: MixedOperands 3.175 ns, NearMaxOperands 3.177 ns, TinyOperands 3.178 ns.
+	/// Status: Implemented
+    /// </remarks>
+    [Benchmark]
+    public MutableUInt128 MultiplyAddFullyInlined()
+    {
+        MutableUInt128 value = new(Input.InitialValue);
+        value.MulAdd(Input.Multiplier, Input.Addend);
+        return value;
+    }
+
+    public readonly record struct MultiplyAddInput(UInt128 InitialValue, ulong Multiplier, ulong Addend, string Name)
+    {
+        public override string ToString()
+        {
+            return Name;
+        }
+    }
+}

EvenPerfectBitScanner.Benchmarks/MutableUInt128SubMutableBenchmarks.cs

@@ -0,0 +1,75 @@
+using System.Runtime.CompilerServices;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+using PerfectNumbers.Core;
+
+namespace EvenPerfectBitScanner.Benchmarks;
+
+[ShortRunJob(RuntimeMoniker.Net80)]
+[MemoryDiagnoser]
+public class MutableUInt128SubMutableBenchmarks
+{
+	private static readonly BenchmarkInput[] Inputs =
+	[
+		new(Create(0UL, 0x0000_0000_0000_0007UL), Create(0, 0x3UL), "TinyOperands"),
+		new(Create(0x1234_5678_9ABC_DEF0UL, 0x0FED_CBA9_8765_4321UL), Create(0xFFFF_FFFF, 0x0000_0001UL), "MixedOperands"),
+		new(Create(0xFFFF_FFFF_FFFF_FFFFUL, 0xFFFF_FFFF_FFFF_FFFFUL), Create(0xFFFF_FFFF,  0xFFFF_FFFBUL), "NearMaxOperands"),
+    ];
+
+    [ParamsSource(nameof(GetInputs))]
+    public BenchmarkInput Input { get; set; }
+
+    public static IEnumerable<BenchmarkInput> GetInputs() => Inputs;
+
+	private static MutableUInt128 Create(ulong high, ulong low) => new(high, low);
+
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	private static void StandardInternal(ref MutableUInt128 source, MutableUInt128 value)
+	{
+        ulong low = source.Low;
+        ulong result = low - value.Low;
+        ulong borrow = low < value.Low ? 1UL : 0UL;
+
+        source.Low = result;
+        source.High = source.High - value.High - borrow;
+	}
+
+	/// <summary>
+	/// Baseline MultiplyAdd implementation that chains Multiply and Add; measured 3.370 ns with mixed operands,
+	/// 3.361 ns when both limbs and inputs are near their maxima, and 3.368 ns with tiny operands.
+	/// </summary>
+	/// <remarks>
+	/// Observed means: MixedOperands 3.370 ns, NearMaxOperands 3.361 ns, TinyOperands 3.368 ns.
+	/// </remarks>
+	[Benchmark(Baseline = true)]
+	public MutableUInt128 Standard()
+	{
+		MutableUInt128 value = Input.InitialValue;
+		StandardInternal(ref value, Input.Addend);
+		return value;
+	}
+
+    /// <summary>
+    /// Fully inlined MultiplyAdd implementation that kept all arithmetic inside the method; landed at 3.175 ns on mixed operands,
+    /// 3.177 ns on near-max inputs, and 3.178 ns on tiny operands.
+    /// </summary>
+    /// <remarks>
+    /// Observed means: MixedOperands 3.175 ns, NearMaxOperands 3.177 ns, TinyOperands 3.178 ns.
+	/// Status: Implemented
+    /// </remarks>
+    [Benchmark]
+    public MutableUInt128 Optimized()
+    {
+        MutableUInt128 value = Input.InitialValue;
+        value.Sub(Input.Addend);
+        return value;
+    }
+
+    public readonly record struct BenchmarkInput(MutableUInt128 InitialValue, MutableUInt128 Addend, string Name)
+    {
+        public override string ToString()
+        {
+            return Name;
+        }
+    }
+}

EvenPerfectBitScanner.Benchmarks/Pow2MontgomeryModBenchmarks.cs

@@ -1,7 +1,9 @@
+using System;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;
 using System.Numerics;
 using PerfectNumbers.Core;
+using PerfectNumbers.Core.Gpu;
 
 namespace EvenPerfectBitScanner.Benchmarks;
 

EvenPerfectBitScanner.Benchmarks/Pow2MontgomeryModCycleComputationBenchmarks.cs

@@ -1,4 +1,6 @@
+using System;
 using System.Buffers.Binary;
+using System.Threading;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;
 using PerfectNumbers.Core;

EvenPerfectBitScanner.Benchmarks/Pow2MontgomeryModUInt128Benchmarks.cs

@@ -1,4 +1,6 @@
+using System;
 using System.Buffers.Binary;
+using System.Numerics;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;
 using PerfectNumbers.Core;

EvenPerfectBitScanner.Benchmarks/Pow2OddPowerTableBenchmarks.cs

@@ -1,4 +1,8 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;
 using PerfectNumbers.Core.Gpu;

EvenPerfectBitScanner.Benchmarks/Program.cs

@@ -1,3 +1,5 @@
+using BenchmarkDotNet.Configs;
+using BenchmarkDotNet.Running;
 using PerfectNumbers.Core.Gpu;
 
 namespace EvenPerfectBitScanner.Benchmarks;
@@ -6,16 +8,22 @@ public static class Program
 {
     public static void Main(string[] args)
     {
-        // var config = DefaultConfig.Instance.WithOptions(ConfigOptions.JoinSummary | ConfigOptions.DisableOptimizationsValidator);
-        // BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args, config);
+		if (args.Length > 0)
+		{
+			IConfig config = DefaultConfig.Instance.WithOptions(ConfigOptions.JoinSummary | ConfigOptions.DisableOptimizationsValidator);
+			BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args, config);
+			return;
+		}
 
-        Pow2MontgomeryModCycleComputationBenchmarks benchmarks = new()
-        {
-            Scale = Pow2MontgomeryModCycleComputationBenchmarks.InputScale.Large
-        };
+		BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run();
 
-        GpuPrimeWorkLimiter.SetLimit(1);
-        benchmarks.Setup();
+        // Pow2MontgomeryModCycleComputationBenchmarks benchmarks = new()
+        // {
+        //     Scale = Pow2MontgomeryModCycleComputationBenchmarks.InputScale.Large
+        // };
+
+        // GpuPrimeWorkLimiter.SetLimit(1);
+        // benchmarks.Setup();
 
         // Console.WriteLine("Press ENTER to run");
         // Console.ReadLine();

EvenPerfectBitScanner.ResultsParser/EvenPerfectBitScanner.ResultsParser.csproj

@@ -11,4 +11,7 @@
     <PackageReference Include="Open.Numeric.Primes" Version="4.0.4" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Compile Remove=".temp.cs" />
+  </ItemGroup>
 </Project>

EvenPerfectBitScanner.Tests/EvenPerfectBitScanner.Tests.csproj

@@ -22,4 +22,7 @@
   <ItemGroup>
     <ProjectReference Include="../EvenPerfectBitScanner/EvenPerfectBitScanner.csproj" />
   </ItemGroup>
+  <ItemGroup>
+    <Compile Remove=".temp.cs" />
+  </ItemGroup>
 </Project>

EvenPerfectBitScanner.Tests/ProgramTests.cs

@@ -540,7 +540,7 @@ public class ProgramTests
     public void Main_displays_help_when_requested()
     {
         var main = typeof(Program).GetMethod("Main", BindingFlags.NonPublic | BindingFlags.Static)!;
-        using var writer = new StringWriter();
+        var writer = new StringWriter();
         TextWriter original = Console.Out;
         Console.SetOut(writer);
 
@@ -554,6 +554,7 @@ public class ProgramTests
         }
 
         string output = writer.ToString();
+        writer.Dispose();
         output.Should().Contain("Usage:");
         output.Should().Contain("--mersenne-device=cpu|gpu");
         output.Should().Contain("--primes-device=cpu|gpu");

EvenPerfectBitScanner/EvenPerfectBitScanner.csproj

@@ -16,4 +16,7 @@
     <PackageReference Include="Open.Numeric" Version="3.0.1" />
     <PackageReference Include="Open.Numeric.Primes" Version="4.0.4" />
   </ItemGroup>
+  <ItemGroup>
+    <Compile Remove=".temp.cs" />
+  </ItemGroup>
 </Project>

EvenPerfectBitScanner/Program.cs

@@ -1,4 +1,5 @@
-using System.Diagnostics;
+using System.Buffers;
+using System.Collections.Generic;
 using System.Globalization;
 using System.Numerics;
 using System.Runtime.CompilerServices;
@@ -43,11 +44,7 @@ internal static class Program
     private static string? _resultsPrefix;
     private static readonly Optimized PrimeIterator = new();
     private static ulong _byDivisorStartPrime;
-
-    private static bool _testMode;
-    private static int _testTargetPrimeCount;
-    private static int _testProcessedPrimeCount;
-    private const string TestTimeFileName = "even_perfect_test_time.txt";
+    private static TimeSpan? _primeTestLimit;
 
     [ThreadStatic]
     private static bool _lastCompositeP;
@@ -78,6 +75,8 @@ internal static class Program
         bool useResidue = false;    // M_p test via residue divisors (replaces LL/incremental)
         bool useDivisor = false;     // M_p divisibility by specific divisor
         bool useByDivisor = false;   // Iterative divisor scan across primes		UInt128 divisor = UInt128.Zero;
+        ByDivisorDeltasDevice byDivisorDeltasDevice = ByDivisorDeltasDevice.Cpu;
+        ByDivisorMontgomeryDevice byDivisorMontgomeryDevice = ByDivisorMontgomeryDevice.Cpu;
                                      // Device routing
         bool useGpuCycles = true;
         bool mersenneOnGpu = true;   // controls Lucas/incremental/pow2mod device
@@ -85,8 +84,6 @@ internal static class Program
         int scanBatchSize = 2_097_152, sliceSize = 32;
         ulong residueKMax = 5_000_000UL;
         string filterFile = string.Empty;
-        UInt128 maxPrimeLimit = UInt128.MaxValue;
-        bool maxPrimeConfigured = false;
         string cyclesPath = DefaultCyclesPath;
         int cyclesBatchSize = 512;
         bool continueCyclesGeneration = false;
@@ -99,10 +96,6 @@ internal static class Program
         ulong remainder = 0UL;
         bool startPrimeProvided = false;
 
-        _testMode = false;
-        _testTargetPrimeCount = 0;
-        _testProcessedPrimeCount = 0;
-
         // NTT backend selection (GPU): reference vs staged
         for (; argIndex < args.Length; argIndex++)
         {
@@ -119,20 +112,6 @@ internal static class Program
                 currentP = ulong.Parse(arg.AsSpan(arg.IndexOf('=') + 1));
                 startPrimeProvided = true;
             }
-            else if (arg.StartsWith("--max-prime=", StringComparison.OrdinalIgnoreCase))
-            {
-                ReadOnlySpan<char> value = arg.AsSpan(arg.IndexOf('=') + 1);
-                if (UInt128.TryParse(value, NumberStyles.None, CultureInfo.InvariantCulture, out UInt128 parsedMaxPrime))
-                {
-                    maxPrimeLimit = parsedMaxPrime;
-                    maxPrimeConfigured = true;
-                }
-                else
-                {
-                    Console.WriteLine("Invalid value for --max-prime.");
-                    return;
-                }
-            }
             else if (arg.Equals("--increment=bit", StringComparison.OrdinalIgnoreCase))
             {
                 useBitTransform = true;
@@ -205,14 +184,55 @@ internal static class Program
             {
                 mersenneOnGpu = !arg.AsSpan(arg.IndexOf('=') + 1).Equals("cpu", StringComparison.OrdinalIgnoreCase);
             }
+            else if (arg.StartsWith("--bydivisor-deltas-device=", StringComparison.OrdinalIgnoreCase))
+            {
+                ReadOnlySpan<char> deviceValue = arg.AsSpan(arg.IndexOf('=') + 1);
+                if (deviceValue.Equals("gpu", StringComparison.OrdinalIgnoreCase))
+                {
+                    byDivisorDeltasDevice = ByDivisorDeltasDevice.Gpu;
+                }
+                else if (deviceValue.Equals("cpu", StringComparison.OrdinalIgnoreCase))
+                {
+                    byDivisorDeltasDevice = ByDivisorDeltasDevice.Cpu;
+                }
+                else
+                {
+                    Console.WriteLine("Invalid --bydivisor-deltas-device value. Expected cpu or gpu.");
+                    return;
+                }
+            }
+            else if (arg.StartsWith("--bydivisor-montgomery-device=", StringComparison.OrdinalIgnoreCase))
+            {
+                ReadOnlySpan<char> deviceValue = arg.AsSpan(arg.IndexOf('=') + 1);
+                if (deviceValue.Equals("gpu", StringComparison.OrdinalIgnoreCase))
+                {
+                    byDivisorMontgomeryDevice = ByDivisorMontgomeryDevice.Gpu;
+                }
+                else if (deviceValue.Equals("cpu", StringComparison.OrdinalIgnoreCase))
+                {
+                    byDivisorMontgomeryDevice = ByDivisorMontgomeryDevice.Cpu;
+                }
+                else
+                {
+                    Console.WriteLine("Invalid --bydivisor-montgomery-device value. Expected cpu or gpu.");
+                    return;
+                }
+            }
+            else if (arg.StartsWith("--prime-test-limit=", StringComparison.OrdinalIgnoreCase))
+            {
+                ReadOnlySpan<char> value = arg.AsSpan(arg.IndexOf('=') + 1);
+                if (!TryParsePrimeTestLimit(value, out TimeSpan parsedLimitValue))
+                {
+                    Console.WriteLine("Failed to parse --prime-test-limit value.");
+                    return;
+                }
+
+                _primeTestLimit = parsedLimitValue;
+            }
             else if (arg.Equals("--workaround-mod", StringComparison.OrdinalIgnoreCase))
             {
                 useModuloWorkaround = true;
             }
-            else if (arg.Equals("--test", StringComparison.OrdinalIgnoreCase))
-            {
-                _testMode = true;
-            }
             else if (arg.Equals("--use-order", StringComparison.OrdinalIgnoreCase))
             {
                 useOrder = true;
@@ -405,18 +425,7 @@ internal static class Program
             }
         }
 
-        int testPrimeCandidateLimit = 0;
-
-        if (_testMode)
-        {
-            currentP = 31UL;
-            remainder = currentP % 6UL;
-            filterFile = string.Empty;
-            maxPrimeLimit = UInt128.MaxValue;
-            maxPrimeConfigured = false;
-            startPrimeProvided = true;
-            testPrimeCandidateLimit = Math.Max(1, threadCount) * 3;
-        }
+        GpuKernelPool.CpuCycleUsesGpu = orderOnGpu;
 
         if (useByDivisor)
         {
@@ -427,7 +436,7 @@ internal static class Program
             _byDivisorStartPrime = 0UL;
         }
 
-        if (useByDivisor && !_testMode && string.IsNullOrEmpty(filterFile))
+        if (useByDivisor && string.IsNullOrEmpty(filterFile))
         {
             Console.WriteLine("--mersenne=bydivisor requires --filter-p=<path>.");
             return;
@@ -558,6 +567,11 @@ internal static class Program
                     ? new MersenneNumberDivisorByDivisorGpuTester()
                     : new MersenneNumberDivisorByDivisorCpuTester();
             _byDivisorTester.BatchSize = scanBatchSize;
+            if (_byDivisorTester is MersenneNumberDivisorByDivisorCpuTester cpuByDivisorTester)
+            {
+                cpuByDivisorTester.DeltasDevice = byDivisorDeltasDevice;
+                cpuByDivisorTester.MontgomeryDevice = byDivisorMontgomeryDevice;
+            }
         }
 
         // Load RLE blacklist (optional)
@@ -593,18 +607,18 @@ internal static class Program
                         useDivisor,
                         useByDivisor,
                         mersenneOnGpu,
-        useOrder,
-        useModuloWorkaround,
-        _useGcdFilter,
-        NttGpuMath.GpuTransformBackend,
-        gpuPrimeThreads,
-        sliceSize,
-        scanBatchSize,
-        _orderWarmupLimitOverride ?? 5_000_000UL,
-        NttGpuMath.ReductionMode,
-        mersenneOnGpu ? "gpu" : "cpu",
-        (GpuContextPool.ForceCpu ? "cpu" : "gpu"),
-        orderOnGpu ? "gpu" : "cpu");
+                        useOrder,
+                        useModuloWorkaround,
+                        _useGcdFilter,
+                        NttGpuMath.GpuTransformBackend,
+                        gpuPrimeThreads,
+                        sliceSize,
+                        scanBatchSize,
+                        _orderWarmupLimitOverride ?? 5_000_000UL,
+                        NttGpuMath.ReductionMode,
+                        mersenneOnGpu ? "gpu" : "cpu",
+                        (GpuContextPool.ForceCpu ? "cpu" : "gpu"),
+                        orderOnGpu ? "gpu" : "cpu");
 
         if (!string.IsNullOrEmpty(_resultsPrefix))
         {
@@ -645,102 +659,51 @@ internal static class Program
             File.WriteAllText(ResultsFileName, $"p,searchedMersenne,detailedCheck,passedAllTests{Environment.NewLine}");
         }
 
-        bool useFilter = !_testMode && !string.IsNullOrEmpty(filterFile);
+        bool useFilter = !string.IsNullOrEmpty(filterFile);
         HashSet<ulong> filter = [];
         List<ulong> byDivisorCandidates = [];
         ulong maxP = 0UL;
         ulong[] localFilter = Array.Empty<ulong>();
         int filterCount = 0;
-
-        if (_useByDivisorMode)
+        if (useFilter)
         {
-            if (_testMode)
+            Console.WriteLine("Loading filter...");
+            if (_useByDivisorMode)
             {
-                byDivisorCandidates = BuildTestPrimeCandidates(testPrimeCandidateLimit);
+                byDivisorCandidates = LoadByDivisorCandidates(filterFile);
             }
             else
             {
-                Console.WriteLine("Loading filter...");
-                int skippedByLimit = 0;
-                byDivisorCandidates = LoadByDivisorCandidates(filterFile, maxPrimeLimit, maxPrimeConfigured, out skippedByLimit);
-                if (maxPrimeConfigured)
+                // TODO: Rent this filter buffer from ArrayPool<ulong> and reuse it across reload batches so
+                // we do not allocate fresh arrays while replaying large result filters.
+                localFilter = new ulong[1024];
+                filterCount = 0;
+                LoadResultsFile(filterFile, (p, detailedCheck, passedAllTests) =>
                 {
-                    if (skippedByLimit > 0)
+                    if (passedAllTests)
                     {
-                        Console.WriteLine($"Skipped {skippedByLimit} by-divisor candidate(s) above --max-prime limit.");
+                        localFilter[filterCount++] = p;
+                        if (p > maxP)
+                        {
+                            maxP = p;
+                        }
+
+                        if (filterCount == 1024)
+                        {
+                            filter.AddRange(localFilter[..filterCount]);
+                            filterCount = 0;
+                            Console.WriteLine($"Added {p}");
+                        }
                     }
+                });
 
-                    if (byDivisorCandidates.Count == 0)
-                    {
-                        Console.WriteLine("No by-divisor candidates fall within the --max-prime limit.");
-                        return;
-                    }
-                }
-            }
-        }
-        else if (useFilter)
-        {
-            Console.WriteLine("Loading filter...");
-            // TODO: Rent this filter buffer from ArrayPool<ulong> and reuse it across reload batches so
-            // we do not allocate fresh arrays while replaying large result filters.
-            localFilter = new ulong[1024];
-            filterCount = 0;
-            bool addedWithinLimit = false;
-            int skippedByLimit = 0;
-            LoadResultsFile(filterFile, (p, detailedCheck, passedAllTests) =>
-            {
-                if (!passedAllTests)
-                {
-                    return;
-                }
-
-                if (maxPrimeConfigured && (UInt128)p > maxPrimeLimit)
-                {
-                    skippedByLimit++;
-                    return;
-                }
-
-                localFilter[filterCount++] = p;
-                addedWithinLimit = true;
-                if (p > maxP)
-                {
-                    maxP = p;
-                }
-
-                if (filterCount == 1024)
+                if (filterCount > 0)
                 {
                     filter.AddRange(localFilter[..filterCount]);
-                    filterCount = 0;
-                    Console.WriteLine($"Added {p}");
-                }
-            });
-
-            if (filterCount > 0)
-            {
-                filter.AddRange(localFilter[..filterCount]);
-            }
-
-            if (maxPrimeConfigured)
-            {
-                if (!addedWithinLimit)
-                {
-                    Console.WriteLine("No filter candidates fall within the --max-prime limit.");
-                    return;
-                }
-
-                if (skippedByLimit > 0)
-                {
-                    Console.WriteLine($"Skipped {skippedByLimit} filter candidate(s) above --max-prime limit.");
                 }
             }
         }
 
-
-        if (_testMode)
-        {
-            _testTargetPrimeCount = testPrimeCandidateLimit;
-        }
-
         if (_primeCount >= 2)
         {
             _primeFoundAfterInit = true;
@@ -753,25 +716,27 @@ internal static class Program
         // Configure batch size for GPU primality sieve
         PrimeTester.GpuBatchSize = gpuPrimeBatch;
 
-        Stopwatch? stopwatch = null;
-        if (_testMode)
-        {
-            stopwatch = Stopwatch.StartNew();
-        }
-
         Console.WriteLine("Starting scan...");
 
         if (_useByDivisorMode)
         {
-            RunByDivisorMode(byDivisorCandidates, threadCount);
-            FlushBuffer();
-            StringBuilderPool.Return(_outputBuilder!);
-            if (stopwatch is not null)
+            if (_byDivisorTester is null)
             {
-                stopwatch.Stop();
-                ReportTestTime(stopwatch.Elapsed);
+                throw new InvalidOperationException("By-divisor tester has not been initialized.");
             }
 
+            MersenneNumberDivisorByDivisorTester.Run(
+                    byDivisorCandidates,
+                    _byDivisorTester,
+                    _byDivisorPreviousResults,
+                    _byDivisorStartPrime,
+                    static () => _lastCompositeP = true,
+                    static () => _lastCompositeP = false,
+                    PrintResult,
+                    threadCount,
+                    _primeTestLimit);
+            FlushBuffer();
+            StringBuilderPool.Return(_outputBuilder!);
             return;
         }
 
@@ -786,14 +751,7 @@ internal static class Program
             }
         }
 
-        if (_testMode)
-        {
-            testPrimeCandidateLimit = Math.Max(1, threadCount) * 3;
-            _testTargetPrimeCount = testPrimeCandidateLimit;
-        }
-
         _state = ((long)currentP << 3) | (long)remainder;
-
         Task[] tasks = new Task[threadCount];
 
         int taskIndex = 0;
@@ -863,71 +821,13 @@ internal static class Program
         }
 
         Task.WaitAll(tasks);
-
-        TimeSpan testElapsed = default;
-        bool reportTestTime = false;
-        if (stopwatch is not null)
-        {
-            stopwatch.Stop();
-            testElapsed = stopwatch.Elapsed;
-            reportTestTime = true;
-        }
-
         FlushBuffer();
         StringBuilderPool.Return(_outputBuilder!);
-
-        if (reportTestTime)
-        {
-            ReportTestTime(testElapsed);
-        }
     }
 
-    private static List<ulong> BuildTestPrimeCandidates(int targetCount)
-    {
-        if (targetCount <= 0)
-        {
-            return [];
-        }
-
-        List<ulong> candidates = new(targetCount);
-        ulong previous = 29UL;
-        int remaining = targetCount;
-        ulong nextPrime = 0UL;
-
-        while (remaining > 0)
-        {
-            try
-            {
-                nextPrime = PrimeIterator.Next(in previous);
-            }
-            catch (InvalidOperationException)
-            {
-                break;
-            }
-
-            if (nextPrime < 31UL)
-            {
-                previous = nextPrime;
-                continue;
-            }
-
-            candidates.Add(nextPrime);
-            remaining--;
-            previous = nextPrime;
-        }
-
-        if (remaining > 0)
-        {
-            Console.WriteLine("Unable to populate the requested number of test primes before reaching the 64-bit limit.");
-        }
-
-        return candidates;
-    }
-
-    private static List<ulong> LoadByDivisorCandidates(string candidateFile, UInt128 maxPrimeLimit, bool maxPrimeConfigured, out int skippedByLimit)
+    private static List<ulong> LoadByDivisorCandidates(string candidateFile)
     {
         List<ulong> candidates = [];
-        skippedByLimit = 0;
         using FileStream readStream = new(candidateFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
         using StreamReader reader = new(readStream);
         string? line;
@@ -967,14 +867,7 @@ internal static class Program
                 // arrive so by-divisor candidate loading avoids per-value string allocations.
                 if (ulong.TryParse(span[start..index], NumberStyles.None, CultureInfo.InvariantCulture, out ulong parsed))
                 {
-                    if (!maxPrimeConfigured || (UInt128)parsed <= maxPrimeLimit)
-                    {
-                        candidates.Add(parsed);
-                    }
-                    else
-                    {
-                        skippedByLimit++;
-                    }
+                    candidates.Add(parsed);
                 }
             }
         }
@@ -982,26 +875,6 @@ internal static class Program
         return candidates;
     }
 
-    private static void RunByDivisorMode(List<ulong> candidates, int threadCount)
-    {
-        if (_byDivisorTester is null)
-        {
-            throw new InvalidOperationException("By-divisor tester has not been initialized.");
-        }
-
-        // TODO: Inline this helper by invoking MersenneNumberDivisorByDivisorTester.Run directly at call sites so
-        // the CLI avoids this extra frame during the hot composite-reporting path.
-        MersenneNumberDivisorByDivisorTester.Run(
-                candidates,
-                _byDivisorTester,
-                _byDivisorPreviousResults,
-                _byDivisorStartPrime,
-                static () => _lastCompositeP = true,
-                static () => _lastCompositeP = false,
-                PrintResult,
-                threadCount);
-    }
-
     private static unsafe void LoadResultsFile(string resultsFileName, Action<ulong, bool, bool> lineProcessorAction)
     {
         using FileStream readStream = new(resultsFileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
@@ -1066,13 +939,57 @@ internal static class Program
         }
     }
 
+    private static bool TryParsePrimeTestLimit(ReadOnlySpan<char> value, out TimeSpan result)
+    {
+        result = TimeSpan.Zero;
+        if (value.IsEmpty)
+        {
+            return false;
+        }
+
+        ReadOnlySpan<char> magnitudeSpan = value;
+        double magnitude;
+
+        if (value.Length >= 2 && value.EndsWith("ms", StringComparison.OrdinalIgnoreCase))
+        {
+            magnitudeSpan = value[..^2];
+            if (!double.TryParse(magnitudeSpan, NumberStyles.Float, CultureInfo.InvariantCulture, out magnitude))
+            {
+                return false;
+            }
+
+            result = TimeSpan.FromMilliseconds(magnitude);
+            return true;
+        }
+
+        char suffix = char.ToLowerInvariant(value[^1]);
+        if (suffix == 's' || suffix == 'm')
+        {
+            magnitudeSpan = value[..^1];
+            if (!double.TryParse(magnitudeSpan, NumberStyles.Float, CultureInfo.InvariantCulture, out magnitude))
+            {
+                return false;
+            }
+
+            result = suffix == 's' ? TimeSpan.FromSeconds(magnitude) : TimeSpan.FromMinutes(magnitude);
+            return true;
+        }
+
+        if (!double.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out magnitude))
+        {
+            return false;
+        }
+
+        result = TimeSpan.FromMilliseconds(magnitude);
+        return true;
+    }
+
     private static void PrintHelp()
     {
         Console.WriteLine("Usage: EvenPerfectBitScanner [options]");
         Console.WriteLine();
         Console.WriteLine("Options:");
         Console.WriteLine("  --prime=<value>        starting exponent (p)");
-        Console.WriteLine("  --max-prime=<value>    inclusive upper bound for primes from filter files");
         Console.WriteLine("  --increment=bit|add    exponent increment method");
         Console.WriteLine("  --threads=<value>      number of worker threads");
         Console.WriteLine("  --block-size=<value>   values processed per thread batch");
@@ -1100,10 +1017,13 @@ internal static class Program
         Console.WriteLine("  --divisor-cycles-batch=<value> batch size for cycles generation (default 512)");
         Console.WriteLine("  --divisor-cycles-continue  continue divisor cycles generation");
         Console.WriteLine("  --divisor-cycles-limit=<value> cycle search iterations when --mersenne=divisor");
+        Console.WriteLine("  --prime-test-limit=<value>   Time limit for --mersenne=bydivisor prime checks (e.g. 5s, 500ms)");
+        Console.WriteLine("  --bydivisor-deltas-device=cpu|gpu  Device for --mersenne=bydivisor residue batches (default: cpu)");
+        Console.WriteLine("  --bydivisor-montgomery-device=cpu|gpu  Device for Montgomery data when using --mersenne=bydivisor (default: cpu)");
         Console.WriteLine("  --use-order            test primality via q order");
         Console.WriteLine("  --workaround-mod       avoid '%' operator on the GPU");
         // mod-automaton removed
-        Console.WriteLine("  --filter-p=<path>      process only p from previous run results (required for --mersenne=bydivisor)");
+        Console.WriteLine("  --filter-p=<path>      process only p from previous run results (required for --mersenne=bydivisor; primes must be strictly increasing)");
         Console.WriteLine("  --write-batch-size=<value> overwrite frequency of disk writes (default 100 lines)");
         Console.WriteLine("  --gcd-filter           enable early sieve based on GCD");
         Console.WriteLine("  --help, -help, --?, -?, /?   show this help message");
@@ -1166,21 +1086,6 @@ internal static class Program
         }
     }
 
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void OnPrimeCandidateConfirmed()
-    {
-        if (!_testMode)
-        {
-            return;
-        }
-
-        int processed = Interlocked.Increment(ref _testProcessedPrimeCount);
-        if (processed == _testTargetPrimeCount)
-        {
-            Volatile.Write(ref _limitReached, true);
-        }
-    }
-
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static bool TryAcquireConsoleSlot(bool primeCandidate, out bool primeFlag)
     {
@@ -1317,75 +1222,6 @@ internal static class Program
         }
     }
 
-    private static void ReportTestTime(TimeSpan elapsed)
-    {
-        double elapsedSeconds = elapsed.TotalSeconds;
-        double elapsedMilliseconds = elapsed.TotalMilliseconds;
-        Console.WriteLine($"Test elapsed time: {elapsedSeconds:F3} s");
-
-        string filePath = GetTestTimeFilePath();
-        bool hasPrevious = TryReadTestTime(filePath, out double previousMilliseconds);
-        string elapsedText = elapsedMilliseconds.ToString("F3", CultureInfo.InvariantCulture);
-
-        if (!hasPrevious)
-        {
-            WriteTestTime(filePath, elapsedMilliseconds);
-            Console.WriteLine($"FIRST TIME: {elapsedText} ms");
-            return;
-        }
-
-        string previousText = previousMilliseconds.ToString("F3", CultureInfo.InvariantCulture);
-        if (elapsedMilliseconds < previousMilliseconds)
-        {
-            WriteTestTime(filePath, elapsedMilliseconds);
-            Console.WriteLine($"BETTER TIME: {elapsedText} ms (previous {previousText} ms)");
-        }
-        else
-        {
-            Console.WriteLine($"WORSE TIME: {elapsedText} ms (best {previousText} ms)");
-        }
-    }
-
-    private static string GetTestTimeFilePath()
-    {
-        if (string.IsNullOrEmpty(_resultsDir))
-        {
-            return TestTimeFileName;
-        }
-
-        return Path.Combine(_resultsDir!, TestTimeFileName);
-    }
-
-    private static bool TryReadTestTime(string filePath, out double milliseconds)
-    {
-        if (!File.Exists(filePath))
-        {
-            milliseconds = 0.0;
-            return false;
-        }
-
-        string content = File.ReadAllText(filePath).Trim();
-        if (content.Length == 0)
-        {
-            milliseconds = 0.0;
-            return false;
-        }
-
-        return double.TryParse(content, NumberStyles.Float, CultureInfo.InvariantCulture, out milliseconds);
-    }
-
-    private static void WriteTestTime(string filePath, double milliseconds)
-    {
-        string? directory = Path.GetDirectoryName(filePath);
-        if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
-        {
-            Directory.CreateDirectory(directory);
-        }
-
-        string formatted = milliseconds.ToString("F6", CultureInfo.InvariantCulture);
-        File.WriteAllText(filePath, formatted);
-    }
-
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     internal static ulong CountOnes(ulong value)
     {
@@ -1616,8 +1452,6 @@ internal static class Program
                 _lastCompositeP = true;
                 return false;
             }
-
-            OnPrimeCandidateConfirmed();
         }
 
         searchedMersenne = true;

PerfectNumbers.Core.Tests/Gpu/GpuKernelCompilationTests.cs

@@ -1,7 +1,10 @@
+using System;
+using System.Collections.Generic;
 using System.Reflection;
 using FluentAssertions;
 using ILGPU;
 using ILGPU.Runtime;
+using PerfectNumbers.Core;
 using PerfectNumbers.Core.Gpu;
 using Xunit;
 

PerfectNumbers.Core.Tests/Gpu/GpuPrimeLimiterTests.cs

@@ -18,13 +18,14 @@ public class GpuPrimeLimiterTests
         var startedSecond = new TaskCompletionSource<bool>();
         var sw = new Stopwatch();
 
-        using var first = GpuPrimeWorkLimiter.Acquire();
+        var first = GpuPrimeWorkLimiter.Acquire();
         sw.Start();
 
         var secondTask = Task.Run(() =>
         {
-            using var second = GpuPrimeWorkLimiter.Acquire();
+            var second = GpuPrimeWorkLimiter.Acquire();
             startedSecond.TrySetResult(true);
+            second.Dispose();
         });
 
         // Give secondTask a moment to attempt acquire (it should block).

PerfectNumbers.Core.Tests/Gpu/NttMontgomeryTests.cs

@@ -34,23 +34,19 @@ public class NttMontgomeryTests
 
         // Device execution
         GpuContextPool.GpuContextLease context = GpuContextPool.Rent();
-        try
-        {
-            var accelerator = context.Accelerator;
-            using var buffer = accelerator.Allocate1D<GpuUInt128>(gpu.Length);
-            buffer.View.CopyFromCPU(ref gpu[0], gpu.Length);
-            NttGpuMath.SquareDevice(accelerator, buffer.View, modulus, primitiveRoot);
-            buffer.View.CopyToCPU(ref gpu[0], gpu.Length);
+        var accelerator = context.Accelerator;
+        var buffer = accelerator.Allocate1D<GpuUInt128>(gpu.Length);
+        buffer.View.CopyFromCPU(ref gpu[0], gpu.Length);
+        NttGpuMath.SquareDevice(accelerator, buffer.View, modulus, primitiveRoot);
+        buffer.View.CopyToCPU(ref gpu[0], gpu.Length);
 
-            for (int i = 0; i < cpu.Length; i++)
-            {
-                gpu[i].Should().Be(cpu[i]);
-            }
-        }
-        finally
+        for (int i = 0; i < cpu.Length; i++)
         {
-            context.Dispose();
+            gpu[i].Should().Be(cpu[i]);
         }
+
+        buffer.Dispose();
+        context.Dispose();
     }
 
     [Fact]

PerfectNumbers.Core.Tests/Gpu/PrimeOrderGpuHeuristicsTests.cs

@@ -1,6 +1,8 @@
+using System;
 using System.Numerics;
 using System.Reflection;
 using FluentAssertions;
+using PerfectNumbers.Core;
 using PerfectNumbers.Core.Gpu;
 using Xunit;
 

PerfectNumbers.Core.Tests/GpuWorkLimiterTests.cs

@@ -17,13 +17,14 @@ public class GpuWorkLimiterTests
         var startedSecond = new TaskCompletionSource<bool>();
         var sw = new Stopwatch();
 
-        using var first = GpuWorkLimiter.Acquire();
+        var first = GpuWorkLimiter.Acquire();
         sw.Start();
 
         var secondTask = Task.Run(() =>
         {
-            using var second = GpuWorkLimiter.Acquire();
+            var second = GpuWorkLimiter.Acquire();
             startedSecond.TrySetResult(true);
+            second.Dispose();
         });
 
         await Task.Delay(50);

PerfectNumbers.Core.Tests/MersenneDivisorCyclesGenerateGpuTests.cs

@@ -14,8 +14,8 @@ public class MersenneDivisorCyclesGenerateGpuTests
         {
             MersenneDivisorCycles.GenerateGpu(path, maxDivisor: 50UL, batchSize: 16, skipCount: 0, nextPosition: 0);
             var pairs = new List<(ulong divisor, ulong cycle)>();
-            using var stream = new FileStream(path, FileMode.Open, FileAccess.Read);
-            using var reader = new BinaryReader(stream);
+            var stream = new FileStream(path, FileMode.Open, FileAccess.Read);
+            var reader = new BinaryReader(stream);
             while (stream.Position < stream.Length)
             {
                 ulong d = reader.ReadUInt64();
@@ -41,6 +41,9 @@ public class MersenneDivisorCyclesGenerateGpuTests
                 MontgomeryDivisorData divisorData = MontgomeryDivisorData.FromModulus(pair.divisor);
                 pair.cycle.Should().Be(MersenneDivisorCycles.CalculateCycleLength(pair.divisor, divisorData));
             }
+
+            reader.Dispose();
+            stream.Dispose();
         }
         finally
         {
@@ -61,8 +64,8 @@ public class MersenneDivisorCyclesGenerateGpuTests
             MersenneDivisorCycles.Generate(path, maxDivisor: 50UL, threads: 4);
 
             var pairs = new List<(ulong divisor, ulong cycle)>();
-            using var stream = new FileStream(path, FileMode.Open, FileAccess.Read);
-            using var reader = new BinaryReader(stream);
+            var stream = new FileStream(path, FileMode.Open, FileAccess.Read);
+            var reader = new BinaryReader(stream);
             while (stream.Position < stream.Length)
             {
                 ulong divisor = reader.ReadUInt64();
@@ -95,6 +98,9 @@ public class MersenneDivisorCyclesGenerateGpuTests
 
             var (_, completeCount) = MersenneDivisorCycles.FindLast(path);
             completeCount.Should().Be(expected.Count);
+
+            reader.Dispose();
+            stream.Dispose();
         }
         finally
         {

PerfectNumbers.Core.Tests/MersenneNumberDivisorByDivisorTesterTests.cs

@@ -1,4 +1,7 @@
+using System;
+using System.Collections.Generic;
 using FluentAssertions;
+using PerfectNumbers.Core;
 using Xunit;
 
 namespace PerfectNumbers.Core.Tests;
@@ -23,7 +26,8 @@ public class MersenneNumberDivisorByDivisorTesterTests
             markComposite: () => compositeMarks++,
             clearComposite: () => clearedMarks++,
             printResult: (prime, searched, detailed, passed) => results.Add((prime, searched, detailed, passed)),
-            threadCount: 1);
+            threadCount: 1,
+            primeTestLimit: null);
 
         tester.ConfiguredMaxPrime.Should().Be(13UL);
         compositeMarks.Should().Be(2);
@@ -56,7 +60,7 @@ public class MersenneNumberDivisorByDivisorTesterTests
             return DivisorLimit;
         }
 
-        public bool IsPrime(ulong prime, out bool divisorsExhausted)
+        public bool IsPrime(ulong prime, out bool divisorsExhausted, TimeSpan? timeLimit = null)
         {
             divisorsExhausted = true;
             return prime % 7UL != 0UL && prime % 11UL != 0UL;
@@ -67,7 +71,7 @@ public class MersenneNumberDivisorByDivisorTesterTests
             return new DummySession();
         }
 
-        public void PrepareCandidates(in ReadOnlySpan<ulong> primes, Span<ulong> allowedMaxValues)
+        public void PrepareCandidates(ReadOnlySpan<ulong> primes, Span<ulong> allowedMaxValues)
         {
             for (int i = 0; i < primes.Length; i++)
             {
@@ -77,7 +81,7 @@ public class MersenneNumberDivisorByDivisorTesterTests
 
         private sealed class DummySession : IMersenneNumberDivisorByDivisorTester.IDivisorScanSession
         {
-            public void CheckDivisor(ulong divisor, in MontgomeryDivisorData divisorData, ulong divisorCycle, in ReadOnlySpan<ulong> primes, Span<byte> hits)
+            public void CheckDivisor(ulong divisor, in MontgomeryDivisorData divisorData, ulong divisorCycle, ReadOnlySpan<ulong> primes, Span<byte> hits)
             {
                 throw new NotSupportedException();
             }

PerfectNumbers.Core.Tests/MersenneNumberDivisorCpuTesterTests.cs

@@ -1,4 +1,6 @@
+using System;
 using FluentAssertions;
+using PerfectNumbers.Core;
 using PerfectNumbers.Core.Cpu;
 using Xunit;
 
@@ -6,78 +8,125 @@ namespace PerfectNumbers.Core.Tests;
 
 public class MersenneNumberDivisorCpuTesterTests
 {
-        [Fact]
-        [Trait("Category", "Fast")]
-        public void ByDivisor_tester_tracks_divisors_across_primes()
+    private const ulong LargeDivisor1 = 4_000_169UL;
+    private const ulong LargeDivisor2 = 4_000_561UL;
+
+    [Fact]
+    [Trait("Category", "Fast")]
+    public void ByDivisor_tester_tracks_divisors_across_primes()
+    {
+        var tester = new MersenneNumberDivisorByDivisorCpuTester();
+        tester.ConfigureFromMaxPrime(83UL);
+
+        tester.IsPrime(59UL, out bool divisorsExhausted).Should().BeTrue();
+        divisorsExhausted.Should().BeTrue();
+
+        tester.IsPrime(61UL, out divisorsExhausted).Should().BeTrue();
+        divisorsExhausted.Should().BeTrue();
+
+        tester.IsPrime(67UL, out divisorsExhausted).Should().BeTrue();
+        divisorsExhausted.Should().BeTrue();
+    }
+
+    [Fact]
+    [Trait("Category", "Fast")]
+    public void ByDivisor_prime_test_limit_disables_divisor_exhaustion()
+    {
+        var tester = new MersenneNumberDivisorByDivisorCpuTester();
+        tester.ConfigureFromMaxPrime(83UL);
+
+        tester.IsPrime(59UL, out bool divisorsExhausted, TimeSpan.Zero).Should().BeTrue();
+        divisorsExhausted.Should().BeFalse();
+    }
+
+    [Fact]
+    [Trait("Category", "Fast")]
+    public void ByDivisor_session_checks_divisors_across_exponents()
+    {
+        var tester = new MersenneNumberDivisorByDivisorCpuTester();
+        tester.ConfigureFromMaxPrime(197UL);
+
+        var session = tester.CreateDivisorSession();
+        ulong[] exponents = { 59UL, 61UL, 67UL, 71UL, 73UL, 79UL, 117_652UL, 333_380UL };
+        byte[] hits = new byte[exponents.Length];
+
+        MontgomeryDivisorData divisor1 = MontgomeryDivisorData.FromModulus(LargeDivisor1);
+        ulong cycle1 = MersenneDivisorCycles.CalculateCycleLength(LargeDivisor1, divisor1);
+        session.CheckDivisor(LargeDivisor1, divisor1, cycle1, exponents, hits);
+
+        byte[] expected1 = new byte[exponents.Length];
+        for (int i = 0; i < exponents.Length; i++)
         {
-                var tester = new MersenneNumberDivisorByDivisorCpuTester();
-                tester.ConfigureFromMaxPrime(11UL);
-
-                tester.IsPrime(5UL, out bool divisorsExhausted).Should().BeTrue();
-                divisorsExhausted.Should().BeTrue();
-
-                tester.IsPrime(7UL, out divisorsExhausted).Should().BeTrue();
-                divisorsExhausted.Should().BeTrue();
-
-                tester.IsPrime(11UL, out divisorsExhausted).Should().BeFalse();
-                divisorsExhausted.Should().BeTrue();
+            expected1[i] = exponents[i].Pow2ModWindowedCpu(divisor1.Modulus) == 1UL ? (byte)1 : (byte)0;
         }
 
-        [Fact]
-        [Trait("Category", "Fast")]
-        public void ByDivisor_session_checks_divisors_across_primes()
+        hits.Should().Equal(expected1);
+
+        Array.Fill(hits, (byte)0);
+        MontgomeryDivisorData divisor2 = MontgomeryDivisorData.FromModulus(LargeDivisor2);
+        ulong cycle2 = MersenneDivisorCycles.CalculateCycleLength(LargeDivisor2, divisor2);
+        session.CheckDivisor(LargeDivisor2, divisor2, cycle2, exponents, hits);
+
+        byte[] expected2 = new byte[exponents.Length];
+        for (int i = 0; i < exponents.Length; i++)
         {
-                var tester = new MersenneNumberDivisorByDivisorCpuTester();
-                tester.ConfigureFromMaxPrime(13UL);
-
-                using var session = tester.CreateDivisorSession();
-                ulong[] primes = { 5UL, 7UL, 11UL, 13UL };
-                byte[] hits = new byte[primes.Length];
-
-                ulong cycle23 = MersenneDivisorCycles.CalculateCycleLength(23UL, MontgomeryDivisorData.FromModulus(23UL));
-                session.CheckDivisor(23UL, MontgomeryDivisorData.FromModulus(23UL), cycle23, primes, hits);
-                hits.Should().ContainInOrder(new byte[] { 0, 0, 1, 0 });
-
-                Array.Fill(hits, (byte)0);
-                ulong cycle31 = MersenneDivisorCycles.CalculateCycleLength(31UL, MontgomeryDivisorData.FromModulus(31UL));
-                session.CheckDivisor(31UL, MontgomeryDivisorData.FromModulus(31UL), cycle31, primes, hits);
-                hits.Should().ContainInOrder(new byte[] { 1, 0, 0, 0 });
+            expected2[i] = exponents[i].Pow2ModWindowedCpu(divisor2.Modulus) == 1UL ? (byte)1 : (byte)0;
         }
 
-        [Fact]
-        [Trait("Category", "Fast")]
-        public void ByDivisor_session_marks_mersenne_numbers_divisible_by_seven_as_composite()
+        hits.Should().Equal(expected2);
+
+        session.Dispose();
+    }
+
+    [Fact]
+    [Trait("Category", "Fast")]
+    public void ByDivisor_session_marks_mersenne_numbers_divisible_by_large_divisor1_as_composite()
+    {
+        var tester = new MersenneNumberDivisorByDivisorCpuTester();
+        tester.ConfigureFromMaxPrime(197UL);
+
+        var session = tester.CreateDivisorSession();
+        MontgomeryDivisorData divisorData = MontgomeryDivisorData.FromModulus(LargeDivisor1);
+        ulong cycle = MersenneDivisorCycles.CalculateCycleLength(LargeDivisor1, divisorData);
+
+        ulong[] exponents = { 59UL, 67UL, cycle, cycle * 2UL, cycle + 1UL };
+        byte[] hits = new byte[exponents.Length];
+        session.CheckDivisor(LargeDivisor1, divisorData, cycle, exponents, hits);
+
+        byte[] expected = new byte[exponents.Length];
+        for (int i = 0; i < exponents.Length; i++)
         {
-                var tester = new MersenneNumberDivisorByDivisorCpuTester();
-                tester.ConfigureFromMaxPrime(43UL);
-
-                using var session = tester.CreateDivisorSession();
-                ulong[] exponents = { 6UL, 7UL, 9UL, 10UL, 12UL };
-                byte[] hits = new byte[exponents.Length];
-
-                MontgomeryDivisorData divisorData = MontgomeryDivisorData.FromModulus(7UL);
-                ulong cycle = MersenneDivisorCycles.CalculateCycleLength(7UL, divisorData);
-                session.CheckDivisor(7UL, divisorData, cycle, exponents, hits);
-
-                hits.Should().Equal(new byte[] { 1, 0, 1, 0, 1 });
+            expected[i] = exponents[i].Pow2ModWindowedCpu(divisorData.Modulus) == 1UL ? (byte)1 : (byte)0;
         }
 
-        [Fact]
-        [Trait("Category", "Fast")]
-        public void ByDivisor_session_marks_mersenne_numbers_divisible_by_eleven_as_composite()
+        hits.Should().Equal(expected);
+
+        session.Dispose();
+    }
+
+    [Fact]
+    [Trait("Category", "Fast")]
+    public void ByDivisor_session_marks_mersenne_numbers_divisible_by_large_divisor2_as_composite()
+    {
+        var tester = new MersenneNumberDivisorByDivisorCpuTester();
+        tester.ConfigureFromMaxPrime(197UL);
+
+        var session = tester.CreateDivisorSession();
+        MontgomeryDivisorData divisorData = MontgomeryDivisorData.FromModulus(LargeDivisor2);
+        ulong cycle = MersenneDivisorCycles.CalculateCycleLength(LargeDivisor2, divisorData);
+
+        ulong[] exponents = { 61UL, 73UL, cycle, cycle * 2UL, cycle - 1UL };
+        byte[] hits = new byte[exponents.Length];
+        session.CheckDivisor(LargeDivisor2, divisorData, cycle, exponents, hits);
+
+        byte[] expected = new byte[exponents.Length];
+        for (int i = 0; i < exponents.Length; i++)
         {
-                var tester = new MersenneNumberDivisorByDivisorCpuTester();
-                tester.ConfigureFromMaxPrime(61UL);
-
-                using var session = tester.CreateDivisorSession();
-                ulong[] exponents = { 10UL, 11UL, 20UL, 21UL, 30UL };
-                byte[] hits = new byte[exponents.Length];
-
-                MontgomeryDivisorData divisorData = MontgomeryDivisorData.FromModulus(11UL);
-                ulong cycle = MersenneDivisorCycles.CalculateCycleLength(11UL, divisorData);
-                session.CheckDivisor(11UL, divisorData, cycle, exponents, hits);
-
-                hits.Should().Equal(new byte[] { 1, 0, 1, 0, 1 });
+            expected[i] = exponents[i].Pow2ModWindowedCpu(divisorData.Modulus) == 1UL ? (byte)1 : (byte)0;
         }
+
+        hits.Should().Equal(expected);
+
+        session.Dispose();
+    }
 }
-

PerfectNumbers.Core.Tests/MersenneNumberDivisorGpuTesterTests.cs

@@ -1,5 +1,8 @@
+using System;
+using System.Collections.Generic;
 using System.Reflection;
 using FluentAssertions;
+using PerfectNumbers.Core;
 using PerfectNumbers.Core.Cpu;
 using PerfectNumbers.Core.Gpu;
 using Xunit;
@@ -9,12 +12,12 @@ namespace PerfectNumbers.Core.Tests;
 public class MersenneNumberDivisorGpuTesterTests
 {
     [Theory]
-    [InlineData(33UL, 7UL, true)]
-    [InlineData(35UL, 31UL, true)]
-    [InlineData(37UL, 223UL, true)]
-    [InlineData(33UL, 13UL, false)]
-    [InlineData(35UL, 73UL, false)]
-    [InlineData(37UL, 227UL, false)]
+    [InlineData(117_652UL, 4_000_169UL, true)]
+    [InlineData(333_380UL, 4_000_561UL, true)]
+    [InlineData(59UL, 4_000_169UL, false)]
+    [InlineData(61UL, 4_000_561UL, false)]
+    [InlineData(333_379UL, 4_000_561UL, false)]
+    [InlineData(117_653UL, 4_000_169UL, false)]
     [Trait("Category", "Fast")]
     public void IsDivisible_returns_expected(ulong exponent, ulong divisor, bool expected)
     {
@@ -83,6 +86,17 @@ public class MersenneNumberDivisorGpuTesterTests
         exhausted.Should().BeTrue();
     }
 
+    [Fact]
+    [Trait("Category", "Fast")]
+    public void ByDivisor_gpu_prime_test_limit_stops_scan_immediately()
+    {
+        var tester = new MersenneNumberDivisorByDivisorGpuTester();
+        tester.ConfigureFromMaxPrime(43UL);
+
+        tester.IsPrime(31UL, out bool divisorsExhausted, TimeSpan.Zero).Should().BeTrue();
+        divisorsExhausted.Should().BeFalse();
+    }
+
     [Fact]
     [Trait("Category", "Fast")]
     public void ByDivisor_tester_requires_configuration()
@@ -138,23 +152,41 @@ public class MersenneNumberDivisorGpuTesterTests
 
     [Fact]
     [Trait("Category", "Fast")]
-    public void ByDivisor_session_checks_divisors_across_primes()
+    public void ByDivisor_session_checks_divisors_across_exponents()
     {
         var tester = new MersenneNumberDivisorByDivisorGpuTester();
-        tester.ConfigureFromMaxPrime(43UL);
+        tester.ConfigureFromMaxPrime(197UL);
 
-        using var session = tester.CreateDivisorSession();
-        ulong[] primes = { 31UL, 37UL, 41UL, 43UL };
-        byte[] hits = new byte[primes.Length];
+        var session = tester.CreateDivisorSession();
+        ulong[] exponents = { 59UL, 61UL, 67UL, 71UL, 73UL, 79UL, 117_652UL, 333_380UL };
+        byte[] hits = new byte[exponents.Length];
 
-        ulong cycle223 = MersenneDivisorCycles.CalculateCycleLength(223UL, MontgomeryDivisorData.FromModulus(223UL));
-        session.CheckDivisor(223UL, MontgomeryDivisorData.FromModulus(223UL), cycle223, primes, hits);
-        hits.Should().ContainInOrder(new byte[] { 0, 1, 0, 0 });
+        MontgomeryDivisorData divisor1 = MontgomeryDivisorData.FromModulus(4_000_169UL);
+        ulong cycle1 = MersenneDivisorCycles.CalculateCycleLength(4_000_169UL, divisor1);
+        session.CheckDivisor(4_000_169UL, divisor1, cycle1, exponents, hits);
+
+        byte[] expected1 = new byte[exponents.Length];
+        for (int i = 0; i < exponents.Length; i++)
+        {
+            expected1[i] = exponents[i].Pow2ModWindowedCpu(divisor1.Modulus) == 1UL ? (byte)1 : (byte)0;
+        }
+
+        hits.Should().Equal(expected1);
 
         Array.Fill(hits, (byte)0);
-        ulong cycle13367 = MersenneDivisorCycles.CalculateCycleLength(13367UL, MontgomeryDivisorData.FromModulus(13367UL));
-        session.CheckDivisor(13367UL, MontgomeryDivisorData.FromModulus(13367UL), cycle13367, primes, hits);
-        hits.Should().ContainInOrder(new byte[] { 0, 0, 1, 0 });
+        MontgomeryDivisorData divisor2 = MontgomeryDivisorData.FromModulus(4_000_561UL);
+        ulong cycle2 = MersenneDivisorCycles.CalculateCycleLength(4_000_561UL, divisor2);
+        session.CheckDivisor(4_000_561UL, divisor2, cycle2, exponents, hits);
+
+        byte[] expected2 = new byte[exponents.Length];
+        for (int i = 0; i < exponents.Length; i++)
+        {
+            expected2[i] = exponents[i].Pow2ModWindowedCpu(divisor2.Modulus) == 1UL ? (byte)1 : (byte)0;
+        }
+
+        hits.Should().Equal(expected2);
+
+        session.Dispose();
     }
 
     [Fact]
@@ -166,122 +198,134 @@ public class MersenneNumberDivisorGpuTesterTests
             GpuBatchSize = 2,
         };
 
-        tester.ConfigureFromMaxPrime(47UL);
+        tester.ConfigureFromMaxPrime(197UL);
 
-        using var session = tester.CreateDivisorSession();
-        ulong[] primes = { 31UL, 37UL, 41UL, 43UL, 47UL };
-        byte[] hits = new byte[primes.Length];
+        var session = tester.CreateDivisorSession();
+        ulong[] exponents = { 59UL, 61UL, 67UL, 71UL, 73UL, 79UL, 117_652UL };
+        byte[] hits = new byte[exponents.Length];
 
-        ulong cycle223 = MersenneDivisorCycles.CalculateCycleLength(223UL, MontgomeryDivisorData.FromModulus(223UL));
-        session.CheckDivisor(223UL, MontgomeryDivisorData.FromModulus(223UL), cycle223, primes, hits);
+        MontgomeryDivisorData divisor = MontgomeryDivisorData.FromModulus(4_000_169UL);
+        ulong cycle = MersenneDivisorCycles.CalculateCycleLength(4_000_169UL, divisor);
+        session.CheckDivisor(4_000_169UL, divisor, cycle, exponents, hits);
 
-        hits.Should().ContainInOrder(new byte[] { 0, 1, 0, 0, 0 });
+        byte[] expected = new byte[exponents.Length];
+        for (int i = 0; i < exponents.Length; i++)
+        {
+            expected[i] = exponents[i].Pow2ModWindowedCpu(divisor.Modulus) == 1UL ? (byte)1 : (byte)0;
+        }
+
+        hits.Should().Equal(expected);
+
+        session.Dispose();
     }
 
     [Fact]
     [Trait("Category", "Fast")]
-    public void ByDivisor_session_marks_mersenne_numbers_divisible_by_seven_as_composite()
+    public void ByDivisor_session_marks_mersenne_numbers_divisible_by_large_divisor1_as_composite()
     {
         var tester = new MersenneNumberDivisorByDivisorGpuTester
         {
             GpuBatchSize = 5,
         };
-        tester.ConfigureFromMaxPrime(43UL);
+        tester.ConfigureFromMaxPrime(197UL);
 
-        using var session = tester.CreateDivisorSession();
-        ulong[] exponents = { 6UL, 7UL, 9UL, 10UL, 12UL };
+        var session = tester.CreateDivisorSession();
+        MontgomeryDivisorData divisorData = MontgomeryDivisorData.FromModulus(4_000_169UL);
+        ulong cycle = MersenneDivisorCycles.CalculateCycleLength(4_000_169UL, divisorData);
+
+        ulong[] exponents = { 59UL, 67UL, cycle, cycle * 2UL, cycle + 1UL };
         byte[] hits = new byte[exponents.Length];
 
-        MontgomeryDivisorData divisorData = MontgomeryDivisorData.FromModulus(7UL);
-        ulong cycle = MersenneDivisorCycles.CalculateCycleLength(7UL, divisorData);
-
-        session.CheckDivisor(7UL, divisorData, cycle, exponents, hits);
+        session.CheckDivisor(4_000_169UL, divisorData, cycle, exponents, hits);
 
         var hostBufferField = typeof(MersenneNumberDivisorByDivisorGpuTester.DivisorScanSession)
             .GetField("_hostBuffer", BindingFlags.NonPublic | BindingFlags.Instance)!;
         ulong[] hostBuffer = (ulong[])hostBufferField.GetValue(session)!;
         Span<ulong> residues = hostBuffer.AsSpan(0, exponents.Length);
-        byte[] computedHits = new byte[exponents.Length];
+        byte[] expected = new byte[exponents.Length];
         for (int i = 0; i < residues.Length; i++)
         {
-            computedHits[i] = residues[i] == divisorData.MontgomeryOne ? (byte)1 : (byte)0;
+            expected[i] = residues[i] == 1UL ? (byte)1 : (byte)0;
         }
 
-        computedHits.Should().Equal(new byte[] { 1, 0, 1, 0, 1 });
+        byte[] direct = new byte[exponents.Length];
+        for (int i = 0; i < exponents.Length; i++)
+        {
+            direct[i] = exponents[i].Pow2ModWindowedCpu(divisorData.Modulus) == 1UL ? (byte)1 : (byte)0;
+        }
+
+        expected.Should().Equal(direct);
+        hits.Should().Equal(direct);
+
+        session.Dispose();
     }
 
     [Fact]
     [Trait("Category", "Fast")]
-    public void ByDivisor_session_marks_mersenne_numbers_divisible_by_eleven_as_composite()
+    public void ByDivisor_session_marks_mersenne_numbers_divisible_by_large_divisor2_as_composite()
     {
         var tester = new MersenneNumberDivisorByDivisorGpuTester
         {
             GpuBatchSize = 5,
         };
-        tester.ConfigureFromMaxPrime(61UL);
+        tester.ConfigureFromMaxPrime(197UL);
 
-        using var session = tester.CreateDivisorSession();
-        ulong[] exponents = { 10UL, 11UL, 20UL, 21UL, 30UL };
+        var session = tester.CreateDivisorSession();
+        MontgomeryDivisorData divisorData = MontgomeryDivisorData.FromModulus(4_000_561UL);
+        ulong cycle = MersenneDivisorCycles.CalculateCycleLength(4_000_561UL, divisorData);
+
+        ulong[] exponents = { 61UL, 73UL, cycle, cycle * 2UL, cycle - 1UL };
         byte[] hits = new byte[exponents.Length];
 
-        MontgomeryDivisorData divisorData = MontgomeryDivisorData.FromModulus(11UL);
-        ulong cycle = MersenneDivisorCycles.CalculateCycleLength(11UL, divisorData);
-
-        session.CheckDivisor(11UL, divisorData, cycle, exponents, hits);
+        session.CheckDivisor(4_000_561UL, divisorData, cycle, exponents, hits);
 
         var hostBufferField = typeof(MersenneNumberDivisorByDivisorGpuTester.DivisorScanSession)
             .GetField("_hostBuffer", BindingFlags.NonPublic | BindingFlags.Instance)!;
         ulong[] hostBuffer = (ulong[])hostBufferField.GetValue(session)!;
         Span<ulong> residues = hostBuffer.AsSpan(0, exponents.Length);
-        byte[] computedHits = new byte[exponents.Length];
+        byte[] expected = new byte[exponents.Length];
         for (int i = 0; i < residues.Length; i++)
         {
-            computedHits[i] = residues[i] == divisorData.MontgomeryOne ? (byte)1 : (byte)0;
+            expected[i] = residues[i] == 1UL ? (byte)1 : (byte)0;
         }
 
-        computedHits.Should().Equal(new byte[] { 1, 0, 1, 0, 1 });
+        byte[] direct = new byte[exponents.Length];
+        for (int i = 0; i < exponents.Length; i++)
+        {
+            direct[i] = exponents[i].Pow2ModWindowedCpu(divisorData.Modulus) == 1UL ? (byte)1 : (byte)0;
+        }
+
+        expected.Should().Equal(direct);
+        hits.Should().Equal(direct);
+
+        session.Dispose();
     }
 
     [Fact]
     [Trait("Category", "Fast")]
-    public void ByDivisor_gpu_tester_skips_divisors_excluded_by_small_cycle_generation()
+    public void ByDivisor_gpu_tester_generates_cycles_for_large_divisors()
     {
-        var cycles = MersenneDivisorCycles.Shared;
-        var tableField = typeof(MersenneDivisorCycles).GetField("_table", BindingFlags.NonPublic | BindingFlags.Instance)!;
-        var smallCyclesField = typeof(MersenneDivisorCycles).GetField("_smallCycles", BindingFlags.NonPublic | BindingFlags.Instance)!;
+        var tester = new MersenneNumberDivisorByDivisorGpuTester();
+        tester.ConfigureFromMaxPrime(197UL);
 
-        var originalTable = (List<(ulong Divisor, ulong Cycle)>)tableField.GetValue(cycles)!;
-        var originalSmall = (ulong[]?)smallCyclesField.GetValue(cycles);
+        var session = tester.CreateDivisorSession();
+        ulong[] exponents = { 59UL, 67UL, 117_652UL };
+        byte[] hits = new byte[exponents.Length];
 
-        try
+        MontgomeryDivisorData divisorData = MontgomeryDivisorData.FromModulus(4_000_169UL);
+        ulong cycle = MersenneDivisorCycles.CalculateCycleLength(4_000_169UL, divisorData);
+
+        session.CheckDivisor(4_000_169UL, divisorData, cycle, exponents, hits);
+
+        byte[] expected = new byte[exponents.Length];
+        for (int i = 0; i < exponents.Length; i++)
         {
-            var patchedTable = new List<(ulong Divisor, ulong Cycle)>();
-            ulong[] patchedSmall = new ulong[PerfectNumberConstants.MaxQForDivisorCycles + 1];
-
-            MontgomeryDivisorData divisorData = MontgomeryDivisorData.FromModulus(191UL);
-            patchedSmall[191] = MersenneDivisorCycles.CalculateCycleLength(191UL, divisorData);
-
-            tableField.SetValue(cycles, patchedTable);
-            smallCyclesField.SetValue(cycles, patchedSmall);
-            DivisorCycleCache.Shared.RefreshSnapshot();
-
-            var tester = new MersenneNumberDivisorByDivisorGpuTester();
-            tester.ConfigureFromMaxPrime(19UL);
-
-            typeof(MersenneNumberDivisorByDivisorGpuTester)
-                .GetField("_divisorLimit", BindingFlags.NonPublic | BindingFlags.Instance)!
-                .SetValue(tester, 200UL);
-
-            tester.IsPrime(19UL, out bool divisorsExhausted).Should().BeTrue();
-            divisorsExhausted.Should().BeTrue();
-        }
-        finally
-        {
-            tableField.SetValue(cycles, originalTable);
-            smallCyclesField.SetValue(cycles, originalSmall);
-            DivisorCycleCache.Shared.RefreshSnapshot();
-            GpuContextPool.DisposeAll();
+            expected[i] = exponents[i].Pow2ModWindowedCpu(divisorData.Modulus) == 1UL ? (byte)1 : (byte)0;
         }
+
+        hits.Should().Equal(expected);
+
+        session.Dispose();
     }
 
     [Fact]
@@ -293,16 +337,25 @@ public class MersenneNumberDivisorGpuTesterTests
             BatchSize = 2,
         };
 
-        tester.ConfigureFromMaxPrime(47UL);
+        tester.ConfigureFromMaxPrime(197UL);
 
-        using var session = tester.CreateDivisorSession();
-        ulong[] primes = { 31UL, 37UL, 41UL, 43UL, 47UL };
-        byte[] hits = new byte[primes.Length];
+        var session = tester.CreateDivisorSession();
+        ulong[] exponents = { 59UL, 61UL, 67UL, 71UL, 73UL, 79UL, 117_652UL };
+        byte[] hits = new byte[exponents.Length];
 
-        ulong cycle223 = MersenneDivisorCycles.CalculateCycleLength(223UL, MontgomeryDivisorData.FromModulus(223UL));
-        session.CheckDivisor(223UL, MontgomeryDivisorData.FromModulus(223UL), cycle223, primes, hits);
+        MontgomeryDivisorData divisor = MontgomeryDivisorData.FromModulus(4_000_169UL);
+        ulong cycle = MersenneDivisorCycles.CalculateCycleLength(4_000_169UL, divisor);
+        session.CheckDivisor(4_000_169UL, divisor, cycle, exponents, hits);
 
-        hits.Should().ContainInOrder(new byte[] { 0, 1, 0, 0, 0 });
+        byte[] expected = new byte[exponents.Length];
+        for (int i = 0; i < exponents.Length; i++)
+        {
+            expected[i] = exponents[i].Pow2ModWindowedCpu(divisor.Modulus) == 1UL ? (byte)1 : (byte)0;
+        }
+
+        hits.Should().Equal(expected);
+
+        session.Dispose();
     }
 }
 

PerfectNumbers.Core.Tests/PerfectNumbers.Core.Tests.csproj

@@ -22,4 +22,7 @@
   <ItemGroup>
     <ProjectReference Include="../PerfectNumbers.Core/PerfectNumbers.Core.csproj" />
   </ItemGroup>
+  <ItemGroup>
+    <Compile Remove=".temp.cs" />
+  </ItemGroup>
 </Project>

PerfectNumbers.Core.Tests/PrimeOrderCalculatorTests.cs

@@ -1,3 +1,5 @@
+using System.Collections.Generic;
+using System.Numerics;
 using FluentAssertions;
 using Xunit;
 
@@ -5,6 +7,9 @@ namespace PerfectNumbers.Core.Tests;
 
 public class PrimeOrderCalculatorTests
 {
+    // EvenPerfectBitScanner never exercises the GPU heuristic device or the small-prime guards that the legacy tests cover,
+    // so those scenarios are commented out because they are unreachable in the production pipeline.
+    /*
     public static IEnumerable<object[]> SmallPrimes()
     {
         yield return new object[] { 3UL };
@@ -195,4 +200,5 @@ public class PrimeOrderCalculatorTests
 
         return order;
     }
+*/
 }

PerfectNumbers.Core.Tests/ULongExtensionsMultiplyShiftTests.cs

@@ -1,5 +1,6 @@
 using System.Numerics;
 using FluentAssertions;
+using PerfectNumbers.Core;
 using Xunit;
 
 namespace PerfectNumbers.Core.Tests;

PerfectNumbers.Core/ByDivisorDeltasDevice.cs

@@ -0,0 +1,7 @@
+namespace PerfectNumbers.Core;
+
+public enum ByDivisorDeltasDevice
+{
+    Cpu,
+    Gpu
+}

PerfectNumbers.Core/ByDivisorMontgomeryDevice.cs

@@ -0,0 +1,7 @@
+namespace PerfectNumbers.Core;
+
+public enum ByDivisorMontgomeryDevice
+{
+    Cpu = 0,
+    Gpu = 1,
+}

PerfectNumbers.Core/Cpu/FactorCacheLease.cs

@@ -1,30 +0,0 @@
-namespace PerfectNumbers.Core.Cpu;
-
-internal struct FactorCacheLease
-{
-    private Dictionary<ulong, MersenneDivisorCycles.FactorCacheEntry>? _cache;
-
-    public void EnsureInitialized(ref Dictionary<ulong, MersenneDivisorCycles.FactorCacheEntry>? cache)
-    {
-        Dictionary<ulong, MersenneDivisorCycles.FactorCacheEntry>? current = cache;
-        if (current is null)
-        {
-            current = ThreadStaticPools.RentMersenneFactorCacheDictionary();
-            cache = current;
-        }
-
-        _cache = current;
-    }
-
-    public void Dispose()
-    {
-        Dictionary<ulong, MersenneDivisorCycles.FactorCacheEntry>? cache = _cache;
-        if (cache is null)
-        {
-            return;
-        }
-
-        ThreadStaticPools.ReturnMersenneFactorCacheDictionary(cache);
-        _cache = null;
-    }
-}

PerfectNumbers.Core/Cpu/MersenneCpuDivisorScanSession.cs

@@ -1,82 +0,0 @@
-namespace PerfectNumbers.Core.Cpu;
-
-internal sealed class MersenneCpuDivisorScanSession : IMersenneNumberDivisorByDivisorTester.IDivisorScanSession
-{
-    private bool _disposed;
-
-    public void Reset()
-    {
-        _disposed = false;
-    }
-
-    public void CheckDivisor(
-        ulong divisor,
-        in MontgomeryDivisorData divisorData,
-        ulong divisorCycle,
-        in ReadOnlySpan<ulong> primes,
-        Span<byte> hits)
-    {
-        int length = primes.Length;
-        // EvenPerfectBitScanner always provides at least one exponent on this path.
-        // Keep the guard commented out for tests that might reuse the session differently.
-        // if (length == 0)
-        // {
-        //     return;
-        // }
-
-        MontgomeryDivisorData cachedData = divisorData;
-        if (cachedData.Modulus != divisor)
-        {
-            cachedData = MontgomeryDivisorDataCache.Get(divisor);
-        }
-
-        if (divisorCycle == 0UL)
-        {
-            divisorCycle = DivisorCycleCache.Shared.GetCycleLength(divisor);
-            if (divisorCycle == 0UL)
-            {
-                hits.Clear();
-                return;
-            }
-        }
-
-        // Keep these remainder steppers in place so future updates continue reusing the previously computed residues.
-        // They are critical for avoiding repeated full Montgomery exponentiation work when scanning divisors.
-        var exponentStepper = new ExponentRemainderStepper(cachedData);
-        if (!exponentStepper.IsValidModulus)
-        {
-            hits.Clear();
-            return;
-        }
-
-        var cycleStepper = new CycleRemainderStepper(divisorCycle);
-
-        ulong remainder = cycleStepper.Initialize(primes[0]);
-        hits[0] = remainder == 0UL
-            ? (exponentStepper.ComputeNextIsUnity(primes[0]) ? (byte)1 : (byte)0)
-            : (byte)0;
-
-        for (int i = 1; i < length; i++)
-        {
-            remainder = cycleStepper.ComputeNext(primes[i]);
-            if (remainder != 0UL)
-            {
-                hits[i] = 0;
-                continue;
-            }
-
-            hits[i] = exponentStepper.ComputeNextIsUnity(primes[i]) ? (byte)1 : (byte)0;
-        }
-    }
-
-    public void Dispose()
-    {
-        if (_disposed)
-        {
-            throw new ObjectDisposedException(nameof(MersenneCpuDivisorScanSession), "Divisor scan session disposed twice.");
-        }
-
-        _disposed = true;
-        ThreadStaticPools.ReturnMersenneCpuDivisorSession(this);
-    }
-}

PerfectNumbers.Core/CycleRemainderStepper.cs

@@ -1,8 +1,9 @@
-using System.Runtime.CompilerServices;
+using System;
+using System.Numerics;
 
 namespace PerfectNumbers.Core;
 
-public struct CycleRemainderStepper
+internal struct CycleRemainderStepper
 {
     private readonly ulong _cycleLength;
     private ulong _previousPrime;
@@ -22,16 +23,15 @@ public struct CycleRemainderStepper
         _hasState = false;
     }
 
-	[MethodImpl(MethodImplOptions.AggressiveInlining)]
-	public void Reset()
-	{
-		// TODO: Inline this reset at the call sites so the hot loops reuse struct reinitialization
-		// measured fastest in MersenneDivisorCycleLengthGpuBenchmarks, avoiding the extra
-		// method call when scanners need to restart stepping.
-		_previousPrime = 0UL;
-		_currentRemainder = 0UL;
-		_hasState = false;
-	}
+    public void Reset()
+    {
+        // TODO: Inline this reset at the call sites so the hot loops reuse struct reinitialization
+        // measured fastest in MersenneDivisorCycleLengthGpuBenchmarks, avoiding the extra
+        // method call when scanners need to restart stepping.
+        _previousPrime = 0UL;
+        _currentRemainder = 0UL;
+        _hasState = false;
+    }
 
     public ulong Initialize(ulong prime)
     {

PerfectNumbers.Core/DeterministicRandom.cs

@@ -1,3 +1,6 @@
+using System;
+using System.Threading;
+
 namespace PerfectNumbers.Core;
 
 internal static class DeterministicRandom

PerfectNumbers.Core/DivisorCycleCache.cs

@@ -1,7 +1,10 @@
+using System;
 using System.Buffers;
 using System.Collections.Concurrent;
+using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using System.Threading;
 using ILGPU;
 using ILGPU.Runtime;
 using PerfectNumbers.Core.Gpu;
@@ -60,7 +63,9 @@ public sealed class DivisorCycleCache
         int[]? rentedMissing = null;
         Span<int> missingBuffer = length <= StackBufferThreshold
             ? stackalloc int[length]
-            : new Span<int>(rentedMissing = ArrayPool<int>.Shared.Rent(length), 0, length);
+            : length < PerfectNumberConstants.PooledArrayThreshold
+                ? new Span<int>(new int[length])
+                : new Span<int>(rentedMissing = ThreadLocalArrayPool<int>.Shared.Rent(length), 0, length);
 
         int missingCount = 0;
 
@@ -81,11 +86,10 @@ public sealed class DivisorCycleCache
                 }
 
                 cycles[i] = cached;
+                continue;
             }
-            else
-            {
-                missingBuffer[missingCount++] = i;
-            }
+
+            missingBuffer[missingCount++] = i;
         }
 
         if (missingCount != 0)
@@ -99,11 +103,12 @@ public sealed class DivisorCycleCache
             {
                 ComputeCyclesCpu(divisors, cycles, missingIndices);
             }
+
         }
 
         if (rentedMissing is not null)
         {
-            ArrayPool<int>.Shared.Return(rentedMissing, clearArray: false);
+            ThreadLocalArrayPool<int>.Shared.Return(rentedMissing, clearArray: false);
         }
     }
 
@@ -125,12 +130,16 @@ public sealed class DivisorCycleCache
         ulong[]? rentedDivisors = null;
         Span<ulong> workDivisors = count <= StackBufferThreshold
             ? stackalloc ulong[count]
-            : new Span<ulong>(rentedDivisors = ArrayPool<ulong>.Shared.Rent(count), 0, count);
+            : count < PerfectNumberConstants.PooledArrayThreshold
+                ? new Span<ulong>(new ulong[count])
+                : new Span<ulong>(rentedDivisors = ThreadLocalArrayPool<ulong>.Shared.Rent(count), 0, count);
 
         ulong[]? rentedResults = null;
         Span<ulong> workResults = count <= StackBufferThreshold
             ? stackalloc ulong[count]
-            : new Span<ulong>(rentedResults = ArrayPool<ulong>.Shared.Rent(count), 0, count);
+            : count < PerfectNumberConstants.PooledArrayThreshold
+                ? new Span<ulong>(new ulong[count])
+                : new Span<ulong>(rentedResults = ThreadLocalArrayPool<ulong>.Shared.Rent(count), 0, count);
 
         for (int i = 0; i < count; i++)
         {
@@ -146,8 +155,12 @@ public sealed class DivisorCycleCache
 
         if (rentedDivisors is not null)
         {
-            ArrayPool<ulong>.Shared.Return(rentedDivisors, clearArray: false);
-            ArrayPool<ulong>.Shared.Return(rentedResults!, clearArray: false);
+            ThreadLocalArrayPool<ulong>.Shared.Return(rentedDivisors, clearArray: false);
+        }
+
+        if (rentedResults is not null)
+        {
+            ThreadLocalArrayPool<ulong>.Shared.Return(rentedResults, clearArray: false);
         }
     }
 
@@ -169,22 +182,30 @@ public sealed class DivisorCycleCache
         ulong[]? rentedPow = null;
         Span<ulong> powSpan = length <= StackBufferThreshold
             ? stackalloc ulong[length]
-            : new Span<ulong>(rentedPow = ArrayPool<ulong>.Shared.Rent(length), 0, length);
+            : length < PerfectNumberConstants.PooledArrayThreshold
+                ? new Span<ulong>(new ulong[length])
+                : new Span<ulong>(rentedPow = ThreadLocalArrayPool<ulong>.Shared.Rent(length), 0, length);
 
         ulong[]? rentedOrder = null;
         Span<ulong> orderSpan = length <= StackBufferThreshold
             ? stackalloc ulong[length]
-            : new Span<ulong>(rentedOrder = ArrayPool<ulong>.Shared.Rent(length), 0, length);
+            : length < PerfectNumberConstants.PooledArrayThreshold
+                ? new Span<ulong>(new ulong[length])
+                : new Span<ulong>(rentedOrder = ThreadLocalArrayPool<ulong>.Shared.Rent(length), 0, length);
 
         ulong[]? rentedResult = null;
         Span<ulong> resultSpan = length <= StackBufferThreshold
             ? stackalloc ulong[length]
-            : new Span<ulong>(rentedResult = ArrayPool<ulong>.Shared.Rent(length), 0, length);
+            : length < PerfectNumberConstants.PooledArrayThreshold
+                ? new Span<ulong>(new ulong[length])
+                : new Span<ulong>(rentedResult = ThreadLocalArrayPool<ulong>.Shared.Rent(length), 0, length);
 
         byte[]? rentedStatus = null;
         Span<byte> statusSpan = length <= StackBufferThreshold
             ? stackalloc byte[length]
-            : new Span<byte>(rentedStatus = ArrayPool<byte>.Shared.Rent(length), 0, length);
+            : length < PerfectNumberConstants.PooledArrayThreshold
+                ? new Span<byte>(new byte[length])
+                : new Span<byte>(rentedStatus = ThreadLocalArrayPool<byte>.Shared.Rent(length), 0, length);
 
         ref ulong divisorRef = ref MemoryMarshal.GetReference(divisors);
         divisorBuffer.View.CopyFromCPU(ref divisorRef, length);
@@ -231,10 +252,22 @@ public sealed class DivisorCycleCache
         resultSpan.CopyTo(destination);
         if (rentedPow is not null)
         {
-            ArrayPool<ulong>.Shared.Return(rentedPow, clearArray: false);
-            ArrayPool<ulong>.Shared.Return(rentedOrder!, clearArray: false);
-            ArrayPool<ulong>.Shared.Return(rentedResult!, clearArray: false);
-            ArrayPool<byte>.Shared.Return(rentedStatus!, clearArray: false);
+            ThreadLocalArrayPool<ulong>.Shared.Return(rentedPow, clearArray: false);
+        }
+
+        if (rentedOrder is not null)
+        {
+            ThreadLocalArrayPool<ulong>.Shared.Return(rentedOrder, clearArray: false);
+        }
+
+        if (rentedResult is not null)
+        {
+            ThreadLocalArrayPool<ulong>.Shared.Return(rentedResult, clearArray: false);
+        }
+
+        if (rentedStatus is not null)
+        {
+            ThreadLocalArrayPool<byte>.Shared.Return(rentedStatus, clearArray: false);
         }
 
         execution.Dispose();

PerfectNumbers.Core/FactorEntry.cs

@@ -1,8 +1,19 @@
 namespace PerfectNumbers.Core
 {
-    public readonly struct FactorEntry(ulong value, int exponent)
-    {
-        public readonly ulong Value = value;
-        public readonly int Exponent = exponent;
-    }
+    public readonly struct FactorEntry
+	{
+		public readonly ulong Value;
+		public readonly int Exponent = 1;
+
+		public FactorEntry(ulong value, int exponent)
+		{
+			Value = value;
+			Exponent = exponent;
+		}
+
+		public FactorEntry(ulong value)
+		{
+			Value = value;
+		}
+	}
 }

PerfectNumbers.Core/FactorEntry128.cs

@@ -1,8 +0,0 @@
-namespace PerfectNumbers.Core;
-
-public readonly struct FactorEntry128(in UInt128 value, int exponent)
-{
-	public readonly UInt128 Value = value;
-
-	public readonly int Exponent = exponent;
-}

PerfectNumbers.Core/Gpu/GpuContextPool.cs

@@ -6,156 +6,159 @@ namespace PerfectNumbers.Core.Gpu;
 
 public static class GpuContextPool
 {
-        private static readonly bool PoolingEnabled = true;
-        // TODO: Introduce accelerator-specific warmup so pooled contexts precompile the ProcessEightBitWindows kernels and load
-        // divisor-cycle data before the first scan begins.
-        // Default device preference for generic GPU kernels (prime scans, NTT, etc.)
-        public static bool ForceCpu { get; set; } = false;
+    private static readonly bool PoolingEnabled = true;
+    // TODO: Introduce accelerator-specific warmup so pooled contexts precompile the ProcessEightBitWindows kernels and load
+    // divisor-cycle data before the first scan begins.
+    // Default device preference for generic GPU kernels (prime scans, NTT, etc.)
+    public static bool ForceCpu { get; set; } = false;
 
-        internal sealed class PooledContext
+    internal sealed class PooledContext
+    {
+        private bool disposed;
+
+        public Context Context { get; }
+        public Accelerator Accelerator { get; }
+        public bool IsCpu { get; }
+        public object ExecutionLock { get; } = new();
+
+        public PooledContext(bool preferCpu)
         {
-                private bool disposed;
-
-                public Context Context { get; }
-                public Accelerator Accelerator { get; }
-                public bool IsCpu { get; }
-                public object ExecutionLock { get; } = new();
-
-		public PooledContext(bool preferCpu)
-		{
-			Context = Context.CreateDefault();
-			Accelerator = Context.GetPreferredDevice(preferCpu).CreateAccelerator(Context);
-			IsCpu = Accelerator.AcceleratorType == AcceleratorType.CPU;
-			// NOTE: Avoid loading/compiling any kernel here to prevent implicit
-			// CL stream/queue creation during accelerator construction.
-			// Some OpenCL drivers are fragile when a queue is created immediately
-			// after device init. Real kernels will be JIT-loaded at first use.
-		}
-
-		public void Dispose()
-		{
-			if (disposed)
-			{
-				return;
-			}
-
-			// Ensure all cached GPU buffers for this accelerator are released.
-			NttGpuMath.ClearCaches(Accelerator);
-			// Release PrimeTester GPU state for this accelerator (kernel/device primes)
-			// Clear any per-accelerator cached resources to avoid releasing
-			// after the accelerator is destroyed.
-			PrimeTester.ClearGpuCaches(Accelerator);
-
-			Accelerator.Dispose();
-			Context.Dispose();
-			disposed = true;
-		}
-	}
-
-	private static readonly ConcurrentQueue<PooledContext> CpuPool = new();
-	private static readonly ConcurrentQueue<PooledContext> GpuPool = new();
-	private static readonly object CreationLock = new();
-
-	public static GpuContextLease Rent()
-	{
-		return RentPreferred(ForceCpu);
-	}
-
-	// Allows callers to choose CPU/GPU per use-case, decoupled from ForceCpu.
-	public static GpuContextLease RentPreferred(bool preferCpu)
-	{
-		if (PoolingEnabled)
-		{
-			if (preferCpu && CpuPool.TryDequeue(out var cpu))
-			{
-				return new GpuContextLease(cpu, CreationLock);
-			}
-
-			if (!preferCpu && GpuPool.TryDequeue(out var gpu))
-			{
-				return new GpuContextLease(gpu, CreationLock);
-			}
-		}
-
-		// Serialize accelerator creation to avoid concurrent CL device/stream setup across threads.
-		lock (CreationLock)
-		{
-			return new GpuContextLease(new PooledContext(preferCpu), CreationLock);
-		}
-	}
-
-	public static void DisposeAll()
-	{
-		if (!PoolingEnabled)
-		{
-			return;
-		}
-
-		while (CpuPool.TryDequeue(out var cpu))
-		{
-			cpu.Dispose();
-		}
-
-		while (GpuPool.TryDequeue(out var gpu))
-		{
-			gpu.Dispose();
-		}
-	}
-
-	private static void Return(PooledContext ctx)
-	{
-		if (PoolingEnabled)
-		{
-			ctx.Accelerator.Synchronize();
-			if (ctx.IsCpu)
-			{
-				CpuPool.Enqueue(ctx);
-			}
-			else
-			{
-				GpuPool.Enqueue(ctx);
-			}
-		}
-
-                else
-                {
-                        lock (CreationLock)
-                        {
-                                ctx.Dispose();
-                        }
-                }
+            Context = Context.CreateDefault();
+            Accelerator = Context.GetPreferredDevice(preferCpu).CreateAccelerator(Context);
+            IsCpu = Accelerator.AcceleratorType == AcceleratorType.CPU;
+            // NOTE: Avoid loading/compiling any kernel here to prevent implicit
+            // CL stream/queue creation during accelerator construction.
+            // Some OpenCL drivers are fragile when a queue is created immediately
+            // after device init. Real kernels will be JIT-loaded at first use.
         }
 
+        public void Dispose()
+        {
+            if (disposed)
+            {
+                return;
+            }
+
+            // Ensure all cached GPU buffers for this accelerator are released.
+            NttGpuMath.ClearCaches(Accelerator);
+            // Release PrimeTester GPU state for this accelerator (kernel/device primes)
+            // Clear any per-accelerator cached resources to avoid releasing
+            // after the accelerator is destroyed.
+            PrimeTester.ClearGpuCaches(Accelerator);
+
+            Accelerator.Dispose();
+            Context.Dispose();
+            disposed = true;
+        }
+    }
+
+    private static readonly ConcurrentQueue<PooledContext> CpuPool = new();
+    private static readonly ConcurrentQueue<PooledContext> GpuPool = new();
+    private static readonly object CreationLock = new();
+
+    public static GpuContextLease Rent()
+    {
+        return RentPreferred(ForceCpu);
+    }
+
+    // Allows callers to choose CPU/GPU per use-case, decoupled from ForceCpu.
+    public static GpuContextLease RentPreferred(bool preferCpu)
+    {
+        if (PoolingEnabled)
+        {
+            if (preferCpu && CpuPool.TryDequeue(out var cpu))
+            {
+                return new GpuContextLease(cpu, CreationLock);
+            }
+
+            if (!preferCpu && GpuPool.TryDequeue(out var gpu))
+            {
+                return new GpuContextLease(gpu, CreationLock);
+            }
+        }
+
+        // Serialize accelerator creation to avoid concurrent CL device/stream setup across threads.
+        lock (CreationLock)
+        {
+            return new GpuContextLease(new PooledContext(preferCpu), CreationLock);
+        }
+    }
+
+    public static void DisposeAll()
+    {
+        if (!PoolingEnabled)
+        {
+            return;
+        }
+
+        while (CpuPool.TryDequeue(out var cpu))
+        {
+            cpu.Dispose();
+        }
+
+        while (GpuPool.TryDequeue(out var gpu))
+        {
+            gpu.Dispose();
+        }
+    }
+
+    private static void Return(PooledContext ctx)
+    {
+        if (PoolingEnabled)
+        {
+            ctx.Accelerator.Synchronize();
+            if (ctx.IsCpu)
+            {
+                CpuPool.Enqueue(ctx);
+            }
+            else
+            {
+                GpuPool.Enqueue(ctx);
+            }
+        }
+
+        else
+        {
+            lock (CreationLock)
+            {
+                ctx.Dispose();
+            }
+        }
+    }
+
     public struct GpuContextLease
     {
         private readonly PooledContext _ctx;
-                private bool disposed;
+        private bool disposed;
 
-                internal GpuContextLease(PooledContext ctx, object kernelInitLock)
+        internal GpuContextLease(PooledContext ctx, object kernelInitLock)
         {
             _ctx = ctx;
-                        KernelInitLock = kernelInitLock;
-                }
+            KernelInitLock = kernelInitLock;
+        }
 
         public Context Context => _ctx.Context;
 
         public Accelerator Accelerator => _ctx.Accelerator;
 
-                public object KernelInitLock { get; }
+        public object KernelInitLock { get; }
 
-                public object ExecutionLock => _ctx.ExecutionLock;
+        public object ExecutionLock => _ctx.ExecutionLock;
 
+        internal void ReturnToPool()
+        {
+            if (disposed)
+            {
+                return;
+            }
 
-                public void Dispose()
-                {
-                        if (disposed)
-			{
-				return;
-			}
+            Return(_ctx);
+            disposed = true;
+        }
 
-			Return(_ctx);
-			disposed = true;
+        public void Dispose()
+        {
+            ReturnToPool();
         }
     }
 }
-

PerfectNumbers.Core/Gpu/GpuKernelPool.cs

@@ -37,6 +37,7 @@ public sealed class KernelContainer
             ResidueAutomatonArgs, ArrayView<int>, ArrayView1D<ulong, Stride1D.Dense>>? IncrementalOrder;
     public Action<AcceleratorStream, Index1D, ulong, GpuUInt128, GpuUInt128, byte, ulong,
         ResidueAutomatonArgs, ArrayView<int>, ArrayView1D<ulong, Stride1D.Dense>>? Pow2ModOrder;
+    public Action<AcceleratorStream, Index1D, ArrayView1D<MontgomeryDivisorData, Stride1D.Dense>, ArrayView1D<int, Stride1D.Dense>, ArrayView1D<ulong, Stride1D.Dense>, int>? MontgomeryOddPowers;
 
     // Optional device buffer with small divisor cycles (<= 4M). Index = divisor, value = cycle length.
     public MemoryBuffer1D<ulong, Stride1D.Dense>? SmallCycles;
@@ -75,10 +76,10 @@ public readonly struct ResiduePrimeViews(
     public readonly ArrayView1D<ulong, Stride1D.Dense> LastSevenPow2 = lastSevenPow2;
 }
 
-public ref struct GpuKernelLease(IDisposable limiter, GpuContextLease gpu, KernelContainer kernels)
+public ref struct GpuKernelLease(GpuPrimeWorkLimiter.Lease limiter, GpuContextLease gpu, KernelContainer kernels)
 {
     private bool disposedValue;
-    private IDisposable? _limiter = limiter;
+    private GpuPrimeWorkLimiter.Lease? _limiter = limiter;
     private GpuContextLease? _gpu = gpu;
     private KernelContainer _kernels = kernels;
     private AcceleratorStream? _stream;
@@ -109,15 +110,15 @@ public ref struct GpuKernelLease(IDisposable limiter, GpuContextLease gpu, Kerne
         get
         {
             var accel = Accelerator; // avoid capturing 'this' in lambda
-            lock (_gpu!.Value.KernelInitLock)
-            {
+            // lock (_gpu!.Value.KernelInitLock)
+            // {
                 return KernelContainer.InitOnce(ref _kernels.Order, () =>
                 {
                     var loaded = accel.LoadAutoGroupedStreamKernel<Index1D, ulong, ulong, ArrayView<GpuUInt128>, ArrayView<ulong>>(OrderKernelScan);
                     var kernel = KernelUtil.GetKernel(loaded);
                     return kernel.CreateLauncherDelegate<Action<AcceleratorStream, Index1D, ulong, ulong, ArrayView<GpuUInt128>, ArrayView<ulong>>>();
                 });
-            }
+            // }
         }
     }
 
@@ -126,15 +127,15 @@ public ref struct GpuKernelLease(IDisposable limiter, GpuContextLease gpu, Kerne
         get
         {
             var accel = Accelerator;
-            lock (_gpu!.Value.KernelInitLock)
-            {
+            // lock (_gpu!.Value.KernelInitLock)
+            // {
                 return KernelContainer.InitOnce(ref _kernels.Pow2Mod, () =>
                 {
                     var loaded = accel.LoadAutoGroupedStreamKernel<Index1D, ulong, GpuUInt128, GpuUInt128, byte, ulong, ResidueAutomatonArgs, ArrayView<ulong>, ArrayView1D<ulong, Stride1D.Dense>, ArrayView1D<uint, Stride1D.Dense>, ArrayView1D<uint, Stride1D.Dense>, ArrayView1D<ulong, Stride1D.Dense>, ArrayView1D<ulong, Stride1D.Dense>>(Pow2ModKernelScan);
                     var kernel = KernelUtil.GetKernel(loaded);
                     return kernel.CreateLauncherDelegate<Action<AcceleratorStream, Index1D, ulong, GpuUInt128, GpuUInt128, byte, ulong, ResidueAutomatonArgs, ArrayView<ulong>, ArrayView1D<ulong, Stride1D.Dense>, ArrayView1D<uint, Stride1D.Dense>, ArrayView1D<uint, Stride1D.Dense>, ArrayView1D<ulong, Stride1D.Dense>, ArrayView1D<ulong, Stride1D.Dense>>>();
                 });
-            }
+            // }
         }
     }
 
@@ -143,15 +144,15 @@ public ref struct GpuKernelLease(IDisposable limiter, GpuContextLease gpu, Kerne
         get
         {
             var accel = Accelerator;
-            lock (_gpu!.Value.KernelInitLock)
-            {
+            // lock (_gpu!.Value.KernelInitLock)
+            // {
                 return KernelContainer.InitOnce(ref _kernels.Incremental, () =>
                 {
                     var loaded = accel.LoadAutoGroupedStreamKernel<Index1D, ulong, GpuUInt128, GpuUInt128, byte, ulong, ulong, ulong, ulong, ulong, ArrayView<ulong>, ArrayView1D<ulong, Stride1D.Dense>>(IncrementalKernelScan);
                     var kernel = KernelUtil.GetKernel(loaded);
                     return kernel.CreateLauncherDelegate<Action<AcceleratorStream, Index1D, ulong, GpuUInt128, GpuUInt128, byte, ulong, ulong, ulong, ulong, ulong, ArrayView<ulong>, ArrayView1D<ulong, Stride1D.Dense>>>();
                 });
-            }
+            // }
         }
     }
 
@@ -160,15 +161,15 @@ public ref struct GpuKernelLease(IDisposable limiter, GpuContextLease gpu, Kerne
         get
         {
             var accel = Accelerator;
-            lock (_gpu!.Value.KernelInitLock)
-            {
+            // lock (_gpu!.Value.KernelInitLock)
+            // {
                 return KernelContainer.InitOnce(ref _kernels.IncrementalOrder, () =>
                 {
                     var loaded = accel.LoadAutoGroupedStreamKernel<Index1D, ulong, GpuUInt128, GpuUInt128, byte, ulong, ResidueAutomatonArgs, ArrayView<int>, ArrayView1D<ulong, Stride1D.Dense>>(IncrementalOrderKernelScan);
                     var kernel = KernelUtil.GetKernel(loaded);
                     return kernel.CreateLauncherDelegate<Action<AcceleratorStream, Index1D, ulong, GpuUInt128, GpuUInt128, byte, ulong, ResidueAutomatonArgs, ArrayView<int>, ArrayView1D<ulong, Stride1D.Dense>>>();
                 });
-            }
+            // }
         }
     }
 
@@ -177,15 +178,66 @@ public ref struct GpuKernelLease(IDisposable limiter, GpuContextLease gpu, Kerne
         get
         {
             var accel = Accelerator;
-            lock (_gpu!.Value.KernelInitLock)
-            {
+            // lock (_gpu!.Value.KernelInitLock)
+            // {
                 return KernelContainer.InitOnce(ref _kernels.Pow2ModOrder, () =>
                 {
                     var loaded = accel.LoadAutoGroupedStreamKernel<Index1D, ulong, GpuUInt128, GpuUInt128, byte, ulong, ResidueAutomatonArgs, ArrayView<int>, ArrayView1D<ulong, Stride1D.Dense>>(Pow2ModOrderKernelScan);
                     var kernel = KernelUtil.GetKernel(loaded);
                     return kernel.CreateLauncherDelegate<Action<AcceleratorStream, Index1D, ulong, GpuUInt128, GpuUInt128, byte, ulong, ResidueAutomatonArgs, ArrayView<int>, ArrayView1D<ulong, Stride1D.Dense>>>();
                 });
-            }
+            // }
+        }
+    }
+
+    public readonly Action<AcceleratorStream, Index1D, ArrayView1D<MontgomeryDivisorData, Stride1D.Dense>, ArrayView1D<int, Stride1D.Dense>, ArrayView1D<ulong, Stride1D.Dense>, int> MontgomeryOddPowerKernel
+    {
+        get
+        {
+            var accel = Accelerator;
+            // lock (_gpu!.Value.KernelInitLock)
+            // {
+                return KernelContainer.InitOnce(ref _kernels.MontgomeryOddPowers, () =>
+                {
+                    var loaded = accel.LoadAutoGroupedStreamKernel<Index1D, ArrayView1D<MontgomeryDivisorData, Stride1D.Dense>, ArrayView1D<int, Stride1D.Dense>, ArrayView1D<ulong, Stride1D.Dense>, int>(MontgomeryOddPowerKernelScan);
+                    var kernel = KernelUtil.GetKernel(loaded);
+                    return kernel.CreateLauncherDelegate<Action<AcceleratorStream, Index1D, ArrayView1D<MontgomeryDivisorData, Stride1D.Dense>, ArrayView1D<int, Stride1D.Dense>, ArrayView1D<ulong, Stride1D.Dense>, int>>();
+                });
+            // }
+        }
+    }
+
+    private static void MontgomeryOddPowerKernelScan(
+        Index1D index,
+        ArrayView1D<MontgomeryDivisorData, Stride1D.Dense> divisors,
+        ArrayView1D<int, Stride1D.Dense> counts,
+        ArrayView1D<ulong, Stride1D.Dense> results,
+        int stride)
+    {
+        int tableIndex = index.X;
+        int baseOffset = tableIndex * stride;
+        MontgomeryDivisorData divisor = divisors[tableIndex];
+        int oddPowerCount = counts[tableIndex];
+        if (oddPowerCount <= 0)
+        {
+            return;
+        }
+
+        ulong montgomeryTwo = divisor.MontgomeryTwo;
+        results[baseOffset] = montgomeryTwo;
+        if (oddPowerCount == 1)
+        {
+            return;
+        }
+
+        ulong modulus = divisor.Modulus;
+        ulong nPrime = divisor.NPrime;
+        ulong square = divisor.MontgomeryTwoSquared;
+        ulong current = montgomeryTwo;
+        for (int i = 1; i < oddPowerCount; i++)
+        {
+            current = ULongExtensions.MontgomeryMultiply(current, square, modulus, nPrime);
+            results[baseOffset + i] = current;
         }
     }
 
@@ -344,7 +396,10 @@ public ref struct GpuKernelLease(IDisposable limiter, GpuContextLease gpu, Kerne
                 _stream?.Dispose();
                 _stream = null;
 
-                _gpu?.Dispose();
+                if (_gpu.HasValue)
+                {
+                    _gpu.Value.ReturnToPool();
+                }
                 _gpu = null;
 
                 _executionLock = null;
@@ -684,18 +739,18 @@ public ref struct GpuKernelLease(IDisposable limiter, GpuContextLease gpu, Kerne
         public ExecutionScope(object? sync)
         {
             _lock = sync;
-            if (_lock is not null)
-            {
-                Monitor.Enter(_lock);
-            }
+            // if (_lock is not null)
+            // {
+            //     Monitor.Enter(_lock);
+            // }
         }
 
         public void Dispose()
         {
-            if (_lock is not null)
-            {
-                Monitor.Exit(_lock);
-            }
+            // if (_lock is not null)
+            // {
+            //     Monitor.Exit(_lock);
+            // }
         }
     }
 }
@@ -704,6 +759,8 @@ public class GpuKernelPool
 {
     private static readonly ConcurrentDictionary<Accelerator, KernelContainer> KernelCache = new(); // TODO: Replace this concurrent map with a simple accelerator-indexed lookup once kernel launchers are prewarmed during startup so we can drop the thread-safe wrapper entirely.
 
+    public static bool CpuCycleUsesGpu { get; set; }
+
     private static KernelContainer GetKernels(Accelerator accelerator)
     {
         return KernelCache.GetOrAdd(accelerator, _ => new KernelContainer());
@@ -720,8 +777,8 @@ public class GpuKernelPool
         }
 
         // Ensure single upload per accelerator even if multiple threads race here.
-        lock (kernels) // TODO: Remove this lock by pre-uploading the immutable small-cycle snapshot during initialization; once no mutation happens at runtime, the pool must expose a simple reference without synchronization.
-        {
+        // lock (kernels) // TODO: Remove this lock by pre-uploading the immutable small-cycle snapshot during initialization; once no mutation happens at runtime, the pool must expose a simple reference without synchronization.
+        // {
             if (kernels.SmallCycles is { } existing)
             {
                 return existing.View;
@@ -732,7 +789,7 @@ public class GpuKernelPool
             device.View.CopyFromCPU(host);
             kernels.SmallCycles = device;
             return device.View;
-        }
+        // }
     }
 
     public static ResiduePrimeViews EnsureSmallPrimesOnDevice(Accelerator accelerator)
@@ -746,8 +803,8 @@ public class GpuKernelPool
             return new ResiduePrimeViews(lastOne.View, lastSeven.View, lastOnePow2.View, lastSevenPow2.View);
         }
 
-        lock (kernels) // TODO: Inline these small-prime uploads into startup initialization alongside the small-cycle snapshot so we can drop runtime locking and keep the GPU pool free of synchronization.
-        {
+        // lock (kernels) // TODO: Inline these small-prime uploads into startup initialization alongside the small-cycle snapshot so we can drop runtime locking and keep the GPU pool free of synchronization.
+        // {
             if (kernels.SmallPrimesLastOne is { } existingLastOne &&
                 kernels.SmallPrimesLastSeven is { } existingLastSeven &&
                 kernels.SmallPrimesPow2LastOne is { } existingLastOnePow2 &&
@@ -776,7 +833,7 @@ public class GpuKernelPool
             kernels.SmallPrimesPow2LastSeven = deviceLastSevenPow2;
 
             return new ResiduePrimeViews(deviceLastOne.View, deviceLastSeven.View, deviceLastOnePow2.View, deviceLastSevenPow2.View);
-        }
+        // }
     }
 
     public static GpuKernelLease GetKernel(bool useGpuOrder)

PerfectNumbers.Core/Gpu/GpuPrimeWorkLimiter.cs

@@ -6,13 +6,13 @@ public static class GpuPrimeWorkLimiter
     private static readonly object _lock = new();
     private static int _currentLimit = 1;
 
-    public static IDisposable Acquire()
+    public static Lease Acquire()
     {
         // TODO: Inline the pooled limiter guard from the GpuLimiterThroughputBenchmarks so prime-sieve
         // GPU jobs stop allocating Releaser instances on every acquisition.
         var sem = _semaphore;
         sem.Wait();
-        return new Releaser(sem);
+        return new Lease(sem);
     }
 
     public static void SetLimit(int value)
@@ -36,12 +36,12 @@ public static class GpuPrimeWorkLimiter
         }
     }
 
-    private sealed class Releaser : IDisposable
+    public sealed class Lease
     {
         private readonly SemaphoreSlim _sem;
         private bool _disposed;
 
-        public Releaser(SemaphoreSlim sem)
+        public Lease(SemaphoreSlim sem)
         {
             _sem = sem;
         }

PerfectNumbers.Core/Gpu/GpuRational.cs

@@ -1,3 +1,5 @@
+using System;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 
 namespace PerfectNumbers.Core.Gpu;

PerfectNumbers.Core/Gpu/GpuUInt128.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using ILGPU.Algorithms;

PerfectNumbers.Core/Gpu/GpuWorkLimiter.cs

@@ -6,14 +6,14 @@ public static class GpuWorkLimiter
     private static readonly object _lock = new();
     private static int _currentLimit = 1;
 
-    public static IDisposable Acquire()
+    public static Lease Acquire()
     {
         // TODO: Replace the per-call Releaser allocation with the pooled struct-based guard from the
         // GpuLimiterThroughputBenchmarks so limiter acquisition does not allocate when we enter the
         // GPU scanning hot path.
         var sem = _semaphore;
         sem.Wait();
-        return new Releaser(sem);
+        return new Lease(sem);
     }
 
     public static void SetLimit(int value)
@@ -40,12 +40,12 @@ public static class GpuWorkLimiter
         }
     }
 
-    private sealed class Releaser : IDisposable
+    public sealed class Lease
     {
         private readonly SemaphoreSlim _sem;
         private bool _disposed;
 
-        public Releaser(SemaphoreSlim sem)
+        public Lease(SemaphoreSlim sem)
         {
             _sem = sem;
         }

PerfectNumbers.Core/Gpu/MersenneNumberDivisorByDivisorGpuTester.cs

@@ -1,9 +1,14 @@
+using System;
 using System.Buffers;
 using System.Collections.Concurrent;
+using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using System.Numerics;
 using ILGPU;
 using ILGPU.Runtime;
+using MontgomeryDivisorData = PerfectNumbers.Core.MontgomeryDivisorData;
+using CycleRemainderStepper = PerfectNumbers.Core.CycleRemainderStepper;
 
 namespace PerfectNumbers.Core.Gpu;
 
@@ -15,7 +20,6 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
     private const int RemainderSlotCount = 4;
 
     private int _gpuBatchSize = GpuConstants.ScanBatchSize;
-    private readonly object _sync = new();
     private ulong _divisorLimit;
     private bool _isConfigured;
 
@@ -31,7 +35,7 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
         _kernelCache.GetOrAdd(accelerator, acc => acc.LoadAutoGroupedStreamKernel<Index1D, ArrayView<MontgomeryDivisorData>, ArrayView<ulong>, ArrayView<byte>>(CheckKernel));
 
     private Action<Index1D, MontgomeryDivisorData, ArrayView<ulong>, ArrayView<ulong>> GetKernelByPrimeExponent(Accelerator accelerator) =>
-        _kernelExponentCache.GetOrAdd(accelerator, acc => acc.LoadAutoGroupedStreamKernel<Index1D, MontgomeryDivisorData, ArrayView<ulong>, ArrayView<ulong>>(ComputeMontgomeryExponentKernel));
+        _kernelExponentCache.GetOrAdd(accelerator, acc => acc.LoadAutoGroupedStreamKernel<Index1D, MontgomeryDivisorData, ArrayView<ulong>, ArrayView<ulong>>(ComputeExponentKernel));
 
     private Action<Index1D, ArrayView<ulong>, ArrayView<byte>, byte> GetRemainderDeltaKernel(Accelerator accelerator) =>
         _remainderDeltaKernelCache.GetOrAdd(accelerator, acc => acc.LoadAutoGroupedStreamKernel<Index1D, ArrayView<ulong>, ArrayView<byte>, byte>(ComputeRemainderDeltasKernel));
@@ -60,34 +64,30 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
 
     public void ConfigureFromMaxPrime(ulong maxPrime)
     {
-        lock (_sync)
-        {
-            _divisorLimit = ComputeDivisorLimitFromMaxPrime(maxPrime);
-            _isConfigured = true;
-        }
+        // Configuration happens once during startup, so no synchronization is required to cache the divisor limit.
+        _divisorLimit = ComputeDivisorLimitFromMaxPrime(maxPrime);
+        _isConfigured = true;
     }
 
-    public bool IsPrime(ulong prime, out bool divisorsExhausted)
+    public bool IsPrime(ulong prime, out bool divisorsExhausted, TimeSpan? timeLimit = null)
     {
-        ulong allowedMax;
-        int batchCapacity;
+        // The CLI always configures the tester during startup, so the historical guard is commented out to avoid branching.
+        // if (!_isConfigured)
+        // {
+        //     throw new InvalidOperationException("ConfigureFromMaxPrime must be called before using the tester.");
+        // }
 
-        lock (_sync)
-        {
-            if (!_isConfigured)
-            {
-                throw new InvalidOperationException("ConfigureFromMaxPrime must be called before using the tester.");
-            }
+        // Configuration is immutable, so the cached values can be read without locking.
+        ulong allowedMax = ComputeAllowedMaxDivisor(prime, _divisorLimit);
+        int batchCapacity = _gpuBatchSize;
 
-            allowedMax = ComputeAllowedMaxDivisor(prime, _divisorLimit);
-            batchCapacity = _gpuBatchSize;
-        }
-
-        if (allowedMax < 3UL)
-        {
-            divisorsExhausted = true;
-            return true;
-        }
+        // The GPU path always receives an allowed maximum well above the minimal divisor, so the legacy
+        // guard stays commented out to document the invariant without branching.
+        // if (allowedMax < 3UL)
+        // {
+        //     divisorsExhausted = true;
+        //     return true;
+        // }
 
         bool composite;
         bool coveredRange;
@@ -104,6 +104,7 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
             composite = CheckDivisors(
             prime,
             allowedMax,
+            timeLimit,
             accelerator,
             kernel,
             resources.DivisorsBuffer,
@@ -122,6 +123,7 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
             resources.CycleCandidates,
             resources.CycleLengths,
             resources.CycleCapacity,
+            resources,
             out lastProcessed,
             out coveredRange,
             out processedCount
@@ -143,25 +145,21 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
         return true;
     }
 
-    public void PrepareCandidates(in ReadOnlySpan<ulong> primes, Span<ulong> allowedMaxValues)
+    public void PrepareCandidates(ReadOnlySpan<ulong> primes, Span<ulong> allowedMaxValues)
     {
         if (allowedMaxValues.Length < primes.Length)
         {
             throw new ArgumentException("allowedMaxValues span must be at least as long as primes span.", nameof(allowedMaxValues));
         }
 
-        ulong divisorLimit;
-
-        lock (_sync)
-        {
-            if (!_isConfigured)
-            {
-                throw new InvalidOperationException("ConfigureFromMaxPrime must be called before using the tester.");
-            }
-
-            divisorLimit = _divisorLimit;
-        }
+        // The GPU pipeline calls ConfigureFromMaxPrime before preparing candidates, so the legacy guard
+        // remains commented out to document the invariant without branching.
+        // if (!_isConfigured)
+        // {
+        //     throw new InvalidOperationException("ConfigureFromMaxPrime must be called before using the tester.");
+        // }
 
+        ulong divisorLimit = _divisorLimit;
         for (int index = 0; index < primes.Length; index++)
         {
             allowedMaxValues[index] = ComputeAllowedMaxDivisor(primes[index], divisorLimit);
@@ -171,6 +169,7 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
     private static bool CheckDivisors(
         ulong prime,
         ulong allowedMax,
+        TimeSpan? timeLimit,
         Accelerator accelerator,
         Action<Index1D, ArrayView<MontgomeryDivisorData>, ArrayView<ulong>, ArrayView<byte>> kernel,
         MemoryBuffer1D<MontgomeryDivisorData, Stride1D.Dense> divisorsBuffer,
@@ -189,6 +188,7 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
         ulong[] cycleCandidates,
         ulong[] cycleLengths,
         int cycleCapacity,
+        BatchResources resources,
         out ulong lastProcessed,
         out bool coveredRange,
         out ulong processedCount)
@@ -198,6 +198,15 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
         bool processedAll = false;
         processedCount = 0UL;
         lastProcessed = 0UL;
+        coveredRange = false;
+
+        PrimeTestTimeLimit limitGuard;
+        if (!PrimeTestTimeLimit.TryCreate(timeLimit, out limitGuard))
+        {
+            return false;
+        }
+
+        bool enforceLimit = limitGuard.IsActive;
 
         Span<MontgomeryDivisorData> divisorDataSpan;
         Span<ulong> divisorSpan;
@@ -207,7 +216,8 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
         ArrayView1D<ulong, Stride1D.Dense> exponentView;
         ArrayView1D<byte, Stride1D.Dense> hitsView;
 
-        cycleCapacity = Math.Max(1, cycleCapacity);
+        // Batch resources expose a positive cycle capacity, so skip the redundant clamp here.
+        // cycleCapacity = Math.Max(1, cycleCapacity);
 
         int chunkCapacity = Math.Min(batchCapacity, cycleCapacity);
         int maxThreadsPerGroup = (int)accelerator.MaxNumThreadsPerGroup;
@@ -216,20 +226,22 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
             chunkCapacity = Math.Min(chunkCapacity, maxThreadsPerGroup);
         }
 
-        if (chunkCapacity <= 0)
-        {
-            chunkCapacity = cycleCapacity;
-        }
+        // cycleCapacity already bounds chunkCapacity above zero, so the fallback would never execute.
+        // if (chunkCapacity <= 0)
+        // {
+        //     chunkCapacity = cycleCapacity;
+        // }
 
         ulong[] filteredDivisors = ArrayPool<ulong>.Shared.Rent(chunkCapacity);
         ulong[] divisorGaps = ArrayPool<ulong>.Shared.Rent(chunkCapacity);
 
         UInt128 twoP128 = (UInt128)prime << 1;
-        if (twoP128 == UInt128.Zero)
-        {
-            coveredRange = true;
-            return false;
-        }
+        // Primes above one yield a non-zero 2p value, so the legacy zero guard remains commented out.
+        // if (twoP128 == UInt128.Zero)
+        // {
+        //     coveredRange = true;
+        //     return false;
+        // }
 
         UInt128 allowedMax128 = allowedMax;
         UInt128 firstDivisor128 = twoP128 + UInt128.One;
@@ -240,11 +252,13 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
         }
 
         UInt128 maxK128 = (allowedMax128 - UInt128.One) / twoP128;
-        if (maxK128 == UInt128.Zero)
-        {
-            coveredRange = true;
-            return false;
-        }
+        // Once the first divisor falls within the allowed range, at least one multiplier k is admissible,
+        // so keep the defensive zero check commented out.
+        // if (maxK128 == UInt128.Zero)
+        // {
+        //     coveredRange = true;
+        //     return false;
+        // }
 
         ulong maxK = maxK128 > ulong.MaxValue ? ulong.MaxValue : (ulong)maxK128;
         ulong currentK = 1UL;
@@ -273,6 +287,12 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
         {
             while (currentK <= maxK)
             {
+                if (enforceLimit && limitGuard.HasExpired())
+                {
+                    processedAll = false;
+                    return false;
+                }
+
                 int chunkCount = Math.Min(chunkCapacity, batchCapacity);
                 ulong remainingK = maxK - currentK + 1UL;
                 if ((ulong)chunkCount > remainingK)
@@ -280,10 +300,12 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
                     chunkCount = (int)remainingK;
                 }
 
-                if (chunkCount <= 0)
-                {
-                    break;
-                }
+                // chunkCapacity and the remaining multiplier range are strictly positive here, so the zero
+                // chunk fallback never triggers on production scans.
+                // if (chunkCount <= 0)
+                // {
+                //     break;
+                // }
 
                 Span<ulong> candidateSpan = cycleCandidates.AsSpan(0, chunkCount);
                 Span<ulong> gapSpan = divisorGaps.AsSpan(0, chunkCount);
@@ -321,10 +343,10 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
 
                 gapView.CopyFromCPU(ref MemoryMarshal.GetReference(gapSpan), chunkCount);
 
-                ComputeRemaindersOnGpu(chunkCount, remainder10, 10, gapView, deltaView, remainder10View, remainderDeltaKernel, remainderScanKernel);
-                ComputeRemaindersOnGpu(chunkCount, remainder8, 8, gapView, deltaView, remainder8View, remainderDeltaKernel, remainderScanKernel);
-                ComputeRemaindersOnGpu(chunkCount, remainder5, 5, gapView, deltaView, remainder5View, remainderDeltaKernel, remainderScanKernel);
-                ComputeRemaindersOnGpu(chunkCount, remainder3, 3, gapView, deltaView, remainder3View, remainderDeltaKernel, remainderScanKernel);
+                ComputeRemaindersOnGpu(chunkCount, remainder10, 10, gapView, deltaView, remainder10View, remainderDeltaKernel, remainderScanKernel, resources.GetRemainderScanConfig);
+                ComputeRemaindersOnGpu(chunkCount, remainder8, 8, gapView, deltaView, remainder8View, remainderDeltaKernel, remainderScanKernel, resources.GetRemainderScanConfig);
+                ComputeRemaindersOnGpu(chunkCount, remainder5, 5, gapView, deltaView, remainder5View, remainderDeltaKernel, remainderScanKernel, resources.GetRemainderScanConfig);
+                ComputeRemaindersOnGpu(chunkCount, remainder3, 3, gapView, deltaView, remainder3View, remainderDeltaKernel, remainderScanKernel, resources.GetRemainderScanConfig);
 
                 BuildCandidateMaskOnGpu(chunkCount, remainder10View, remainder8View, remainder5View, remainder3View, lastIsSevenFlag, maskView, maskSpan, candidateMaskKernel);
 
@@ -391,6 +413,8 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
                     ulong divisorValue = filteredDivisorsSpan[i];
                     divisorSpan[i] = divisorValue;
                     exponentSpan[i] = prime;
+                    // Divisors never repeat while scanning the monotonically increasing sequence, so regenerate
+                    // the Montgomery data for each entry rather than storing cache lines that no future batch would hit.
                     divisorDataSpan[i] = MontgomeryDivisorData.FromModulus(divisorValue);
                 }
 
@@ -440,18 +464,18 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
         ArrayView1D<byte, Stride1D.Dense> deltaView,
         ArrayView1D<byte, Stride1D.Dense> remainderView,
         Action<Index1D, ArrayView<ulong>, ArrayView<byte>, byte> deltaKernel,
-        Action<KernelConfig, Index1D, ArrayView<byte>, ArrayView<byte>, byte, byte> scanKernel)
+        Action<KernelConfig, Index1D, ArrayView<byte>, ArrayView<byte>, byte, byte> scanKernel,
+        Func<int, KernelConfig> configProvider)
     {
-        if (count <= 0)
-        {
-            return;
-        }
+        // GPU batches always contain at least one divisor gap, so the empty-count guard remains commented
+        // to eliminate redundant branching.
+        // if (count <= 0)
+        // {
+        //     return;
+        // }
 
         deltaKernel(count, gapView, deltaView, modulus);
-        SharedMemoryConfig sharedMemoryConfig = SharedMemoryConfig.RequestDynamic<int>(count);
-        Index1D gridDim = new Index1D(1);
-        Index1D groupDim = new Index1D(count);
-        KernelConfig kernelConfig = new KernelConfig(gridDim, groupDim, sharedMemoryConfig);
+        KernelConfig kernelConfig = configProvider(count);
 
         scanKernel(kernelConfig, new Index1D(count), deltaView, remainderView, baseRemainder, modulus);
     }
@@ -468,11 +492,13 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
         Span<byte> destination,
         Action<Index1D, ArrayView<byte>, ArrayView<byte>, ArrayView<byte>, ArrayView<byte>, byte, ArrayView<byte>> maskKernel)
     {
-        if (count <= 0)
-        {
-            destination.Clear();
-            return;
-        }
+        // Candidate batches always provide at least one entry, so the zero-count guard stays commented out
+        // to avoid clearing spans unnecessarily.
+        // if (count <= 0)
+        // {
+        //     destination.Clear();
+        //     return;
+        // }
 
         maskKernel(count, remainder10View, remainder8View, remainder5View, remainder3View, lastIsSevenFlag, maskView);
         maskView.CopyToCPU(ref MemoryMarshal.GetReference(destination), count);
@@ -480,10 +506,12 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
 
     private static byte FetchLastRemainder(ArrayView1D<byte, Stride1D.Dense> remainderView, int count)
     {
-        if (count <= 0)
-        {
-            return 0;
-        }
+        // Kernels always process at least one remainder in this path, so the empty-span guard remains
+        // commented to document the invariant.
+        // if (count <= 0)
+        // {
+        //     return 0;
+        // }
 
         byte value = 0;
         remainderView.SubView(count - 1, 1).CopyToCPU(ref value, 1);
@@ -496,10 +524,11 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
         if (result >= modulus)
         {
             result -= modulus;
-            if (result >= modulus)
-            {
-                result %= modulus;
-            }
+            // The step deltas remain below the modulus, so a single subtraction suffices on this path.
+            // if (result >= modulus)
+            // {
+            //     result %= modulus;
+            // }
         }
 
         return (byte)result;
@@ -507,46 +536,60 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
 
     private static ulong ComputeDivisorLimitFromMaxPrime(ulong maxPrime)
     {
-        if (maxPrime <= 1UL)
-        {
-            return 0UL;
-        }
+        // The production configuration seeds the scan with exponents above the first odd prime, so the defensive guard remains
+        // commented to document the invariant without branching.
+        // if (maxPrime <= 1UL)
+        // {
+        //     return 0UL;
+        // }
 
-        if (maxPrime - 1UL >= 64UL)
-        {
-            return ulong.MaxValue;
-        }
+        // Real workloads push maxPrime well past the 64-bit shift boundary, so keep the historical implementation commented out
+        // and return ulong.MaxValue directly.
+        // if (maxPrime - 1UL >= 64UL)
+        // {
+        //     return ulong.MaxValue;
+        // }
+        //
+        // return (1UL << (int)(maxPrime - 1UL)) - 1UL;
 
-        return (1UL << (int)(maxPrime - 1UL)) - 1UL;
+        return ulong.MaxValue;
     }
 
     private static ulong ComputeAllowedMaxDivisor(ulong prime, ulong divisorLimit)
     {
-        if (prime <= 1UL)
-        {
-            return 0UL;
-        }
+        // The by-divisor search emits candidate exponents starting at the first odd prime, so the defensive guard remains
+        // commented to document that invariant.
+        // if (prime <= 1UL)
+        // {
+        //     return 0UL;
+        // }
 
-        if (prime - 1UL >= 64UL)
-        {
-            return divisorLimit;
-        }
+        // Production exponents are always large enough that the shift-based clamp would overflow, so skip the legacy branch and
+        // return the configured divisor limit directly.
+        // if (prime - 1UL >= 64UL)
+        // {
+        //     return divisorLimit;
+        // }
+        //
+        // return Math.Min((1UL << (int)(prime - 1UL)) - 1UL, divisorLimit);
 
-        return Math.Min((1UL << (int)(prime - 1UL)) - 1UL, divisorLimit);
+        return divisorLimit;
     }
 
     private static void CheckKernel(Index1D index, ArrayView<MontgomeryDivisorData> divisors, ArrayView<ulong> exponents, ArrayView<byte> hits)
     {
         MontgomeryDivisorData divisor = divisors[index];
         ulong modulus = divisor.Modulus;
-        if (modulus <= 1UL || (modulus & 1UL) == 0UL)
-        {
-            hits[index] = 0;
-            return;
-        }
+        // The divisor staging path filters out non-prime and even moduli before they reach the device, so this guard
+        // would never fire for EvenPerfectBitScanner workloads.
+        // if (modulus <= 1UL || (modulus & 1UL) == 0UL)
+        // {
+        //     hits[index] = 0;
+        //     return;
+        // }
 
         ulong exponent = exponents[index];
-        hits[index] = ULongExtensions.Pow2MontgomeryModWindowedKernel(exponent, divisor, keepMontgomery: false) == 1UL ? (byte)1 : (byte)0;
+        hits[index] = exponent.Pow2ModWindowedGpu(modulus) == 1UL ? (byte)1 : (byte)0;
     }
 
     public sealed class DivisorScanSession : IMersenneNumberDivisorByDivisorTester.IDivisorScanSession
@@ -578,7 +621,7 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
             _disposed = false;
         }
 
-        public void CheckDivisor(ulong divisor, in MontgomeryDivisorData divisorData, ulong divisorCycle, in ReadOnlySpan<ulong> primes, Span<byte> hits)
+        public void CheckDivisor(ulong divisor, in MontgomeryDivisorData divisorData, ulong divisorCycle, ReadOnlySpan<ulong> primes, Span<byte> hits)
         {
             if (_disposed)
             {
@@ -586,16 +629,20 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
             }
 
             int length = primes.Length;
-            if (length == 0)
-            {
-                return;
-            }
+            // Production batches always contain at least one exponent, so the empty-span guard remains commented out to remove
+            // the redundant branch.
+            // if (length == 0)
+            // {
+            //     return;
+            // }
 
-            if (divisorData.Modulus <= 1UL || (divisorData.Modulus & 1UL) == 0UL)
-            {
-                hits.Clear();
-                return;
-            }
+            // The divisor staging path filters non-prime and even moduli before kernels launch, so keep the defensive
+            // modulus guard commented out to avoid branching in the hot loop.
+            // if (divisorData.Modulus <= 1UL || (divisorData.Modulus & 1UL) == 0UL)
+            // {
+            //     hits.Clear();
+            //     return;
+            // }
 
             ArrayView1D<ulong, Stride1D.Dense> exponentsView = _exponentsBuffer.View;
             ArrayView1D<ulong, Stride1D.Dense> resultsView = _resultsBuffer.View;
@@ -754,33 +801,34 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
         mask[globalIndex] = 1;
     }
 
-    private static void ComputeMontgomeryExponentKernel(Index1D index, MontgomeryDivisorData divisor, ArrayView<ulong> exponents, ArrayView<ulong> results)
+    private static void ComputeExponentKernel(Index1D index, MontgomeryDivisorData divisor, ArrayView<ulong> exponents, ArrayView<ulong> results)
     {
         ulong modulus = divisor.Modulus;
-        if (modulus <= 1UL || (modulus & 1UL) == 0UL)
-        {
-            results[index] = 0UL;
-            return;
-        }
+        // Kernel inputs are constrained to odd prime moduli, so this defensive branch would never execute on the configured
+        // scanning path.
+        // if (modulus <= 1UL || (modulus & 1UL) == 0UL)
+        // {
+        //     results[index] = 0UL;
+        //     return;
+        // }
 
         ulong exponent = exponents[index];
 
-        results[index] = ULongExtensions.Pow2MontgomeryModWindowedKernel(exponent, divisor, keepMontgomery: true);
+        results[index] = exponent.Pow2ModWindowedGpu(modulus);
     }
 
     public ulong DivisorLimit
     {
         get
         {
-            lock (_sync)
-            {
-                if (!_isConfigured)
-                {
-                    throw new InvalidOperationException("ConfigureFromMaxPrime must be called before using the tester.");
-                }
+            // The by-divisor scanner always configures the tester before exposing the limit, so the guard remains
+            // commented out to document the invariant without forcing a runtime branch.
+            // if (!_isConfigured)
+            // {
+            //     throw new InvalidOperationException("ConfigureFromMaxPrime must be called before using the tester.");
+            // }
 
-                return _divisorLimit;
-            }
+            return _divisorLimit;
         }
     }
 
@@ -797,15 +845,17 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
 
     private void ReturnBatchResources(Accelerator accelerator, BatchResources resources) => _resourcePools.GetOrAdd(accelerator, static _ => []).Add(resources);
 
-    private sealed class BatchResources : IDisposable
+    private sealed class BatchResources
     {
         internal BatchResources(MersenneNumberDivisorByDivisorGpuTester owner, Accelerator accelerator, int capacity)
         {
             int cycleCapacity = DivisorCycleCache.Shared.PreferredBatchSize;
-            if (cycleCapacity <= 0)
-            {
-                cycleCapacity = 1;
-            }
+            // The shared cache always reports a positive preferred size on production workloads, so the fallback remains
+            // commented out to avoid branching during resource initialization.
+            // if (cycleCapacity <= 0)
+            // {
+            //     cycleCapacity = 1;
+            // }
 
             int actualCapacity = Math.Max(capacity, cycleCapacity);
 
@@ -857,10 +907,24 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
         internal readonly Action<KernelConfig, Index1D, ArrayView<byte>, ArrayView<byte>, byte, byte> RemainderScanKernel;
         internal readonly Action<Index1D, ArrayView<byte>, ArrayView<byte>, ArrayView<byte>, ArrayView<byte>, byte, ArrayView<byte>> CandidateMaskKernel;
 
+        private readonly Dictionary<int, KernelConfig> _remainderScanConfigs = new();
+
         internal readonly int Capacity;
 
         internal readonly int CycleCapacity;
 
+        internal KernelConfig GetRemainderScanConfig(int count)
+        {
+            if (!_remainderScanConfigs.TryGetValue(count, out KernelConfig config))
+            {
+                SharedMemoryConfig sharedMemoryConfig = SharedMemoryConfig.RequestDynamic<int>(count);
+                config = new KernelConfig(new Index1D(1), new Index1D(count), sharedMemoryConfig);
+                _remainderScanConfigs[count] = config;
+            }
+
+            return config;
+        }
+
         public void Dispose()
         {
             DivisorsBuffer.Dispose();
@@ -889,37 +953,33 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
 
     public ulong GetAllowedMaxDivisor(ulong prime)
     {
-        lock (_sync)
-        {
-            if (!_isConfigured)
-            {
-                throw new InvalidOperationException("ConfigureFromMaxPrime must be called before using the tester.");
-            }
+        // The CLI configures the GPU tester once at startup, so callers never request divisor limits before
+        // initialization completes.
+        // if (!_isConfigured)
+        // {
+        //     throw new InvalidOperationException("ConfigureFromMaxPrime must be called before using the tester.");
+        // }
 
-            return ComputeAllowedMaxDivisor(prime, _divisorLimit);
-        }
+        return ComputeAllowedMaxDivisor(prime, _divisorLimit);
     }
 
-    public DivisorScanSession CreateDivisorSession()
+    public IMersenneNumberDivisorByDivisorTester.IDivisorScanSession CreateDivisorSession()
     {
-        lock (_sync)
+        // Divisor sessions are handed out only after configuration, so this guard would never trigger on the
+        // production path.
+        // if (!_isConfigured)
+        // {
+        //     throw new InvalidOperationException("ConfigureFromMaxPrime must be called before using the tester.");
+        // }
+
+        if (_sessionPool.TryTake(out DivisorScanSession? session))
         {
-            if (!_isConfigured)
-            {
-                throw new InvalidOperationException("ConfigureFromMaxPrime must be called before using the tester.");
-            }
-
-            if (_sessionPool.TryTake(out DivisorScanSession? session))
-            {
-                session.Reset();
-                return session;
-            }
-
-            return new DivisorScanSession(this);
+            session.Reset();
+            return session;
         }
-    }
 
-    IMersenneNumberDivisorByDivisorTester.IDivisorScanSession IMersenneNumberDivisorByDivisorTester.CreateDivisorSession() => CreateDivisorSession();
+        return new DivisorScanSession(this);
+    }
 }
 
 

PerfectNumbers.Core/Gpu/MersenneNumberDivisorCandidateGpuEvaluator.cs

@@ -0,0 +1,273 @@
+using System;
+using System.Buffers;
+using System.Runtime.InteropServices;
+using ILGPU;
+using ILGPU.Runtime;
+
+namespace PerfectNumbers.Core.Gpu;
+
+internal sealed class MersenneNumberDivisorCandidateGpuEvaluator
+{
+    private const int RemainderCount = 6;
+
+    private readonly GpuContextPool.GpuContextLease _lease;
+    private readonly Accelerator _accelerator;
+    private readonly Action<Index1D, CandidateFilterArgs, ArrayView<ulong>, ArrayView<byte>> _kernel;
+    private MemoryBuffer1D<ulong, Stride1D.Dense> _candidateBuffer;
+    private MemoryBuffer1D<byte, Stride1D.Dense> _maskBuffer;
+    private ulong[] _hostCandidates;
+    private byte[] _hostMask;
+    private int _capacity;
+    private bool _disposed;
+
+    internal MersenneNumberDivisorCandidateGpuEvaluator(int batchSize)
+    {
+        _lease = GpuContextPool.RentPreferred(preferCpu: false);
+        _accelerator = _lease.Accelerator;
+        _kernel = _accelerator.LoadAutoGroupedStreamKernel<Index1D, CandidateFilterArgs, ArrayView<ulong>, ArrayView<byte>>(EvaluateCandidatesKernel);
+        _capacity = Math.Max(1, batchSize);
+        _candidateBuffer = _accelerator.Allocate1D<ulong>(_capacity);
+        _maskBuffer = _accelerator.Allocate1D<byte>(_capacity);
+        _hostCandidates = ArrayPool<ulong>.Shared.Rent(_capacity);
+        _hostMask = ArrayPool<byte>.Shared.Rent(_capacity);
+    }
+
+    public void Dispose()
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        _disposed = true;
+        _candidateBuffer.Dispose();
+        _maskBuffer.Dispose();
+        ArrayPool<ulong>.Shared.Return(_hostCandidates, clearArray: false);
+        ArrayPool<byte>.Shared.Return(_hostMask, clearArray: false);
+        _lease.Dispose();
+    }
+
+    internal void EvaluateCandidates(
+        ulong startDivisor,
+        ulong step,
+        ulong limit,
+        ReadOnlySpan<byte> remainders,
+        ReadOnlySpan<byte> steps,
+        bool lastIsSeven,
+        Span<ulong> candidates,
+        Span<byte> mask)
+    {
+        if (_disposed)
+        {
+            throw new ObjectDisposedException(nameof(MersenneNumberDivisorCandidateGpuEvaluator));
+        }
+
+        if (remainders.Length != RemainderCount || steps.Length != RemainderCount)
+        {
+            throw new ArgumentException("Remainder and step tables must contain exactly six entries.");
+        }
+
+        int count = candidates.Length;
+        // Candidate batches always carry at least one divisor on the by-divisor path, so the empty-count
+        // guard remains commented out to eliminate the branch.
+        // if (count == 0)
+        // {
+        //     return;
+        // }
+
+        if (count > _capacity)
+        {
+            EnsureCapacity(count);
+        }
+
+        Span<ulong> hostCandidateSpan = _hostCandidates.AsSpan(0, count);
+        Span<byte> hostMaskSpan = _hostMask.AsSpan(0, count);
+
+        ArrayView1D<ulong, Stride1D.Dense> candidateView = _candidateBuffer.View.SubView(0, count);
+        ArrayView1D<byte, Stride1D.Dense> maskView = _maskBuffer.View.SubView(0, count);
+
+        var args = new CandidateFilterArgs(
+            startDivisor,
+            step,
+            limit,
+            remainders[0],
+            remainders[1],
+            remainders[2],
+            remainders[3],
+            remainders[4],
+            remainders[5],
+            steps[0],
+            steps[1],
+            steps[2],
+            steps[3],
+            steps[4],
+            steps[5],
+            lastIsSeven ? (byte)1 : (byte)0);
+
+        _kernel(count, args, candidateView, maskView);
+
+        candidateView.CopyToCPU(ref MemoryMarshal.GetReference(hostCandidateSpan), count);
+        maskView.CopyToCPU(ref MemoryMarshal.GetReference(hostMaskSpan), count);
+
+        hostCandidateSpan.CopyTo(candidates);
+        hostMaskSpan.CopyTo(mask);
+    }
+
+    private void EnsureCapacity(int required)
+    {
+        if (required <= _capacity)
+        {
+            return;
+        }
+
+        int newCapacity = _capacity;
+        // The evaluator always starts with a positive capacity, so the zero-capacity fallback remains commented.
+        // if (newCapacity == 0)
+        // {
+        //     newCapacity = 1;
+        // }
+        while (newCapacity < required)
+        {
+            newCapacity <<= 1;
+        }
+
+        _candidateBuffer.Dispose();
+        _maskBuffer.Dispose();
+        ArrayPool<ulong>.Shared.Return(_hostCandidates, clearArray: false);
+        ArrayPool<byte>.Shared.Return(_hostMask, clearArray: false);
+
+        _capacity = newCapacity;
+        _candidateBuffer = _accelerator.Allocate1D<ulong>(_capacity);
+        _maskBuffer = _accelerator.Allocate1D<byte>(_capacity);
+        _hostCandidates = ArrayPool<ulong>.Shared.Rent(_capacity);
+        _hostMask = ArrayPool<byte>.Shared.Rent(_capacity);
+    }
+
+    private static void EvaluateCandidatesKernel(
+        Index1D index,
+        CandidateFilterArgs args,
+        ArrayView<ulong> candidates,
+        ArrayView<byte> mask)
+    {
+        int idx = index;
+        if (idx >= mask.Length)
+        {
+            return;
+        }
+
+        ulong offset = (ulong)idx;
+        ulong candidate = args.StartDivisor + args.Step * offset;
+        candidates[idx] = candidate;
+
+        if (candidate > args.Limit || (args.Step != 0UL && candidate < args.StartDivisor))
+        {
+            mask[idx] = 0;
+            return;
+        }
+
+        int remainderValue10 = ComputeRemainder(args.Remainder10, args.Step10, idx, 10);
+        int remainderValue8 = ComputeRemainder(args.Remainder8, args.Step8, idx, 8);
+        int remainderValue5 = ComputeRemainder(args.Remainder5, args.Step5, idx, 5);
+        int remainderValue3 = ComputeRemainder(args.Remainder3, args.Step3, idx, 3);
+        int remainderValue7 = ComputeRemainder(args.Remainder7, args.Step7, idx, 7);
+        int remainderValue11 = ComputeRemainder(args.Remainder11, args.Step11, idx, 11);
+
+        bool lastIsSeven = args.LastIsSevenFlag != 0;
+        bool admissible = lastIsSeven
+            ? (remainderValue10 == 3 || remainderValue10 == 7 || remainderValue10 == 9)
+            : (remainderValue10 == 1 || remainderValue10 == 3 || remainderValue10 == 9);
+
+        if (!admissible)
+        {
+            mask[idx] = 0;
+            return;
+        }
+
+        if ((remainderValue8 != 1 && remainderValue8 != 7)
+            || remainderValue3 == 0
+            || remainderValue5 == 0
+            || remainderValue7 == 0
+            || remainderValue11 == 0)
+        {
+            mask[idx] = 0;
+            return;
+        }
+
+        mask[idx] = 1;
+    }
+
+    private static int ComputeRemainder(byte remainder, byte step, int index, int modulus)
+    {
+        // Modulus lookups only cover {10, 8, 5, 3, 7, 11}, so the zero-modulus guard stays commented out.
+        // if (modulus == 0)
+        // {
+        //     return 0;
+        // }
+
+        long value = remainder;
+        value += (long)step * index;
+        int result = (int)(value % modulus);
+        if (result < 0)
+        {
+            result += modulus;
+        }
+
+        return result;
+    }
+
+    private readonly struct CandidateFilterArgs
+    {
+        public CandidateFilterArgs(
+            ulong startDivisor,
+            ulong step,
+            ulong limit,
+            byte remainder10,
+            byte remainder8,
+            byte remainder5,
+            byte remainder3,
+            byte remainder7,
+            byte remainder11,
+            byte step10,
+            byte step8,
+            byte step5,
+            byte step3,
+            byte step7,
+            byte step11,
+            byte lastIsSevenFlag)
+        {
+            StartDivisor = startDivisor;
+            Step = step;
+            Limit = limit;
+            Remainder10 = remainder10;
+            Remainder8 = remainder8;
+            Remainder5 = remainder5;
+            Remainder3 = remainder3;
+            Remainder7 = remainder7;
+            Remainder11 = remainder11;
+            Step10 = step10;
+            Step8 = step8;
+            Step5 = step5;
+            Step3 = step3;
+            Step7 = step7;
+            Step11 = step11;
+            LastIsSevenFlag = lastIsSevenFlag;
+        }
+
+        public ulong StartDivisor { get; }
+        public ulong Step { get; }
+        public ulong Limit { get; }
+        public byte Remainder10 { get; }
+        public byte Remainder8 { get; }
+        public byte Remainder5 { get; }
+        public byte Remainder3 { get; }
+        public byte Remainder7 { get; }
+        public byte Remainder11 { get; }
+        public byte Step10 { get; }
+        public byte Step8 { get; }
+        public byte Step5 { get; }
+        public byte Step3 { get; }
+        public byte Step7 { get; }
+        public byte Step11 { get; }
+        public byte LastIsSevenFlag { get; }
+    }
+}

PerfectNumbers.Core/Gpu/MersenneNumberDivisorMontgomeryGpuBuilder.cs

@@ -0,0 +1,190 @@
+using System;
+using System.Buffers;
+using System.Runtime.InteropServices;
+using PerfectNumbers.Core;
+using ILGPU;
+using ILGPU.Runtime;
+
+namespace PerfectNumbers.Core.Gpu;
+
+internal sealed class MersenneNumberDivisorMontgomeryGpuBuilder
+{
+    private readonly GpuContextPool.GpuContextLease _lease;
+    private readonly Accelerator _accelerator;
+    private readonly Action<Index1D, ArrayView<ulong>, ArrayView<MontgomeryDivisorData>> _kernel;
+    private MemoryBuffer1D<ulong, Stride1D.Dense> _modulusBuffer;
+    private MemoryBuffer1D<MontgomeryDivisorData, Stride1D.Dense> _resultBuffer;
+    private ulong[] _hostModulusBuffer;
+    private MontgomeryDivisorData[] _hostResultBuffer;
+    private int _capacity;
+    private bool _disposed;
+
+    internal MersenneNumberDivisorMontgomeryGpuBuilder(int batchSize)
+    {
+        _lease = GpuContextPool.RentPreferred(preferCpu: false);
+        _accelerator = _lease.Accelerator;
+        _kernel = _accelerator.LoadAutoGroupedStreamKernel<Index1D, ArrayView<ulong>, ArrayView<MontgomeryDivisorData>>(BuildKernel);
+        _capacity = Math.Max(1, batchSize);
+        _modulusBuffer = _accelerator.Allocate1D<ulong>(_capacity);
+        _resultBuffer = _accelerator.Allocate1D<MontgomeryDivisorData>(_capacity);
+        _hostModulusBuffer = ArrayPool<ulong>.Shared.Rent(_capacity);
+        _hostResultBuffer = ArrayPool<MontgomeryDivisorData>.Shared.Rent(_capacity);
+    }
+
+    public void Dispose()
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        _disposed = true;
+        _modulusBuffer.Dispose();
+        _resultBuffer.Dispose();
+        ArrayPool<ulong>.Shared.Return(_hostModulusBuffer, clearArray: false);
+        ArrayPool<MontgomeryDivisorData>.Shared.Return(_hostResultBuffer, clearArray: false);
+        _lease.Dispose();
+    }
+
+    internal void Build(ReadOnlySpan<ulong> moduli, Span<MontgomeryDivisorData> destination)
+    {
+        if (_disposed)
+        {
+            throw new ObjectDisposedException(nameof(MersenneNumberDivisorMontgomeryGpuBuilder));
+        }
+
+        int length = moduli.Length;
+        // Montgomery batches always include at least one modulus on the by-divisor path, so the empty-length
+        // guard stays commented out to avoid branching.
+        // if (length == 0)
+        // {
+        //     return;
+        // }
+
+        EnsureCapacity(length);
+
+        Span<ulong> hostModulusSpan = _hostModulusBuffer.AsSpan(0, length);
+        moduli.CopyTo(hostModulusSpan);
+
+        ArrayView1D<ulong, Stride1D.Dense> modulusView = _modulusBuffer.View.SubView(0, length);
+        modulusView.CopyFromCPU(ref MemoryMarshal.GetReference(hostModulusSpan), length);
+
+        ArrayView1D<MontgomeryDivisorData, Stride1D.Dense> resultView = _resultBuffer.View.SubView(0, length);
+        _kernel(length, modulusView, resultView);
+
+        Span<MontgomeryDivisorData> hostResultSpan = _hostResultBuffer.AsSpan(0, length);
+        resultView.CopyToCPU(ref MemoryMarshal.GetReference(hostResultSpan), length);
+
+        hostResultSpan.CopyTo(destination);
+    }
+
+    private void EnsureCapacity(int required)
+    {
+        if (required <= _capacity)
+        {
+            return;
+        }
+
+        int newCapacity = _capacity;
+        // The builder always starts with a positive capacity, so the zero-capacity fallback remains commented.
+        // if (newCapacity == 0)
+        // {
+        //     newCapacity = 1;
+        // }
+        while (newCapacity < required)
+        {
+            newCapacity <<= 1;
+        }
+
+        _modulusBuffer.Dispose();
+        _resultBuffer.Dispose();
+        ArrayPool<ulong>.Shared.Return(_hostModulusBuffer, clearArray: false);
+        ArrayPool<MontgomeryDivisorData>.Shared.Return(_hostResultBuffer, clearArray: false);
+
+        _capacity = newCapacity;
+        _modulusBuffer = _accelerator.Allocate1D<ulong>(_capacity);
+        _resultBuffer = _accelerator.Allocate1D<MontgomeryDivisorData>(_capacity);
+        _hostModulusBuffer = ArrayPool<ulong>.Shared.Rent(_capacity);
+        _hostResultBuffer = ArrayPool<MontgomeryDivisorData>.Shared.Rent(_capacity);
+    }
+
+    private static void BuildKernel(Index1D index, ArrayView<ulong> moduli, ArrayView<MontgomeryDivisorData> destination)
+    {
+        int idx = index;
+        // The builder launches kernels with an extent equal to the modulus count, so the bounds guard remains commented
+        // out to avoid redundant branching on every thread.
+        // if (idx >= moduli.Length)
+        // {
+        //     return;
+        // }
+
+        ulong modulus = moduli[idx];
+        // All staged divisors are odd primes on the scanner path, so keep the defensive modulus guard commented out to
+        // remove the branch from the kernel.
+        // if (modulus <= 1UL || (modulus & 1UL) == 0UL)
+        // {
+        //     destination[idx] = default;
+        //     return;
+        // }
+
+        ulong nPrime = ComputeMontgomeryNPrime(modulus);
+        ulong montgomeryOne = ComputeMontgomeryResidue64(modulus);
+        ulong montgomeryTwo = montgomeryOne.MulMod64(2UL, modulus);
+        ulong montgomeryTwoSquared = MontgomeryMultiplyGpu(montgomeryTwo, montgomeryTwo, modulus, nPrime);
+
+        destination[idx] = new MontgomeryDivisorData(
+            modulus,
+            nPrime,
+            montgomeryOne,
+            montgomeryTwo,
+            montgomeryTwoSquared);
+    }
+
+    private static ulong ComputeMontgomeryResidue64(ulong modulus)
+    {
+        ulong remainder = ulong.MaxValue % modulus;
+        remainder++;
+        if (remainder >= modulus)
+        {
+            remainder -= modulus;
+        }
+
+        return remainder;
+    }
+
+    private static ulong MontgomeryMultiplyGpu(ulong a, ulong b, ulong modulus, ulong nPrime)
+    {
+        GpuUInt128 product = new(a);
+        product.Mul64(new GpuUInt128(b));
+        ulong tLow = product.Low;
+        ulong tHigh = product.High;
+
+        ulong m = unchecked(tLow * nPrime);
+        GpuUInt128 mProduct = new(m);
+        mProduct.Mul64(new GpuUInt128(modulus));
+        ulong mLow = mProduct.Low;
+        ulong mHigh = mProduct.High;
+
+        ulong carry = unchecked((tLow + mLow) < tLow ? 1UL : 0UL);
+        ulong result = tHigh + mHigh + carry;
+        if (result >= modulus)
+        {
+            result -= modulus;
+        }
+
+        return result;
+    }
+
+    private static ulong ComputeMontgomeryNPrime(ulong modulus)
+    {
+        ulong inv = modulus;
+        inv *= unchecked(2UL - modulus * inv);
+        inv *= unchecked(2UL - modulus * inv);
+        inv *= unchecked(2UL - modulus * inv);
+        inv *= unchecked(2UL - modulus * inv);
+        inv *= unchecked(2UL - modulus * inv);
+        inv *= unchecked(2UL - modulus * inv);
+        inv *= unchecked(2UL - modulus * inv);
+        return unchecked(0UL - inv);
+    }
+}

PerfectNumbers.Core/Gpu/MersenneNumberDivisorRemainderGpuStepper.cs

@@ -0,0 +1,146 @@
+using System;
+using System.Buffers;
+using System.Runtime.InteropServices;
+using ILGPU;
+using ILGPU.Runtime;
+
+namespace PerfectNumbers.Core.Gpu;
+
+internal sealed class MersenneNumberDivisorRemainderGpuStepper
+{
+    private const int RemainderCount = 6;
+
+    private readonly GpuContextPool.GpuContextLease _lease;
+    private readonly Accelerator _accelerator;
+    private readonly Action<Index1D, int, ArrayView<byte>, ArrayView<byte>, ArrayView<byte>> _kernel;
+    private MemoryBuffer1D<byte, Stride1D.Dense> _remainderBuffer;
+    private MemoryBuffer1D<byte, Stride1D.Dense> _stepBuffer;
+    private MemoryBuffer1D<byte, Stride1D.Dense> _resultBuffer;
+    private byte[] _hostRemainders;
+    private byte[] _hostSteps;
+    private readonly int _length;
+    private int _capacity;
+    private bool _disposed;
+
+    internal MersenneNumberDivisorRemainderGpuStepper(ReadOnlySpan<byte> steps)
+    {
+        if (steps.Length != RemainderCount)
+        {
+            throw new ArgumentException("Step table must contain exactly six entries.");
+        }
+
+        _lease = GpuContextPool.RentPreferred(preferCpu: false);
+        _accelerator = _lease.Accelerator;
+        _kernel = _accelerator.LoadAutoGroupedStreamKernel<Index1D, int, ArrayView<byte>, ArrayView<byte>, ArrayView<byte>>(AdvanceRemaindersKernel);
+
+        _length = steps.Length;
+        _capacity = Math.Max(1, _length);
+        _remainderBuffer = _accelerator.Allocate1D<byte>(_capacity);
+        _stepBuffer = _accelerator.Allocate1D<byte>(_capacity);
+        _resultBuffer = _accelerator.Allocate1D<byte>(_capacity);
+
+        _hostRemainders = ArrayPool<byte>.Shared.Rent(_capacity);
+        _hostSteps = ArrayPool<byte>.Shared.Rent(_capacity);
+
+        steps.CopyTo(_hostSteps.AsSpan(0, _length));
+
+        ArrayView1D<byte, Stride1D.Dense> stepView = _stepBuffer.View.SubView(0, _length);
+        stepView.CopyFromCPU(ref MemoryMarshal.GetReference(_hostSteps.AsSpan(0, _length)), _length);
+    }
+
+    public void Dispose()
+    {
+        if (_disposed)
+        {
+            throw new InvalidOperationException("MersenneNumberDivisorRemainderGpuStepper was disposed more than once.");
+        }
+
+        _disposed = true;
+        _remainderBuffer.Dispose();
+        _stepBuffer.Dispose();
+        _resultBuffer.Dispose();
+        ArrayPool<byte>.Shared.Return(_hostRemainders, clearArray: false);
+        ArrayPool<byte>.Shared.Return(_hostSteps, clearArray: false);
+        _lease.Dispose();
+    }
+
+    internal void Advance(int advanceCount, Span<byte> remainders)
+    {
+        if (_disposed)
+        {
+            throw new ObjectDisposedException(nameof(MersenneNumberDivisorRemainderGpuStepper));
+        }
+
+        // GPU remainder batches always advance by a positive chunk count and operate on fixed-size tables, so
+        // the defensive early-return remains commented out.
+        // if (advanceCount <= 0 || remainders.Length == 0)
+        // {
+        //     return;
+        // }
+
+        // Production code always calls the stepper with a fixed-length table, so the historical length guard stays commented.
+        // if (remainders.Length != _length)
+        // {
+        //     throw new ArgumentException("Remainder buffer length must match the configured length.");
+        // }
+
+        Span<byte> hostRemainderSpan = _hostRemainders.AsSpan(0, _length);
+        remainders.CopyTo(hostRemainderSpan);
+
+        ArrayView1D<byte, Stride1D.Dense> remainderView = _remainderBuffer.View.SubView(0, _length);
+        remainderView.CopyFromCPU(ref MemoryMarshal.GetReference(hostRemainderSpan), _length);
+
+        ArrayView1D<byte, Stride1D.Dense> stepView = _stepBuffer.View.SubView(0, _length);
+        ArrayView1D<byte, Stride1D.Dense> resultView = _resultBuffer.View.SubView(0, _length);
+
+        _kernel(_length, advanceCount, remainderView, stepView, resultView);
+
+        resultView.CopyToCPU(ref MemoryMarshal.GetReference(hostRemainderSpan), _length);
+        hostRemainderSpan.CopyTo(remainders);
+    }
+
+    private static void AdvanceRemaindersKernel(Index1D index, int advanceCount, ArrayView<byte> remainders, ArrayView<byte> steps, ArrayView<byte> results)
+    {
+        int idx = index;
+        // Kernel launches match the remainder table length, so the bounds guard stays commented to avoid redundant branching.
+        // if (idx >= remainders.Length)
+        // {
+        //     return;
+        // }
+
+        int modulus = GetModulus(idx);
+        // The modulus selector only emits positive bases (10, 8, 5, 3, 7, 11) for the configured indices, so the zero-modulus
+        // fallback remains commented out.
+        // if (modulus == 0)
+        // {
+        //     results[idx] = remainders[idx];
+        //     return;
+        // }
+
+        int remainder = remainders[idx] % modulus;
+        int step = steps[idx] % modulus;
+
+        long delta = (long)step * advanceCount;
+        int adjusted = (int)((remainder + delta) % modulus);
+        if (adjusted < 0)
+        {
+            adjusted += modulus;
+        }
+
+        results[idx] = (byte)adjusted;
+    }
+
+    private static int GetModulus(int index)
+    {
+        return index switch
+        {
+            0 => 10,
+            1 => 8,
+            2 => 5,
+            3 => 3,
+            4 => 7,
+            5 => 11,
+            _ => 0,
+        };
+    }
+}

PerfectNumbers.Core/Gpu/MersenneNumberDivisorResidueGpuEvaluator.cs

@@ -0,0 +1,128 @@
+using System;
+using System.Buffers;
+using System.Runtime.InteropServices;
+using PerfectNumbers.Core;
+using ILGPU;
+using ILGPU.Runtime;
+
+namespace PerfectNumbers.Core.Gpu;
+
+internal sealed class MersenneNumberDivisorResidueGpuEvaluator
+{
+    private readonly GpuContextPool.GpuContextLease _lease;
+    private readonly Accelerator _accelerator;
+    private readonly Action<Index1D, MontgomeryDivisorData, ArrayView<ulong>, ArrayView<ulong>> _kernel;
+    private MemoryBuffer1D<ulong, Stride1D.Dense> _exponentBuffer;
+    private MemoryBuffer1D<ulong, Stride1D.Dense> _resultBuffer;
+    private ulong[] _hostBuffer;
+    private int _capacity;
+    private bool _disposed;
+
+    internal MersenneNumberDivisorResidueGpuEvaluator(int batchSize)
+    {
+        _lease = GpuContextPool.RentPreferred(preferCpu: false);
+        _accelerator = _lease.Accelerator;
+        _kernel = _accelerator.LoadAutoGroupedStreamKernel<Index1D, MontgomeryDivisorData, ArrayView<ulong>, ArrayView<ulong>>(ComputeResiduesKernel);
+        _capacity = Math.Max(1, batchSize);
+        _exponentBuffer = _accelerator.Allocate1D<ulong>(_capacity);
+        _resultBuffer = _accelerator.Allocate1D<ulong>(_capacity);
+        _hostBuffer = ArrayPool<ulong>.Shared.Rent(_capacity);
+    }
+
+    public void Dispose()
+    {
+        if (_disposed)
+        {
+            throw new InvalidOperationException("MersenneNumberDivisorResidueGpuEvaluator was disposed more than once.");
+        }
+
+        _disposed = true;
+        _exponentBuffer.Dispose();
+        _resultBuffer.Dispose();
+        ArrayPool<ulong>.Shared.Return(_hostBuffer, clearArray: false);
+        _lease.Dispose();
+    }
+
+    internal void ComputeResidues(ReadOnlySpan<ulong> exponents, in MontgomeryDivisorData divisorData, Span<ulong> destination)
+    {
+        if (_disposed)
+        {
+            throw new ObjectDisposedException(nameof(MersenneNumberDivisorResidueGpuEvaluator));
+        }
+
+        int length = exponents.Length;
+        // Residue batches always include at least one exponent when scheduled from the by-divisor scanner, so
+        // the empty-length guard remains commented out to avoid branching.
+        // if (length == 0)
+        // {
+        //     return;
+        // }
+
+        EnsureCapacity(length);
+
+        Span<ulong> hostSpan = _hostBuffer.AsSpan(0, length);
+        exponents.CopyTo(hostSpan);
+
+        ArrayView1D<ulong, Stride1D.Dense> exponentView = _exponentBuffer.View.SubView(0, length);
+        exponentView.CopyFromCPU(ref MemoryMarshal.GetReference(hostSpan), length);
+
+        ArrayView1D<ulong, Stride1D.Dense> resultView = _resultBuffer.View.SubView(0, length);
+        _kernel(length, divisorData, exponentView, resultView);
+        resultView.CopyToCPU(ref MemoryMarshal.GetReference(hostSpan), length);
+
+        hostSpan.CopyTo(destination);
+    }
+
+    private void EnsureCapacity(int required)
+    {
+        if (required <= _capacity)
+        {
+            return;
+        }
+
+        int newCapacity = _capacity;
+        // The evaluator always starts with a positive capacity, so the zero-capacity fallback stays commented.
+        // if (newCapacity == 0)
+        // {
+        //     newCapacity = 1;
+        // }
+
+        while (newCapacity < required)
+        {
+            newCapacity <<= 1;
+        }
+
+        _exponentBuffer.Dispose();
+        _resultBuffer.Dispose();
+        ArrayPool<ulong>.Shared.Return(_hostBuffer, clearArray: false);
+
+        _capacity = newCapacity;
+        _exponentBuffer = _accelerator.Allocate1D<ulong>(_capacity);
+        _resultBuffer = _accelerator.Allocate1D<ulong>(_capacity);
+        _hostBuffer = ArrayPool<ulong>.Shared.Rent(_capacity);
+    }
+
+    private static void ComputeResiduesKernel(Index1D index, MontgomeryDivisorData divisorData, ArrayView<ulong> exponents, ArrayView<ulong> results)
+    {
+        int idx = index;
+        int length = (int)exponents.Length;
+        // Batched launches match the buffer length on production workloads, so the bounds guard stays commented out to remove
+        // the redundant comparison.
+        // if (idx >= length)
+        // {
+        //     return;
+        // }
+
+        ulong exponent = exponents[idx];
+        ulong modulus = divisorData.Modulus;
+        // Residue batches only include valid odd moduli, so the defensive check stays commented to avoid re-validating
+        // the invariant on every iteration.
+        // if (modulus <= 1UL || (modulus & 1UL) == 0UL)
+        // {
+        //     results[idx] = 0UL;
+        //     return;
+        // }
+
+        results[idx] = exponent.Pow2ModWindowedGpu(modulus);
+    }
+}

PerfectNumbers.Core/Gpu/MersenneNumberIncrementalGpuTester.cs

@@ -1,5 +1,8 @@
+using System;
 using System.Buffers;
+using System.Threading;
 using System.Runtime.InteropServices;
+using ILGPU;
 using ILGPU.Runtime;
 
 namespace PerfectNumbers.Core.Gpu;

PerfectNumbers.Core/Gpu/MersenneNumberLucasLehmerGpuTester.cs

@@ -327,8 +327,9 @@ public class MersenneNumberLucasLehmerGpuTester
             // TODO: Replace StreamWriter with the pooled TextFileWriter pipeline so persisting NTT
             // parameters reuses the zero-allocation buffered writes highlighted in the scanner I/O
             // benchmarks instead of allocating a new encoder per append.
-            using var writer = new StreamWriter(ParameterFilePath, append: true);
+            var writer = new StreamWriter(ParameterFilePath, append: true);
             writer.WriteLine($"{length} {modulus.High} {modulus.Low} {primitiveRoot.High} {primitiveRoot.Low}");
+            writer.Dispose();
         }
     }
 
@@ -338,7 +339,7 @@ public class MersenneNumberLucasLehmerGpuTester
         ulong foundRoot = 0UL;
         bool success = false;
         var processorCount = Environment.ProcessorCount;
-        using var cts = new System.Threading.CancellationTokenSource();
+        var cts = new System.Threading.CancellationTokenSource();
         object sync = new();
 
         // TODO: Move this Parallel.For to the shared low-overhead work scheduler once the NTT parameter
@@ -381,11 +382,13 @@ public class MersenneNumberLucasLehmerGpuTester
         {
             modulus = new GpuUInt128(0UL, foundCandidate);
             primitiveRoot = new GpuUInt128(0UL, foundRoot);
+            cts.Dispose();
             return true;
         }
 
         modulus = new GpuUInt128(0UL, 18446744069414584321UL);
         primitiveRoot = new GpuUInt128(0UL, 7UL);
+        cts.Dispose();
         return false;
     }
 

PerfectNumbers.Core/Gpu/MersenneNumberResidueGpuTester.cs

@@ -1,5 +1,6 @@
 using System.Buffers;
 using System.Runtime.InteropServices;
+using System.Threading;
 using ILGPU.Runtime;
 
 namespace PerfectNumbers.Core.Gpu;

PerfectNumbers.Core/Gpu/MontgomeryOddPowerGpu.cs

@@ -0,0 +1,88 @@
+using System;
+using System.Runtime.InteropServices;
+using ILGPU.Runtime;
+
+namespace PerfectNumbers.Core.Gpu;
+
+internal static class MontgomeryOddPowerGpu
+{
+    public static bool TryCompute(in MontgomeryDivisorData divisor, int oddPowerCount, Span<ulong> destination)
+    {
+        if (oddPowerCount <= 0)
+        {
+            return true;
+        }
+
+        Span<MontgomeryDivisorData> divisorSpan = stackalloc MontgomeryDivisorData[1];
+        divisorSpan[0] = divisor;
+        Span<int> countSpan = stackalloc int[1];
+        countSpan[0] = oddPowerCount;
+        Span<ulong> resultSpan = stackalloc ulong[PerfectNumberConstants.MaxOddPowersCount];
+
+        if (!TryComputeBatch(divisorSpan, countSpan, resultSpan, PerfectNumberConstants.MaxOddPowersCount))
+        {
+            return false;
+        }
+
+        resultSpan[..oddPowerCount].CopyTo(destination);
+        return true;
+    }
+
+    public static bool TryComputeBatch(
+        ReadOnlySpan<MontgomeryDivisorData> divisors,
+        ReadOnlySpan<int> oddPowerCounts,
+        Span<ulong> results,
+        int stride)
+    {
+        int divisorCount = divisors.Length;
+        if (divisorCount == 0)
+        {
+            return true;
+        }
+
+        if (oddPowerCounts.Length < divisorCount)
+        {
+            throw new ArgumentException(
+                "oddPowerCounts span must contain at least as many elements as divisors span.",
+                nameof(oddPowerCounts));
+        }
+
+        if (results.Length < divisorCount * stride)
+        {
+            throw new ArgumentException(
+                "The result span is shorter than the required batched odd power storage.",
+                nameof(results));
+        }
+
+        if (GpuContextPool.ForceCpu)
+        {
+            return false;
+        }
+
+        var lease = GpuKernelPool.GetKernel(useGpuOrder: true);
+        var execution = lease.EnterExecutionScope();
+        var accelerator = lease.Accelerator;
+        var stream = lease.Stream;
+
+        var divisorBuffer = accelerator.Allocate1D<MontgomeryDivisorData>(divisorCount);
+        var countBuffer = accelerator.Allocate1D<int>(divisorCount);
+        var resultBuffer = accelerator.Allocate1D<ulong>(divisorCount * stride);
+
+        divisorBuffer.View.CopyFromCPU(ref MemoryMarshal.GetReference(divisors), divisorCount);
+        countBuffer.View.CopyFromCPU(ref MemoryMarshal.GetReference(oddPowerCounts), divisorCount);
+        resultBuffer.MemSetToZero();
+
+        var kernel = lease.MontgomeryOddPowerKernel;
+        kernel(stream, divisorCount, divisorBuffer.View, countBuffer.View, resultBuffer.View, stride);
+        stream.Synchronize();
+
+        resultBuffer.View.CopyToCPU(ref MemoryMarshal.GetReference(results), divisorCount * stride);
+
+        resultBuffer.Dispose();
+        countBuffer.Dispose();
+        divisorBuffer.Dispose();
+        execution.Dispose();
+        lease.Dispose();
+        return true;
+    }
+}

PerfectNumbers.Core/Gpu/NttGpuMath.cs

@@ -47,7 +47,7 @@ public static class NttGpuMath
 
     private static readonly ConcurrentDictionary<Accelerator, Action<Index1D, ArrayView<GpuUInt128>, int>> BitReverseKernelCache = new(); // TODO: Precompute bit-reversal kernels during boot so we can remove the concurrent lookup overhead flagged in the benchmarks.
 
-    private sealed class SquareCacheEntry : IDisposable
+    private sealed class SquareCacheEntry
     {
         public MemoryBuffer1D<GpuUInt128, Stride1D.Dense> Buffer { get; }
         public GpuUInt128 Root { get; }

PerfectNumbers.Core/Gpu/PrimeOrderGpuHeuristics.cs

@@ -1,8 +1,10 @@
+using System;
 using System.Buffers;
 using System.Collections.Concurrent;
 using ILGPU;
 using ILGPU.Runtime;
 using System.Numerics;
+using PerfectNumbers.Core;
 using System.Runtime.InteropServices;
 using System.Runtime.CompilerServices;
 using ILGPU.Runtime.OpenCL;
@@ -803,13 +805,15 @@ internal static partial class PrimeOrderGpuHeuristics
         for (int i = 0; i < factorCount; i++)
         {
             ulong factor = factors[i];
-            if (factor <= 1UL)
-            {
-                continue;
-            }
+            // The factorization routine emits strictly greater-than-one factors for phi on this path, so the
+            // defensive continue would never execute.
+            // if (factor <= 1UL)
+            // {
+            //     continue;
+            // }
 
             ulong reduced = phi / factor;
-            if (ULongExtensions.Pow2MontgomeryModWindowedKernel(reduced, divisor, keepMontgomery: false) == 1UL)
+            if (reduced.Pow2ModWindowedGpu(divisor.Modulus) == 1UL)
             {
                 return false;
             }
@@ -825,7 +829,7 @@ internal static partial class PrimeOrderGpuHeuristics
         if (residue == 1UL || residue == 7UL)
         {
             ulong half = phi >> 1;
-            if (Pow2EqualsOneKernel(half, divisor))
+            if ((half).Pow2ModWindowedGpu(divisor.Modulus) == 1UL)
             {
                 order = half;
             }
@@ -846,10 +850,11 @@ internal static partial class PrimeOrderGpuHeuristics
         {
             ulong primeFactor = factors[i];
             int exponent = exponents[i];
-            if (primeFactor <= 1UL)
-            {
-                continue;
-            }
+            // Factorization never yields unity on the scanning path, so skip the redundant guard.
+            // if (primeFactor <= 1UL)
+            // {
+            //     continue;
+            // }
 
             for (int iteration = 0; iteration < exponent; iteration++)
             {
@@ -859,7 +864,7 @@ internal static partial class PrimeOrderGpuHeuristics
                 }
 
                 ulong reduced = order / primeFactor;
-                if (Pow2EqualsOneKernel(reduced, divisor))
+                if ((reduced).Pow2ModWindowedGpu(divisor.Modulus) == 1UL)
                 {
                     order = reduced;
                     continue;
@@ -885,12 +890,14 @@ internal static partial class PrimeOrderGpuHeuristics
         ArrayView1D<ulong, Stride1D.Dense> compositeStack,
         ArrayView1D<byte, Stride1D.Dense> statusOut)
     {
-        if (order == 0UL)
-        {
-            return false;
-        }
+        // Order values handed to the kernel are strictly positive on the production path, so the zero guard stays commented
+        // out to remove the redundant branch.
+        // if (order == 0UL)
+        // {
+        //     return false;
+        // }
 
-        if (!Pow2EqualsOneKernel(order, divisor))
+        if ((order).Pow2ModWindowedGpu(divisor.Modulus) != 1UL)
         {
             return false;
         }
@@ -920,10 +927,11 @@ internal static partial class PrimeOrderGpuHeuristics
         {
             ulong primeFactor = factors[i];
             int exponent = exponents[i];
-            if (primeFactor <= 1UL)
-            {
-                continue;
-            }
+            // Factorization never yields one on the by-divisor path, so the defensive continue stays commented out.
+            // if (primeFactor <= 1UL)
+            // {
+            //     continue;
+            // }
 
             ulong reduced = order;
             for (int iteration = 0; iteration < exponent; iteration++)
@@ -934,7 +942,7 @@ internal static partial class PrimeOrderGpuHeuristics
                 }
 
                 reduced /= primeFactor;
-                if (Pow2EqualsOneKernel(reduced, divisor))
+                if ((reduced).Pow2ModWindowedGpu(divisor.Modulus) == 1UL)
                 {
                     return false;
                 }
@@ -996,28 +1004,32 @@ internal static partial class PrimeOrderGpuHeuristics
         long candidateCapacity = candidates.Length;
         int candidateLimit = candidateCapacity < HeuristicCandidateLimit ? (int)candidateCapacity : HeuristicCandidateLimit;
         int candidateCount = BuildCandidatesKernel(order, workFactors, workExponents, factorCount, candidates, stackIndex, stackExponent, stackProduct, candidateLimit);
-        if (candidateCount == 0)
-        {
-            return false;
-        }
+        // Candidate enumeration always yields at least one order on the configured workloads, so the zero-count guard remains
+        // commented out to eliminate the redundant branch.
+        // if (candidateCount == 0)
+        // {
+        //     return false;
+        // }
 
         SortCandidatesKernel(prime, previousOrder, hasPreviousOrder != 0, candidates, candidateCount);
 
         int powBudget = maxPowChecks <= 0 ? candidateCount : maxPowChecks;
-        if (powBudget <= 0)
-        {
-            powBudget = candidateCount;
-        }
+        // The heuristics always reserve at least one check, so the zero-budget fallback remains commented out.
+        // if (powBudget <= 0)
+        // {
+        //     powBudget = candidateCount;
+        // }
 
         int powUsed = 0;
 
         for (int i = 0; i < candidateCount && powUsed < powBudget; i++)
         {
             ulong candidate = candidates[i];
-            if (candidate <= 1UL)
-            {
-                continue;
-            }
+            // Candidate generation skips 1 by construction, so the defensive continue stays commented out.
+            // if (candidate <= 1UL)
+            // {
+            //     continue;
+            // }
 
             if (powUsed >= powBudget)
             {
@@ -1025,7 +1037,7 @@ internal static partial class PrimeOrderGpuHeuristics
             }
 
             powUsed++;
-            if (!Pow2EqualsOneKernel(candidate, divisor))
+            if ((candidate).Pow2ModWindowedGpu(divisor.Modulus) != 1UL)
             {
                 continue;
             }
@@ -1305,10 +1317,11 @@ internal static partial class PrimeOrderGpuHeuristics
         {
             ulong primeFactor = factors[i];
             int exponent = exponents[i];
-            if (primeFactor <= 1UL)
-            {
-                continue;
-            }
+            // Factorization never yields one for candidate orders, so keep the guard commented out to avoid re-checking inputs.
+            // if (primeFactor <= 1UL)
+            // {
+            //     continue;
+            // }
 
             ulong reduced = candidate;
             for (int iteration = 0; iteration < exponent; iteration++)
@@ -1325,7 +1338,7 @@ internal static partial class PrimeOrderGpuHeuristics
                 }
 
                 powUsed++;
-                if (Pow2EqualsOneKernel(reduced, divisor))
+                if ((reduced).Pow2ModWindowedGpu(divisor.Modulus) == 1UL)
                 {
                     return false;
                 }
@@ -1347,17 +1360,21 @@ internal static partial class PrimeOrderGpuHeuristics
         ArrayView1D<ulong, Stride1D.Dense> compositeStack,
         ArrayView1D<byte, Stride1D.Dense> statusOut)
     {
-        if (initial <= 1UL)
-        {
-            return true;
-        }
+        // Composite candidates sent here are always greater than one during production scans, so the trivial-return branch stays
+        // commented out.
+        // if (initial <= 1UL)
+        // {
+        //     return true;
+        // }
 
         int stackCapacity = (int)compositeStack.Length;
-        if (stackCapacity <= 0)
-        {
-            statusOut[0] = (byte)PrimeOrderKernelStatus.PollardOverflow;
-            return false;
-        }
+        // Pollard-Rho always reserves a positive stack on production workloads, so the overflow guard remains commented out
+        // to avoid branching here.
+        // if (stackCapacity <= 0)
+        // {
+        //     statusOut[0] = (byte)PrimeOrderKernelStatus.PollardOverflow;
+        //     return false;
+        // }
 
         int stackTop = 0;
         compositeStack[stackTop] = initial;
@@ -1367,10 +1384,12 @@ internal static partial class PrimeOrderGpuHeuristics
         {
             stackTop--;
             ulong composite = compositeStack[stackTop];
-            if (composite <= 1UL)
-            {
-                continue;
-            }
+            // Composite values enqueued for factoring are always greater than one on production workloads, so the guard stays
+            // commented out to avoid extra branching.
+            // if (composite <= 1UL)
+            // {
+            //     continue;
+            // }
 
             if (!PeelSmallPrimesKernel(
                     composite,
@@ -1578,9 +1597,7 @@ internal static partial class PrimeOrderGpuHeuristics
             bLocal >>= BitOperations.TrailingZeroCount(bLocal);
             if (aLocal > bLocal)
             {
-                ulong temp = aLocal;
-                aLocal = bLocal;
-                bLocal = temp;
+                (aLocal, bLocal) = (bLocal, aLocal);
             }
 
             bLocal -= aLocal;
@@ -1591,15 +1608,10 @@ internal static partial class PrimeOrderGpuHeuristics
         }
     }
 
-    private static bool Pow2EqualsOneKernel(ulong exponent, in MontgomeryDivisorData divisor)
-    {
-        return ULongExtensions.Pow2MontgomeryModWindowedKernel(exponent, divisor, keepMontgomery: false) == 1UL;
-    }
-
     private static ulong CalculateByDoublingKernel(ulong prime)
     {
         ulong order = 1UL;
-        ulong value = 2UL % prime;
+        ulong value = 2UL; // Candidate primes exceed two, so the modulo would always return two.
 
         while (value != 1UL)
         {
@@ -1617,10 +1629,11 @@ internal static partial class PrimeOrderGpuHeuristics
 
     private static GpuPow2ModStatus TryPow2ModBatchInternal(ReadOnlySpan<UInt128> exponents, UInt128 prime, Span<UInt128> remainders)
     {
-        if (exponents.Length == 0)
-        {
-            return GpuPow2ModStatus.Success;
-        }
+        // Residue batches are never empty on production workloads, so skip the zero-length success shortcut.
+        // if (exponents.Length == 0)
+        // {
+        //     return GpuPow2ModStatus.Success;
+        // }
 
         if (remainders.Length < exponents.Length)
         {
@@ -1696,27 +1709,30 @@ internal static partial class PrimeOrderGpuHeuristics
     private static void ComputePow2ModCpu(ReadOnlySpan<ulong> exponents, ulong prime, in MontgomeryDivisorData divisorData, Span<ulong> results)
     {
         int length = exponents.Length;
+        ulong modulus = divisorData.Modulus;
+        _ = prime; // modulus and divisorData both describe the same q; retain the parameter to preserve the public signature.
         for (int i = 0; i < length; i++)
         {
-            results[i] = Pow2ModCpu(exponents[i], prime, divisorData);
+            results[i] = exponents[i].Pow2ModWindowedCpu(modulus);
         }
     }
 
     private static bool TryComputeOnGpuWide(ReadOnlySpan<UInt128> exponents, UInt128 prime, Span<UInt128> results)
     {
         int length = exponents.Length;
-        if (length == 0)
-        {
-            return true;
-        }
+        // Production launches always carry work, so keep the empty-batch shortcut commented out.
+        // if (length == 0)
+        // {
+        //     return true;
+        // }
 
         GpuUInt128[]? rentedExponents = null;
         GpuUInt128[]? rentedResults = null;
         var lease = GpuKernelPool.GetKernel(useGpuOrder: true);
+        var execution = lease.EnterExecutionScope();
 
         try
         {
-            var execution = lease.EnterExecutionScope();
             Accelerator accelerator = lease.Accelerator;
             AcceleratorStream stream = lease.Stream;
             var kernel = GetPow2ModWideKernel(accelerator);
@@ -1753,7 +1769,6 @@ internal static partial class PrimeOrderGpuHeuristics
 
             exponentBuffer.Dispose();
             remainderBuffer.Dispose();
-            execution.Dispose();
             return true;
         }
         catch (Exception)
@@ -1763,6 +1778,8 @@ internal static partial class PrimeOrderGpuHeuristics
         }
         finally
         {
+            // Small batches use the stack-allocated fast path, leaving the rented arrays null. Retain the guards so pooled
+            // buffers are only returned when they were actually leased.
             if (rentedExponents is not null)
             {
                 ArrayPool<GpuUInt128>.Shared.Return(rentedExponents, clearArray: false);
@@ -1773,6 +1790,7 @@ internal static partial class PrimeOrderGpuHeuristics
                 ArrayPool<GpuUInt128>.Shared.Return(rentedResults, clearArray: false);
             }
 
+            execution.Dispose();
             lease.Dispose();
         }
     }
@@ -1786,16 +1804,6 @@ internal static partial class PrimeOrderGpuHeuristics
         }
     }
 
-    private static ulong Pow2ModCpu(ulong exponent, ulong modulus, in MontgomeryDivisorData divisorData)
-    {
-        if (modulus <= 1UL)
-        {
-            return 0UL;
-        }
-
-        return ULongExtensions.Pow2MontgomeryModWindowedKernel(exponent, divisorData, keepMontgomery: false);
-    }
-
     private static Action<AcceleratorStream, Index1D, ArrayView1D<ulong, Stride1D.Dense>, MontgomeryDivisorData, ArrayView1D<ulong, Stride1D.Dense>> GetPow2ModKernel(Accelerator accelerator)
     {
         return Pow2ModKernelCache.GetOrAdd(accelerator, static accel =>
@@ -1808,8 +1816,17 @@ internal static partial class PrimeOrderGpuHeuristics
 
     private static void Pow2ModKernel(Index1D index, ArrayView1D<ulong, Stride1D.Dense> exponents, MontgomeryDivisorData divisor, ArrayView1D<ulong, Stride1D.Dense> remainders)
     {
+        ulong modulus = divisor.Modulus;
+        // The by-divisor heuristics call this kernel only with odd prime moduli, so the defensive branch stays commented to
+        // document the invariant without spending a branch in the kernel.
+        // if (modulus <= 1UL || (modulus & 1UL) == 0UL)
+        // {
+        //     remainders[index] = 0UL;
+        //     return;
+        // }
+
         ulong exponent = exponents[index];
-        remainders[index] = ULongExtensions.Pow2MontgomeryModWindowedKernel(exponent, divisor, keepMontgomery: false);
+        remainders[index] = exponent.Pow2ModWindowedGpu(modulus);
     }
 
     private static Action<AcceleratorStream, Index1D, ArrayView1D<GpuUInt128, Stride1D.Dense>, GpuUInt128, ArrayView1D<GpuUInt128, Stride1D.Dense>> GetPow2ModWideKernel(Accelerator accelerator)

PerfectNumbers.Core/Gpu/ReadOnlyGpuUInt128.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 

PerfectNumbers.Core/IMersenneNumberDivisorByDivisorTester.cs

@@ -1,3 +1,5 @@
+using System;
+
 namespace PerfectNumbers.Core;
 
 public interface IMersenneNumberDivisorByDivisorTester
@@ -10,14 +12,16 @@ public interface IMersenneNumberDivisorByDivisorTester
 
     ulong GetAllowedMaxDivisor(ulong prime);
 
-    bool IsPrime(ulong prime, out bool divisorsExhausted);
+    bool IsPrime(ulong prime, out bool divisorsExhausted, TimeSpan? timeLimit = null);
 
     IDivisorScanSession CreateDivisorSession();
 
-    void PrepareCandidates(in ReadOnlySpan<ulong> primes, Span<ulong> allowedMaxValues);
+    void PrepareCandidates(ReadOnlySpan<ulong> primes, Span<ulong> allowedMaxValues);
 
-    public interface IDivisorScanSession : IDisposable
+    public interface IDivisorScanSession
     {
-        void CheckDivisor(ulong divisor, in MontgomeryDivisorData divisorData, ulong divisorCycle, in ReadOnlySpan<ulong> primes, Span<byte> hits);
+        void CheckDivisor(ulong divisor, in MontgomeryDivisorData divisorData, ulong divisorCycle, ReadOnlySpan<ulong> primes, Span<byte> hits);
+
+        void Dispose();
     }
 }

PerfectNumbers.Core/MersenneDivisorCycles.cs

@@ -1,9 +1,12 @@
+using System;
 using System.Buffers;
 using System.Buffers.Binary;
+using System.Collections.Generic;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Security.Cryptography;
 using System.Text;
+using System.Threading;
 using PerfectNumbers.Core.Gpu;
 using ILGPU;
 using ILGPU.Runtime;
@@ -15,6 +18,13 @@ public class MersenneDivisorCycles
     private List<(ulong divisor, ulong cycleLength)> _table = [];
     // Lightweight read-mostly cache for small divisors (<= 4,000,000). 0 => unknown
     private ulong[]? _smallCycles;
+
+    [ThreadStatic]
+    private static Dictionary<ulong, int>? s_factorCountsPool;
+
+    [ThreadStatic]
+    private static Dictionary<ulong, int>? s_factorScratchPool;
+
     public static MersenneDivisorCycles Shared { get; } = new MersenneDivisorCycles();
 
     public MersenneDivisorCycles()
@@ -64,23 +74,27 @@ public class MersenneDivisorCycles
             return true;
         }
 
-        if (exponent <= 1UL || divisor <= 1UL || (divisor & 1UL) == 0UL)
-        {
-            return false;
-        }
+        // Exponent and divisor validation happens during scheduling, so the defensive guard remains commented out to keep the
+        // hot path branch-free.
+        // if (exponent <= 1UL || divisor <= 1UL || (divisor & 1UL) == 0UL)
+        // {
+        //     return false;
+        // }
 
-        if (divisor <= PerfectNumberConstants.MaxQForDivisorCycles)
-        {
-            var small = Shared._smallCycles;
-            if (small is not null)
-            {
-                ulong cached = small[(int)divisor];
-                if (cached != 0UL)
-                {
-                    return cached == exponent;
-                }
-            }
-        }
+        // Production scans never revisit divisors in the small-cycle snapshot, so skip the legacy lookup here. Factoring and
+        // diagnostics can query TryMatchSmallCycleForFactoring when they need those cached values.
+        // if (divisor <= PerfectNumberConstants.MaxQForDivisorCycles)
+        // {
+        //     var small = Shared._smallCycles;
+        //     if (small is not null)
+        //     {
+        //         ulong cached = small[(int)divisor];
+        //         if (cached != 0UL)
+        //         {
+        //             return cached == exponent;
+        //         }
+        //     }
+        // }
 
         if (TryCalculateCycleLengthHeuristic(divisor, divisorData, out ulong heuristicCycle) && heuristicCycle != 0UL)
         {
@@ -88,6 +102,7 @@ public class MersenneDivisorCycles
         }
 
         Dictionary<ulong, FactorCacheEntry>? cache = factorCache;
+        // Each by-divisor scan session starts with a null cache and fills it lazily, so keep the allocation guard in place.
         if (cache is null)
         {
             cache = new Dictionary<ulong, FactorCacheEntry>(8);
@@ -99,7 +114,7 @@ public class MersenneDivisorCycles
             return cycleLength == exponent;
         }
 
-        return exponent.Pow2MontgomeryModWindowedCpu(divisorData, keepMontgomery: false) == 1UL;
+        return exponent.Pow2ModWindowedCpu(divisorData.Modulus) == 1UL;
     }
 
     public static bool CycleEqualsExponentForMersenneCandidate(ulong divisor, in MontgomeryDivisorData divisorData, ulong exponent)
@@ -109,35 +124,70 @@ public class MersenneDivisorCycles
             return false;
         }
 
-        if (divisor <= PerfectNumberConstants.MaxQForDivisorCycles)
+        // Candidate divisors on the production path sit well above the precomputed snapshot, so skip the small-cycle lookup
+        // here and leave factoring scenarios to call TryMatchSmallCycleForFactoring when necessary.
+        // if (divisor <= PerfectNumberConstants.MaxQForDivisorCycles)
+        // {
+        //     MersenneDivisorCycles shared = Shared;
+        //     ulong[]? small = shared._smallCycles;
+        //     if (small is not null)
+        //     {
+        //         ulong cached = small[(int)divisor];
+        //         if (cached != 0UL)
+        //         {
+        //             return cached == exponent;
+        //         }
+        //     }
+        // }
+
+        return exponent.Pow2ModWindowedCpu(divisorData.Modulus) == 1UL;
+    }
+
+    public static bool TryMatchSmallCycleForFactoring(ulong divisor, ulong exponent, out ulong cycleLength)
+    {
+        if (divisor > PerfectNumberConstants.MaxQForDivisorCycles)
         {
-            MersenneDivisorCycles shared = Shared;
-            ulong[]? small = shared._smallCycles;
-            if (small is not null)
-            {
-                ulong cached = small[(int)divisor];
-                if (cached != 0UL)
-                {
-                    return cached == exponent;
-                }
-            }
+            // Factoring helpers probe arbitrary divisors, so anything above the snapshot limit legitimately misses here.
+            cycleLength = 0UL;
+            return false;
         }
 
-        return exponent.Pow2MontgomeryModWindowedCpu(divisorData, keepMontgomery: false) == 1UL;
+        ulong[]? small = Shared._smallCycles;
+        if (small is null)
+        {
+            // Snapshot recycling during diagnostics can temporarily clear the table; surface the miss so callers recompute.
+            cycleLength = 0UL;
+            return false;
+        }
+
+        ulong cached = small[(int)divisor];
+        if (cached == 0UL)
+        {
+            // Only a subset of small divisors carry cached cycles; signal the miss so factoring falls back to the GPU helper.
+            cycleLength = 0UL;
+            return false;
+        }
+
+        cycleLength = cached;
+        return cached == exponent;
     }
 
     private static bool IsValidMersenneDivisorCandidate(ulong divisor, ulong exponent)
     {
-        if (exponent <= 1UL || divisor <= 1UL || (divisor & 1UL) == 0UL)
-        {
-            return false;
-        }
+        // Production workloads pre-filter invalid inputs, so skip the defensive guards here. Factoring and diagnostics should
+        // validate inputs before calling into the candidate path.
+        // if (exponent <= 1UL || divisor <= 1UL || (divisor & 1UL) == 0UL)
+        // {
+        //     return false;
+        // }
 
         UInt128 step = (UInt128)exponent << 1;
-        if (step == UInt128.Zero)
-        {
-            return false;
-        }
+        // The overflow bail-out is handled by factoring-specific call sites; keep the historical branch commented to document the
+        // legacy behavior.
+        // if (step == UInt128.Zero)
+        // {
+        //     return false;
+        // }
 
         UInt128 adjusted = (UInt128)divisor - UInt128.One;
         return adjusted % step == UInt128.Zero;
@@ -146,7 +196,7 @@ public class MersenneDivisorCycles
     public static IEnumerable<(ulong divisor, ulong cycleLength)> EnumerateStream(Stream compressor)
     {
         // Binary pairs: (ulong divisor, ulong cycle)
-        using var reader = new BinaryReader(compressor, Encoding.UTF8, leaveOpen: true);
+        var reader = new BinaryReader(compressor, Encoding.UTF8, leaveOpen: true);
         while (true)
         {
             ulong d, c;
@@ -157,6 +207,7 @@ public class MersenneDivisorCycles
             }
             catch (EndOfStreamException)
             {
+                reader.Dispose();
                 yield break;
             }
 
@@ -262,7 +313,7 @@ public class MersenneDivisorCycles
     }
 
     public static bool TryCalculateCycleLengthForExponent(
-        ulong divisor,
+        ulong divisor,        
         ulong exponent,
         in MontgomeryDivisorData divisorData,
         Dictionary<ulong, FactorCacheEntry>? factorCache,
@@ -270,17 +321,24 @@ public class MersenneDivisorCycles
     {
         cycleLength = 0UL;
 
-        if ((divisor & (divisor - 1UL)) == 0UL)
-        {
-            cycleLength = 1UL;
-            return true;
-        }
+        // The by-divisor scanner only supplies odd candidates of the form 2*k*exponent + 1,
+        // so this power-of-two fast-path never triggers on that call path.
+        // The historical fast-path is left here for reference but commented out because it is unreachable
+        // on the EvenPerfectBitScanner pipeline.
+        // if ((divisor & (divisor - 1UL)) == 0UL)
+        // {
+        //     cycleLength = 1UL;
+        //     return true;
+        // }
 
-        if (divisor <= 3UL || exponent <= 1UL)
-        {
-            cycleLength = CalculateCycleLength(divisor, divisorData);
-            return true;
-        }
+        // EvenPerfectBitScanner filters exponents <= 3 before invoking this helper and each
+        // divisor candidate is at least 2 * exponent + 1, so this guard never matches.
+        // The fallback calculation is therefore unreachable on the active call path.
+        // if (divisor <= 3UL || exponent <= 1UL)
+        // {
+        //     cycleLength = CalculateCycleLength(divisor, divisorData);
+        //     return true;
+        // }
 
         ulong computedOrder = PrimeOrderCalculator.Calculate(
             divisor,
@@ -295,8 +353,9 @@ public class MersenneDivisorCycles
         }
 
         ulong phi = divisor - 1UL;
-        // A zero totient would imply divisor == 0, which never occurs on the tested path. Keep the guard documented without
-        // branching in the hot loop.
+        // Divisors reach this helper only when they exceed the cached table, which means
+        // divisor >= 2 * exponent + 1 and phi cannot underflow to zero here.
+        // The defensive underflow guard is kept for posterity but disabled for the EvenPerfectBitScanner path.
         // if (phi == 0UL)
         // {
         //     return false;
@@ -304,38 +363,43 @@ public class MersenneDivisorCycles
 
         int twoCount = BitOperations.TrailingZeroCount(phi);
         ulong reducedPhi = phi >> twoCount;
-        if (reducedPhi == 0UL || (reducedPhi % exponent) != 0UL)
-        {
-            return false;
-        }
+        // Every divisor candidate generated by the by-divisor scan satisfies q ≡ 1 (mod 2 * exponent),
+        // ensuring reducedPhi keeps a factor of exponent and remains non-zero in this context.
+        // The divisibility check is therefore unreachable for the current caller and is commented out.
+        // if (reducedPhi == 0UL || (reducedPhi % exponent) != 0UL)
+        // {
+        //     return false;
+        // }
 
         ulong k = reducedPhi / exponent;
-        // k == 0 would indicate reducedPhi < exponent, which the EvenPerfectBitScanner call flow prevents. Document the
-        // assumption instead of branching.
+        // reducedPhi always contains at least one factor of exponent, so dividing by exponent leaves k >= 1.
         // if (k == 0UL)
         // {
         //     return false;
         // }
 
-        Dictionary<ulong, int> factorCounts = ThreadStaticPools.RentFactorCountDictionary();
-        bool success = false;
-
-        if (twoCount > 0)
+        Dictionary<ulong, int> factorCounts = AcquireFactorCountDictionary(8);
+        try
         {
+            // The divisor candidates are odd, so phi is even and this branch always records at least one factor of two.
+            // if (twoCount > 0)
+            // {
+            //     factorCounts[2UL] = twoCount;
+            // }
             factorCounts[2UL] = twoCount;
+
+            if (!AccumulateFactors(exponent, factorCache, factorCounts, cacheResult: true) || !AccumulateFactors(k, factorCache, factorCounts, cacheResult: false))
+            {
+                return false;
+            }
+
+            cycleLength = ReduceOrder(divisorData, phi, factorCounts, exponent);
+            return true;
         }
-
-        bool exponentAccumulated = AccumulateFactors(exponent, factorCache, factorCounts, cacheResult: true);
-        bool factorsAccumulated = exponentAccumulated && AccumulateFactors(k, factorCache, factorCounts, cacheResult: false);
-
-        if (factorsAccumulated)
+        finally
         {
-            cycleLength = ReduceOrder(divisorData, phi, factorCounts);
-            success = true;
+            ReleaseFactorCountDictionary(factorCounts);
         }
-
-        ThreadStaticPools.ReturnFactorCountDictionary(factorCounts);
-        return success;
     }
 
     private static bool AccumulateFactors(
@@ -349,99 +413,127 @@ public class MersenneDivisorCycles
             return true;
         }
 
-        if (!TryGetFactorization(value, cache, cacheResult, out FactorCacheEntry? factorization, out bool releaseAfterUse) || factorization is null)
-        {
-            return false;
-        }
+        FactorCacheEntry cachedFactorization;
+        PrimeFactorPartialResult? lease = null;
+        bool fromCache;
 
-        FactorCacheEntry actualFactorization = factorization;
-        KeyValuePair<ulong, int>[]? pairs = actualFactorization.Pairs;
-        if (pairs is not null)
+        try
         {
-            int length = actualFactorization.Count;
-
-            for (int i = 0; i < length; i++)
+            if (!TryGetFactorization(value, cache, cacheResult, out cachedFactorization, out lease, out fromCache))
             {
-                KeyValuePair<ulong, int> pair = pairs[i];
-                AddFactor(counts, pair.Key, pair.Value);
+                return false;
             }
-        }
 
-        if (releaseAfterUse)
+            if (fromCache)
+            {
+                ulong[] primes = cachedFactorization.Primes;
+                byte[] exponents = cachedFactorization.Exponents;
+                int length = cachedFactorization.Count;
+
+                for (int i = 0; i < length; i++)
+                {
+                    AddFactor(counts, primes[i], exponents[i]);
+                }
+
+                return true;
+            }
+
+            if (lease is null || lease.Count == 0)
+            {
+                return true;
+            }
+
+            ReadOnlySpan<ulong> primesSpan = lease.Primes;
+            ReadOnlySpan<byte> exponentsSpan = lease.Exponents;
+            int spanLength = lease.Count;
+
+            for (int i = 0; i < spanLength; i++)
+            {
+                AddFactor(counts, primesSpan[i], exponentsSpan[i]);
+            }
+
+            return true;
+        }
+        finally
         {
-            actualFactorization.ReturnToPool();
+            lease?.Dispose();
         }
-
-        return true;
     }
 
     private static bool TryGetFactorization(
         ulong value,
         Dictionary<ulong, FactorCacheEntry>? cache,
         bool cacheResult,
-        out FactorCacheEntry? factorization,
-        out bool releaseAfterUse)
+        out FactorCacheEntry factorization,
+        out PrimeFactorPartialResult? lease,
+        out bool fromCache)
     {
-        releaseAfterUse = false;
+        factorization = default;
+        lease = null;
+        fromCache = false;
 
-        if (cache is not null && cache.TryGetValue(value, out FactorCacheEntry? cachedEntry))
+        if (value <= 1UL)
         {
-            factorization = cachedEntry;
             return true;
         }
 
-        Dictionary<ulong, int> scratch = ThreadStaticPools.RentFactorScratchDictionary();
-        bool factored = TryFactorIntoCountsInternal(value, scratch);
-        if (!factored)
+        if (cache is not null && cache.TryGetValue(value, out factorization))
         {
-            ThreadStaticPools.ReturnFactorScratchDictionary(scratch);
-            factorization = null;
-            return false;
+            fromCache = true;
+            return true;
         }
 
-        int count = scratch.Count;
-        FactorCacheEntry entry = ThreadStaticPools.RentFactorCacheEntry();
-        if (count == 0)
+        Dictionary<ulong, int> scratch = AcquireFactorScratchDictionary(8);
+        try
         {
-            entry.Initialize(null, 0, fromPool: false);
-            factorization = entry;
-            releaseAfterUse = cache is null || !cacheResult;
-            if (cache is not null && cacheResult)
+            if (!TryFactorIntoCountsInternal(value, scratch))
             {
-                cache[value] = entry;
+                factorization = default;
+                return false;
+            }
+
+            int count = scratch.Count;
+            if (count == 0)
+            {
+                return true;
+            }
+
+            PrimeFactorPartialResult result = PrimeFactorPartialResult.Rent(count);
+            lease = result;
+
+            Span<ulong> primes = result.PrimeWriteSpan;
+            Span<byte> exponents = result.ExponentWriteSpan;
+            int index = 0;
+            foreach (KeyValuePair<ulong, int> entry in scratch)
+            {
+                primes[index] = entry.Key;
+                exponents[index] = checked((byte)entry.Value);
+                index++;
+            }
+
+            result.CommitCount(index);
+            result.Sort();
+
+            if (cache is not null && cacheResult)
+            {
+                FactorCacheEntry cacheEntry = result.ToCacheEntry();
+                cache[value] = cacheEntry;
             }
 
-            ThreadStaticPools.ReturnFactorScratchDictionary(scratch);
             return true;
         }
-
-        KeyValuePair<ulong, int>[] pairs = ThreadStaticPools.FactorKeyValuePairPool.Rent(count);
-        ((ICollection<KeyValuePair<ulong, int>>)scratch).CopyTo(pairs, 0);
-        ThreadStaticPools.ReturnFactorScratchDictionary(scratch);
-        Array.Sort(pairs, 0, count, FactorPairValueComparer.Instance);
-
-        entry.Initialize(pairs, count, fromPool: true);
-        factorization = entry;
-
-        if (cache is not null && cacheResult)
+        finally
         {
-            cache[value] = entry;
+            ReleaseFactorScratchDictionary(scratch);
         }
-        else
-        {
-            releaseAfterUse = true;
-        }
-
-        return true;
     }
 
     private static bool TryFactorIntoCountsInternal(ulong value, Dictionary<ulong, int> counts)
     {
-        // The EvenPerfectBitScanner only requests factors for values >= 2 here. Leave the guard documented without executing it.
-        // if (value <= 1UL)
-        // {
-        //     return true;
-        // }
+        if (value <= 1UL)
+        {
+            return true;
+        }
 
         ulong remaining = value;
         uint[] smallPrimes = PrimesGenerator.SmallPrimes;
@@ -456,7 +548,6 @@ public class MersenneDivisorCycles
                 break;
             }
 
-            // TODO: Reuse the remainder-tracking update from the cycle heuristic so repeated divisions disappear from this loop.
             while ((remaining % prime) == 0UL)
             {
                 AddFactor(counts, prime);
@@ -469,43 +560,20 @@ public class MersenneDivisorCycles
             return true;
         }
 
-        // TODO: Benchmark PrimeTester.IsPrimeInternal against Open.Numeric.Primes on the EvenPerfectBitScanner workloads to confirm the faster option for wide composites.
         if (PrimeTester.IsPrimeInternal(remaining, CancellationToken.None))
         {
             AddFactor(counts, remaining);
             return true;
         }
 
-        // TODO: Evaluate folding the remainder-tracking mechanism into PollardRho64 so the walk leverages previously computed residues.
         ulong factor = PollardRho64(remaining);
         if (factor == 0UL || factor == remaining)
         {
-            // Pollard-Rho can still stall on rare stubborn composites during test and benchmark runs, so keep the failure guard in place
-            // and let the caller fall back to the cached cycle calculator.
             return false;
         }
 
-        // TODO: Investigate computing this quotient via remainder tracking or reciprocal multiplication to avoid the division.
         ulong quotient = remaining / factor;
-        // Pollard-Rho never returns factors <= 1 on the EvenPerfectBitScanner path; keep the old guard documented
-        // for completeness without branching in the hot path.
-        // if (factor > 1UL && !TryFactorIntoCountsInternal(factor, counts))
-        // {
-        //     return false;
-        // }
-
-        if (!TryFactorIntoCountsInternal(factor, counts))
-        {
-            return false;
-        }
-
-        // Guard the recursive calls to terminate once Pollard-Rho reduces either branch to 1.
-        if (quotient > 1UL && !TryFactorIntoCountsInternal(quotient, counts))
-        {
-            return false;
-        }
-
-        return true;
+        return TryFactorIntoCountsInternal(factor, counts) && TryFactorIntoCountsInternal(quotient, counts);
     }
 
     private static void AddFactor(Dictionary<ulong, int> counts, ulong factor)
@@ -532,15 +600,22 @@ public class MersenneDivisorCycles
         }
     }
 
-    private static ulong ReduceOrder(in MontgomeryDivisorData divisorData, ulong initialOrder, Dictionary<ulong, int> factorCounts)
+    private static ulong ReduceOrder(
+        in MontgomeryDivisorData divisorData,
+        ulong initialOrder,
+        Dictionary<ulong, int> factorCounts,
+        ulong targetOrder)
     {
-        if (factorCounts.Count == 0)
+        if (factorCounts.Count == 0 || initialOrder == targetOrder)
         {
             return initialOrder;
         }
 
         int count = factorCounts.Count;
-        ulong[] primes = ArrayPool<ulong>.Shared.Rent(count);
+        bool rentFromPool = count >= PerfectNumberConstants.PooledArrayThreshold;
+        ulong[] primes = rentFromPool
+            ? ThreadLocalArrayPool<ulong>.Shared.Rent(count)
+            : new ulong[count];
         try
         {
             int index = 0;
@@ -569,6 +644,13 @@ public class MersenneDivisorCycles
                     if (candidate.Pow2MontgomeryModWindowedCpu(divisorData, keepMontgomery: false) == 1UL)
                     {
                         order = candidate;
+                        if (order == targetOrder)
+                        {
+                            // Early-exit once the order matches the tested exponent;
+                            // further factor processing would not change the outcome for the by-divisor scan.
+                            return order;
+                        }
+
                         continue;
                     }
 
@@ -580,7 +662,10 @@ public class MersenneDivisorCycles
         }
         finally
         {
-            ArrayPool<ulong>.Shared.Return(primes, clearArray: false);
+            if (rentFromPool)
+            {
+                ThreadLocalArrayPool<ulong>.Shared.Return(primes, clearArray: false);
+            }
         }
     }
 
@@ -653,6 +738,53 @@ public class MersenneDivisorCycles
         }
     }
 
+    // Thread-local dictionary pools keep the factoring helpers reusable so the GC stays out of the by-divisor CPU loop.
+    private static Dictionary<ulong, int> AcquireFactorCountDictionary(int capacityHint)
+    {
+        Dictionary<ulong, int>? dictionary = s_factorCountsPool;
+        if (dictionary is null)
+        {
+            return new Dictionary<ulong, int>(capacityHint);
+        }
+
+        s_factorCountsPool = null;
+        dictionary.Clear();
+        dictionary.EnsureCapacity(capacityHint);
+        return dictionary;
+    }
+
+    private static void ReleaseFactorCountDictionary(Dictionary<ulong, int> dictionary)
+    {
+        dictionary.Clear();
+        if (s_factorCountsPool is null)
+        {
+            s_factorCountsPool = dictionary;
+        }
+    }
+
+    private static Dictionary<ulong, int> AcquireFactorScratchDictionary(int capacityHint)
+    {
+        Dictionary<ulong, int>? dictionary = s_factorScratchPool;
+        if (dictionary is null)
+        {
+            return new Dictionary<ulong, int>(capacityHint);
+        }
+
+        s_factorScratchPool = null;
+        dictionary.Clear();
+        dictionary.EnsureCapacity(capacityHint);
+        return dictionary;
+    }
+
+    private static void ReleaseFactorScratchDictionary(Dictionary<ulong, int> dictionary)
+    {
+        dictionary.Clear();
+        if (s_factorScratchPool is null)
+        {
+            s_factorScratchPool = dictionary;
+        }
+    }
+
     private static ulong NextRandomUInt64()
     {
         Span<byte> buffer = stackalloc byte[8];
@@ -660,66 +792,19 @@ public class MersenneDivisorCycles
         return BinaryPrimitives.ReadUInt64LittleEndian(buffer);
     }
 
-    private sealed class FactorPairValueComparer : IComparer<KeyValuePair<ulong, int>>
+    public readonly struct FactorCacheEntry
     {
-        public static readonly FactorPairValueComparer Instance = new FactorPairValueComparer();
-
-        private FactorPairValueComparer()
+        public FactorCacheEntry(ulong[] primes, byte[] exponents, int count)
         {
-        }
-
-        public int Compare(KeyValuePair<ulong, int> x, KeyValuePair<ulong, int> y)
-        {
-            if (x.Key < y.Key)
-            {
-                return -1;
-            }
-
-            if (x.Key > y.Key)
-            {
-                return 1;
-            }
-
-            return 0;
-        }
-    }
-
-    public sealed class FactorCacheEntry
-    {
-        internal FactorCacheEntry? Next;
-        internal KeyValuePair<ulong, int>[]? Pairs;
-        internal int Count;
-        private bool _fromPool;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal void Reset()
-        {
-            Pairs = null;
-            Count = 0;
-            _fromPool = false;
-            Next = null;
-        }
-
-        internal void Initialize(KeyValuePair<ulong, int>[]? pairs, int count, bool fromPool)
-        {
-            Pairs = pairs;
+            Primes = primes;
+            Exponents = exponents;
             Count = count;
-            _fromPool = fromPool;
-            Next = null;
         }
+        public ulong[] Primes { get; }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal void ReturnToPool()
-        {
-            KeyValuePair<ulong, int>[]? pairs = Pairs;
-            if (_fromPool && pairs is not null)
-            {
-                ThreadStaticPools.FactorKeyValuePairPool.Return(pairs, clearArray: false);
-            }
+        public byte[] Exponents { get; }
 
-            Reset();
-            ThreadStaticPools.ReturnFactorCacheEntry(this);
-        }
+        public int Count { get; }
     }
 
     public static (long nextPosition, long completeCount) FindLast(string path)
@@ -745,7 +830,7 @@ public class MersenneDivisorCycles
         // Start fresh to avoid mixing formats
         outputStream.SetLength(0L);
         outputStream.Position = 0L;
-        using var writer = new BinaryWriter(outputStream, Encoding.UTF8, leaveOpen: false);
+        var writer = new BinaryWriter(outputStream, Encoding.UTF8, leaveOpen: false);
         for (var taskIndex = 0; taskIndex < threads; taskIndex++)
         {
             ulong threadStart = start + (ulong)taskIndex * blockSize;
@@ -766,7 +851,11 @@ public class MersenneDivisorCycles
             tasks[taskIndex] = Task.Run(() =>
             {
                 ulong rangeLength = localEnd - localStart + 1UL;
-                (ulong divisor, ulong cycle)[] localCycles = ArrayPool<(ulong, ulong)>.Shared.Rent(checked((int)rangeLength));
+                int localLength = checked((int)rangeLength);
+                bool rentLocalCycles = localLength >= PerfectNumberConstants.PooledArrayThreshold;
+                (ulong divisor, ulong cycle)[] localCycles = rentLocalCycles
+                    ? ThreadLocalArrayPool<(ulong, ulong)>.Shared.Rent(localLength)
+                    : new (ulong divisor, ulong cycle)[localLength];
                 int localCycleIndex = 0;
 
                 try
@@ -814,12 +903,16 @@ public class MersenneDivisorCycles
                 }
                 finally
                 {
-                    ArrayPool<(ulong, ulong)>.Shared.Return(localCycles, clearArray: false);
+                    if (rentLocalCycles)
+                    {
+                        ThreadLocalArrayPool<(ulong, ulong)>.Shared.Return(localCycles, clearArray: false);
+                    }
                 }
             });
         }
 
         Task.WaitAll(tasks);
+        writer.Dispose();
     }
 
     public static void GenerateGpu(string path, ulong maxDivisor, int batchSize = 1_000_000, long skipCount = 0L, long nextPosition = 0L)
@@ -829,7 +922,7 @@ public class MersenneDivisorCycles
         ulong start = 3UL;
         var locker = new object();
 
-        var pool = ArrayPool<ulong>.Shared;
+        var pool = ThreadLocalArrayPool<ulong>.Shared;
         ulong batchSizeUL = (ulong)batchSize, d, end;
         int count = (int)Math.Min(batchSizeUL, maxDivisor), i, idx;
         ulong[] divisors, outCycles, validDivisors;
@@ -856,7 +949,7 @@ public class MersenneDivisorCycles
             outputStream.Position = 0L;
         }
 
-        using var writer = new BinaryWriter(outputStream, Encoding.UTF8, leaveOpen: false);
+        var writer = new BinaryWriter(outputStream, Encoding.UTF8, leaveOpen: false);
         try
         {
             while (skipCount > 0L && start <= maxDivisor)
@@ -931,6 +1024,7 @@ public class MersenneDivisorCycles
             pool.Return(outCycles, clearArray: false);
         }
 
+        writer.Dispose();
         stream.Dispose();
         lease.Dispose();
 
@@ -1034,17 +1128,22 @@ public class MersenneDivisorCycles
 
     internal static bool TryCalculateCycleLengthHeuristic(ulong divisor, in MontgomeryDivisorData divisorData, out ulong cycleLength)
     {
-        if ((divisor & (divisor - 1UL)) == 0UL)
-        {
-            cycleLength = 1UL;
-            return true;
-        }
+        // The by-divisor scanner only supplies odd candidates of the form 2*k*exponent + 1,
+        // so this power-of-two fast-path never triggers on that call path.
+        // The early exit is retained for reference but commented out because it is unreachable on the scanner path.
+        // if ((divisor & (divisor - 1UL)) == 0UL)
+        // {
+        //     cycleLength = 1UL;
+        //     return true;
+        // }
 
-        if (divisor <= 3UL)
-        {
-            cycleLength = CalculateCycleLengthFallback(divisor);
-            return true;
-        }
+        // By the divisor-by-divisor pipeline, candidates have the shape 2 * exponent * k + 1 with exponent >= 5,
+        // so the divisor never drops below 11 on this call path.
+        // if (divisor <= 3UL)
+        // {
+        //     cycleLength = CalculateCycleLengthFallback(divisor);
+        //     return true;
+        // }
 
         if (PrimeTester.IsPrimeInternal(divisor, CancellationToken.None))
         {

PerfectNumbers.Core/MersenneNumberDivisorByDivisorTester.cs

@@ -1,129 +1,139 @@
+using System;
 using System.Buffers;
+using System.Collections.Generic;
 using System.Globalization;
+using System.Threading.Tasks;
+using Open.Numeric.Primes;
 using System.Runtime.InteropServices;
 
 namespace PerfectNumbers.Core;
 
 public static class MersenneNumberDivisorByDivisorTester
 {
-	public static void Run(
-			List<ulong> candidates,
-			IMersenneNumberDivisorByDivisorTester tester,
-			Dictionary<ulong, (bool DetailedCheck, bool PassedAllTests)>? previousResults,
-			ulong startPrime,
-			Action markComposite,
-			Action clearComposite,
-			Action<ulong, bool, bool, bool> printResult,
-			int threadCount)
-	{
-		if (candidates.Count == 0)
-		{
-			Console.WriteLine("No candidates were provided for --mersenne=bydivisor.");
-			return;
-		}
+    public static void Run(
+            List<ulong> candidates,
+            IMersenneNumberDivisorByDivisorTester tester,
+            Dictionary<ulong, (bool DetailedCheck, bool PassedAllTests)>? previousResults,
+            ulong startPrime,
+            Action markComposite,
+            Action clearComposite,
+            Action<ulong, bool, bool, bool> printResult,
+            int threadCount,
+            TimeSpan? primeTestLimit)
+    {
+        if (candidates.Count == 0)
+        {
+            Console.WriteLine("No candidates were provided for --mersenne=bydivisor.");
+            return;
+        }
 
-		candidates.Sort();
-		Span<ulong> candidateSpan = CollectionsMarshal.AsSpan(candidates);
-		int candidateCount = candidateSpan.Length;
+        _ = threadCount;
 
-		bool applyStartPrime = startPrime > 0UL;
-		int skippedByPreviousResults = 0;
+        candidates.Sort();
+        Span<ulong> candidateSpan = CollectionsMarshal.AsSpan(candidates);
+        int candidateCount = candidateSpan.Length;
 
-		ArrayPool<ulong> pool = ThreadStaticPools.UlongPool;
-		if (previousResults is not null && previousResults.Count > 0)
-		{
-			int recordedCount = previousResults.Count;
-			ulong[] recordedCandidates = pool.Rent(recordedCount);
+        bool applyStartPrime = startPrime > 0UL;
+        int skippedByPreviousResults = 0;
 
-			Span<ulong> recordedSpan = recordedCandidates.AsSpan(0, recordedCount);
-			int recordedIndex = 0;
-			foreach (ulong value in previousResults.Keys)
-			{
-				recordedSpan[recordedIndex++] = value;
-			}
+        if (previousResults is not null && previousResults.Count > 0)
+        {
+            int recordedCount = previousResults.Count;
+            ulong[] recordedCandidates = ArrayPool<ulong>.Shared.Rent(recordedCount);
+            try
+            {
+                Span<ulong> recordedSpan = recordedCandidates.AsSpan(0, recordedCount);
+                int recordedIndex = 0;
+                foreach (ulong value in previousResults.Keys)
+                {
+                    recordedSpan[recordedIndex++] = value;
+                }
 
-			recordedSpan.Sort();
+                recordedSpan.Sort();
 
-			int writeIndex = 0;
-			int skipIndex = 0;
+                int writeIndex = 0;
+                int skipIndex = 0;
 
-			for (int readIndex = 0; readIndex < candidateCount; readIndex++)
-			{
-				ulong candidate = candidateSpan[readIndex];
+                for (int readIndex = 0; readIndex < candidateCount; readIndex++)
+                {
+                    ulong candidate = candidateSpan[readIndex];
 
-				while (skipIndex < recordedCount && recordedSpan[skipIndex] < candidate)
-				{
-					skipIndex++;
-				}
+                    while (skipIndex < recordedCount && recordedSpan[skipIndex] < candidate)
+                    {
+                        skipIndex++;
+                    }
 
-				if (skipIndex < recordedCount && recordedSpan[skipIndex] == candidate)
-				{
-					skippedByPreviousResults++;
-					skipIndex++;
-					continue;
-				}
+                    if (skipIndex < recordedCount && recordedSpan[skipIndex] == candidate)
+                    {
+                        skippedByPreviousResults++;
+                        skipIndex++;
+                        continue;
+                    }
 
-				candidateSpan[writeIndex++] = candidate;
-			}
+                    candidateSpan[writeIndex++] = candidate;
+                }
 
-			if (writeIndex < candidateCount)
-			{
-				candidates.RemoveRange(writeIndex, candidateCount - writeIndex);
-				candidateSpan = CollectionsMarshal.AsSpan(candidates);
-				candidateCount = candidateSpan.Length;
-			}
+                if (writeIndex < candidateCount)
+                {
+                    candidates.RemoveRange(writeIndex, candidateCount - writeIndex);
+                    candidateSpan = CollectionsMarshal.AsSpan(candidates);
+                    candidateCount = candidateSpan.Length;
+                }
+            }
+            finally
+            {
+                ArrayPool<ulong>.Shared.Return(recordedCandidates, clearArray: true);
+            }
+        }
 
-			pool.Return(recordedCandidates, clearArray: true);
-		}
+        if (skippedByPreviousResults > 0)
+        {
+            Console.WriteLine($"Skipped {skippedByPreviousResults.ToString(CultureInfo.InvariantCulture)} candidates excluded by previous results.");
+        }
 
-		if (skippedByPreviousResults > 0)
-		{
-			Console.WriteLine($"Skipped {skippedByPreviousResults.ToString(CultureInfo.InvariantCulture)} candidates excluded by previous results.");
-		}
+        int startIndex = 0;
+        if (applyStartPrime)
+        {
+            startIndex = candidates.BinarySearch(startPrime);
+            if (startIndex < 0)
+            {
+                startIndex = ~startIndex;
+            }
+            else
+            {
+                while (startIndex > 0 && candidates[startIndex - 1] >= startPrime)
+                {
+                    startIndex--;
+                }
+            }
+        }
 
-		int startIndex = 0;
-		if (applyStartPrime)
-		{
-			startIndex = candidates.BinarySearch(startPrime);
-			if (startIndex < 0)
-			{
-				startIndex = ~startIndex;
-			}
-			else
-			{
-				while (startIndex > 0 && candidates[startIndex - 1] >= startPrime)
-				{
-					startIndex--;
-				}
-			}
-		}
-
-		List<ulong> primesToTest = candidates;
-		Span<ulong> primesSpan = CollectionsMarshal.AsSpan(primesToTest);
-		ulong maxPrime = 0UL;
-		int primeWriteIndex = 0;
+        List<ulong> primesToTest = candidates;
+        Span<ulong> primesSpan = CollectionsMarshal.AsSpan(primesToTest);
+        ulong maxPrime = 0UL;
+        int primeWriteIndex = 0;
 
 		// This implementation is terribly slow, while this method expect prime p given as --filter-p input already.
 		// We don't need to additionally check it.
 
-		// using IEnumerator<ulong> primeEnumerator = Prime.Numbers.GetEnumerator();
-		// bool hasPrime = primeEnumerator.MoveNext();
-		// ulong currentPrime = hasPrime ? primeEnumerator.Current : 0UL;
+        // using IEnumerator<ulong> primeEnumerator = Prime.Numbers.GetEnumerator();
+        // bool hasPrime = primeEnumerator.MoveNext();
+        // ulong currentPrime = hasPrime ? primeEnumerator.Current : 0UL;
 
-		for (int index = startIndex; index < candidateCount; index++)
-		{
-			ulong candidate = primesSpan[index];
+        for (int index = startIndex; index < candidateCount; index++)
+        {
+            ulong candidate = primesSpan[index];
 
-			if (candidate <= 1UL)
-			{
-				markComposite();
-				printResult(candidate, false, false, false);
-				continue;
-			}
+            if (candidate <= 1UL)
+            {
+                markComposite();
+                printResult(candidate, false, false, false);
+                continue;
+            }
 
 			// This implementation is terribly slow, while this method expect prime p given as --filter-p input already.
 			// We don't need to additionally check it.
-
+			
 			// while (hasPrime && currentPrime < candidate)
 			// {
 			//     hasPrime = primeEnumerator.MoveNext();
@@ -145,118 +155,156 @@ public static class MersenneNumberDivisorByDivisorTester
 
 			primesSpan[primeWriteIndex++] = candidate;
 
-			if (candidate > maxPrime)
-			{
-				maxPrime = candidate;
-			}
-		}
+            if (candidate > maxPrime)
+            {
+                maxPrime = candidate;
+            }
+        }
 
-		if (primeWriteIndex < primesToTest.Count)
-		{
-			primesToTest.RemoveRange(primeWriteIndex, primesToTest.Count - primeWriteIndex);
-		}
+        if (primeWriteIndex < primesToTest.Count)
+        {
+            primesToTest.RemoveRange(primeWriteIndex, primesToTest.Count - primeWriteIndex);
+        }
 
-		if (primesToTest.Count == 0)
-		{
-			if (applyStartPrime)
-			{
-				Console.WriteLine($"No primes greater than or equal to {startPrime.ToString(CultureInfo.InvariantCulture)} were found for --mersenne=bydivisor.");
-			}
-			else
-			{
-				Console.WriteLine("No prime candidates remain for --mersenne=bydivisor after filtering.");
-			}
+        if (primesToTest.Count == 0)
+        {
+            if (applyStartPrime)
+            {
+                Console.WriteLine($"No primes greater than or equal to {startPrime.ToString(CultureInfo.InvariantCulture)} were found for --mersenne=bydivisor.");
+            }
+            else
+            {
+                Console.WriteLine("No prime candidates remain for --mersenne=bydivisor after filtering.");
+            }
 
-			return;
-		}
+            return;
+        }
 
-		if (maxPrime <= 1UL)
-		{
-			Console.WriteLine("The filter specified by --filter-p must contain at least one prime exponent greater than 1 for --mersenne=bydivisor.");
-			return;
-		}
+        // EvenPerfectBitScanner removes candidates <= 1 before reaching this point,
+        // so this guard never triggers during production runs.
+        // if (maxPrime <= 1UL)
+        // {
+        //     Console.WriteLine("The filter specified by --filter-p must contain at least one prime exponent greater than 1 for --mersenne=bydivisor.");
+        //     return;
+        // }
 
-		tester.ConfigureFromMaxPrime(maxPrime);
+        tester.ConfigureFromMaxPrime(maxPrime);
 
-		int primeCount = primesToTest.Count;
-		ulong[] primeBatch = pool.Rent(primeCount);
-		ulong[] allowedMaxBatch = pool.Rent(primeCount);
-		List<ulong> filteredPrimes = new(primeCount);
+        int primeCount = primesToTest.Count;
+        ulong[] primeBatch = ArrayPool<ulong>.Shared.Rent(primeCount);
+        ulong[] allowedMaxBatch = ArrayPool<ulong>.Shared.Rent(primeCount);
+        List<ulong> filteredPrimes = new(primeCount);
 
-		Span<ulong> primeSpan = primeBatch.AsSpan(0, primeCount);
-		Span<ulong> allowedMaxSpan = allowedMaxBatch.AsSpan(0, primeCount);
+        try
+        {
+            Span<ulong> primeSpan = primeBatch.AsSpan(0, primeCount);
+            Span<ulong> allowedMaxSpan = allowedMaxBatch.AsSpan(0, primeCount);
 
-		for (int i = 0; i < primeCount; i++)
-		{
-			primeSpan[i] = primesToTest[i];
-		}
+            for (int i = 0; i < primeCount; i++)
+            {
+                primeSpan[i] = primesToTest[i];
+            }
 
-		tester.PrepareCandidates(primeSpan, allowedMaxSpan);
+            tester.PrepareCandidates(primeSpan, allowedMaxSpan);
 
-		for (int i = 0; i < primeCount; i++)
-		{
-			ulong prime = primeSpan[i];
-			ulong allowedMax = allowedMaxSpan[i];
+            for (int i = 0; i < primeCount; i++)
+            {
+                ulong prime = primeSpan[i];
+                ulong allowedMax = allowedMaxSpan[i];
 
-			if (allowedMax < 3UL)
-			{
-				clearComposite();
-				printResult(prime, true, true, true);
-				continue;
-			}
+                if (allowedMax < 3UL)
+                {
+                    clearComposite();
+                    printResult(prime, true, true, true);
+                    continue;
+                }
 
-			filteredPrimes.Add(prime);
-		}
+                filteredPrimes.Add(prime);
+            }
+        }
+        finally
+        {
+            ArrayPool<ulong>.Shared.Return(allowedMaxBatch, clearArray: true);
+            ArrayPool<ulong>.Shared.Return(primeBatch, clearArray: true);
+        }
 
-		pool.Return(allowedMaxBatch, clearArray: true);
-		pool.Return(primeBatch, clearArray: true);
+        if (filteredPrimes.Count == 0)
+        {
+            if (applyStartPrime)
+            {
+                Console.WriteLine($"No primes greater than or equal to {startPrime.ToString(CultureInfo.InvariantCulture)} were found for --mersenne=bydivisor.");
+            }
 
-		if (filteredPrimes.Count == 0)
-		{
-			if (applyStartPrime)
-			{
-				Console.WriteLine($"No primes greater than or equal to {startPrime.ToString(CultureInfo.InvariantCulture)} were found for --mersenne=bydivisor.");
-			}
+            return;
+        }
 
-			return;
-		}
+        int workerCount = threadCount <= 0 ? Environment.ProcessorCount : threadCount;
+        if (workerCount < 1)
+        {
+            workerCount = 1;
+        }
 
-		int workerCount = threadCount <= 0 ? Environment.ProcessorCount : threadCount;
-		if (workerCount < 1)
-		{
-			workerCount = 1;
-		}
+        void ProcessPrime(ulong prime)
+        {
+            bool isPrime = tester.IsPrime(prime, out bool divisorsExhausted, primeTestLimit);
 
-		void ProcessPrime(ulong prime)
-		{
-			bool isPrime = tester.IsPrime(prime, out bool divisorsExhausted);
+            if (!isPrime)
+            {
+                markComposite();
+                printResult(prime, true, true, false);
+                return;
+            }
 
-			if (!isPrime)
-			{
-				markComposite();
-				printResult(prime, true, true, false);
-				return;
-			}
+            clearComposite();
+            printResult(prime, true, divisorsExhausted, true);
+        }
 
-			clearComposite();
-			printResult(prime, true, divisorsExhausted, true);
-		}
+        if (workerCount > filteredPrimes.Count)
+        {
+            workerCount = filteredPrimes.Count;
+        }
 
-		if (workerCount == 1)
-		{
-			foreach (ulong prime in filteredPrimes)
-			{
-				ProcessPrime(prime);
-			}
-		}
-		else
-		{
-			ParallelOptions options = new()
-			{
-				MaxDegreeOfParallelism = workerCount
-			};
+        if (workerCount <= 1)
+        {
+            foreach (ulong prime in filteredPrimes)
+            {
+                ProcessPrime(prime);
+            }
 
-			Parallel.ForEach(filteredPrimes, options, ProcessPrime);
-		}
-	}
+            return;
+        }
+
+        (int Start, int End)[] workerRanges = new (int, int)[workerCount];
+        int totalPrimeCount = filteredPrimes.Count;
+        int baseGroupSize = totalPrimeCount / workerCount;
+        int remaining = totalPrimeCount % workerCount;
+        int groupStartIndex = 0;
+
+        for (int workerIndex = 0; workerIndex < workerCount; workerIndex++)
+        {
+            int groupSize = baseGroupSize;
+            if (workerIndex < remaining)
+            {
+                groupSize++;
+            }
+
+            startIndex = groupStartIndex;
+            int endIndex = startIndex + groupSize;
+            workerRanges[workerIndex] = (startIndex, endIndex);
+            groupStartIndex = endIndex;
+        }
+
+        ParallelOptions parallelOptions = new()
+        {
+            MaxDegreeOfParallelism = workerCount
+        };
+
+        Parallel.ForEach(workerRanges, parallelOptions, range =>
+        {
+            for (int candidateIndex = range.Start; candidateIndex < range.End; candidateIndex++)
+            {
+                ProcessPrime(filteredPrimes[candidateIndex]);
+            }
+        });
+    }
 }

PerfectNumbers.Core/MontgomeryDivisorData.cs

@@ -1,3 +1,5 @@
+using System;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 
 namespace PerfectNumbers.Core;
@@ -43,32 +45,4 @@ public readonly struct MontgomeryDivisorData(ulong modulus, ulong nPrime, ulong
             montgomeryTwo,
             montgomeryTwoSquared);
     }
-
-}
-
-internal static class MontgomeryDivisorDataCache
-{
-    [ThreadStatic]
-    private static bool s_hasCachedValue;
-
-    [ThreadStatic]
-    private static ulong s_cachedModulus;
-
-    [ThreadStatic]
-    private static MontgomeryDivisorData s_cachedData;
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static MontgomeryDivisorData Get(ulong modulus)
-    {
-        if (s_hasCachedValue && s_cachedModulus == modulus)
-        {
-            return s_cachedData;
-        }
-
-        MontgomeryDivisorData computed = MontgomeryDivisorData.FromModulus(modulus);
-        s_cachedModulus = modulus;
-        s_cachedData = computed;
-        s_hasCachedValue = true;
-        return computed;
-    }
 }

PerfectNumbers.Core/MutableUInt128.cs

@@ -0,0 +1,243 @@
+using System;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+
+namespace PerfectNumbers.Core;
+
+/// <summary>
+/// Mutable helper for 128-bit arithmetic derived from the .NET runtime UInt128 implementation.
+/// Portions adapted from https://github.com/dotnet/runtime/blob/v8.0.0/src/libraries/System.Private.CoreLib/src/System/UInt128.cs.
+/// </summary>
+public struct MutableUInt128
+{
+    public ulong High;
+    public ulong Low;
+
+    public MutableUInt128(ulong value)
+    {
+        Low = value;
+    }
+
+    public MutableUInt128(ulong high, ulong low)
+    {
+        High = high;
+        Low = low;
+    }
+
+    public MutableUInt128(UInt128 value)
+    {
+        High = (ulong)(value >> 64);
+        Low = (ulong)value;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Set(ulong value)
+    {
+        High = 0UL;
+        Low = value;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Set(UInt128 value)
+    {
+        High = (ulong)(value >> 64);
+        Low = (ulong)value;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Set(ulong high, ulong low)
+    {
+        High = high;
+        Low = low;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly UInt128 ToUInt128() => ((UInt128)High << 64) | Low;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Add(ulong value)
+    {
+        ulong low = Low + value;
+        if (low < value)
+        {
+            High++;
+        }
+
+        Low = low;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Add(MutableUInt128 value)
+    {
+        ulong temp = Low + value.Low;
+        Low = temp;
+        temp = temp < Low ? 1UL : 0UL;
+		temp += High;
+		temp += value.High;
+        High = temp;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Sub(ulong value)
+    {
+        ulong temp = Low;
+        ulong result = temp - value;
+        temp = result > temp ? 1UL : 0UL;
+
+        Low = result;
+        High -= temp;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Sub(MutableUInt128 value)
+    {
+        ulong temp = Low;
+        ulong result = temp - value.Low;
+        temp = temp < value.Low ? 1UL : 0UL;
+
+        Low = result;
+        High = High - value.High - temp;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Mul(ulong value)
+    {
+        ulong currentHigh = High;
+        ulong currentLow = Low;
+
+        ulong temp = Mul64(currentLow, value, out currentLow);
+        Mul64(currentHigh, value, out currentHigh);
+        temp += currentHigh;
+
+        Low = currentLow;
+        High = temp;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static ulong Mul64(ulong left, ulong right, out ulong low)
+    {
+        const ulong Mask32 = 0xFFFF_FFFFUL;
+
+        ulong leftHigh = left >> 32;
+        ulong rightLow = right & Mask32;
+
+        ulong leftLow = left & Mask32;
+        ulong lowLow = leftLow * rightLow;
+        ulong temp = right >> 32;
+        leftLow *= temp;
+        rightLow *= leftHigh;
+        leftHigh *= temp;
+
+        temp = (lowLow >> 32) + (leftLow & Mask32) + (rightLow & Mask32);
+        leftHigh += (leftLow >> 32) + (rightLow >> 32) + (temp >> 32);
+
+        low = ((temp & Mask32) << 32) | (lowLow & Mask32);
+        return leftHigh;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void MulAdd(ulong multiplier, ulong addend)
+    {
+        const ulong Mask32 = 0xFFFF_FFFFUL;
+
+        ulong multiplierLow = multiplier & Mask32;
+        ulong multiplierHigh = multiplier >> 32;
+
+        ulong product11 = Low;
+        ulong product01 = product11 & Mask32;
+        product11 >>= 32;
+
+        ulong product00 = product01 * multiplierLow;
+        product01 *= multiplierHigh;
+        ulong product10 = product11 * multiplierLow;
+        product11 *= multiplierHigh;
+
+        ulong high = (product00 >> 32) + (product01 & Mask32) + (product10 & Mask32);
+        product11 = product11 + (product01 >> 32) + (product10 >> 32) + (high >> 32);
+        product10 = ((high & Mask32) << 32) | (product00 & Mask32);
+
+        high = High;
+        product00 = high & Mask32;
+        high >>= 32;
+
+        product01 = product00 * multiplierLow;
+        product00 *= multiplierHigh;
+        high *= multiplierLow;
+
+        high = (product01 >> 32) + (product00 & Mask32) + (high & Mask32);
+		product01 = ((high & Mask32) << 32) | (product01 & Mask32);
+
+		// Calculate low. We're assigning addend to local variable for a tiny bit better performance.
+		product00 = addend;
+		high = product10 + product00;
+        Low = high;
+
+		// Calculate high including carry
+		high = high < product00 ? 1UL : 0UL;
+		high += product11 + product01;
+		
+        // Discard overflow above 128 bits to match Multiply's truncation semantics.
+        High = high;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public readonly ulong Mod(ulong modulus)
+	{
+		// This case will never happen in production code.
+		// if (modulus == 0UL)
+		// {
+		//     throw new DivideByZeroException();
+		// }
+
+		ulong high = High;
+		if (high == 0UL)
+        {
+            return Low % modulus;
+        }
+
+        MutableUInt128 remainder = default;
+        int highBitLength = 64 - BitOperations.LeadingZeroCount(high);
+        if (highBitLength > 0)
+        {
+            ProcessWord(ref remainder, high, highBitLength, modulus);
+        }
+
+        ProcessWord(ref remainder, Low, 64, modulus);
+        return remainder.Low;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void ProcessWord(ref MutableUInt128 remainder, ulong word, int bitCount, ulong modulus)
+    {
+        for (int bit = bitCount - 1; bit >= 0; bit--)
+        {
+            remainder.ShiftLeft();
+            if (((word >> bit) & 1UL) != 0)
+            {
+                remainder.Add(1UL);
+            }
+
+            remainder.Reduce(modulus);
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private void ShiftLeft()
+    {
+        High = (High << 1) | (Low >> 63);
+        Low <<= 1;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private void Reduce(ulong modulus)
+    {
+        if (High != 0UL || Low >= modulus)
+        {
+            Sub(modulus);
+            if (High != 0UL || Low >= modulus)
+            {
+                Sub(modulus);
+            }
+        }
+    }
+}

PerfectNumbers.Core/PartialFactorResult.cs

@@ -1,4 +1,4 @@
-using System.Buffers;
+using System;
 
 namespace PerfectNumbers.Core
 {
@@ -7,12 +7,20 @@ namespace PerfectNumbers.Core
         [ThreadStatic]
         private static PartialFactorResult? s_poolHead;
 
+        public static readonly PartialFactorResult Empty = new()
+        {
+            Cofactor = 1UL,
+            FullyFactored = true,
+        };
+
         public FactorEntry[]? Factors;
-        private PartialFactorResult? _next;
         public ulong Cofactor;
         public bool FullyFactored;
         public int Count;
 
+        private PartialFactorResult? _next;
+        private bool _factorsFromPool;
+
         private PartialFactorResult()
         {
         }
@@ -29,52 +37,58 @@ namespace PerfectNumbers.Core
                 s_poolHead = instance._next;
             }
 
+            FactorEntry[]? factorArray = factors;
             instance._next = null;
-            instance.Factors = factors;
+            instance.Factors = factorArray;
             instance.Cofactor = cofactor;
             instance.FullyFactored = fullyFactored;
             instance.Count = count;
+            instance._factorsFromPool = factorArray is not null && factorArray.Length >= PerfectNumberConstants.PooledArrayThreshold;
             return instance;
         }
 
-        public static readonly PartialFactorResult Empty = new()
-		{
-            Cofactor = 1UL,
-            FullyFactored = true,
-        };
-
         public PartialFactorResult WithAdditionalPrime(ulong prime)
         {
             FactorEntry[]? source = Factors;
             if (source is null || Count == 0)
             {
-                FactorEntry[] local = ArrayPool<FactorEntry>.Shared.Rent(1);
-                local[0] = new FactorEntry(prime, 1);
-                return Rent(local, 1UL, true, 1);
+                FactorEntry[] single = new FactorEntry[1];
+                single[0] = new FactorEntry(prime);
+                return Rent(single, 1UL, true, 1);
             }
 
-            FactorEntry[] extended = ArrayPool<FactorEntry>.Shared.Rent(Count + 1);
+            int newCount = Count + 1;
+            FactorEntry[] extended = newCount >= PerfectNumberConstants.PooledArrayThreshold
+                ? ThreadLocalArrayPool<FactorEntry>.Shared.Rent(newCount)
+                : new FactorEntry[newCount];
+
             Array.Copy(source, 0, extended, 0, Count);
-            extended[Count] = new FactorEntry(prime, 1);
-            Span<FactorEntry> span = extended.AsSpan(0, Count + 1);
+            extended[Count] = new FactorEntry(prime);
+            Span<FactorEntry> span = extended.AsSpan(0, newCount);
             span.Sort(static (a, b) => a.Value.CompareTo(b.Value));
-            return Rent(extended, 1UL, true, Count + 1);
+            return Rent(extended, 1UL, true, newCount);
         }
 
         public void Dispose()
         {
-            if (this != Empty)
+            if (this == Empty)
             {
-                FactorEntry[]? factors = Factors;
-                if (factors is not null)
-                {
-                    Factors = null;
-                    ThreadStaticPools.FactorEntryPool.Return(factors, clearArray: false);
-                }
-
-                _next = s_poolHead;
-                s_poolHead = this;
+                return;
             }
+
+            FactorEntry[]? factors = Factors;
+            if (factors is not null)
+            {
+                Factors = null;
+                if (_factorsFromPool)
+                {
+                    ThreadLocalArrayPool<FactorEntry>.Shared.Return(factors, clearArray: false);
+                }
+            }
+
+            _factorsFromPool = false;
+            _next = s_poolHead;
+            s_poolHead = this;
         }
     }
 }

PerfectNumbers.Core/PerfectNumbers.Core.csproj

@@ -22,4 +22,7 @@
     <InternalsVisibleTo Include="EvenPerfectBitScanner.Benchmarks" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Compile Remove=".temp.cs" />
+  </ItemGroup>
 </Project>

PerfectNumbers.Core/PrimeFactorPartialResult.cs

@@ -0,0 +1,150 @@
+using System;
+using System.Buffers;
+
+namespace PerfectNumbers.Core
+{
+    internal sealed class PrimeFactorPartialResult
+    {
+        [ThreadStatic]
+        private static PrimeFactorPartialResult? s_poolHead;
+
+        private PrimeFactorPartialResult? _next;
+        private ulong[]? _primes;
+        private byte[]? _exponents;
+        private bool _arraysFromPool;
+        private int _capacity;
+
+        private PrimeFactorPartialResult()
+        {
+        }
+
+        public static PrimeFactorPartialResult Rent(int capacity)
+        {
+            PrimeFactorPartialResult? instance = s_poolHead;
+            if (instance is null)
+            {
+                instance = new PrimeFactorPartialResult();
+            }
+            else
+            {
+                s_poolHead = instance._next;
+            }
+
+            instance._next = null;
+            instance.EnsureCapacity(capacity);
+            instance.Count = 0;
+            return instance;
+        }
+
+        public int Count { get; private set; }
+
+        internal ReadOnlySpan<ulong> Primes => _primes is null ? ReadOnlySpan<ulong>.Empty : _primes.AsSpan(0, Count);
+
+        internal ReadOnlySpan<byte> Exponents => _exponents is null ? ReadOnlySpan<byte>.Empty : _exponents.AsSpan(0, Count);
+
+        internal Span<ulong> PrimeWriteSpan => _primes is null ? Span<ulong>.Empty : _primes.AsSpan(0, _capacity);
+
+        internal Span<byte> ExponentWriteSpan => _exponents is null ? Span<byte>.Empty : _exponents.AsSpan(0, _capacity);
+
+        internal void CommitCount(int count)
+        {
+            Count = count;
+        }
+
+        internal void Sort()
+        {
+            if (Count == 0 || _primes is null || _exponents is null)
+            {
+                return;
+            }
+
+            Array.Sort(_primes, _exponents, 0, Count);
+        }
+
+        internal MersenneDivisorCycles.FactorCacheEntry ToCacheEntry()
+        {
+            if (Count == 0 || _primes is null || _exponents is null)
+            {
+                return default;
+            }
+
+            ulong[] primes = new ulong[Count];
+            byte[] exponents = new byte[Count];
+            Array.Copy(_primes, 0, primes, 0, Count);
+            Array.Copy(_exponents, 0, exponents, 0, Count);
+            return new MersenneDivisorCycles.FactorCacheEntry(primes, exponents, Count);
+        }
+
+        public void Dispose()
+        {
+            if (_arraysFromPool)
+            {
+                if (_primes is not null)
+                {
+                    ThreadLocalArrayPool<ulong>.Shared.Return(_primes, clearArray: false);
+                }
+
+                if (_exponents is not null)
+                {
+                    ThreadLocalArrayPool<byte>.Shared.Return(_exponents, clearArray: false);
+                }
+
+                _arraysFromPool = false;
+                _primes = null;
+                _exponents = null;
+            }
+
+            _capacity = 0;
+            Count = 0;
+
+            _next = s_poolHead;
+            s_poolHead = this;
+        }
+
+        private void EnsureCapacity(int capacity)
+        {
+            if (capacity <= 0)
+            {
+                _capacity = 0;
+                return;
+            }
+
+            if (_primes is not null && _primes.Length >= capacity)
+            {
+                _capacity = capacity;
+                return;
+            }
+
+            if (_arraysFromPool)
+            {
+                if (_primes is not null)
+                {
+                    ThreadLocalArrayPool<ulong>.Shared.Return(_primes, clearArray: false);
+                }
+
+                if (_exponents is not null)
+                {
+                    ThreadLocalArrayPool<byte>.Shared.Return(_exponents, clearArray: false);
+                }
+
+                _arraysFromPool = false;
+                _primes = null;
+                _exponents = null;
+            }
+
+            if (capacity >= PerfectNumberConstants.PooledArrayThreshold)
+            {
+                _primes = ThreadLocalArrayPool<ulong>.Shared.Rent(capacity);
+                _exponents = ThreadLocalArrayPool<byte>.Shared.Rent(capacity);
+                _arraysFromPool = true;
+            }
+            else
+            {
+                _primes = new ulong[capacity];
+                _exponents = new byte[capacity];
+            }
+
+            _capacity = capacity;
+        }
+    }
+}

PerfectNumbers.Core/PrimeOrderCalculator.Gpu.cs

@@ -1,45 +0,0 @@
-using PerfectNumbers.Core.Gpu;
-
-namespace PerfectNumbers.Core;
-
-internal static partial class PrimeOrderCalculator
-{
-        private static bool IsGpuPow2Allowed => s_pow2ModeInitialized && s_allowGpuPow2;
-
-        private const int GpuSmallPrimeFactorSlots = 64;
-
-        private static bool TryPopulateSmallPrimeFactorsGpu(ulong value, uint limit, Dictionary<ulong, int> counts, out ulong remaining)
-        {
-                ulong[] primeBufferArray = ThreadStaticPools.UlongPool.Rent(GpuSmallPrimeFactorSlots);
-                int[] exponentBufferArray = ThreadStaticPools.IntPool.Rent(GpuSmallPrimeFactorSlots);
-                Span<ulong> primeBuffer = primeBufferArray.AsSpan(0, GpuSmallPrimeFactorSlots);
-                Span<int> exponentBuffer = exponentBufferArray.AsSpan(0, GpuSmallPrimeFactorSlots);
-                primeBuffer.Clear();
-                exponentBuffer.Clear();
-
-                if (!PrimeOrderGpuHeuristics.TryPartialFactor(value, limit, primeBuffer, exponentBuffer, out int factorCount, out ulong gpuRemaining, out _))
-                {
-                        remaining = value;
-                        ThreadStaticPools.UlongPool.Return(primeBufferArray);
-                        ThreadStaticPools.IntPool.Return(exponentBufferArray);
-                        return false;
-                }
-
-                remaining = gpuRemaining;
-                for (int i = 0; i < factorCount; i++)
-                {
-                        ulong primeValue = primeBuffer[i];
-                        int exponent = exponentBuffer[i];
-                        if (primeValue == 0UL || exponent == 0)
-                        {
-                                continue;
-                        }
-
-                        counts[primeValue] = exponent;
-                }
-
-                ThreadStaticPools.UlongPool.Return(primeBufferArray);
-                ThreadStaticPools.IntPool.Return(exponentBufferArray);
-                return true;
-        }
-}

PerfectNumbers.Core/PrimeOrderCalculator.Wide.cs

@@ -1,88 +1,55 @@
 using System.Buffers;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.Numerics;
+using System.Threading;
 using PerfectNumbers.Core.Gpu;
 
 namespace PerfectNumbers.Core;
 
 internal static partial class PrimeOrderCalculator
 {
-        [ThreadStatic]
-        private static bool s_pow2ModeInitialized;
-
-        [ThreadStatic]
-        private static bool s_allowGpuPow2;
-
-        [ThreadStatic]
-        private static PrimeOrderHeuristicDevice s_deviceMode;
-
-        [ThreadStatic]
-        private static bool s_debugLoggingEnabled;
-
-        private static bool IsGpuHeuristicDevice => s_pow2ModeInitialized && s_deviceMode == PrimeOrderHeuristicDevice.Gpu;
-
-        private readonly struct Pow2ModeScope
+    public static UInt128 Calculate(
+        UInt128 prime,
+        UInt128? previousOrder,
+        PrimeOrderSearchConfig config,
+        PrimeOrderHeuristicDevice device)
+    {
+        var scope = UsePow2Mode(device);
+        MontgomeryDivisorData divisorData;
+        UInt128 result;
+        if (prime <= ulong.MaxValue)
         {
-                private readonly bool _previousInitialized;
-                private readonly bool _previousAllow;
-                private readonly PrimeOrderHeuristicDevice _previousDevice;
-
-                public Pow2ModeScope(PrimeOrderHeuristicDevice device)
+            ulong? previous = null;
+            if (previousOrder.HasValue)
+            {
+                UInt128 previousValue = previousOrder.Value;
+                if (previousValue <= ulong.MaxValue)
                 {
-                        _previousInitialized = s_pow2ModeInitialized;
-                        _previousAllow = s_allowGpuPow2;
-                        _previousDevice = s_deviceMode;
-                        s_pow2ModeInitialized = true;
-                        s_allowGpuPow2 = device == PrimeOrderHeuristicDevice.Gpu;
-                        s_deviceMode = device;
+                    previous = (ulong)previousValue;
                 }
-
-                public void Dispose()
+                else
                 {
-                        s_allowGpuPow2 = _previousAllow;
-                        s_pow2ModeInitialized = _previousInitialized;
-                        s_deviceMode = _previousDevice;
+                    previous = ulong.MaxValue;
                 }
+            }
+
+            ulong prime64 = (ulong)prime;
+            divisorData = MontgomeryDivisorData.FromModulus(prime64);
+            ulong order64 = Calculate(prime64, previous, divisorData, config, device);
+            result = order64 == 0UL ? UInt128.Zero : (UInt128)order64;
+        }
+        else
+        {
+            divisorData = default;
+            result = CalculateWideInternal(prime, previousOrder, divisorData, config);
         }
 
-        private readonly struct DebugLoggingScope
-        {
-                private readonly bool _previous;
+        scope.Dispose();
+        return result;
+    }
 
-                public DebugLoggingScope(bool enabled)
-                {
-                        _previous = s_debugLoggingEnabled;
-                        s_debugLoggingEnabled = enabled;
-                }
-
-                public void Dispose()
-                {
-                        s_debugLoggingEnabled = _previous;
-                }
-        }
-
-        private static Pow2ModeScope UsePow2Mode(PrimeOrderHeuristicDevice device) => new(device);
-
-        private static DebugLoggingScope UseDebugLogging(bool enabled) => new(enabled);
-
-        [Conditional("DEBUG")]
-        private static void DebugLog(string message)
-        {
-                if (s_debugLoggingEnabled)
-                {
-                        Console.WriteLine(message);
-                }
-        }
-
-        [Conditional("DEBUG")]
-        private static void DebugLog(Func<string> messageFactory)
-        {
-                if (s_debugLoggingEnabled)
-                {
-                        Console.WriteLine(messageFactory());
-                }
-        }
-    private static UInt128 CalculateWideInternal(in UInt128 prime, in UInt128? previousOrder, in MontgomeryDivisorData divisorData, in PrimeOrderSearchConfig config)
+    private static UInt128 CalculateWideInternal(UInt128 prime, UInt128? previousOrder, in MontgomeryDivisorData divisorData, PrimeOrderSearchConfig config)
     {
         if (prime <= UInt128.One)
         {
@@ -112,12 +79,12 @@ internal static partial class PrimeOrderCalculator
     }
 
     private static UInt128 RunHeuristicPipelineWide(
-        in UInt128 prime,
-        in UInt128? previousOrder,
+        UInt128 prime,
+        UInt128? previousOrder,
         in MontgomeryDivisorData divisorData,
-        in PrimeOrderSearchConfig config,
-        in UInt128 phi,
-        in PartialFactorResult128 phiFactors)
+        PrimeOrderSearchConfig config,
+        UInt128 phi,
+        PartialFactorResult128 phiFactors)
     {
         if (phiFactors.FullyFactored && TrySpecialMaxWide(phi, prime, divisorData, phiFactors))
         {
@@ -145,12 +112,12 @@ internal static partial class PrimeOrderCalculator
         return candidateOrder;
     }
 
-    private static UInt128 FinishStrictlyWide(in UInt128 prime, in MontgomeryDivisorData divisorData)
+    private static UInt128 FinishStrictlyWide(UInt128 prime, in MontgomeryDivisorData divisorData)
     {
         return CalculateByFactorizationWide(prime, divisorData);
     }
 
-    private static bool TrySpecialMaxWide(in UInt128 phi, in UInt128 prime, in MontgomeryDivisorData divisorData, in PartialFactorResult128 factors)
+    private static bool TrySpecialMaxWide(UInt128 phi, UInt128 prime, in MontgomeryDivisorData divisorData, PartialFactorResult128 factors)
     {
         ReadOnlySpan<FactorEntry128> factorSpan = factors.Factors;
         int length = factors.Count;
@@ -167,7 +134,7 @@ internal static partial class PrimeOrderCalculator
         return true;
     }
 
-    private static UInt128 InitializeStartingOrderWide(in UInt128 prime, in UInt128 phi, in MontgomeryDivisorData divisorData)
+    private static UInt128 InitializeStartingOrderWide(UInt128 prime, UInt128 phi, in MontgomeryDivisorData divisorData)
     {
         UInt128 order = phi;
         UInt128 mod8 = prime & (UInt128)7UL;
@@ -183,20 +150,19 @@ internal static partial class PrimeOrderCalculator
         return order;
     }
 
-    private static UInt128 ExponentLoweringWide(UInt128 order, in UInt128 prime, in MontgomeryDivisorData divisorData, in PartialFactorResult128 factors)
+    private static UInt128 ExponentLoweringWide(UInt128 order, UInt128 prime, in MontgomeryDivisorData divisorData, PartialFactorResult128 factors)
     {
-		ArrayPool<FactorEntry128> pool = ThreadStaticPools.FactorEntry128Pool;
-		ReadOnlySpan<FactorEntry128> factorSpan = factors.Factors;
-		int length = factors.Count;
-		// TODO: This should never trigger from production code - check
-		// if (length == 0)
-		// {
-		//     return order;
-		// }
-		FactorEntry128[]? tempArray = pool.Rent(length + 1);
+        FactorEntry128[]? tempArray = null;
         try
         {
+            ReadOnlySpan<FactorEntry128> factorSpan = factors.Factors;
+            int length = factors.Count;
+            if (length == 0)
+            {
+                return order;
+            }
 
+            tempArray = ThreadLocalArrayPool<FactorEntry128>.Shared.Rent(length + 1);
             Span<FactorEntry128> buffer = tempArray.AsSpan(0, length);
             factorSpan.CopyTo(buffer);
 
@@ -232,11 +198,14 @@ internal static partial class PrimeOrderCalculator
         }
         finally
         {
-			pool.Return(tempArray, clearArray: false);
+            if (tempArray is not null)
+            {
+                ThreadLocalArrayPool<FactorEntry128>.Shared.Return(tempArray, clearArray: false);
+            }
         }
     }
 
-    private static bool TryConfirmOrderWide(in UInt128 prime, in UInt128 order, in MontgomeryDivisorData divisorData, in PrimeOrderSearchConfig config)
+    private static bool TryConfirmOrderWide(UInt128 prime, UInt128 order, in MontgomeryDivisorData divisorData, PrimeOrderSearchConfig config)
     {
         if (order == UInt128.Zero)
         {
@@ -294,11 +263,11 @@ internal static partial class PrimeOrderCalculator
     }
 
     private static bool TryHeuristicFinishWide(
-        in UInt128 prime,
-        in UInt128 order,
-        in UInt128? previousOrder,
+        UInt128 prime,
+        UInt128 order,
+        UInt128? previousOrder,
         in MontgomeryDivisorData divisorData,
-        in PrimeOrderSearchConfig config,
+        PrimeOrderSearchConfig config,
         out UInt128 result)
     {
         result = UInt128.Zero;
@@ -370,7 +339,7 @@ internal static partial class PrimeOrderCalculator
         return false;
     }
 
-    private static void SortCandidatesWide(UInt128 prime, in UInt128? previousOrder, List<UInt128> candidates)
+    private static void SortCandidatesWide(UInt128 prime, UInt128? previousOrder, List<UInt128> candidates)
     {
         UInt128 previous = previousOrder ?? UInt128.Zero;
         int previousGroup = previousOrder.HasValue ? GetGroupWide(previousOrder.Value, prime) : 1;
@@ -398,9 +367,9 @@ internal static partial class PrimeOrderCalculator
     }
 
     private static CandidateKey128 BuildKeyWide(
-        in UInt128 value,
-        in UInt128 prime,
-        in UInt128 previous,
+        UInt128 value,
+        UInt128 prime,
+        UInt128 previous,
         int previousGroup,
         bool hasPrevious)
     {
@@ -422,7 +391,7 @@ internal static partial class PrimeOrderCalculator
         return new CandidateKey128(primary, false, distance, false, value);
     }
 
-    private static int CompareComponents(bool descendingX, in UInt128 valueX, bool descendingY, in UInt128 valueY)
+    private static int CompareComponents(bool descendingX, UInt128 valueX, bool descendingY, UInt128 valueY)
     {
         if (descendingX == descendingY)
         {
@@ -447,7 +416,7 @@ internal static partial class PrimeOrderCalculator
         return valueX > valueY ? 1 : -1;
     }
 
-    private static int GetGroupWide(in UInt128 value, in UInt128 prime)
+    private static int GetGroupWide(UInt128 value, UInt128 prime)
     {
         UInt128 threshold1 = prime >> 3;
         if (value <= threshold1)
@@ -470,7 +439,7 @@ internal static partial class PrimeOrderCalculator
         return 0;
     }
 
-    private static void BuildCandidatesWide(in UInt128 order, FactorEntry128[] factors, int count, List<UInt128> candidates, int limit)
+    private static void BuildCandidatesWide(UInt128 order, FactorEntry128[] factors, int count, List<UInt128> candidates, int limit)
     {
         if (count == 0)
         {
@@ -483,10 +452,10 @@ internal static partial class PrimeOrderCalculator
     }
 
     private static void BuildCandidatesRecursiveWide(
-        in UInt128 order,
-        in ReadOnlySpan<FactorEntry128> factors,
+        UInt128 order,
+        ReadOnlySpan<FactorEntry128> factors,
         int index,
-        in UInt128 divisorProduct,
+        UInt128 divisorProduct,
         List<UInt128> candidates,
         int limit)
     {
@@ -542,7 +511,7 @@ internal static partial class PrimeOrderCalculator
         }
     }
 
-    private static bool TryConfirmCandidateWide(in UInt128 prime, in UInt128 candidate, in PrimeOrderSearchConfig config, ref int powUsed, int powBudget, in MontgomeryDivisorData divisorData)
+    private static bool TryConfirmCandidateWide(UInt128 prime, UInt128 candidate, PrimeOrderSearchConfig config, ref int powUsed, int powBudget, in MontgomeryDivisorData divisorData)
     {
         PartialFactorResult128 factorization = PartialFactorWide(candidate, config);
         if (factorization.Factors is null)
@@ -595,7 +564,7 @@ internal static partial class PrimeOrderCalculator
         return true;
     }
 
-    private static PartialFactorResult128 PartialFactorWide(in UInt128 value, in PrimeOrderSearchConfig config)
+    private static PartialFactorResult128 PartialFactorWide(UInt128 value, PrimeOrderSearchConfig config)
     {
         if (value <= UInt128.One)
         {
@@ -636,12 +605,12 @@ internal static partial class PrimeOrderCalculator
 
         if (config.PollardRhoMilliseconds > 0 && pending.Count > 0)
         {
-            long deadlineTimestamp = CreateDeadlineTimestamp(config.PollardRhoMilliseconds);
+            Stopwatch stopwatch = Stopwatch.StartNew();
+            long budgetTicks = TimeSpan.FromMilliseconds(config.PollardRhoMilliseconds).Ticks;
             Stack<UInt128> stack = new();
             stack.Push(remaining);
             pending.Clear();
 
-            long timestamp = 0L; // reused for deadline checks.
             while (stack.Count > 0)
             {
                 UInt128 composite = stack.Pop();
@@ -656,14 +625,13 @@ internal static partial class PrimeOrderCalculator
                     continue;
                 }
 
-                timestamp = Stopwatch.GetTimestamp();
-                if (timestamp > deadlineTimestamp)
+                if (stopwatch.ElapsedTicks > budgetTicks)
                 {
                     pending.Add(composite);
                     continue;
                 }
 
-                if (!TryPollardRhoWide(composite, deadlineTimestamp, out UInt128 factor))
+                if (!TryPollardRhoWide(composite, stopwatch, budgetTicks, out UInt128 factor))
                 {
                     pending.Add(composite);
                     continue;
@@ -696,8 +664,7 @@ internal static partial class PrimeOrderCalculator
             return new PartialFactorResult128(null, value, false, 0);
         }
 
-		ArrayPool<FactorEntry128>? pool = null;
-		FactorEntry128[]? rented = counts.Count > 0 ?  (pool = ThreadStaticPools.FactorEntry128Pool).Rent(counts.Count) : null;
+        FactorEntry128[]? rented = counts.Count > 0 ? ThreadLocalArrayPool<FactorEntry128>.Shared.Rent(counts.Count) : null;
         int index = 0;
         if (rented is not null)
         {
@@ -709,20 +676,20 @@ internal static partial class PrimeOrderCalculator
         }
 
         FactorEntry128[]? resultArray = null;
-        if (pool is not null)
+        if (rented is not null)
         {
             Span<FactorEntry128> span = rented.AsSpan(0, index);
             span.Sort(static (a, b) => a.Value.CompareTo(b.Value));
             resultArray = new FactorEntry128[index];
             span.CopyTo(resultArray);
-            pool.Return(rented!, clearArray: false);
+            ThreadLocalArrayPool<FactorEntry128>.Shared.Return(rented, clearArray: false);
         }
 
         bool fullyFactored = cofactor == UInt128.One;
         return new PartialFactorResult128(resultArray, cofactor, fullyFactored, index);
     }
 
-    private static UInt128 PopulateSmallPrimeFactorsCpuWide(in UInt128 value, uint limit, Dictionary<UInt128, int> counts)
+    private static UInt128 PopulateSmallPrimeFactorsCpuWide(UInt128 value, uint limit, Dictionary<UInt128, int> counts)
     {
         UInt128 remaining = value;
         uint[] primes = PrimesGenerator.SmallPrimes;
@@ -762,7 +729,7 @@ internal static partial class PrimeOrderCalculator
 
         return remaining;
     }
-    private static bool TryPollardRhoWide(in UInt128 n, long deadlineTimestamp, out UInt128 factor)
+    private static bool TryPollardRhoWide(UInt128 n, Stopwatch stopwatch, long budgetTicks, out UInt128 factor)
     {
         factor = UInt128.Zero;
         if ((n & UInt128.One) == UInt128.Zero)
@@ -774,12 +741,10 @@ internal static partial class PrimeOrderCalculator
         UInt128 c = UInt128.One;
         UInt128 x = (UInt128)2UL;
         UInt128 y = x;
-        long timestamp = 0L; // reused for deadline checks.
 
         while (true)
         {
-            timestamp = Stopwatch.GetTimestamp();
-            if (timestamp > deadlineTimestamp)
+            if (stopwatch.ElapsedTicks > budgetTicks)
             {
                 return false;
             }
@@ -806,7 +771,7 @@ internal static partial class PrimeOrderCalculator
         }
     }
 
-    private static UInt128 AdvancePolynomialWide(in UInt128 x, in UInt128 c, in UInt128 modulus)
+    private static UInt128 AdvancePolynomialWide(UInt128 x, UInt128 c, UInt128 modulus)
     {
         BigInteger value = (BigInteger)x;
         value = (value * value + (BigInteger)c) % (BigInteger)modulus;
@@ -844,7 +809,7 @@ internal static partial class PrimeOrderCalculator
         }
     }
 
-    private static int TrailingZeroCountWide(in UInt128 value)
+    private static int TrailingZeroCountWide(UInt128 value)
     {
         if (value == UInt128.Zero)
         {
@@ -900,7 +865,7 @@ internal static partial class PrimeOrderCalculator
         return order;
     }
 
-    private static void FactorCompletelyWide(in UInt128 value, Dictionary<UInt128, int> counts)
+    private static void FactorCompletelyWide(UInt128 value, Dictionary<UInt128, int> counts)
     {
         if (value <= UInt128.One)
         {
@@ -918,7 +883,7 @@ internal static partial class PrimeOrderCalculator
         FactorCompletelyWide(value / factor, counts);
     }
 
-    private static UInt128 PollardRhoWide(in UInt128 n)
+    private static UInt128 PollardRhoWide(UInt128 n)
     {
         if ((n & UInt128.One) == UInt128.Zero)
         {
@@ -951,7 +916,7 @@ internal static partial class PrimeOrderCalculator
         }
     }
 
-    private static bool IsPrimeWide(in UInt128 value)
+    private static bool IsPrimeWide(UInt128 value)
     {
         if (value <= ulong.MaxValue)
         {
@@ -1031,7 +996,7 @@ internal static partial class PrimeOrderCalculator
         return true;
     }
 
-    private static UInt128 Pow2ModWide(in UInt128 exponent, in UInt128 modulus, in MontgomeryDivisorData divisorData)
+    private static UInt128 Pow2ModWide(UInt128 exponent, in UInt128 modulus, in MontgomeryDivisorData divisorData)
     {
         if (modulus == UInt128.One)
         {
@@ -1061,7 +1026,7 @@ internal static partial class PrimeOrderCalculator
         return exponent.Pow2MontgomeryModWindowed(modulus);
     }
 
-    private static void AddFactor(Dictionary<UInt128, int> counts, in UInt128 prime, int exponent)
+    private static void AddFactor(Dictionary<UInt128, int> counts, UInt128 prime, int exponent)
     {
         if (counts.TryGetValue(prime, out int existing))
         {
@@ -1073,43 +1038,77 @@ internal static partial class PrimeOrderCalculator
         }
     }
 
-    private readonly struct CandidateKey128(int primary, bool secondaryDescending, in UInt128 secondary, bool tertiaryDescending, in UInt128 tertiary)
-	{
-		public int Primary { get; } = primary;
+    private readonly struct CandidateKey128
+    {
+        public CandidateKey128(int primary, bool secondaryDescending, UInt128 secondary, bool tertiaryDescending, UInt128 tertiary)
+        {
+            Primary = primary;
+            SecondaryDescending = secondaryDescending;
+            Secondary = secondary;
+            TertiaryDescending = tertiaryDescending;
+            Tertiary = tertiary;
+        }
 
-		public bool SecondaryDescending { get; } = secondaryDescending;
+        public int Primary { get; }
 
-		public UInt128 Secondary { get; } = secondary;
+        public bool SecondaryDescending { get; }
 
-		public bool TertiaryDescending { get; } = tertiaryDescending;
+        public UInt128 Secondary { get; }
 
-		public UInt128 Tertiary { get; } = tertiary;
-	}
+        public bool TertiaryDescending { get; }
 
-    private readonly struct PartialFactorResult128(FactorEntry128[]? factors, UInt128 cofactor, bool fullyFactored, int count)
-	{
-		public FactorEntry128[]? Factors { get; } = factors;
+        public UInt128 Tertiary { get; }
+    }
 
-		public UInt128 Cofactor { get; } = cofactor;
+    private readonly struct FactorEntry128
+    {
+		public FactorEntry128(UInt128 value)
+		{
+			Value = value;
+		}
 
-		public bool FullyFactored { get; } = fullyFactored;
+		public FactorEntry128(UInt128 value, int exponent)
+		{
+			Value = value;
+			Exponent = exponent;
+		}
 
-		public int Count { get; } = count;
+        public readonly UInt128 Value;
 
-		public static PartialFactorResult128 Empty => new(null, UInt128.One, true, 0);
+		public readonly int Exponent = 1;
+    }
+
+    private readonly struct PartialFactorResult128
+    {
+        public PartialFactorResult128(FactorEntry128[]? factors, UInt128 cofactor, bool fullyFactored, int count)
+        {
+            Factors = factors;
+            Cofactor = cofactor;
+            FullyFactored = fullyFactored;
+            Count = count;
+        }
+
+		public readonly FactorEntry128[]? Factors;
+
+		public readonly UInt128 Cofactor;
+
+		public readonly bool FullyFactored;
+
+		public readonly int Count;
+
+        public static PartialFactorResult128 Empty => new(null, UInt128.One, true, 0);
 
         public PartialFactorResult128 WithAdditionalPrime(UInt128 prime)
         {
             if (Factors is null)
             {
-                FactorEntry128[] local = new FactorEntry128[1];
-                local[0] = new FactorEntry128(prime, 1);
-                return new PartialFactorResult128(local, UInt128.One, true, 1);
+                FactorEntry128[] local = [new FactorEntry128(prime)];
+				return new PartialFactorResult128(local, UInt128.One, true, 1);
             }
 
             FactorEntry128[] extended = new FactorEntry128[Count + 1];
             Array.Copy(Factors, extended, Count);
-            extended[Count] = new FactorEntry128(prime, 1);
+            extended[Count] = new FactorEntry128(prime);
             return new PartialFactorResult128(extended, UInt128.One, true, Count + 1);
         }
     }

PerfectNumbers.Core/PrimeTestTimeLimit.cs

@@ -0,0 +1,72 @@
+using System;
+using System.Diagnostics;
+
+namespace PerfectNumbers.Core;
+
+internal readonly struct PrimeTestTimeLimit
+{
+    private readonly long _deadlineTimestamp;
+
+    private PrimeTestTimeLimit(bool isActive, long deadlineTimestamp)
+    {
+        IsActive = isActive;
+        _deadlineTimestamp = deadlineTimestamp;
+    }
+
+    internal bool IsActive { get; }
+
+    internal static bool TryCreate(TimeSpan? timeLimit, out PrimeTestTimeLimit limit)
+    {
+        if (!timeLimit.HasValue)
+        {
+            limit = new PrimeTestTimeLimit(isActive: false, deadlineTimestamp: long.MaxValue);
+            return true;
+        }
+
+        TimeSpan limitValue = timeLimit.GetValueOrDefault();
+        if (limitValue <= TimeSpan.Zero)
+        {
+            limit = new PrimeTestTimeLimit(isActive: true, deadlineTimestamp: long.MinValue);
+            return false;
+        }
+
+        double seconds = limitValue.TotalSeconds;
+        if (double.IsInfinity(seconds))
+        {
+            limit = new PrimeTestTimeLimit(isActive: true, deadlineTimestamp: long.MaxValue);
+            return true;
+        }
+
+        double scaled = seconds * Stopwatch.Frequency;
+        long limitTicks = scaled >= long.MaxValue ? long.MaxValue : (long)scaled;
+        long startTimestamp = Stopwatch.GetTimestamp();
+        long deadline = startTimestamp <= long.MaxValue - limitTicks ? startTimestamp + limitTicks : long.MaxValue;
+        if (deadline < startTimestamp)
+        {
+            deadline = long.MaxValue;
+        }
+
+        limit = new PrimeTestTimeLimit(isActive: true, deadlineTimestamp: deadline);
+        return true;
+    }
+
+    internal bool HasExpired()
+    {
+        if (!IsActive)
+        {
+            return false;
+        }
+
+        if (_deadlineTimestamp == long.MaxValue)
+        {
+            return false;
+        }
+
+        if (_deadlineTimestamp == long.MinValue)
+        {
+            return true;
+        }
+
+        return Stopwatch.GetTimestamp() >= _deadlineTimestamp;
+    }
+}

PerfectNumbers.Core/PrimeTester.cs

@@ -176,7 +176,7 @@ public sealed class PrimeTester(bool useInternal = false)
             DevicePrimes.View.CopyFromCPU(primes);
         }
 
-        internal sealed class ScratchBuffers : IDisposable
+        internal sealed class ScratchBuffers
         {
             public MemoryBuffer1D<ulong, Stride1D.Dense> Input { get; private set; }
             public MemoryBuffer1D<byte, Stride1D.Dense> Output { get; private set; }

PerfectNumbers.Core/TextFileWriter.cs

@@ -3,7 +3,7 @@ namespace PerfectNumbers.Core;
 /// <summary>
 /// Provides thread-safe file writing for both text and binary data.
 /// </summary>
-public sealed class TextFileWriter : IDisposable
+public sealed class TextFileWriter
 {
     private readonly FileStream _stream;
     private StreamWriter? _textWriter;

PerfectNumbers.Core/ThreadLocalArrayPool.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Buffers;
+using System.Runtime.CompilerServices;
+
+namespace PerfectNumbers.Core;
+
+internal static class ThreadLocalArrayPool<T>
+{
+    [ThreadStatic]
+    private static ArrayPool<T>? s_threadPool;
+
+    public static ArrayPool<T> Shared
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get
+        {
+            ArrayPool<T>? pool = s_threadPool;
+            if (pool is null)
+            {
+                pool = ArrayPool<T>.Create();
+                s_threadPool = pool;
+            }
+
+            return pool;
+        }
+    }
+}

PerfectNumbers.Core/ThreadStaticPools.cs

@@ -1,320 +0,0 @@
-using System.Buffers;
-using System.Runtime.CompilerServices;
-using PerfectNumbers.Core.Cpu;
-
-namespace PerfectNumbers.Core
-{
-    public readonly struct ThreadStaticPools
-    {
-        [ThreadStatic]
-        private static ArrayPool<FactorEntry>? _factorEntryPool;
-
-        public static ArrayPool<FactorEntry> FactorEntryPool
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            get
-            {
-                return _factorEntryPool ??= ArrayPool<FactorEntry>.Create();
-            }
-        }
-
-        [ThreadStatic]
-        private static ArrayPool<FactorEntry128>? _factorEntry128Pool;
-
-        public static ArrayPool<FactorEntry128> FactorEntry128Pool
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            get
-            {
-                return _factorEntry128Pool ??= ArrayPool<FactorEntry128>.Create();
-            }
-        }
-
-
-        [ThreadStatic]
-        private static ArrayPool<KeyValuePair<ulong, int>>? _factorKeyValuePairPool;
-
-        public static ArrayPool<KeyValuePair<ulong, int>> FactorKeyValuePairPool
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            get
-            {
-                return _factorKeyValuePairPool ??= ArrayPool<KeyValuePair<ulong, int>>.Create();
-            }
-        }
-        [ThreadStatic]
-        private static MersenneCpuDivisorScanSession? _mersenneCpuDivisorSession;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static MersenneCpuDivisorScanSession? RentMersenneCpuDivisorSession()
-        {
-            MersenneCpuDivisorScanSession? session = _mersenneCpuDivisorSession;
-            if (session is null)
-            {
-                return null;
-            }
-
-            _mersenneCpuDivisorSession = null;
-            session.Reset();
-            return session;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static void ReturnMersenneCpuDivisorSession(MersenneCpuDivisorScanSession session)
-        {
-            _mersenneCpuDivisorSession = session;
-        }
-
-        [ThreadStatic]
-        private static ArrayPool<ulong>? _ulongPool;
-
-        public static ArrayPool<ulong> UlongPool
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            get
-            {
-                return _ulongPool ??= ArrayPool<ulong>.Create();
-            }
-        }
-
-        [ThreadStatic]
-        private static ArrayPool<int>? _intPool;
-
-        public static ArrayPool<int> IntPool
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            get
-            {
-                return _intPool ??= ArrayPool<int>.Create();
-            }
-        }
-
-
-        [ThreadStatic]
-        private static List<List<ulong>>? _ulongListPool;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static List<ulong> RentUlongList(int capacityHint)
-        {
-            List<List<ulong>>? pool = _ulongListPool;
-            if (pool is not null && pool.Count > 0)
-            {
-                int lastIndex = pool.Count - 1;
-                List<ulong> list = pool[lastIndex];
-                pool.RemoveAt(lastIndex);
-                if (list.Count > 0)
-                {
-                    list.Clear();
-                }
-
-                if (list.Capacity < capacityHint)
-                {
-                    list.Capacity = capacityHint;
-                }
-
-                return list;
-            }
-
-            return new List<ulong>(capacityHint);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void ReturnUlongList(List<ulong> list)
-        {
-            List<List<ulong>>? pool = _ulongListPool;
-            if (pool is null)
-            {
-                pool = new List<List<ulong>>(4);
-                _ulongListPool = pool;
-            }
-
-            pool.Add(list);
-        }
-
-        [ThreadStatic]
-        private static List<Stack<ulong>>? _ulongStackPool;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Stack<ulong> RentUlongStack(int capacityHint)
-        {
-            List<Stack<ulong>>? pool = _ulongStackPool;
-            if (pool is not null && pool.Count > 0)
-            {
-                int lastIndex = pool.Count - 1;
-                Stack<ulong> stack = pool[lastIndex];
-                pool.RemoveAt(lastIndex);
-                if (stack.Count > 0)
-                {
-                    stack.Clear();
-                }
-
-                if (stack.Count < capacityHint)
-                {
-                    stack.EnsureCapacity(capacityHint);
-                }
-
-                return stack;
-            }
-
-            return new Stack<ulong>(capacityHint);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void ReturnUlongStack(Stack<ulong> stack)
-        {
-            List<Stack<ulong>>? pool = _ulongStackPool;
-            if (pool is null)
-            {
-                pool = new List<Stack<ulong>>(4);
-                _ulongStackPool = pool;
-            }
-
-            pool.Add(stack);
-        }
-
-        [ThreadStatic]
-        private static List<Dictionary<ulong, int>>? _ulongIntDictionaryPool;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Dictionary<ulong, int> RentUlongIntDictionary(int capacityHint)
-        {
-            List<Dictionary<ulong, int>>? pool = _ulongIntDictionaryPool;
-            if (pool is not null && pool.Count > 0)
-            {
-                int lastIndex = pool.Count - 1;
-                Dictionary<ulong, int> dictionary = pool[lastIndex];
-                pool.RemoveAt(lastIndex);
-                if (dictionary.Count > 0)
-                {
-                    dictionary.Clear();
-                }
-
-                if (dictionary.Count < capacityHint)
-                {
-                    dictionary.EnsureCapacity(capacityHint);
-                }
-
-                return dictionary;
-            }
-
-            return new Dictionary<ulong, int>(capacityHint);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void ReturnUlongIntDictionary(Dictionary<ulong, int> dictionary)
-        {
-            List<Dictionary<ulong, int>>? pool = _ulongIntDictionaryPool;
-            if (pool is null)
-            {
-                pool = new List<Dictionary<ulong, int>>(4);
-                _ulongIntDictionaryPool = pool;
-            }
-
-            pool.Add(dictionary);
-        }
-
-        [ThreadStatic]
-        private static Dictionary<ulong, MersenneDivisorCycles.FactorCacheEntry>? _mersenneFactorCacheDictionary;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Dictionary<ulong, MersenneDivisorCycles.FactorCacheEntry> RentMersenneFactorCacheDictionary()
-        {
-            Dictionary<ulong, MersenneDivisorCycles.FactorCacheEntry>? cache = _mersenneFactorCacheDictionary;
-            if (cache is null)
-            {
-                return new Dictionary<ulong, MersenneDivisorCycles.FactorCacheEntry>(8);
-            }
-
-            _mersenneFactorCacheDictionary = null;
-            cache.Clear();
-            return cache;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void ReturnMersenneFactorCacheDictionary(Dictionary<ulong, MersenneDivisorCycles.FactorCacheEntry> cache)
-        {
-            for (Dictionary<ulong, MersenneDivisorCycles.FactorCacheEntry>.Enumerator enumerator = cache.GetEnumerator(); enumerator.MoveNext();)
-            {
-                enumerator.Current.Value.ReturnToPool();
-            }
-
-            cache.Clear();
-            _mersenneFactorCacheDictionary = cache;
-        }
-
-        [ThreadStatic]
-        private static MersenneDivisorCycles.FactorCacheEntry? _factorCacheEntryPoolHead;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static MersenneDivisorCycles.FactorCacheEntry RentFactorCacheEntry()
-        {
-            MersenneDivisorCycles.FactorCacheEntry? entry = _factorCacheEntryPoolHead;
-            if (entry is null)
-            {
-                entry = new MersenneDivisorCycles.FactorCacheEntry();
-            }
-            else
-            {
-                _factorCacheEntryPoolHead = entry.Next;
-            }
-
-            entry.Reset();
-            return entry;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void ReturnFactorCacheEntry(MersenneDivisorCycles.FactorCacheEntry entry)
-        {
-            entry.Next = _factorCacheEntryPoolHead;
-            _factorCacheEntryPoolHead = entry;
-        }
-
-        [ThreadStatic]
-        private static Dictionary<ulong, int>? _factorCountDictionary;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Dictionary<ulong, int> RentFactorCountDictionary()
-        {
-            Dictionary<ulong, int>? dictionary = _factorCountDictionary;
-            if (dictionary is null)
-            {
-                return new Dictionary<ulong, int>(8);
-            }
-
-            _factorCountDictionary = null;
-            dictionary.Clear();
-            return dictionary;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void ReturnFactorCountDictionary(Dictionary<ulong, int> dictionary)
-        {
-            dictionary.Clear();
-            _factorCountDictionary = dictionary;
-        }
-
-        [ThreadStatic]
-        private static Dictionary<ulong, int>? _factorScratchDictionary;
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Dictionary<ulong, int> RentFactorScratchDictionary()
-        {
-            Dictionary<ulong, int>? dictionary = _factorScratchDictionary;
-            if (dictionary is null)
-            {
-                return new Dictionary<ulong, int>(8);
-            }
-
-            _factorScratchDictionary = null;
-            dictionary.Clear();
-            return dictionary;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static void ReturnFactorScratchDictionary(Dictionary<ulong, int> dictionary)
-        {
-            dictionary.Clear();
-            _factorScratchDictionary = dictionary;
-        }
-    }
-}

PerfectNumbers.Core/UInt128Extensions.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using PerfectNumbers.Core.Gpu;

apply_patch.cs

@@ -335,10 +335,13 @@ if (patchResults.Any(static r => !r.Success))
 
 static List<PatchFile> ParsePatchFromFile(string patchFilePath)
 {
-    using var stream = File.OpenRead(patchFilePath);
-    using var reader = new StreamReader(stream, Encoding.UTF8, detectEncodingFromByteOrderMarks: true, bufferSize: 16_384, leaveOpen: false);
-    using var lineReader = new PatchLineReader(reader);
+    var stream = File.OpenRead(patchFilePath);
+    var reader = new StreamReader(stream, Encoding.UTF8, detectEncodingFromByteOrderMarks: true, bufferSize: 16_384, leaveOpen: false);
+    var lineReader = new PatchLineReader(reader);
     var files = ParsePatch(lineReader);
+    lineReader.Dispose();
+    reader.Dispose();
+    stream.Dispose();
     return files;
 }
 
@@ -500,7 +503,7 @@ static void FinalizePatchFile(
     files.Add(new PatchFile(originalPath, modifiedPath, hunks ?? new List<PatchHunk>(), type));
 }
 
-private sealed class PatchLineReader : IDisposable
+private sealed class PatchLineReader
 {
     private const int ReadBufferSize = 4096;
     private const int InitialLineBufferSize = 256;

todo_list.txt

@@ -122,7 +122,6 @@ PerfectNumbers.Core\Cpu\MersenneNumberDivisorByDivisorCpuTester.cs:203:
 PerfectNumbers.Core\Cpu\MersenneNumberDivisorByDivisorCpuTester.cs:207:                // TODO: When divisorCycle is zero (cache miss), compute only that single cycle on the device
 PerfectNumbers.Core\Cpu\MersenneNumberDivisorByDivisorCpuTester.cs:214:                // TODO: Remove this no-cycle branch and require on-demand cycle computation (without
 PerfectNumbers.Core\Cpu\MersenneNumberDivisorByDivisorCpuTester.cs:240:            // TODO: Replace this linear increment with the batched divisor-cycle walker validated in the
-PerfectNumbers.Core\Cpu\MersenneNumberDivisorByDivisorCpuTester.cs:262:                : prime.Pow2MontgomeryMod(divisorData); // TODO: Switch to the upcoming ProcessEightBitWindows helper once the
 PerfectNumbers.Core\Cpu\MersenneNumberDivisorByDivisorCpuTester.cs:283:        // TODO: Replace this modulo with the ring-buffer style counter (subtract loop) used in the fast CLI
 PerfectNumbers.Core\Cpu\MersenneNumberDivisorByDivisorCpuTester.cs:356:                // TODO: Replace this guard with an on-demand CPU/GPU cycle computation path that skips
 PerfectNumbers.Core\Cpu\MersenneNumberDivisorByDivisorCpuTester.cs:396:            // TODO: Remove this no-cycle fallback once divisor cycles are mandatory; the per-prime pow2 ladder here
@@ -266,7 +265,6 @@ todo_list.txt:121:PerfectNumbers.Core\Cpu\MersenneNumberDivisorByDivisorCpuTeste
 todo_list.txt:122:PerfectNumbers.Core\Cpu\MersenneNumberDivisorByDivisorCpuTester.cs:207:                // TODO: When divisorCycle is zero (cache miss), compute only that single cycle on the device
 todo_list.txt:123:PerfectNumbers.Core\Cpu\MersenneNumberDivisorByDivisorCpuTester.cs:214:                // TODO: Remove this no-cycle branch and require on-demand cycle computation (without
 todo_list.txt:124:PerfectNumbers.Core\Cpu\MersenneNumberDivisorByDivisorCpuTester.cs:240:            // TODO: Replace this linear increment with the batched divisor-cycle walker validated in the
-todo_list.txt:125:PerfectNumbers.Core\Cpu\MersenneNumberDivisorByDivisorCpuTester.cs:262:                : prime.Pow2MontgomeryMod(divisorData); // TODO: Switch to the upcoming ProcessEightBitWindows helper once the
 todo_list.txt:126:PerfectNumbers.Core\Cpu\MersenneNumberDivisorByDivisorCpuTester.cs:283:        // TODO: Replace this modulo with the ring-buffer style counter (subtract loop) used in the fast CLI
 todo_list.txt:127:PerfectNumbers.Core\Cpu\MersenneNumberDivisorByDivisorCpuTester.cs:356:                // TODO: Replace this guard with an on-demand CPU/GPU cycle computation path that skips
 todo_list.txt:128:PerfectNumbers.Core\Cpu\MersenneNumberDivisorByDivisorCpuTester.cs:396:            // TODO: Remove this no-cycle fallback once divisor cycles are mandatory; the per-prime pow2 ladder here
@@ -407,17 +405,6 @@ PerfectNumbers.Core\ModResidueTracker.cs:257:                        // TODO: Us
 PerfectNumbers.Core\ModResidueTracker.cs:263:                // TODO: Consult MersenneDivisorCycles.Shared (or similar caches) here so we reuse precomputed cycle lengths
 PerfectNumbers.Core\ModResidueTracker.cs:295:                                // TODO: Route this through the planned UInt128 windowed powmod so the inner MulMod adopts the
 PerfectNumbers.Core\ModResidueTracker.cs:314:                // TODO: Replace this double-and-add fallback with the UInt128 intrinsic-backed multiplier once the
-PerfectNumbers.Core\Gpu\MersenneNumberDivisorByDivisorGpuTester.cs:49:        set => _useDivisorCycles = value; // TODO: Remove this flag once GPU runs unconditionally fetch cycle lengths so every divisor check benefits from the measured speedups.
-PerfectNumbers.Core\Gpu\MersenneNumberDivisorByDivisorGpuTester.cs:298:                // TODO: Stage MontgomeryDivisorData in a GPU-ready cache keyed by divisor so we can copy
-PerfectNumbers.Core\Gpu\MersenneNumberDivisorByDivisorGpuTester.cs:372:        // TODO: Replace the block lease with a direct single-cycle lookup so the GPU path
-PerfectNumbers.Core\Gpu\MersenneNumberDivisorByDivisorGpuTester.cs:395:                        // TODO: Drop this block hand-off once the cache exposes a direct
-PerfectNumbers.Core\Gpu\MersenneNumberDivisorByDivisorGpuTester.cs:409:                            // TODO: Replace this `%` with the cycle-cache helper that subtracts precomputed
-PerfectNumbers.Core\Gpu\MersenneNumberDivisorByDivisorGpuTester.cs:425:                        // TODO: Trigger an immediate GPU computation for the single missing cycle without storing
-PerfectNumbers.Core\Gpu\MersenneNumberDivisorByDivisorGpuTester.cs:476:                    // TODO: Preload ProcessEightBitWindows-friendly divisor metadata for GPU batches so this
-PerfectNumbers.Core\Gpu\MersenneNumberDivisorByDivisorGpuTester.cs:563:        hits[index] = exponent.Pow2MontgomeryMod(divisor) == 1UL ? (byte)1 : (byte)0; // TODO: Replace Pow2MontgomeryMod with the ProcessEightBitWindows helper once available so GPU by-divisor scans reuse the benchmarked fast pow2 ladder.
-PerfectNumbers.Core\Gpu\MersenneNumberDivisorByDivisorGpuTester.cs:632:                // TODO: Replace this guard with an on-demand cycle computation that runs on the device selected
-PerfectNumbers.Core\Gpu\MersenneNumberDivisorByDivisorGpuTester.cs:787:                        // TODO: Replace this `%` with the divisor-cycle remainder helper so we reuse cached
-PerfectNumbers.Core\Gpu\MersenneNumberDivisorByDivisorGpuTester.cs:858:        results[index] = exponent.Pow2MontgomeryModMontgomery(divisor); // TODO: Swap this Montgomery-domain pow2 with the windowed helper slated to replace the slower ladder in Pow2Minus1Mod benchmarks.
 PerfectNumbers.Core\MersenneNumberDivisorByDivisorTester.cs:43:                // TODO: Swap this per-run enumerator creation for the shared PrimeIterator so by-divisor scans reuse the
 PerfectNumbers.Core\MersenneNumberDivisorByDivisorTester.cs:219:                        // TODO: Swap Task.Factory.StartNew for the shared low-overhead work queue once the scanner's
 PerfectNumbers.Core\MersenneNumberDivisorByDivisorTester.cs:240:                                bool useDivisorCycles = tester.UseDivisorCycles; // TODO: Remove the conditional path once all testers always enable divisor cycles to keep every divisor scan on the faster cached-length track.

tools/GpuNumericTypeProbe.csx

@@ -54,10 +54,11 @@ static ProbeResult ProbeBigInteger(Accelerator accelerator)
     try
     {
         var kernel = accelerator.LoadAutoGroupedStreamKernel<Index1D, ArrayView1D<int, Stride1D.Dense>>(BigIntegerKernel);
-        using var buffer = accelerator.Allocate1D<int>(1);
+        var buffer = accelerator.Allocate1D<int>(1);
         var extent = new Index1D((int)buffer.Length);
         kernel(extent, buffer.View);
         accelerator.Synchronize();
+        buffer.Dispose();
         return ProbeResult.Success(
             "System.Numerics.BigInteger",
             "Addition, subtraction, multiplication, division, and modulo compile on the CPU accelerator.");
@@ -73,9 +74,10 @@ static ProbeResult ProbeEInteger(Accelerator accelerator)
     try
     {
         var kernel = accelerator.LoadAutoGroupedStreamKernel<Index1D, ArrayView1D<int, Stride1D.Dense>>(EIntegerKernel);
-        using var buffer = accelerator.Allocate1D<int>(1);
+        var buffer = accelerator.Allocate1D<int>(1);
         kernel(new Index1D((int)buffer.Length), buffer.View);
         accelerator.Synchronize();
+        buffer.Dispose();
         return ProbeResult.Success(
             "PeterO.Numbers.EInteger",
             "Addition, subtraction, multiplication, division, and remainder compile on the CPU accelerator.");
@@ -93,7 +95,7 @@ static ProbeResult ProbeERational(Accelerator accelerator)
     try
     {
         var kernel = accelerator.LoadAutoGroupedStreamKernel<Index1D, ArrayView1D<int, Stride1D.Dense>>(ERationalKernel);
-        using var buffer = accelerator.Allocate1D<int>(1);
+        var buffer = accelerator.Allocate1D<int>(1);
         kernel(new Index1D((int)buffer.Length), buffer.View);
         accelerator.Synchronize();
 
@@ -101,6 +103,7 @@ static ProbeResult ProbeERational(Accelerator accelerator)
         details += hasRemainder
             ? " ERational exposes a remainder API that requires further investigation."
             : " ERational does not expose a remainder/modulo API.";
+        buffer.Dispose();
         return ProbeResult.Success("PeterO.Numbers.ERational", details);
     }
     catch (Exception ex)
@@ -120,9 +123,10 @@ static ProbeResult ProbeOpenNumericPrimesIsPrime(Accelerator accelerator)
     try
     {
         var kernel = accelerator.LoadAutoGroupedStreamKernel<Index1D, ArrayView1D<int, Stride1D.Dense>>(OpenNumericPrimesIsPrimeKernel);
-        using var buffer = accelerator.Allocate1D<int>(4);
+        var buffer = accelerator.Allocate1D<int>(4);
         kernel(new Index1D((int)buffer.Length), buffer.View);
         accelerator.Synchronize();
+        buffer.Dispose();
         return ProbeResult.Success(
             "Open.Numeric.Primes.Prime.Numbers.IsPrime",
             "IsPrime compiles and runs on the CPU accelerator kernel.");

tools/HeuristicMultiplyShiftTiming/HeuristicMultiplyShiftTiming.csproj

@@ -8,4 +8,7 @@
   <ItemGroup>
     <ProjectReference Include="../../PerfectNumbers.Core/PerfectNumbers.Core.csproj" />
   </ItemGroup>
-</Project>
+  <ItemGroup>
+    <Compile Remove=".temp.cs" />
+  </ItemGroup>
+</Project>