GPU stabilization improvements to prevent calculation crashes

PerfectNumbers.Core/PrimeOrderCalculator.Cpu.cs

@@ -3,8 +3,8 @@ using System.Diagnostics;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
-using ILGPU;
 using PerfectNumbers.Core.Gpu;
+using PerfectNumbers.Core.Gpu.Accelerators;
 
 namespace PerfectNumbers.Core;
 
@@ -52,8 +52,10 @@ internal static partial class PrimeOrderCalculator
 
 		ulong phi = prime - 1UL;
 
+		Pow2MontgomeryAccelerator gpu = Pow2MontgomeryAccelerator.Rent();
 		if (IsGpuHeuristicDevice && PrimeOrderGpuHeuristics.TryCalculateOrder(prime, previousOrder, config, divisorData, out ulong gpuOrder))
 		{
+			Pow2MontgomeryAccelerator.Return(gpu);
 			return gpuOrder;
 		}
 
@@ -62,17 +64,19 @@ internal static partial class PrimeOrderCalculator
 		ulong result;
 		if (phiFactors.Factors is null)
 		{
-			result = CalculateByFactorizationCpu(prime, divisorData);
+			result = CalculateByFactorizationCpu(gpu, prime, divisorData);
 			phiFactors.Dispose();
 			return result;
 		}
 
-		result = RunHeuristicPipelineCpu(prime, previousOrder, config, divisorData, phi, phiFactors);
+		result = RunHeuristicPipelineCpu(gpu, prime, previousOrder, config, divisorData, phi, phiFactors);
 		phiFactors.Dispose();
+		Pow2MontgomeryAccelerator.Return(gpu);
 		return result;
 	}
 
 	private static ulong RunHeuristicPipelineCpu(
+		Pow2MontgomeryAccelerator gpu,
 		ulong prime,
 		ulong? previousOrder,
 		in PrimeOrderSearchConfig config,
@@ -85,25 +89,30 @@ internal static partial class PrimeOrderCalculator
 			return phi;
 		}
 
-		ulong candidateOrder = InitializeStartingOrderCpu(prime, phi, divisorData);
+		GpuPrimeWorkLimiter.Acquire();
+		ulong candidateOrder = InitializeStartingOrderCpu(gpu, prime, phi, divisorData);
 		candidateOrder = ExponentLoweringCpu(candidateOrder, prime, phiFactors, divisorData);
 
-		if (TryConfirmOrderCpu(prime, candidateOrder, divisorData, config, out PartialFactorResult? orderFactors))
+		if (TryConfirmOrderCpu(gpu, prime, candidateOrder, divisorData, config, out PartialFactorResult? orderFactors))
 		{
+			GpuPrimeWorkLimiter.Release();
 			return candidateOrder;
 		}
 
 		if (config.Mode == PrimeOrderMode.Strict)
 		{
 			orderFactors?.Dispose();
-			return CalculateByFactorizationCpu(prime, divisorData);
+			GpuPrimeWorkLimiter.Release();
+			return CalculateByFactorizationCpu(gpu, prime, divisorData);
 		}
 
 		if (TryHeuristicFinishCpu(prime, candidateOrder, previousOrder, divisorData, config, phiFactors, orderFactors, out ulong order))
 		{
+			GpuPrimeWorkLimiter.Release();
 			return order;
 		}
 
+		GpuPrimeWorkLimiter.Release();
 		return candidateOrder;
 	}
 
@@ -185,13 +194,13 @@ internal static partial class PrimeOrderCalculator
 		return true;
 	}
 
