IsPrime with cancellation token removed.

PerfectNumbers.Core/HeuristicPrimeTester.cs

@@ -77,10 +77,8 @@ public sealed class HeuristicPrimeTester
 
     public static HeuristicPrimeTester Exclusive => _tester ??= new();
 
-    public bool IsPrimeCpu(ulong n, CancellationToken ct)
+    public bool IsPrimeCpu(ulong n)
     {
-        ct.ThrowIfCancellationRequested();
-
         byte nMod10 = (byte)n.Mod10();
         ulong maxDivisorSquare = ComputeHeuristicDivisorSquareLimit(n);
 
@@ -93,11 +91,6 @@ public sealed class HeuristicPrimeTester
         return HeuristicTrialDivisionCpu(n, maxDivisorSquare, nMod10, includeGroupB);
     }
 
-    public bool IsPrimeCpu(ulong n)
-    {
-        return IsPrimeCpu(n, CancellationToken.None);
-    }
-
     public bool IsPrimeGpu(ulong n)
     {
         byte nMod10 = (byte)n.Mod10();

PerfectNumbers.Core/MersenneDivisorCycles.cs

@@ -411,8 +411,8 @@ public class MersenneDivisorCycles
 		// Atomic.Add(ref _tryFactorIntoCountsInternalHits, 1UL);
 		// Console.WriteLine($"MersenneDivisorCycles.TryFactorIntoCountsInternal hits {Volatile.Read(ref _tryFactorIntoCountsInternalHits)}");
 
-		HeuristicPrimeTester primeTester = _primeTester ??= new();
-		if (primeTester.IsPrimeGpu(remaining))
+		// HeuristicPrimeTester primeTester = _primeTester ??= new();
+		if (PrimeTester.IsPrime(remaining))
 		// if (PrimeTester.IsPrimeCpu(remaining, CancellationToken.None))
 		{
 			AddFactor(counts, remaining);
@@ -917,8 +917,8 @@ public class MersenneDivisorCycles
         return CalculateCycleLengthFallback(divisor);
     }
 
-	[ThreadStatic]
-	private static HeuristicPrimeTester? _primeTester;
+	// [ThreadStatic]
+	// private static HeuristicPrimeTester? _primeTester;
 
 	internal static bool TryCalculateCycleLengthHeuristic(ulong divisor, in MontgomeryDivisorData divisorData, out ulong cycleLength, bool skipPrimeOrderHeuristic = false)
 	{
@@ -940,10 +940,10 @@ public class MersenneDivisorCycles
 		// 	Console.WriteLine($"MersenneDivisorCycles.CalculateCycleLengthFallback hits {Volatile.Read(ref _tryCalculateCycleLengthHeuristicHits)}");			
 		// }
 
-		HeuristicPrimeTester primeTester = _primeTester ??= new();
+		// HeuristicPrimeTester primeTester = _primeTester ??= new();
 		// if (!skipPrimeOrderHeuristic && HeuristicPrimeTester.Exclusive.IsPrimeCpu(divisor, CancellationToken.None))
-		if (!skipPrimeOrderHeuristic && primeTester.IsPrimeGpu(divisor))
-		// if (!skipPrimeOrderHeuristic && PrimeTester.IsPrimeCpu(divisor, CancellationToken.None))
+		// if (!skipPrimeOrderHeuristic && primeTester.IsPrimeGpu(divisor))
+		if (!skipPrimeOrderHeuristic && PrimeTester.IsPrime(divisor))
 		{
 			ulong computedOrder = PrimeOrderCalculator.Calculate(
 					divisor,

PerfectNumbers.Core/MersennePrimeFactorTester.cs

@@ -34,7 +34,7 @@ public static class MersennePrimeFactorTester
 		// Atomic.Add(ref _isPrimeFactorHits, 1UL);
 		// Console.WriteLine($"MersennePrimeFactorTester.IsPrimeFactor hits {Volatile.Read(ref _isPrimeFactorHits)}");
 
-        if (!PrimeTester.IsPrimeCpu(q, ct))
+        if (!PrimeTester.IsPrime(q))
         {
             return false;
         }
@@ -247,7 +247,7 @@ public static class MersennePrimeFactorTester
 			// Console.WriteLine($"MersennePrimeFactorTester.Factor64 hits {Volatile.Read(ref _factor64Hits)}");
 
             // if (HeuristicPrimeTester.Exclusive.IsPrime(m, ct))
-            if (PrimeTester.IsPrimeCpu(m, ct))
+            if (PrimeTester.IsPrime(m))
             {
                 dict[m] = 1;
                 continue;

PerfectNumbers.Core/PrimeOrderCalculator.Cpu.cs

@@ -1079,7 +1079,7 @@ internal static partial class PrimeOrderCalculator
 		PartialFactorResult result;
 		PrimeTester primeTester = PrimeTester.Exclusive;
 		CancellationToken ct = CancellationToken.None;
-		HeuristicPrimeTester? tester = _tester ??= new();
+		// HeuristicPrimeTester? tester = _tester ??= new();
 
 		if (!gpuFactored)
 		{
@@ -1152,7 +1152,7 @@ internal static partial class PrimeOrderCalculator
 					// Console.WriteLine($"Partial factor hits {Volatile.Read(ref _partialFactorHits)}");
 
 					// bool isPrime = PrimeTester.IsPrimeCpu(composite, CancellationToken.None);
-					bool isPrime = tester.IsPrimeGpu(composite);
+					bool isPrime = PrimeTester.IsPrime(composite);
 					// bool isPrime = Open.Numeric.Primes.Prime.Numbers.IsPrime(composite);
 
 					if (isPrime)
@@ -1220,7 +1220,7 @@ internal static partial class PrimeOrderCalculator
 				// Console.WriteLine($"Partial factor pending hits {Volatile.Read(ref _partialFactorPendingHits)}");
 
 				// bool isPrime = PrimeTester.IsPrimeCpu(composite, CancellationToken.None);
-				bool isPrime = tester.IsPrimeGpu(composite);
+				bool isPrime = PrimeTester.IsPrime(composite);
 				// bool isPrime = Open.Numeric.Primes.Prime.Numbers.IsPrime(composite);
 
 				entry = entry.WithPrimality(isPrime);
@@ -1257,7 +1257,7 @@ internal static partial class PrimeOrderCalculator
 			// Atomic.Add(ref _partialFactorCofactorHits, 1UL);
 			// Console.WriteLine($"Partial factor cofactor hits {Volatile.Read(ref _partialFactorCofactorHits)}");
 
-			cofactorIsPrime = tester.IsPrimeGpu(cofactor);
+			cofactorIsPrime = PrimeTester.IsPrime(cofactor);
 			// cofactorIsPrime = PrimeTester.IsPrimeGpu(cofactor);
 			// cofactorIsPrime = Open.Numeric.Primes.Prime.Numbers.IsPrime(cofactor);
 		}
@@ -1782,8 +1782,8 @@ internal static partial class PrimeOrderCalculator
 
 	// private static ulong _factorCompletelyHits;
 	// private static ulong _factorCompletelyPollardRhoHits;
-	[ThreadStatic]
-	private static HeuristicPrimeTester? _tester;
+	// [ThreadStatic]
+	// private static HeuristicPrimeTester? _tester;
 
 	private static void FactorCompletely(ulong value, Dictionary<ulong, int> counts, bool knownComposite)
 	{
@@ -1794,10 +1794,10 @@ internal static partial class PrimeOrderCalculator
 
 		// Atomic.Add(ref _factorCompletelyHits, 1UL);
 		// Console.WriteLine($"Factor completely hits {Volatile.Read(ref _factorCompletelyHits)}");
-		HeuristicPrimeTester tester = _tester ??= new();
+		// HeuristicPrimeTester tester = _tester ??= new();
 
 		// bool isPrime = primeTester.HeuristicIsPrimeGpu(value);
-		bool isPrime = tester.IsPrimeGpu(value);
+		bool isPrime = PrimeTester.IsPrime(value);
 		// bool isPrime = PrimeTester.IsPrimeGpu(value);
 		// bool isPrime = Open.Numeric.Primes.Prime.Numbers.IsPrime(value);
 		if (!knownComposite && isPrime)
@@ -1813,7 +1813,7 @@ internal static partial class PrimeOrderCalculator
 		// Console.WriteLine($"Factor completely after PollardRho hits {Volatile.Read(ref _factorCompletelyPollardRhoHits)}");
 
 		// isPrime = primeTester.HeuristicIsPrimeGpu(factor);
-		isPrime = tester.IsPrimeGpu(factor);
+		isPrime = PrimeTester.IsPrime(factor);
 		// isPrime = PrimeTester.IsPrimeGpu(factor);
 		// isPrime = Open.Numeric.Primes.Prime.Numbers.IsPrime(factor);
 		if (isPrime)
@@ -1850,7 +1850,7 @@ internal static partial class PrimeOrderCalculator
 			// Atomic.Add(ref _partialFactorCofactorHits, 1UL);
 			// Console.WriteLine($"Partial factor cofactor hits {Volatile.Read(ref _partialFactorCofactorHits)}");
 
-			isPrime = tester.IsPrimeGpu(quotient);
+			isPrime = PrimeTester.IsPrime(quotient);
 			// isPrime = PrimeTester.IsPrimeGpu(quotient);
 			// isPrime = Open.Numeric.Primes.Prime.Numbers.IsPrime(quotient);
 		}

PerfectNumbers.Core/PrimeOrderCalculator.Shared.cs

@@ -950,7 +950,7 @@ internal static partial class PrimeOrderCalculator
         if (value <= ulong.MaxValue)
         {
             // return HeuristicPrimeTester.Exclusive.IsPrimeCpu((ulong)value, CancellationToken.None);
-            return PrimeTester.IsPrimeCpu((ulong)value, CancellationToken.None);
+            return PrimeTester.IsPrime((ulong)value);
         }
 
         if ((value & UInt128.One) == UInt128.Zero)

PerfectNumbers.Core/PrimeTester.cs

@@ -1,7 +1,5 @@
-using System;
 using System.Buffers;
 using System.Collections.Concurrent;
-using System.Collections.Generic;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -22,7 +20,7 @@ public sealed class PrimeTester
 
 	public static PrimeTester Exclusive => _tester ??= new();
 
-	public static bool IsPrime(ulong n, CancellationToken ct)
+	public static bool IsPrime(ulong n)
 	{
 		if (n <= 1UL)
 		{
@@ -92,310 +90,298 @@ public sealed class PrimeTester
 		return result;
 	}
 
-	public static bool IsPrimeGpu(ulong n)
-	{
-		return Exclusive.IsPrimeGpu(n, CancellationToken.None);
-	}
-
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
-	public bool IsPrimeGpu(ulong n, CancellationToken ct)
-        {
-                bool forceCpu = GpuContextPool.ForceCpu;
-                bool belowGpuRange = n < 31UL;
-
-                if (forceCpu || belowGpuRange)
-                {
-                        return IsPrimeCpu(n, ct);
-                }
-
-                var limiter = GpuPrimeWorkLimiter.Acquire();
-                var gpu = PrimeTesterGpuContextPool.Rent(1);
-                var accelerator = gpu.Accelerator;
-                var kernel = gpu.Kernel;
-
-                ulong value = n;
-                byte flag = 0;
-
-                var input = gpu.Input;
-                var output = gpu.Output;
-                var inputView = input.View;
-                var outputView = output.View;
-
-                inputView.CopyFromCPU(ref value, 1);
-                kernel(
-                                1,
-                                inputView,
-                                gpu.DevicePrimesDefault.View,
-                                gpu.DevicePrimesLastOne.View,
-                                gpu.DevicePrimesLastSeven.View,
-                                gpu.DevicePrimesLastThree.View,
-                                gpu.DevicePrimesLastNine.View,
-                                gpu.DevicePrimesPow2Default.View,
-                                gpu.DevicePrimesPow2LastOne.View,
-                                gpu.DevicePrimesPow2LastSeven.View,
-                                gpu.DevicePrimesPow2LastThree.View,
-                                gpu.DevicePrimesPow2LastNine.View,
-                                outputView);
-                accelerator.Synchronize();
-                outputView.CopyToCPU(ref flag, 1);
-
-                gpu.Dispose();
-                limiter.Dispose();
-
-                return flag != 0;
-        }
-
-public static bool IsPrimeCpu(ulong n, CancellationToken ct)
+	public bool IsPrimeGpu(ulong n)
 	{
-		// Preserve the legacy entry point for callers that bypass the thread-local caches.
-		return IsPrime(n, ct);
-	}
+		bool forceCpu = GpuContextPool.ForceCpu;
+		bool belowGpuRange = n < 31UL;
 
+		if (forceCpu || belowGpuRange)
+		{
+			return IsPrime(n);
+		}
+
+		var limiter = GpuPrimeWorkLimiter.Acquire();
+		var gpu = PrimeTesterGpuContextPool.Rent(1);
+		var accelerator = gpu.Accelerator;
+		var kernel = gpu.Kernel;
+
+		ulong value = n;
+		byte flag = 0;
+
+		var input = gpu.Input;
+		var output = gpu.Output;
+		var inputView = input.View;
+		var outputView = output.View;
+
+		inputView.CopyFromCPU(ref value, 1);
+		kernel(
+						1,
+						inputView,
+						gpu.DevicePrimesDefault.View,
+						gpu.DevicePrimesLastOne.View,
+						gpu.DevicePrimesLastSeven.View,
+						gpu.DevicePrimesLastThree.View,
+						gpu.DevicePrimesLastNine.View,
+						gpu.DevicePrimesPow2Default.View,
+						gpu.DevicePrimesPow2LastOne.View,
+						gpu.DevicePrimesPow2LastSeven.View,
+						gpu.DevicePrimesPow2LastThree.View,
+						gpu.DevicePrimesPow2LastNine.View,
+						outputView);
+		accelerator.Synchronize();
+		outputView.CopyToCPU(ref flag, 1);
+
+		gpu.Dispose();
+		limiter.Dispose();
+
+		return flag != 0;
+	}
 
 	public static int GpuBatchSize { get; set; } = 262_144;
 
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static void IsPrimeBatchGpu(ReadOnlySpan<ulong> values, Span<byte> results)
-        {
-                var limiter = GpuPrimeWorkLimiter.Acquire();
-                var gpu = PrimeTesterGpuContextPool.Rent(GpuBatchSize);
-                var accelerator = gpu.Accelerator;
-                var kernel = gpu.Kernel;
-                int totalLength = values.Length;
-                int batchSize = GpuBatchSize;
+	{
+		var limiter = GpuPrimeWorkLimiter.Acquire();
+		var gpu = PrimeTesterGpuContextPool.Rent(GpuBatchSize);
+		var accelerator = gpu.Accelerator;
+		var kernel = gpu.Kernel;
+		int totalLength = values.Length;
+		int batchSize = GpuBatchSize;
 
-                var input = gpu.Input;
-                var output = gpu.Output;
-                var inputView = input.View;
-                var outputView = output.View;
+		var input = gpu.Input;
+		var output = gpu.Output;
+		var inputView = input.View;
+		var outputView = output.View;
 
-                int pos = 0;
-                while (pos < totalLength)
-                {
-                        int remaining = totalLength - pos;
-                        int count = remaining > batchSize ? batchSize : remaining;
+		int pos = 0;
+		while (pos < totalLength)
+		{
+			int remaining = totalLength - pos;
+			int count = remaining > batchSize ? batchSize : remaining;
 
-                        var valueSlice = values.Slice(pos, count);
-                        ref ulong valueRef = ref MemoryMarshal.GetReference(valueSlice);
-                        inputView.CopyFromCPU(ref valueRef, count);
+			var valueSlice = values.Slice(pos, count);
+			ref ulong valueRef = ref MemoryMarshal.GetReference(valueSlice);
+			inputView.CopyFromCPU(ref valueRef, count);
 
-                        kernel(
-                                count,
-                                inputView,
-                                gpu.DevicePrimesDefault.View,
-                                gpu.DevicePrimesLastOne.View,
-                                gpu.DevicePrimesLastSeven.View,
-                                gpu.DevicePrimesLastThree.View,
-                                gpu.DevicePrimesLastNine.View,
-                                gpu.DevicePrimesPow2Default.View,
-                                gpu.DevicePrimesPow2LastOne.View,
-                                gpu.DevicePrimesPow2LastSeven.View,
-                                gpu.DevicePrimesPow2LastThree.View,
-                                gpu.DevicePrimesPow2LastNine.View,
-                                outputView);
-                        accelerator.Synchronize();
-                        var resultSlice = results.Slice(pos, count);
-                        ref byte resultRef = ref MemoryMarshal.GetReference(resultSlice);
-                        outputView.CopyToCPU(ref resultRef, count);
+			kernel(
+					count,
+					inputView,
+					gpu.DevicePrimesDefault.View,
+					gpu.DevicePrimesLastOne.View,
+					gpu.DevicePrimesLastSeven.View,
+					gpu.DevicePrimesLastThree.View,
+					gpu.DevicePrimesLastNine.View,
+					gpu.DevicePrimesPow2Default.View,
+					gpu.DevicePrimesPow2LastOne.View,
+					gpu.DevicePrimesPow2LastSeven.View,
+					gpu.DevicePrimesPow2LastThree.View,
+					gpu.DevicePrimesPow2LastNine.View,
+					outputView);
+			accelerator.Synchronize();
+			var resultSlice = results.Slice(pos, count);
+			ref byte resultRef = ref MemoryMarshal.GetReference(resultSlice);
+			outputView.CopyToCPU(ref resultRef, count);
 
-                        pos += count;
-                }
+			pos += count;
+		}
 
-                gpu.Dispose();
-                limiter.Dispose();
-        }
+		gpu.Dispose();
+		limiter.Dispose();
+	}
 
-        internal static class PrimeTesterGpuContextPool
-        {
-                private static readonly ConcurrentQueue<PrimeTesterGpuContextLease> Pool = new();
+	internal static class PrimeTesterGpuContextPool
+	{
+		private static readonly ConcurrentQueue<PrimeTesterGpuContextLease> Pool = new();
 
-                internal static PrimeTesterGpuContextLease Rent(int minBufferCapacity = 1)
-                {
-                        if (!Pool.TryDequeue(out var lease))
-                        {
-                                lease = new PrimeTesterGpuContextLease(minBufferCapacity);
-                        }
-                        else
-                        {
-                                lease.EnsureCapacity(minBufferCapacity);
-                        }
+		internal static PrimeTesterGpuContextLease Rent(int minBufferCapacity = 1)
+		{
+			if (!Pool.TryDequeue(out var lease))
+			{
+				lease = new PrimeTesterGpuContextLease(minBufferCapacity);
+			}
+			else
+			{
+				lease.EnsureCapacity(minBufferCapacity);
+			}
 
-                        lease.ResetReturnFlag();
-                        return lease;
-                }
+			lease.ResetReturnFlag();
+			return lease;
+		}
 
-                internal static void Return(PrimeTesterGpuContextLease lease)
-                {
-                        lease.Accelerator.Synchronize();
-                        Pool.Enqueue(lease);
-                }
+		internal static void Return(PrimeTesterGpuContextLease lease)
+		{
+			lease.Accelerator.Synchronize();
+			Pool.Enqueue(lease);
+		}
 
-                internal static void DisposeAll()
-                {
-                        while (Pool.TryDequeue(out var lease))
-                        {
-                                lease.DisposeResources();
-                        }
-                }
+		internal static void DisposeAll()
+		{
+			while (Pool.TryDequeue(out var lease))
+			{
+				lease.DisposeResources();
+			}
+		}
 
-                internal static void Clear(Accelerator accelerator)
-                {
-                        if (accelerator is null)
-                        {
-                                return;
-                        }
+		internal static void Clear(Accelerator accelerator)
+		{
+			if (accelerator is null)
+			{
+				return;
+			}
 
-                        var retained = new List<PrimeTesterGpuContextLease>();
-                        while (Pool.TryDequeue(out var lease))
-                        {
-                                if (lease.Accelerator == accelerator)
-                                {
-                                        lease.DisposeResources();
-                                }
-                                else
-                                {
-                                        retained.Add(lease);
-                                }
-                        }
+			var retained = new List<PrimeTesterGpuContextLease>();
+			while (Pool.TryDequeue(out var lease))
+			{
+				if (lease.Accelerator == accelerator)
+				{
+					lease.DisposeResources();
+				}
+				else
+				{
+					retained.Add(lease);
+				}
+			}
 
-                        int retainedCount = retained.Count;
-                        for (int i = 0; i < retainedCount; i++)
-                        {
-                                Pool.Enqueue(retained[i]);
-                        }
-                }
+			int retainedCount = retained.Count;
+			for (int i = 0; i < retainedCount; i++)
+			{
+				Pool.Enqueue(retained[i]);
+			}
+		}
 
-                internal sealed class PrimeTesterGpuContextLease : IDisposable
-                {
-                        private bool _returned;
+		internal sealed class PrimeTesterGpuContextLease : IDisposable
+		{
+			private bool _returned;
 
-                        internal readonly Context AcceleratorContext;
-                        public readonly Accelerator Accelerator;
-                        public readonly Action<Index1D, ArrayView<ulong>, ArrayView<uint>, ArrayView<uint>, ArrayView<uint>, ArrayView<uint>, ArrayView<uint>, ArrayView<ulong>, ArrayView<ulong>, ArrayView<ulong>, ArrayView<ulong>, ArrayView<ulong>, ArrayView<byte>> Kernel;
-                        public readonly Action<Index1D, ArrayView<ulong>, ulong, ArrayView<int>> HeuristicTrialDivisionKernel;
-                        public readonly MemoryBuffer1D<uint, Stride1D.Dense> DevicePrimesDefault;
-                        public readonly MemoryBuffer1D<uint, Stride1D.Dense> DevicePrimesLastOne;
-                        public readonly MemoryBuffer1D<uint, Stride1D.Dense> DevicePrimesLastSeven;
-                        public readonly MemoryBuffer1D<uint, Stride1D.Dense> DevicePrimesLastThree;
-                        public readonly MemoryBuffer1D<uint, Stride1D.Dense> DevicePrimesLastNine;
-                        public readonly MemoryBuffer1D<ulong, Stride1D.Dense> DevicePrimesPow2Default;
-                        public readonly MemoryBuffer1D<ulong, Stride1D.Dense> DevicePrimesPow2LastOne;
-                        public readonly MemoryBuffer1D<ulong, Stride1D.Dense> DevicePrimesPow2LastSeven;
-                        public readonly MemoryBuffer1D<ulong, Stride1D.Dense> DevicePrimesPow2LastThree;
-                        public readonly MemoryBuffer1D<ulong, Stride1D.Dense> DevicePrimesPow2LastNine;
-                        public MemoryBuffer1D<ulong, Stride1D.Dense> Input;
-                        public MemoryBuffer1D<byte, Stride1D.Dense> Output;
-                        public MemoryBuffer1D<int, Stride1D.Dense> HeuristicFlag;
-                        public int BufferCapacity;
+			internal readonly Context AcceleratorContext;
+			public readonly Accelerator Accelerator;
+			public readonly Action<Index1D, ArrayView<ulong>, ArrayView<uint>, ArrayView<uint>, ArrayView<uint>, ArrayView<uint>, ArrayView<uint>, ArrayView<ulong>, ArrayView<ulong>, ArrayView<ulong>, ArrayView<ulong>, ArrayView<ulong>, ArrayView<byte>> Kernel;
+			public readonly Action<Index1D, ArrayView<ulong>, ulong, ArrayView<int>> HeuristicTrialDivisionKernel;
+			public readonly MemoryBuffer1D<uint, Stride1D.Dense> DevicePrimesDefault;
+			public readonly MemoryBuffer1D<uint, Stride1D.Dense> DevicePrimesLastOne;
+			public readonly MemoryBuffer1D<uint, Stride1D.Dense> DevicePrimesLastSeven;
+			public readonly MemoryBuffer1D<uint, Stride1D.Dense> DevicePrimesLastThree;
+			public readonly MemoryBuffer1D<uint, Stride1D.Dense> DevicePrimesLastNine;
+			public readonly MemoryBuffer1D<ulong, Stride1D.Dense> DevicePrimesPow2Default;
+			public readonly MemoryBuffer1D<ulong, Stride1D.Dense> DevicePrimesPow2LastOne;
+			public readonly MemoryBuffer1D<ulong, Stride1D.Dense> DevicePrimesPow2LastSeven;
+			public readonly MemoryBuffer1D<ulong, Stride1D.Dense> DevicePrimesPow2LastThree;
+			public readonly MemoryBuffer1D<ulong, Stride1D.Dense> DevicePrimesPow2LastNine;
+			public MemoryBuffer1D<ulong, Stride1D.Dense> Input;
+			public MemoryBuffer1D<byte, Stride1D.Dense> Output;
+			public MemoryBuffer1D<int, Stride1D.Dense> HeuristicFlag;
+			public int BufferCapacity;
 
-                        internal PrimeTesterGpuContextLease(int minBufferCapacity)
-                        {
-                                AcceleratorContext = Context.CreateDefault();
-                                Accelerator = AcceleratorContext.GetPreferredDevice(false).CreateAccelerator(AcceleratorContext);
-                                Kernel = Accelerator.LoadAutoGroupedStreamKernel<Index1D, ArrayView<ulong>, ArrayView<uint>, ArrayView<uint>, ArrayView<uint>, ArrayView<uint>, ArrayView<uint>, ArrayView<ulong>, ArrayView<ulong>, ArrayView<ulong>, ArrayView<ulong>, ArrayView<ulong>, ArrayView<byte>>(PrimeTesterKernels.SmallPrimeSieveKernel);
-                                HeuristicTrialDivisionKernel = Accelerator.LoadAutoGroupedStreamKernel<Index1D, ArrayView<ulong>, ulong, ArrayView<int>>(PrimeTesterKernels.HeuristicTrialDivisionKernel);
+			internal PrimeTesterGpuContextLease(int minBufferCapacity)
+			{
+				AcceleratorContext = Context.CreateDefault();
+				Accelerator = AcceleratorContext.GetPreferredDevice(false).CreateAccelerator(AcceleratorContext);
+				Kernel = Accelerator.LoadAutoGroupedStreamKernel<Index1D, ArrayView<ulong>, ArrayView<uint>, ArrayView<uint>, ArrayView<uint>, ArrayView<uint>, ArrayView<uint>, ArrayView<ulong>, ArrayView<ulong>, ArrayView<ulong>, ArrayView<ulong>, ArrayView<ulong>, ArrayView<byte>>(PrimeTesterKernels.SmallPrimeSieveKernel);
+				HeuristicTrialDivisionKernel = Accelerator.LoadAutoGroupedStreamKernel<Index1D, ArrayView<ulong>, ulong, ArrayView<int>>(PrimeTesterKernels.HeuristicTrialDivisionKernel);
 
-                                var primesDefault = DivisorGenerator.SmallPrimes;
-                                DevicePrimesDefault = Accelerator.Allocate1D<uint>(primesDefault.Length);
-                                DevicePrimesDefault.View.CopyFromCPU(primesDefault);
+				var primesDefault = DivisorGenerator.SmallPrimes;
+				DevicePrimesDefault = Accelerator.Allocate1D<uint>(primesDefault.Length);
+				DevicePrimesDefault.View.CopyFromCPU(primesDefault);
 
-                                var primesLastOne = DivisorGenerator.SmallPrimesLastOne;
-                                DevicePrimesLastOne = Accelerator.Allocate1D<uint>(primesLastOne.Length);
-                                DevicePrimesLastOne.View.CopyFromCPU(primesLastOne);
+				var primesLastOne = DivisorGenerator.SmallPrimesLastOne;
+				DevicePrimesLastOne = Accelerator.Allocate1D<uint>(primesLastOne.Length);
+				DevicePrimesLastOne.View.CopyFromCPU(primesLastOne);
 
-                                var primesLastSeven = DivisorGenerator.SmallPrimesLastSeven;
-                                DevicePrimesLastSeven = Accelerator.Allocate1D<uint>(primesLastSeven.Length);
-                                DevicePrimesLastSeven.View.CopyFromCPU(primesLastSeven);
+				var primesLastSeven = DivisorGenerator.SmallPrimesLastSeven;
+				DevicePrimesLastSeven = Accelerator.Allocate1D<uint>(primesLastSeven.Length);
+				DevicePrimesLastSeven.View.CopyFromCPU(primesLastSeven);
 
-                                var primesLastThree = DivisorGenerator.SmallPrimesLastThree;
-                                DevicePrimesLastThree = Accelerator.Allocate1D<uint>(primesLastThree.Length);
-                                DevicePrimesLastThree.View.CopyFromCPU(primesLastThree);
+				var primesLastThree = DivisorGenerator.SmallPrimesLastThree;
+				DevicePrimesLastThree = Accelerator.Allocate1D<uint>(primesLastThree.Length);
+				DevicePrimesLastThree.View.CopyFromCPU(primesLastThree);
 
-                                var primesLastNine = DivisorGenerator.SmallPrimesLastNine;
-                                DevicePrimesLastNine = Accelerator.Allocate1D<uint>(primesLastNine.Length);
-                                DevicePrimesLastNine.View.CopyFromCPU(primesLastNine);
+				var primesLastNine = DivisorGenerator.SmallPrimesLastNine;
+				DevicePrimesLastNine = Accelerator.Allocate1D<uint>(primesLastNine.Length);
+				DevicePrimesLastNine.View.CopyFromCPU(primesLastNine);
 
-                                var primesPow2Default = DivisorGenerator.SmallPrimesPow2;
-                                DevicePrimesPow2Default = Accelerator.Allocate1D<ulong>(primesPow2Default.Length);
-                                DevicePrimesPow2Default.View.CopyFromCPU(primesPow2Default);
+				var primesPow2Default = DivisorGenerator.SmallPrimesPow2;
+				DevicePrimesPow2Default = Accelerator.Allocate1D<ulong>(primesPow2Default.Length);
+				DevicePrimesPow2Default.View.CopyFromCPU(primesPow2Default);
 
-                                var primesPow2LastOne = DivisorGenerator.SmallPrimesPow2LastOne;
-                                DevicePrimesPow2LastOne = Accelerator.Allocate1D<ulong>(primesPow2LastOne.Length);
-                                DevicePrimesPow2LastOne.View.CopyFromCPU(primesPow2LastOne);
+				var primesPow2LastOne = DivisorGenerator.SmallPrimesPow2LastOne;
+				DevicePrimesPow2LastOne = Accelerator.Allocate1D<ulong>(primesPow2LastOne.Length);
+				DevicePrimesPow2LastOne.View.CopyFromCPU(primesPow2LastOne);
 
-                                var primesPow2LastSeven = DivisorGenerator.SmallPrimesPow2LastSeven;
-                                DevicePrimesPow2LastSeven = Accelerator.Allocate1D<ulong>(primesPow2LastSeven.Length);
-                                DevicePrimesPow2LastSeven.View.CopyFromCPU(primesPow2LastSeven);
+				var primesPow2LastSeven = DivisorGenerator.SmallPrimesPow2LastSeven;
+				DevicePrimesPow2LastSeven = Accelerator.Allocate1D<ulong>(primesPow2LastSeven.Length);
+				DevicePrimesPow2LastSeven.View.CopyFromCPU(primesPow2LastSeven);
 
-                                var primesPow2LastThree = DivisorGenerator.SmallPrimesPow2LastThree;
-                                DevicePrimesPow2LastThree = Accelerator.Allocate1D<ulong>(primesPow2LastThree.Length);
-                                DevicePrimesPow2LastThree.View.CopyFromCPU(primesPow2LastThree);
+				var primesPow2LastThree = DivisorGenerator.SmallPrimesPow2LastThree;
+				DevicePrimesPow2LastThree = Accelerator.Allocate1D<ulong>(primesPow2LastThree.Length);
+				DevicePrimesPow2LastThree.View.CopyFromCPU(primesPow2LastThree);
 
-                                var primesPow2LastNine = DivisorGenerator.SmallPrimesPow2LastNine;
-                                DevicePrimesPow2LastNine = Accelerator.Allocate1D<ulong>(primesPow2LastNine.Length);
-                                DevicePrimesPow2LastNine.View.CopyFromCPU(primesPow2LastNine);
+				var primesPow2LastNine = DivisorGenerator.SmallPrimesPow2LastNine;
+				DevicePrimesPow2LastNine = Accelerator.Allocate1D<ulong>(primesPow2LastNine.Length);
+				DevicePrimesPow2LastNine.View.CopyFromCPU(primesPow2LastNine);
 
-                                BufferCapacity = minBufferCapacity < 1 ? 1 : minBufferCapacity;
-                                Input = Accelerator.Allocate1D<ulong>(BufferCapacity);
-                                Output = Accelerator.Allocate1D<byte>(BufferCapacity);
-                                HeuristicFlag = Accelerator.Allocate1D<int>(BufferCapacity);
-                                _returned = false;
-                        }
+				BufferCapacity = minBufferCapacity < 1 ? 1 : minBufferCapacity;
+				Input = Accelerator.Allocate1D<ulong>(BufferCapacity);
+				Output = Accelerator.Allocate1D<byte>(BufferCapacity);
+				HeuristicFlag = Accelerator.Allocate1D<int>(BufferCapacity);
+				_returned = false;
+			}
 
-                        public void EnsureCapacity(int minCapacity)
-                        {
-                                int required = minCapacity < 1 ? 1 : minCapacity;
-                                if (required <= BufferCapacity)
-                                {
-                                        return;
-                                }
+			public void EnsureCapacity(int minCapacity)
+			{
+				int required = minCapacity < 1 ? 1 : minCapacity;
+				if (required <= BufferCapacity)
+				{
+					return;
+				}
 
-                                Input.Dispose();
-                                Output.Dispose();
-                                HeuristicFlag.Dispose();
-                                Input = Accelerator.Allocate1D<ulong>(required);
-                                Output = Accelerator.Allocate1D<byte>(required);
-                                HeuristicFlag = Accelerator.Allocate1D<int>(required);
-                                BufferCapacity = required;
-                        }
+				Input.Dispose();
+				Output.Dispose();
+				HeuristicFlag.Dispose();
+				Input = Accelerator.Allocate1D<ulong>(required);
+				Output = Accelerator.Allocate1D<byte>(required);
+				HeuristicFlag = Accelerator.Allocate1D<int>(required);
+				BufferCapacity = required;
+			}
 
-                        internal void ResetReturnFlag()
-                        {
-                                _returned = false;
-                        }
+			internal void ResetReturnFlag()
+			{
+				_returned = false;
+			}
 
-                        public void Dispose()
-                        {
-                                if (_returned)
-                                {
-                                        return;
-                                }
+			public void Dispose()
+			{
+				if (_returned)
+				{
+					return;
+				}
 
-                                _returned = true;
-                                PrimeTesterGpuContextPool.Return(this);
-                        }
+				_returned = true;
+				PrimeTesterGpuContextPool.Return(this);
+			}
 
-                        internal void DisposeResources()
-                        {
-                                Input.Dispose();
-                                Output.Dispose();
-                                HeuristicFlag.Dispose();
-                                DevicePrimesDefault.Dispose();
-                                DevicePrimesLastOne.Dispose();
-                                DevicePrimesLastSeven.Dispose();
-                                DevicePrimesLastThree.Dispose();
-                                DevicePrimesLastNine.Dispose();
-                                DevicePrimesPow2Default.Dispose();
-                                DevicePrimesPow2LastOne.Dispose();
-                                DevicePrimesPow2LastSeven.Dispose();
-                                DevicePrimesPow2LastThree.Dispose();
-                                DevicePrimesPow2LastNine.Dispose();
-                                Accelerator.Dispose();
-                                AcceleratorContext.Dispose();
-                        }
-                }
-        }
-        // Expose cache clearing for accelerator disposal coordination
+			internal void DisposeResources()
+			{
+				Input.Dispose();
+				Output.Dispose();
+				HeuristicFlag.Dispose();
+				DevicePrimesDefault.Dispose();
+				DevicePrimesLastOne.Dispose();
+				DevicePrimesLastSeven.Dispose();
+				DevicePrimesLastThree.Dispose();
+				DevicePrimesLastNine.Dispose();
+				DevicePrimesPow2Default.Dispose();
+				DevicePrimesPow2LastOne.Dispose();
+				DevicePrimesPow2LastSeven.Dispose();
+				DevicePrimesPow2LastThree.Dispose();
+				DevicePrimesPow2LastNine.Dispose();
+				Accelerator.Dispose();
+				AcceleratorContext.Dispose();
+			}
+		}
+	}
+	// Expose cache clearing for accelerator disposal coordination
 	public static void ClearGpuCaches(Accelerator accelerator)
 	{
 		PrimeTesterGpuContextPool.Clear(accelerator);