Initial PollardRho implementation for GPU. Added pool for accelerator streams shared across the threads. GPU processing performance and stabilization improvements. GpuUInt128.BinaryGcd switched to the version which outperformed other in benchmarks.

PerfectNumbers.Core/Gpu/Accelerators/AcceleratorStreamPool.cs

@@ -0,0 +1,36 @@
+using System.Collections.Concurrent;
+using ILGPU.Runtime;
+
+namespace PerfectNumbers.Core.Gpu.Accelerators;
+
+public static class AcceleratorStreamPool
+{
+	private static readonly ConcurrentDictionary<Accelerator, ConcurrentQueue<AcceleratorStream>> _streams = new(20_480, PerfectNumberConstants.RollingAccelerators);
+	// private static readonly ConcurrentDictionary<Accelerator, AcceleratorStream> _streams = new(AcceleratorPool.Shared.Accelerators.ToDictionary(static x => x, CreateStream));
+
+	private static SemaphoreSlim CreateLock() => new(PerfectNumberConstants.ThreadsByStream);
+	private static AcceleratorStream CreateStream(Accelerator accelerator) => accelerator.CreateStream();
+
+	private static readonly ConcurrentDictionary<Accelerator, SemaphoreSlim> _locks = new(AcceleratorPool.Shared.Accelerators.ToDictionary(x => x, static x => CreateLock()));
+
+	public static AcceleratorStream Rent(Accelerator accelerator)
+	{
+		var streamLock = _locks.GetOrAdd(accelerator, static _ => new SemaphoreSlim(PerfectNumberConstants.ThreadsByStream));
+
+		streamLock.Wait();
+		var queue = _streams.GetOrAdd(accelerator, static _ => new());
+
+		return queue.TryDequeue(out var stream)
+			? stream
+			: accelerator.CreateStream();
+	}
+
+	public static void Return(AcceleratorStream stream)
+	{
+		Accelerator accelerator = stream.Accelerator;
+		var streamLock = _locks.GetOrAdd(accelerator, static _ => CreateLock());
+		var queue = _streams.GetOrAdd(accelerator, static _ => new());
+		queue.Enqueue(stream);
+		streamLock.Release();
+	}
+}

PerfectNumbers.Core/Gpu/Accelerators/Pow2MontgomeryAccelerator.cs

@@ -12,7 +12,7 @@ public sealed class Pow2MontgomeryAccelerator
 	[ThreadStatic]
 	private static Queue<Pow2MontgomeryAccelerator>? _pool;
 
-	private static AcceleratorPool _accelerators = new(PerfectNumberConstants.RollingAccelerators << 1);
+	private static AcceleratorPool _accelerators = new(PerfectNumberConstants.RollingAccelerators);
 
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static Pow2MontgomeryAccelerator Rent(int primeTesterCapacity)
@@ -25,8 +25,8 @@ public sealed class Pow2MontgomeryAccelerator
 		}
 		else
 		{
-			gpu.Stream = gpu.Accelerator.CreateStream();
-			gpu.EnsureCapacity(PerfectNumberConstants.DefaultFactorsBuffer,primeTesterCapacity);
+			// gpu.Stream = gpu.Accelerator.CreateStream();
+			gpu.EnsureCapacity(PerfectNumberConstants.DefaultFactorsBuffer, primeTesterCapacity);
 		}
 
 		return gpu;
@@ -35,8 +35,8 @@ public sealed class Pow2MontgomeryAccelerator
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static void Return(Pow2MontgomeryAccelerator gpu)
 	{
-		gpu.Stream!.Dispose();
-		gpu.Stream = null;
+		// gpu.Stream!.Dispose();
+		// gpu.Stream = null;
 		_pool!.Enqueue(gpu);
 	}
 
@@ -87,9 +87,9 @@ public sealed class Pow2MontgomeryAccelerator
 
 	public readonly Accelerator Accelerator;
 	public readonly MemoryBuffer1D<ulong, Stride1D.Dense> Input;