-	private static ulong InitializeStartingOrderCpu(ulong prime, ulong phi, in MontgomeryDivisorData divisorData)
+	private static ulong InitializeStartingOrderCpu(Pow2MontgomeryAccelerator gpu, ulong prime, ulong phi, in MontgomeryDivisorData divisorData)
 	{
 		ulong order = phi;
 		if ((prime & 7UL) == 1UL || (prime & 7UL) == 7UL)
 		{
 			ulong half = phi >> 1;
-			if (Pow2EqualsOneCpu(half, prime, divisorData))
+			if (Pow2EqualsOneCpu(gpu, half, prime, divisorData))
 			{
 				order = half;
 			}
@@ -319,6 +328,7 @@ internal static partial class PrimeOrderCalculator
 	}
 
 	private static bool TryConfirmOrderCpu(
+		Pow2MontgomeryAccelerator gpu,
 		ulong prime,
 		ulong order,
 		in MontgomeryDivisorData divisorData,
@@ -332,7 +342,7 @@ internal static partial class PrimeOrderCalculator
 			return false;
 		}
 
-		if (!Pow2EqualsOneCpu(order, prime, divisorData))
+		if (!Pow2EqualsOneCpu(gpu, order, prime, divisorData))
 		{
 			return false;
 		}
@@ -1021,11 +1031,15 @@ internal static partial class PrimeOrderCalculator
 		return false;
 	}
 
-	private static bool Pow2EqualsOneCpu(ulong exponent, ulong prime, in MontgomeryDivisorData divisorData)
+	private static ulong _pow2GpuHits;
+	private static ulong _pow2CpuHits;
+	private static bool Pow2EqualsOneCpu(Pow2MontgomeryAccelerator gpu, ulong exponent, ulong prime, in MontgomeryDivisorData divisorData)
 	{
-		if (IsGpuPow2Allowed)
+		if (exponent <= (PerfectNumberConstants.MaxQForDivisorCycles) || prime <= (PerfectNumberConstants.MaxQForDivisorCycles))
 		{
-			ulong remainder = exponent.Pow2MontgomeryModWindowedGpu(divisorData, false);
+			// Atomic.Add(ref _pow2GpuHits, 1);
+			// Console.WriteLine($"pow2 GPU Hits {_pow2GpuHits}");
+			ulong remainder = exponent.Pow2MontgomeryModWindowedConvertGpu(gpu, divisorData);
 			// GpuPow2ModStatus status = PrimeOrderGpuHeuristics.TryPow2Mod(exponent, prime, out ulong remainder, divisorData);
 			// if (status == GpuPow2ModStatus.Success)
 			// {
@@ -1033,6 +1047,8 @@ internal static partial class PrimeOrderCalculator
 			// }
 		}
 
+		// Atomic.Add(ref _pow2CpuHits, 1);
+		// Console.WriteLine($"pow2 CPU Hits {_pow2CpuHits}");
 		return exponent.Pow2MontgomeryModWindowedCpu(divisorData, keepMontgomery: false) == 1UL;
 	}
 
@@ -1638,7 +1654,7 @@ internal static partial class PrimeOrderCalculator
 		exponents = newExponentSpan;
 	}
 
-	private static ulong CalculateByFactorizationCpu(ulong prime, in MontgomeryDivisorData divisorData)
+	private static ulong CalculateByFactorizationCpu(Pow2MontgomeryAccelerator gpu, ulong prime, in MontgomeryDivisorData divisorData)
 	{
 		ulong phi = prime - 1UL;
 		Dictionary<ulong, int> counts = new(capacity: 8);
@@ -1653,6 +1669,8 @@ internal static partial class PrimeOrderCalculator
 
 		ulong order = phi;
 		int entryCount = entries.Count;
+
+		GpuPrimeWorkLimiter.Acquire();
 		for (int i = 0; i < entryCount; i++)
 		{
 			ulong primeFactor = entries[i].Key;
@@ -1665,7 +1683,10 @@ internal static partial class PrimeOrderCalculator
 				}
 
 				ulong candidate = order / primeFactor;
-				if (Pow2EqualsOneCpu(candidate, prime, divisorData))
+
+				// if (candidate.Pow2MontgomeryModWindowedCpu(divisorData, keepMontgomery: false) == 1UL)
+				if (candidate.Pow2MontgomeryModWindowedConvertGpu(gpu, divisorData) == 1UL)
+				// if (Pow2EqualsOneCpu(candidate, prime, divisorData))
 				{
 					order = candidate;
 					continue;
@@ -1675,6 +1696,7 @@ internal static partial class PrimeOrderCalculator
 			}
 		}
 
+		GpuPrimeWorkLimiter.Release();
 		return order;
 	}