-	public readonly MemoryBuffer1D<ulong, Stride1D.Dense> Output;
+	public readonly MemoryBuffer1D<ulong, Stride1D.Dense> OutputUlong;
 	public MemoryBuffer1D<ulong, Stride1D.Dense> PrimeTestInput;
-	public MemoryBuffer1D<byte, Stride1D.Dense> PrimeTestOutput;
+	public MemoryBuffer1D<byte, Stride1D.Dense> OutputByte;
 	public MemoryBuffer1D<int, Stride1D.Dense> HeuristicFlag;
 	public MemoryBuffer1D<KeyValuePair<ulong, int>, Stride1D.Dense> Pow2ModEntriesToTestOnDevice;
 	public Dictionary<ulong, int> Pow2ModEntriesToTestOnHost = [];
@@ -101,14 +101,14 @@ public sealed class Pow2MontgomeryAccelerator
 	public readonly MemoryBuffer1D<ulong, Stride1D.Dense> DevicePrimesPow2LastSeven;
 	public readonly MemoryBuffer1D<ulong, Stride1D.Dense> DevicePrimesPow2LastThree;
 	public readonly MemoryBuffer1D<ulong, Stride1D.Dense> DevicePrimesPow2LastNine;
-	public readonly Action<AcceleratorStream, Index1D, ArrayView<ulong>, ArrayView<uint>, ArrayView<uint>, ArrayView<uint>, ArrayView<uint>, ArrayView<ulong>, ArrayView<ulong>, ArrayView<ulong>, ArrayView<ulong>, ArrayView<byte>> SmallPrimeSieveKernel;
+	public readonly Kernel SmallPrimeSieveKernel;
 
-	public AcceleratorStream? Stream;
-
-	public readonly Action<AcceleratorStream, Index1D, ArrayView1D<ulong, Stride1D.Dense>, MontgomeryDivisorData, ArrayView1D<ulong, Stride1D.Dense>> ConvertToStandardKernel;
-	public readonly Action<AcceleratorStream, Index1D, ArrayView1D<ulong, Stride1D.Dense>, MontgomeryDivisorData, ArrayView1D<ulong, Stride1D.Dense>> KeepMontgomeryKernel;
+	// public AcceleratorStream? Stream;
 
 	public readonly Kernel CheckFactorsKernel;
+	public readonly Kernel ConvertToStandardKernel;
+	public readonly Kernel KeepMontgomeryKernel;
+	public readonly Kernel PollardRhoKernel;
 
 	[ThreadStatic]
 	private static Dictionary<Accelerator, Action<AcceleratorStream, Index1D, ArrayView<ulong>, ArrayView<uint>, ArrayView<uint>, ArrayView<uint>, ArrayView<uint>, ArrayView<ulong>, ArrayView<ulong>, ArrayView<ulong>, ArrayView<ulong>, ArrayView<byte>>>? SmallPrimeSieveKernelPool;
@@ -137,15 +137,14 @@ public sealed class Pow2MontgomeryAccelerator
 
 		if (primeTesterCapacity > PrimeTestInput.Length)
 		{
-
 			PrimeTestInput?.Dispose();
-			PrimeTestOutput?.Dispose();
+			OutputByte?.Dispose();
 			HeuristicFlag?.Dispose();
 
 			// lock (Accelerator)
 			{
 				PrimeTestInput = Accelerator.Allocate1D<ulong>(primeTesterCapacity);
-				PrimeTestOutput = Accelerator.Allocate1D<byte>(primeTesterCapacity);
+				OutputByte = Accelerator.Allocate1D<byte>(primeTesterCapacity);
 				HeuristicFlag = Accelerator.Allocate1D<int>(primeTesterCapacity);
 			}
 		}
@@ -154,14 +153,16 @@ public sealed class Pow2MontgomeryAccelerator
 	public Pow2MontgomeryAccelerator(Accelerator accelerator, int factorsCount, int primeTesterCapacity)
 	{
 		Accelerator = accelerator;
-		AcceleratorStream stream = accelerator.CreateStream();
-		Stream = stream;
+		AcceleratorStream stream = AcceleratorStreamPool.Rent(accelerator);
+		// AcceleratorStream stream = accelerator.DefaultStream;
+		// AcceleratorStream stream = accelerator.CreateStream();
+		// Stream = stream;
 
 		Input = accelerator.Allocate1D<ulong>(1);
-		Output = accelerator.Allocate1D<ulong>(1);
+		OutputUlong = accelerator.Allocate1D<ulong>(1);
 		Pow2ModEntriesToTestOnDevice = accelerator.Allocate1D<KeyValuePair<ulong, int>>(factorsCount);
 		PrimeTestInput = Accelerator.Allocate1D<ulong>(primeTesterCapacity);
-		PrimeTestOutput = Accelerator.Allocate1D<byte>(primeTesterCapacity);
+		OutputByte = Accelerator.Allocate1D<byte>(primeTesterCapacity);
 		HeuristicFlag = Accelerator.Allocate1D<int>(primeTesterCapacity);
 
 		var sharedTables = LastDigitGpuTables.EnsureStaticTables(accelerator, stream);
@@ -174,30 +175,30 @@ public sealed class Pow2MontgomeryAccelerator
 		DevicePrimesPow2LastThree = sharedTables.DevicePrimesPow2LastThree;
 		DevicePrimesPow2LastNine = sharedTables.DevicePrimesPow2LastNine;
 
-		var keepKernel = accelerator.LoadAutoGroupedStreamKernel<Index1D, ArrayView1D<ulong, Stride1D.Dense>, MontgomeryDivisorData, ArrayView1D<ulong, Stride1D.Dense>>(Pow2MontgomeryKernels.Pow2MontgomeryKernelKeepMontgomery);
-		var keepLauncher = KernelUtil.GetKernel(keepKernel);
-
-		KeepMontgomeryKernel = keepLauncher.CreateLauncherDelegate<Action<AcceleratorStream, Index1D, ArrayView1D<ulong, Stride1D.Dense>, MontgomeryDivisorData, ArrayView1D<ulong, Stride1D.Dense>>>();
-
-		var convertKernel = accelerator.LoadAutoGroupedStreamKernel<Index1D, ArrayView1D<ulong, Stride1D.Dense>, MontgomeryDivisorData, ArrayView1D<ulong, Stride1D.Dense>>(Pow2MontgomeryKernels.Pow2MontgomeryKernelConvertToStandard);
-		var convertLauncher = KernelUtil.GetKernel(convertKernel);
-
-		ConvertToStandardKernel = convertLauncher.CreateLauncherDelegate<Action<AcceleratorStream, Index1D, ArrayView1D<ulong, Stride1D.Dense>, MontgomeryDivisorData, ArrayView1D<ulong, Stride1D.Dense>>>();
-
 		var checkFactorsKernel = accelerator.LoadStreamKernel<int, ulong, ArrayView1D<KeyValuePair<ulong, int>, Stride1D.Dense>, MontgomeryDivisorData, ArrayView1D<ulong, Stride1D.Dense>>(PrimeOrderGpuHeuristics.CheckFactorsKernel);
 		CheckFactorsKernel = KernelUtil.GetKernel(checkFactorsKernel);
 
-		SmallPrimeSieveKernel = KernelUtil.GetKernel(accelerator.LoadAutoGroupedStreamKernel<Index1D, ArrayView<ulong>, ArrayView<uint>, ArrayView<uint>, ArrayView<uint>, ArrayView<uint>, ArrayView<ulong>, ArrayView<ulong>, ArrayView<ulong>, ArrayView<ulong>, ArrayView<byte>>(PrimeTesterKernels.SmallPrimeSieveKernel)).CreateLauncherDelegate<Action<AcceleratorStream, Index1D, ArrayView<ulong>, ArrayView<uint>, ArrayView<uint>, ArrayView<uint>, ArrayView<uint>, ArrayView<ulong>, ArrayView<ulong>, ArrayView<ulong>, ArrayView<ulong>, ArrayView<byte>>>();
+		var convertKernel = accelerator.LoadAutoGroupedStreamKernel<Index1D, ArrayView1D<ulong, Stride1D.Dense>, MontgomeryDivisorData, ArrayView1D<ulong, Stride1D.Dense>>(Pow2MontgomeryKernels.Pow2MontgomeryKernelConvertToStandard);
+		ConvertToStandardKernel = KernelUtil.GetKernel(convertKernel);
+
+		var keepKernel = accelerator.LoadAutoGroupedStreamKernel<Index1D, ArrayView1D<ulong, Stride1D.Dense>, MontgomeryDivisorData, ArrayView1D<ulong, Stride1D.Dense>>(Pow2MontgomeryKernels.Pow2MontgomeryKernelKeepMontgomery);
+		KeepMontgomeryKernel = KernelUtil.GetKernel(keepKernel);
+
+		SmallPrimeSieveKernel = KernelUtil.GetKernel(accelerator.LoadAutoGroupedStreamKernel<Index1D, ArrayView<ulong>, ArrayView<uint>, ArrayView<uint>, ArrayView<uint>, ArrayView<uint>, ArrayView<ulong>, ArrayView<ulong>, ArrayView<ulong>, ArrayView<ulong>, ArrayView<byte>>(PrimeTesterKernels.SmallPrimeSieveKernel));
+
+		PollardRhoKernel = KernelUtil.GetKernel(accelerator.LoadStreamKernel<ulong, int, ArrayView1D<ulong, Stride1D.Dense>, ArrayView1D<byte, Stride1D.Dense>, ArrayView1D<ulong, Stride1D.Dense>>(Pow2MontgomeryKernels.TryPollardRhoKernel));
+
+		AcceleratorStreamPool.Return(stream);
 	}
 
 	public void Dispose()
 	{
 		Input.Dispose();
-		Output.Dispose();
-		Stream?.Dispose();
+		OutputUlong.Dispose();
+		// Stream?.Dispose();
 		Pow2ModEntriesToTestOnDevice.Dispose();
 		PrimeTestInput?.Dispose();
-		PrimeTestOutput?.Dispose();
+		OutputByte?.Dispose();
 		HeuristicFlag?.Dispose();
 
 		// Stream is disposed upon return to the queue, so we don't need to dispose it here.

PerfectNumbers.Core/Gpu/DeterministicRandomGpu.cs

@@ -0,0 +1,75 @@
+using System.Runtime.CompilerServices;
+using ILGPU;
+
+namespace PerfectNumbers.Core.Gpu;
+
+public static class ThreadStaticDeterministicRandomGpu
+{
+	[ThreadStatic]
+	private static DeterministicRandomGpu? _exclusive;
+	internal static DeterministicRandomGpu Exclusive => _exclusive ?? new DeterministicRandomGpu();
+}
+
+internal struct DeterministicRandomGpu
+{
+	private static long s_seedCounter;
+
+	private ulong _state;
+	public readonly ulong State
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get
+		{
+			return _state;
+		}
+	}
+
+	public DeterministicRandomGpu()
+	{
+		_state = CreateThreadState();
+	}
+
+	public DeterministicRandomGpu(ulong initialState)
+	{
+		_state = initialState;
+	}
+
+	public ulong NextUInt64()
+	{
+		ulong state = _state;
+		state ^= state >> 12;
+		state ^= state << 25;
+		state ^= state >> 27;
+		_state = state;
+		return state * 2685821657736338717UL;
+	}
+
+	public GpuUInt128 NextUInt128()
+	{
+		GpuUInt128 high = (GpuUInt128)NextUInt64();
+		ReadOnlyGpuUInt128 low = (ReadOnlyGpuUInt128)NextUInt64();
+		high.ShiftLeft(64);
+		high.Add(low);
+		return high;
+	}
+
+	public void SetState(ulong state)
+	{
+		_state = state;
+	}
+
+	private static ulong CreateThreadState()
+	{
+		ulong seed = (ulong)Atomic.Add(ref s_seedCounter, 1);
+		seed += 0x9E3779B97F4A7C15UL;
+		seed = (seed ^ (seed >> 30)) * 0xBF58476D1CE4E5B9UL;
+		seed = (seed ^ (seed >> 27)) * 0x94D049BB133111EBUL;
+		seed ^= seed >> 31;
+		if (seed == 0UL)
+		{
+			seed = 0x9E3779B97F4A7C15UL;
+		}
+
+		return seed;
+	}
+}

PerfectNumbers.Core/Gpu/GpuUInt128.cs

@@ -261,13 +261,13 @@ public struct GpuUInt128 : IComparable<GpuUInt128>, IEquatable<GpuUInt128>
     public override readonly int GetHashCode() => HashCode.Combine(High, Low);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void Add(in ReadOnlyGpuUInt128 other) => AddInternal(other.High, other.Low);
+    public void Add(in ReadOnlyGpuUInt128 other) => Add(other.High, other.Low);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void Add(GpuUInt128 other) => AddInternal(other.High, other.Low);
+    public void Add(GpuUInt128 other) => Add(other.High, other.Low);
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private void AddInternal(ulong otherHigh, ulong otherLow)
+    public void Add(ulong otherHigh, ulong otherLow)
     {
         ulong originalLow = Low;
         // We're reusing originalLow for carry to avoid an extra local.
@@ -316,7 +316,7 @@ public struct GpuUInt128 : IComparable<GpuUInt128>, IEquatable<GpuUInt128>
             return;
         }
 
-        AddInternal(valueHigh, valueLow);
+        Add(valueHigh, valueLow);
         if (CompareTo(in modulus) >= 0)
         {
             Sub(in modulus);
@@ -589,9 +589,6 @@ public struct GpuUInt128 : IComparable<GpuUInt128>, IEquatable<GpuUInt128>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static GpuUInt128 BinaryGcd(GpuUInt128 u, GpuUInt128 v)
     {
-        // TODO: Replace this scalar binary GCD with the branchless reduction from
-        // GpuUInt128BinaryGcdBenchmarks so CPU fallbacks stay aligned with the GPU kernel
-        // performance when resolving large divisor residues.
         if (u.IsZero)
         {
             return v;
@@ -602,26 +599,50 @@ public struct GpuUInt128 : IComparable<GpuUInt128>, IEquatable<GpuUInt128>
             return u;
         }
 
-        int shift = TrailingZeroCount(new GpuUInt128(u.High | v.High, u.Low | v.Low));
+        ulong combinedLow = u.Low | v.Low;
+        int shift;
+        if (combinedLow != 0UL)
+        {
+            shift = BitOperations.TrailingZeroCount(combinedLow);
+        }
+        else
+        {
+            ulong combinedHigh = u.High | v.High;
+            shift = 64 + BitOperations.TrailingZeroCount(combinedHigh);
+        }
+
         int zu = TrailingZeroCount(u);
         u >>= zu;
 
-        do
+        GpuUInt128 currentV = v;
+        while (true)
         {
-            int zv = TrailingZeroCount(v);
-            v >>= zv;
-            if (u > v)
+            int zv = TrailingZeroCount(currentV);
+            currentV >>= zv;
+
+            bool swap = u > currentV;
+            GpuUInt128 min = ConditionalSelect(u, currentV, swap);
+            GpuUInt128 max = ConditionalSelect(currentV, u, swap);
+            max.Sub(min);
+
+            if (max.IsZero)
             {
-                (u, v) = (v, u);
+                return min << shift;
             }
 
-            v -= u;
+            u = min;
+            currentV = max;
         }
-        while (!v.IsZero);
-
-        return u << shift;
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static GpuUInt128 ConditionalSelect(in GpuUInt128 left, in GpuUInt128 right, bool useRight)
+    {
+        ulong mask = useRight ? ulong.MaxValue : 0UL;
+        return new GpuUInt128(
+            left.High ^ ((left.High ^ right.High) & mask),
+            left.Low ^ ((left.Low ^ right.Low) & mask));
+    }
 
     public void Sub(ulong value)
     {
@@ -1529,6 +1550,15 @@ public struct GpuUInt128 : IComparable<GpuUInt128>, IEquatable<GpuUInt128>
         high = hi;
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Pow2()
+    {
+        ulong operand = Low;
+        Low = operand * operand;
+        ulong highProduct = operand * High;
+        High = highProduct + MulHigh(operand, operand);
+    }
+
 }
 
 // TODO: Check if the TODO below is still relevant.

PerfectNumbers.Core/Gpu/Kernels/Pow2MontgomeryKernels.cs

@@ -1,3 +1,4 @@
+using System.Runtime.CompilerServices;
 using ILGPU;
 using ILGPU.Runtime;
 
@@ -5,21 +6,75 @@ namespace PerfectNumbers.Core.Gpu.Kernels;
 
 internal static class Pow2MontgomeryKernels
 {
-    public static void Pow2MontgomeryKernelKeepMontgomery(
-        Index1D index,
-        ArrayView1D<ulong, Stride1D.Dense> exponents,
-        MontgomeryDivisorData divisor,
-        ArrayView1D<ulong, Stride1D.Dense> results)
-    {
-        results[index] = ULongExtensions.Pow2MontgomeryModWindowedGpuKeepMontgomery(divisor, exponents[index]);
-    }
+	[MethodImpl(MethodImplOptions.AggressiveInlining)]
+	private static GpuUInt128 AdvancePolynomialGpu(GpuUInt128 x, ulong c, ulong modulus)
+	{
+		x.Pow2();
+		x.AddMod(c, modulus);
+		return x;
+	}
 
-    public static void Pow2MontgomeryKernelConvertToStandard(
-        Index1D index,
-        ArrayView1D<ulong, Stride1D.Dense> exponents,
-        MontgomeryDivisorData divisor,
-        ArrayView1D<ulong, Stride1D.Dense> results)
-    {
-        results[index] = ULongExtensions.Pow2MontgomeryModWindowedGpuConvertToStandard(divisor, exponents[index]);
-    }
+	public static void Pow2MontgomeryKernelKeepMontgomery(
+		Index1D index,
+		ArrayView1D<ulong, Stride1D.Dense> exponents,
+		MontgomeryDivisorData divisor,
+		ArrayView1D<ulong, Stride1D.Dense> results)
+	{
+		results[0] = ULongExtensions.Pow2MontgomeryModWindowedGpuKeepMontgomery(divisor, exponents[0]);
+	}
+
+	public static void Pow2MontgomeryKernelConvertToStandard(
+		Index1D index,
+		ArrayView1D<ulong, Stride1D.Dense> exponents,
+		MontgomeryDivisorData divisor,
+		ArrayView1D<ulong, Stride1D.Dense> results)
+	{
+		results[0] = ULongExtensions.Pow2MontgomeryModWindowedGpuConvertToStandard(divisor, exponents[0]);
+	}
+
+
+	public static void TryPollardRhoKernel(ulong n, int limit, ArrayView1D<ulong, Stride1D.Dense> randomState, ArrayView1D<byte, Stride1D.Dense> factored, ArrayView1D<ulong, Stride1D.Dense> factor)
+	{
+		factored[0] = 0;
+		if ((n & 1UL) == 0UL)
+		{
+			factor[0] = 2UL;
+			factored[0] = 1;
+			return;
+		}
+
+		int attempt = 0;
+		GpuUInt128 nGpuUInt128 = (GpuUInt128)n;
+		DeterministicRandomGpu random = new(randomState[0]);
+		while (attempt < limit)
+		{
+			ulong c = (random.NextUInt64() % (n - 1UL)) + 1UL;
+			GpuUInt128 x = (random.NextUInt64() % (n - 2UL)) + 2UL;
+			GpuUInt128 y = x;
+			GpuUInt128 d = GpuUInt128.One;
+
+			while (d.CompareTo(GpuUInt128.One) == 0)
+			{
+				x = AdvancePolynomialGpu(x, c, modulus: n);
+				y = AdvancePolynomialGpu(y, c, n);
+				y = AdvancePolynomialGpu(y, c, n);
+				GpuUInt128 diff = x.CompareTo(y) > 0 ? x - y : y - x;
+				d = GpuUInt128.BinaryGcd(diff, nGpuUInt128);
+			}
+
+			if (d != n)
+			{
+				if (d.High == 0)
+				{
+					factor[0] = d.Low;
+					factored[0] = 1;
+					return;
+				}
+			}
+
+			attempt++;
+		}
+
+		randomState[0] = random.State;
+	}
 }

PerfectNumbers.Core/Gpu/Kernels/PrimeOrderKernels.cs

@@ -2,6 +2,7 @@ using System.Numerics;
 using System.Runtime.CompilerServices;
 using ILGPU;
 using ILGPU.Runtime;
+using PerfectNumbers.Core.Cpu;
 
 namespace PerfectNumbers.Core.Gpu;
 
@@ -1410,5 +1411,4 @@ internal static partial class PrimeOrderGpuHeuristics
 		ulong directMask = (1UL << windowBitCount) - 1UL;
 		return exponent.Low & directMask;
 	}
-
 }

PerfectNumbers.Core/Gpu/MersenneNumberLucasLehmerGpuTester.cs

@@ -147,13 +147,11 @@ public class MersenneNumberLucasLehmerGpuTester
             return false;
         }
 
-        GpuPrimeWorkLimiter.Acquire();
         bool result;
         if (exponent >= 128UL)
         {
             if (!TryGetNttParameters(exponent, out var nttMod, out var primitiveRoot))
             {
-				GpuPrimeWorkLimiter.Release();
                 throw new NotSupportedException("NTT parameters for the given exponent are not available.");
             }
 
@@ -161,6 +159,7 @@ public class MersenneNumberLucasLehmerGpuTester
         }
         else
         {
+        	GpuPrimeWorkLimiter.Acquire();
             var accelerator = AcceleratorPool.Shared.Rent();
             var stream = accelerator.CreateStream();
             var modulus = new GpuUInt128(((UInt128)1 << (int)exponent) - 1UL); // TODO: Cache these Mersenne moduli per exponent so LL GPU runs skip rebuilding them every launch.

PerfectNumbers.Core/Gpu/Pow2MontgomeryGpuCalculator.cs

@@ -10,25 +10,28 @@ public static class Pow2MontgomeryGpuCalculator
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static ulong CalculateKeep(ulong exponent, in MontgomeryDivisorData divisor)
 	{
+		GpuPrimeWorkLimiter.Acquire();
 
 		var gpu = Pow2MontgomeryAccelerator.Rent(1);
 		Accelerator? accelerator = gpu.Accelerator;
-		AcceleratorStream stream = gpu.Stream!;
+		AcceleratorStream stream = AcceleratorStreamPool.Rent(accelerator);
+		// AcceleratorStream stream = gpu.Stream!;
 		MemoryBuffer1D<ulong, Stride1D.Dense> exponentBuffer = gpu.Input;
-		MemoryBuffer1D<ulong, Stride1D.Dense> resultBuffer = gpu.Output;
 
 		exponentBuffer.View.CopyFromCPU(stream, ref exponent, 1);
 		// We don't need to worry about any left-overs here.
 		// resultBuffer.MemSetToZero(stream);
 
+		MemoryBuffer1D<ulong, Stride1D.Dense> resultBuffer = gpu.OutputUlong;
 		var kernel = gpu.KeepMontgomeryKernel;
+		var kernelLauncher = kernel.CreateLauncherDelegate<Action<AcceleratorStream, Index1D, ArrayView1D<ulong, Stride1D.Dense>, MontgomeryDivisorData, ArrayView1D<ulong, Stride1D.Dense>>>();
 
-		GpuPrimeWorkLimiter.Acquire();
-		kernel(stream, 1, exponentBuffer.View, divisor, resultBuffer.View);
+		kernelLauncher(stream, 1, exponentBuffer.View, divisor, resultBuffer.View);
 
 		ulong result = 0UL;
 		resultBuffer.View.CopyToCPU(stream, ref result, 1);
 		stream.Synchronize();
+		AcceleratorStreamPool.Return(stream);
 		GpuPrimeWorkLimiter.Release();
 
 		Pow2MontgomeryAccelerator.Return(gpu);
@@ -38,24 +41,26 @@ public static class Pow2MontgomeryGpuCalculator
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static ulong CalculateConvert(ulong exponent, in MontgomeryDivisorData divisor)
 	{
+		GpuPrimeWorkLimiter.Acquire();
 
 		var gpu = Pow2MontgomeryAccelerator.Rent(1);
-		AcceleratorStream stream = gpu.Stream!;
+		AcceleratorStream stream = AcceleratorStreamPool.Rent(gpu.Accelerator);
+		// AcceleratorStream stream = gpu.Stream!;
 		MemoryBuffer1D<ulong, Stride1D.Dense> exponentBuffer = gpu.Input;
-		MemoryBuffer1D<ulong, Stride1D.Dense> resultBuffer = gpu.Output;
 
 		exponentBuffer.View.CopyFromCPU(stream, ref exponent, 1);
 		// We don't need to worry about any left-overs here.
 		// resultBuffer.MemSetToZero(stream);
 
+		MemoryBuffer1D<ulong, Stride1D.Dense> resultBuffer = gpu.OutputUlong;
 		var kernel = gpu.ConvertToStandardKernel;
 
-		GpuPrimeWorkLimiter.Acquire();
-		kernel(stream, 1, exponentBuffer.View, divisor, resultBuffer.View);
+		kernel.Launch(stream, 1, 1, exponentBuffer.View, divisor, resultBuffer.View);
 
 		ulong result = 0UL;
 		resultBuffer.View.CopyToCPU(stream, ref result, 1);
 		stream.Synchronize();
+		AcceleratorStreamPool.Return(stream);
 		GpuPrimeWorkLimiter.Release();
 
 		Pow2MontgomeryAccelerator.Return(gpu);
@@ -65,20 +70,24 @@ public static class Pow2MontgomeryGpuCalculator
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static ulong CalculateConvert(Pow2MontgomeryAccelerator gpu, ulong exponent, in MontgomeryDivisorData divisor)
 	{
-		AcceleratorStream stream = gpu.Stream!;
+		AcceleratorStream stream = AcceleratorStreamPool.Rent(gpu.Accelerator);
+		// AcceleratorStream stream = gpu.Stream!;
 		MemoryBuffer1D<ulong, Stride1D.Dense> exponentBuffer = gpu.Input;
-		MemoryBuffer1D<ulong, Stride1D.Dense> resultBuffer = gpu.Output;
 
 		exponentBuffer.View.CopyFromCPU(stream, ref exponent, 1);
 		// We don't need to worry about any left-overs here.
 		// resultBuffer.MemSetToZero(stream);
 
+		MemoryBuffer1D<ulong, Stride1D.Dense> resultBuffer = gpu.OutputUlong;
 		var kernel = gpu.ConvertToStandardKernel;
-		kernel(stream, 1, exponentBuffer.View, divisor, resultBuffer.View);
+		var kernelLauncher = kernel.CreateLauncherDelegate<Action<AcceleratorStream, Index1D, ArrayView1D<ulong, Stride1D.Dense>, MontgomeryDivisorData, ArrayView1D<ulong, Stride1D.Dense>>>();
+
+		kernelLauncher(stream, 1,exponentBuffer.View, divisor, resultBuffer.View);
 
 		ulong result = 0UL;
 		resultBuffer.View.CopyToCPU(stream, ref result, 1);
 		stream.Synchronize();
+		AcceleratorStreamPool.Return(stream);
 
 		return result;
 	}