PrimeOrderCalculator converted to a template.

EvenPerfectBitScanner.Benchmarks/Pow2ModBenchmarks.cs

@@ -619,11 +619,11 @@ public class Pow2ModBenchmarks
 				return MersenneDivisorCyclesCpu.CalculateCycleLength(modulus, divisorData);
 			}
 
-			ulong order = PrimeOrderCalculator.CalculateCpu(
+			ulong order = PrimeOrderCalculatorCpu.Calculate(
 				modulus,
 				previousPrimeOrder,
 				divisorData,
-				PrimeOrderCalculator.PrimeOrderCalculatorConfig.HeuristicDefault);
+				PrimeOrderCalculatorConfig.HeuristicDefault);
 
 			if (order != 0UL)
 			{
@@ -642,10 +642,10 @@ public class Pow2ModBenchmarks
 				return MersenneDivisorCyclesCpu.GetCycle(modulus);
 			}
 
-			UInt128 order = PrimeOrderCalculator.CalculateCpu(
+			UInt128 order = PrimeOrderCalculatorCpu.Calculate(
 				modulus,
 				previousWidePrimeOrder,
-				PrimeOrderCalculator.PrimeOrderCalculatorConfig.HeuristicDefault);
+				PrimeOrderCalculatorConfig.HeuristicDefault);
 
 			if (order != UInt128.Zero)
 			{
@@ -689,11 +689,11 @@ public class Pow2ModBenchmarks
 #if DEBUG
 		Console.WriteLine("Trying heuristic. Prime order calculation");
 #endif
-		ulong order = PrimeOrderCalculator.CalculateCpu(
+		ulong order = PrimeOrderCalculatorCpu.Calculate(
 			modulus,
 			_previousPrimeOrder,
 			divisorData,
-			PrimeOrderCalculator.PrimeOrderCalculatorConfig.HeuristicDefault);
+			PrimeOrderCalculatorConfig.HeuristicDefault);
 
 		if (order != 0UL)
 		{
@@ -718,12 +718,12 @@ public class Pow2ModBenchmarks
 #if DEBUG
 		Console.WriteLine("Trying heuristic. Prime order calculation");
 #endif
-		ulong order = PrimeOrderCalculator.CalculateGpu(
+		ulong order = PrimeOrderCalculatorGpu.Calculate(
 			gpu,
 			modulus,
 			_previousPrimeOrder,
 			divisorData,
-			PrimeOrderCalculator.PrimeOrderCalculatorConfig.HeuristicDefault);
+			PrimeOrderCalculatorConfig.HeuristicDefault);
 
 		if (order != 0UL)
 		{
@@ -747,10 +747,10 @@ public class Pow2ModBenchmarks
 #if DEBUG
 		Console.WriteLine("Trying heuristic. Wide prime order calculation");
 #endif
-		UInt128 order = PrimeOrderCalculator.CalculateCpu(
+		UInt128 order = PrimeOrderCalculatorCpu.Calculate(
 			modulus,
 			_previousWidePrimeOrder,
-			PrimeOrderCalculator.PrimeOrderCalculatorConfig.HeuristicDefault);
+			PrimeOrderCalculatorConfig.HeuristicDefault);
 
 		if (order != UInt128.Zero)
 		{
@@ -774,11 +774,11 @@ public class Pow2ModBenchmarks
 #if DEBUG
 		Console.WriteLine("Trying heuristic. Wide prime order calculation");
 #endif
-		UInt128 order = PrimeOrderCalculator.CalculateGpu(
+		UInt128 order = PrimeOrderCalculatorGpu.Calculate(
 			gpu,
 			modulus,
 			_previousWidePrimeOrder,
-			PrimeOrderCalculator.PrimeOrderCalculatorConfig.HeuristicDefault);
+			PrimeOrderCalculatorConfig.HeuristicDefault);
 
 		if (order != UInt128.Zero)
 		{

PerfectNumbers.Core.Tests/Gpu/PrimeOrderGpuHeuristicsTests.cs

@@ -398,7 +398,7 @@ public class PrimeOrderGpuHeuristicsTests
 			PrimeOrderGpuHeuristics.OverflowRegistry[prime] = 0;
 
 			MontgomeryDivisorData divisorData = MontgomeryDivisorData.FromModulus(prime);
-			ulong result = PrimeOrderCalculator.CalculateGpu(gpu, prime, null, divisorData, PrimeOrderCalculator.PrimeOrderCalculatorConfig.HeuristicDefault);
+			ulong result = PrimeOrderCalculatorGpu.Calculate(gpu, prime, null, divisorData, PrimeOrderCalculatorConfig.HeuristicDefault);
 
 			result.Should().Be(3UL);
 		}

PerfectNumbers.Core.Tests/PrimeOrderCalculatorTests.cs

@@ -45,12 +45,12 @@ public class PrimeOrderCalculatorTests
 		ulong expected = ComputeOrderByDoubling(prime);
 		var gpu = PrimeOrderCalculatorAccelerator.Rent(1);
 
-		ulong result = PrimeOrderCalculator.CalculateGpu(
+		ulong result = PrimeOrderCalculatorGpu.Calculate(
 			gpu,
 			prime,
 			previousOrder: null,
 			MontgomeryDivisorData.FromModulus(prime),
-			PrimeOrderCalculator.PrimeOrderCalculatorConfig.HeuristicDefault);
+			PrimeOrderCalculatorConfig.HeuristicDefault);
 
 		PrimeOrderCalculatorAccelerator.Return(gpu);
 
@@ -65,19 +65,19 @@ public class PrimeOrderCalculatorTests
 		ulong previousOrder = ComputeOrderByDoubling(previousPrime);
 
 		var gpu = PrimeOrderCalculatorAccelerator.Rent(1);
-		ulong heuristic = PrimeOrderCalculator.CalculateGpu(
+		ulong heuristic = PrimeOrderCalculatorGpu.Calculate(
 			gpu,
 			prime,
 			previousOrder,
 			MontgomeryDivisorData.FromModulus(prime),
-			PrimeOrderCalculator.PrimeOrderCalculatorConfig.HeuristicDefault);
+			PrimeOrderCalculatorConfig.HeuristicDefault);
 
-		ulong strict = PrimeOrderCalculator.CalculateGpu(
+		ulong strict = PrimeOrderCalculatorGpu.Calculate(
 			gpu,
 			prime,
 			previousOrder: null,
 			MontgomeryDivisorData.FromModulus(prime),
-			PrimeOrderCalculator.PrimeOrderCalculatorConfig.StrictDefault);
+			PrimeOrderCalculatorConfig.StrictDefault);
 
 		PrimeOrderCalculatorAccelerator.Return(gpu);
 
@@ -91,12 +91,12 @@ public class PrimeOrderCalculatorTests
 	public void Calculate_handles_trivial_primes(ulong prime, ulong expectedOrder)
 	{
 		var gpu = PrimeOrderCalculatorAccelerator.Rent(1);
-		ulong result = PrimeOrderCalculator.CalculateGpu(
+		ulong result = PrimeOrderCalculatorGpu.Calculate(
 			gpu,
 			prime,
 			previousOrder: null,
 			MontgomeryDivisorData.FromModulus(prime),
-			PrimeOrderCalculator.PrimeOrderCalculatorConfig.HeuristicDefault);
+			PrimeOrderCalculatorConfig.HeuristicDefault);
 
 		PrimeOrderCalculatorAccelerator.Return(gpu);
 		result.Should().Be(expectedOrder);
@@ -106,14 +106,14 @@ public class PrimeOrderCalculatorTests
 	[Trait("Category", "Fast")]
 	public void Calculate_heuristic_mode_returns_unresolved_when_phi_cannot_be_factored()
 	{
-		var config = new PrimeOrderCalculator.PrimeOrderCalculatorConfig(
+		var config = new PrimeOrderCalculatorConfig(
 			smallFactorLimit: 1,
 			pollardRhoMilliseconds: 0,
 			maxPowChecks: 8,
 			strictMode: false);
 
 		var gpu = PrimeOrderCalculatorAccelerator.Rent(1);
-		ulong result = PrimeOrderCalculator.CalculateGpu(
+		ulong result = PrimeOrderCalculatorGpu.Calculate(
 			gpu,
 			prime: 13UL,
 			previousOrder: null,
@@ -128,7 +128,7 @@ public class PrimeOrderCalculatorTests
 	[Trait("Category", "Fast")]
 	public void Calculate_heuristic_mode_attempts_candidates_before_falling_back_to_strict_mode()
 	{
-		var heuristicConfig = new PrimeOrderCalculator.PrimeOrderCalculatorConfig(
+		var heuristicConfig = new PrimeOrderCalculatorConfig(
 			smallFactorLimit: 2,
 			pollardRhoMilliseconds: 0,
 			maxPowChecks: 1,
@@ -138,7 +138,7 @@ public class PrimeOrderCalculatorTests
 		try
 		{
 			MontgomeryDivisorData divisorData = MontgomeryDivisorData.FromModulus(239UL);
-			ulong heuristic = PrimeOrderCalculator.CalculateGpu(
+			ulong heuristic = PrimeOrderCalculatorGpu.Calculate(
 				gpu,
 				prime: 239UL,
 				previousOrder: null,
@@ -147,13 +147,13 @@ public class PrimeOrderCalculatorTests
 
 			heuristic.Should().Be(ComputeOrderByDoubling(239UL));
 
-			var strictConfig = new PrimeOrderCalculator.PrimeOrderCalculatorConfig(
+			var strictConfig = new PrimeOrderCalculatorConfig(
 				smallFactorLimit: 2,
 				pollardRhoMilliseconds: 0,
 				maxPowChecks: 1,
 				strictMode: true);
 
-			ulong strict = PrimeOrderCalculator.CalculateGpu(
+			ulong strict = PrimeOrderCalculatorGpu.Calculate(
 				gpu,
 				prime: 239UL,
 				previousOrder: null,
@@ -175,11 +175,11 @@ public class PrimeOrderCalculatorTests
 		UInt128 prime = UInt128.Parse("18446744073709641691");
 
 		var gpu = PrimeOrderCalculatorAccelerator.Rent(1);
-		UInt128 result = PrimeOrderCalculator.CalculateGpu(
+		UInt128 result = PrimeOrderCalculatorGpu.Calculate(
 				gpu,
 				prime,
 				previousOrder: null,
-				PrimeOrderCalculator.PrimeOrderCalculatorConfig.HeuristicDefault);
+				PrimeOrderCalculatorConfig.HeuristicDefault);
 
 		PrimeOrderCalculatorAccelerator.Return(gpu);
 		result.Should().Be((UInt128)1229782938247309446UL);

PerfectNumbers.Core/Gpu/PrimeOrderConstants.cs

@@ -10,5 +10,9 @@ public static class PrimeOrderConstants
 	public const int Pow2WindowOddPowerCount = 1 << (Pow2WindowSizeBits - 1);
 	public const int Pow2WindowSizeBits = 8;
 	public const int WideStackThreshold = 12;
+	public const int MaxCompositeSlots = 256;
+	public const int ExponentSlotLimit = 256;
+	public const int PrimeSlotLimit = 256;
+	public const int ScratchSlots = 64;
 
 }

PerfectNumbers.Core/Gpu/PrimeOrderGpuHeuristics.cs

@@ -253,7 +253,7 @@ internal static partial class PrimeOrderGpuHeuristics
 		PrimeOrderCalculatorAccelerator gpu,
 		ulong prime,
 		ulong? previousOrder,
-		PrimeOrderCalculator.PrimeOrderCalculatorConfig config,
+		PrimeOrderCalculatorConfig config,
 		in MontgomeryDivisorData divisorData,
 		out ulong order)
 	{

PerfectNumbers.Core/MersenneDivisorCyclesTemplate.cs

@@ -259,22 +259,23 @@ public struct MersenneDivisorCyclesTemplate
 		}
 
 #if DEVICE_GPU
-		UInt128 wideOrder = PrimeOrderCalculator.CalculateGpu(
+		UInt128 wideOrder = PrimeOrderCalculatorGpu.Calculate(
 			gpu,
 			divisor,
 			previousOrder: null,
-			PrimeOrderCalculator.PrimeOrderCalculatorConfig.HeuristicDefault);
+			PrimeOrderCalculatorConfig.HeuristicDefault);
 #elif DEVICE_HYBRID
-		UInt128 wideOrder = PrimeOrderCalculator.CalculateHybrid(
+		UInt128 wideOrder = PrimeOrderCalculatorHybrid.Calculate(
 			gpu,
 			divisor,
 			previousOrder: null,
-			PrimeOrderCalculator.PrimeOrderCalculatorConfig.HeuristicDefault);
+			MontgomeryDivisorData.FromModulus((ulong)divisor),
+			PrimeOrderCalculatorConfig.HeuristicDefault);
 #else
-		UInt128 wideOrder = PrimeOrderCalculator.CalculateCpu(
+		UInt128 wideOrder = PrimeOrderCalculatorCpu.Calculate(
 			divisor,
 			previousOrder: null,
-			PrimeOrderCalculator.PrimeOrderCalculatorConfig.HeuristicDefault);
+			PrimeOrderCalculatorConfig.HeuristicDefault);
 #endif
 		if (wideOrder != UInt128.Zero)
 		{
@@ -329,25 +330,25 @@ public struct MersenneDivisorCyclesTemplate
 		// }
 
 #if DEVICE_GPU
-		ulong computedOrder = PrimeOrderCalculator.CalculateGpu(
+		ulong computedOrder = PrimeOrderCalculatorGpu.Calculate(
 			gpu,
 			divisor,
 			previousOrder: null,
 			divisorData,
-			PrimeOrderCalculator.PrimeOrderCalculatorConfig.HeuristicDefault);
+			PrimeOrderCalculatorConfig.HeuristicDefault);
 #elif DEVICE_HYBRID
-		ulong computedOrder = PrimeOrderCalculator.CalculateHybrid(
+		ulong computedOrder = PrimeOrderCalculatorHybrid.Calculate(
 			gpu,
 			divisor,
 			previousOrder: null,
 			divisorData,
-			PrimeOrderCalculator.PrimeOrderCalculatorConfig.HeuristicDefault);
+			PrimeOrderCalculatorConfig.HeuristicDefault);
 #else
-		ulong computedOrder = PrimeOrderCalculator.CalculateCpu(
+		ulong computedOrder = PrimeOrderCalculatorCpu.Calculate(
 			divisor,
 			previousOrder: null,
 			divisorData,
-			PrimeOrderCalculator.PrimeOrderCalculatorConfig.HeuristicDefault);
+			PrimeOrderCalculatorConfig.HeuristicDefault);
 #endif
 		if (computedOrder != 0UL)
 		{
@@ -1013,12 +1014,12 @@ public struct MersenneDivisorCyclesTemplate
 #if DEVICE_GPU
 			if (!skipPrimeOrderHeuristic && HeuristicPrimeTester.IsPrimeGpu(gpu, divisor))
 			{
-			ulong computedOrder = PrimeOrderCalculator.CalculateGpu(
+				ulong computedOrder = PrimeOrderCalculatorGpu.Calculate(
 						gpu,
 						divisor,
 						previousOrder: null,
 						divisorData,
-					PrimeOrderCalculator.PrimeOrderCalculatorConfig.HeuristicDefault);
+						PrimeOrderCalculatorConfig.HeuristicDefault);
 			if (computedOrder != 0UL)
 			{
 				cycleLength = computedOrder;
@@ -1028,12 +1029,12 @@ public struct MersenneDivisorCyclesTemplate
 #elif DEVICE_HYBRID
 			if (!skipPrimeOrderHeuristic && HeuristicPrimeTester.IsPrimeCpu(divisor))
 			{
-			ulong computedOrder = PrimeOrderCalculator.CalculateHybrid(
+				ulong computedOrder = PrimeOrderCalculatorHybrid.Calculate(
 						gpu,
 						divisor,
 						previousOrder: null,
 						divisorData,
-					PrimeOrderCalculator.PrimeOrderCalculatorConfig.HeuristicDefault);
+						PrimeOrderCalculatorConfig.HeuristicDefault);
 			if (computedOrder != 0UL)
 			{
 				cycleLength = computedOrder;
@@ -1043,11 +1044,11 @@ public struct MersenneDivisorCyclesTemplate
 #else
 		if (!skipPrimeOrderHeuristic && HeuristicPrimeTester.IsPrimeCpu(divisor))
 		{
-			ulong computedOrder = PrimeOrderCalculator.CalculateCpu(
+			ulong computedOrder = PrimeOrderCalculatorCpu.Calculate(
 					divisor,
 					previousOrder: null,
 					divisorData,
-					PrimeOrderCalculator.PrimeOrderCalculatorConfig.HeuristicDefault);
+					PrimeOrderCalculatorConfig.HeuristicDefault);
 			if (computedOrder != 0UL)
 			{
 				cycleLength = computedOrder;

PerfectNumbers.Core/PerfectNumberConstants.cs

@@ -23,6 +23,7 @@ public static class PerfectNumberConstants
 	public const int ThreadsByAccelerator = 1;
 	public const int ByDivisorStateSaveInterval = 200_000;
 	public const string ByDivisorStateDirectory = "Checks";
+	public const int PollardRhoMilliseconds = 100;
     // TODO: Load these limits from the benchmark-driven configuration so CPU and GPU scans stay aligned with the optimal
     // divisor-cycle datasets we generate offline.
     // TODO: Promote these magic numbers into a runtime profile derived from EvenPerfectBitScanner.Benchmarks so we can retune

PerfectNumbers.Core/PerfectNumbers.Core.csproj

@@ -5,6 +5,7 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <LangVersion>12.0</LangVersion>
+    <DefineConstants>$(DefineConstants);DEVICE_CPU</DefineConstants>
     <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
     <CompilerGeneratedFilesOutputPath>$(IntermediateOutputPath)generated</CompilerGeneratedFilesOutputPath>
   </PropertyGroup>

PerfectNumbers.Core/PrimeNumberConstants.cs

@@ -0,0 +1,6 @@
+namespace PerfectNumbers.Core;
+
+public static class PrimeNumberConstants
+{
+    public const ulong GpuSmallPrimeBound = 1_000_000UL;
+}

PerfectNumbers.Core/PrimeOrderCalculator.Config.cs

@@ -1,39 +0,0 @@
-using System.Runtime.CompilerServices;
-
-namespace PerfectNumbers.Core;
-
-internal static partial class PrimeOrderCalculator
-{
-	internal readonly struct PrimeOrderCalculatorConfig(uint smallFactorLimit, int pollardRhoMilliseconds, int maxPowChecks, bool strictMode)
-	{
-		private static PrimeOrderCalculatorConfig _heuristicDefault = CreateHeuristicDefault(UnboundedTaskScheduler.ConfiguredThreadCount);
-
-		public static PrimeOrderCalculatorConfig HeuristicDefault
-		{
-			[MethodImpl(MethodImplOptions.AggressiveInlining)]
-			get => _heuristicDefault;
-		}
-
-		public static readonly PrimeOrderCalculatorConfig StrictDefault = new(smallFactorLimit: 1_000_000, pollardRhoMilliseconds: 0, maxPowChecks: 0, true);
-
-		public static void ConfigureHeuristicDefault(int threadCount)
-		{
-			_heuristicDefault = CreateHeuristicDefault(threadCount);
-		}
-
-		public static PrimeOrderCalculatorConfig CreateHeuristicDefault(int threadCount)
-		{
-			int normalizedThreadCount = threadCount < 1 ? 1 : threadCount;
-			return new(smallFactorLimit: 100_000, pollardRhoMilliseconds: normalizedThreadCount * 24, maxPowChecks: 24, false);
-		}
-
-		public readonly uint SmallFactorLimit = smallFactorLimit;
-		public readonly int PollardRhoMilliseconds = pollardRhoMilliseconds;
-		public readonly int MaxPowChecks = maxPowChecks;
-		public readonly int MaxPowChecksCapacity = maxPowChecks << 2;
-		public readonly bool StrictMode = strictMode;
-	}
-
-	// TODO: Remove branching on the CPU / GPU paths
-	// TODO: Split big non-static functions into smaller / extract static code to limit JIT time
-}

PerfectNumbers.Core/PrimeOrderCalculator.Hybrid.cs

@@ -1,651 +0,0 @@
-using System.Buffers;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using ILGPU;
-using PerfectNumbers.Core.Gpu;
-using PerfectNumbers.Core.Gpu.Accelerators;
-
-namespace PerfectNumbers.Core;
-
-internal static partial class PrimeOrderCalculator
-{
-	public static ulong CalculateHybrid(
-		PrimeOrderCalculatorAccelerator gpu,
-		ulong prime,
-		ulong? previousOrder,
-		in MontgomeryDivisorData divisorData,
-		in PrimeOrderCalculatorConfig config)
-	{
-		// TODO: Is this condition ever met on EvenPerfectBitScanner's execution path? If not, we can add a clarification comment and comment out the entire block. We want to support p candidates at least greater or equal to 31.
-		if (prime <= 3UL)
-		{
-			return prime == 3UL ? 2UL : 1UL;
-		}
-
-		ulong phi = prime - 1UL;
-
-		PartialFactorResult phiFactors = PartialFactorHybrid(gpu, phi, divisorData, config);
-
-		ulong result;
-		if (phiFactors.Factors is null)
-		{
-			result = CalculateByFactorizationCpu(prime, divisorData);
-
-			phiFactors.Dispose();
-			return result;
-		}
-
-		result = RunHeuristicPipelineHybrid(gpu, prime, previousOrder, config, divisorData, phi, phiFactors);
-
-		phiFactors.Dispose();
-		return result;
-	}
-
-	public static UInt128 CalculateHybrid(
-			PrimeOrderCalculatorAccelerator gpu,
-			in UInt128 prime,
-			in UInt128? previousOrder,
-			in PrimeOrderCalculatorConfig config)
-	{
-		MontgomeryDivisorData divisorData;
-		UInt128 result;
-		if (prime <= ulong.MaxValue)
-		{
-			ulong? previous = null;
-			if (previousOrder.HasValue)
-			{
-				UInt128 previousValue = previousOrder.Value;
-				if (previousValue <= ulong.MaxValue)
-				{
-					previous = (ulong)previousValue;
-				}
-				else
-				{
-					previous = ulong.MaxValue;
-				}
-			}
-
-			ulong prime64 = (ulong)prime;
-			divisorData = MontgomeryDivisorData.FromModulus(prime64);
-			ulong order64 = CalculateHybrid(gpu, prime64, previous, divisorData, config);
-			result = order64 == 0UL ? UInt128.Zero : (UInt128)order64;
-		}
-		else
-		{
-			divisorData = MontgomeryDivisorData.Empty;
-			result = CalculateWideInternalCpu(prime, previousOrder, divisorData, config);
-		}
-
-		return result;
-	}
-
-	[MethodImpl(MethodImplOptions.AggressiveOptimization)]
-	private static void CollectFactorsHybrid(PrimeOrderCalculatorAccelerator gpu, Span<ulong> primeSlots, Span<int> exponentSlots, ref int factorCount, List<PartialFactorPendingEntry> pending, FixedCapacityStack<ulong> compositeStack, long deadlineTimestamp, out bool pollardRhoDeadlineReached)
-	{
-		while (compositeStack.Count > 0)
-		{
-			ulong composite = compositeStack.Pop();
-			bool isPrime = RunOnCpu() ? PrimeTesterByLastDigit.IsPrimeCpu(composite) : HeuristicCombinedPrimeTester.IsPrimeGpu(gpu, composite);
-
-			if (isPrime)
-			{
-				AddFactorToCollector(primeSlots, exponentSlots, ref factorCount, composite);
-				continue;
-			}
-
-			pollardRhoDeadlineReached = Stopwatch.GetTimestamp() > deadlineTimestamp;
-			if (pollardRhoDeadlineReached)
-			{
-				pending.Add(new PartialFactorPendingEntry(composite, knownComposite: true));
-				continue;
-			}
-
-			if (!TryPollardRhoCpu(composite, deadlineTimestamp, out ulong factor))
-			{
-				pending.Add(new PartialFactorPendingEntry(composite, knownComposite: true));
-				continue;
-			}
-
-			ulong quotient = composite / factor;
-			compositeStack.Push(factor);
-			compositeStack.Push(quotient);
-		}
-
-		pollardRhoDeadlineReached = false;
-	}
-
-	[MethodImpl(MethodImplOptions.AggressiveOptimization)]
-	private static ulong InitializeStartingOrderHybrid(PrimeOrderCalculatorAccelerator gpu, ulong prime, ulong phi, in MontgomeryDivisorData divisorData)
-	{
-		ulong order = phi;
-		if ((prime & 7UL) == 1UL || (prime & 7UL) == 7UL)
-		{
-			ulong half = phi >> 1;
-			if (Pow2EqualsOneHybrid(gpu, half, prime, divisorData))
-			{
-				order = half;
-			}
-		}
-
-		return order;
-	}
-
-	[MethodImpl(MethodImplOptions.AggressiveOptimization)]
-	private static PartialFactorResult PartialFactorHybrid(PrimeOrderCalculatorAccelerator gpu, ulong value, in MontgomeryDivisorData divisorData, in PrimeOrderCalculatorConfig config)
-	{
-		if (value <= 1UL)
-		{
-			return PartialFactorResult.Empty;
-		}
-
-		// stackalloc is faster than pooling
-
-		var result = PartialFactorResult.Rent(divisorData);
-		ulong[] factors = result.Factors;
-		Span<ulong> primeSlots = new(factors);
-		int[] exponents = result.Exponents;
-		Span<int> exponentSlots = new(exponents);
-		// We don't need to worry about leftovers, because we always use indexes within the calculated counts
-		// primeSlots.Clear();
-		// exponentSlots.Clear();
-
-		uint limit = config.SmallFactorLimit == 0 ? uint.MaxValue : config.SmallFactorLimit;
-
-		List<PartialFactorPendingEntry> pending = ThreadStaticPools.RentPrimeOrderPendingEntryList(2);
-
-		PopulateSmallPrimeFactorsCpu(
-			value,
-			limit,
-			primeSlots,
-			exponentSlots,
-			out int factorCount,
-			out ulong remaining);
-
-		bool limitReached;
-		if (remaining > 1UL)
-		{
-			if (config.PollardRhoMilliseconds > 0)
-			{
-				long deadlineTimestamp = CreateDeadlineTimestamp(config.PollardRhoMilliseconds);
-				FixedCapacityStack<ulong> compositeStack = ThreadStaticPools.RentUlongStack(4);
-				compositeStack.Push(remaining);
-
-				CollectFactorsHybrid(gpu, primeSlots, exponentSlots, ref factorCount, pending, compositeStack, deadlineTimestamp, out limitReached);
-
-				if (limitReached)
-				{
-					while (compositeStack.Count > 0)
-					{
-						pending.Add(new PartialFactorPendingEntry(compositeStack.Pop(), knownComposite: false));
-					}
-				}
-
-				compositeStack.Clear();
-				ThreadStaticPools.ReturnUlongStack(compositeStack);
-			}
-			else
-			{
-				pending.Add(new PartialFactorPendingEntry(remaining, knownComposite: false));
-			}
-		}
-
-		ulong cofactor = 1UL;
-		bool cofactorContainsComposite = false;
-		int pendingCount = pending.Count;
-		int index = 0;
-		for (; index < pendingCount; index++)
-		{
-			PartialFactorPendingEntry entry = pending[index];
-			ulong composite = entry.Value;
-
-			if (entry.KnownComposite)
-			{
-				cofactor = checked(cofactor * composite);
-				cofactorContainsComposite = true;
-				continue;
-			}
-
-			if (!entry.HasKnownPrimality)
-			{
-				bool isPrime = RunOnCpu() ? PrimeTesterByLastDigit.IsPrimeCpu(composite) : HeuristicCombinedPrimeTester.IsPrimeGpu(gpu, composite);
-
-				entry.WithPrimality(isPrime);
-				pending[index] = entry;
-			}
-
-			if (entry.IsPrime)
-			{
-				AddFactorToCollector(primeSlots, exponentSlots, ref factorCount, composite);
-			}
-			// composite is never smaller on the execution path
-			// else if (composite > 1UL)
-			else
-			{
-				cofactor = checked(cofactor * composite);
-				cofactorContainsComposite = true;
-			}
-		}
-
-		bool cofactorIsPrime;
-		if (cofactor <= 1UL)
-		{
-			cofactorIsPrime = false;
-		}
-		else if (cofactorContainsComposite)
-		{
-			cofactorIsPrime = false;
-		}
-		else
-		{
-			cofactorIsPrime = RunOnCpu() ? PrimeTesterByLastDigit.IsPrimeCpu(cofactor) : HeuristicCombinedPrimeTester.IsPrimeGpu(gpu, cofactor);
-		}
-
-		// This will never happen in production code. We'll always get at least 1 factor
-		// if (factorCount == 0)
-		// {
-		// 	if (cofactor == value)
-		// 	{
-		// 		result = PartialFactorResult.Rent(null, value, false, 0);
-		// 		goto ReturnResult;
-		// 	}
-
-		// 	result = PartialFactorResult.Rent(null, cofactor, cofactor == 1UL, 0);
-		// 	goto ReturnResult;
-		// }
-
-		Array.Sort(factors, exponents, 0, factorCount);
-
-		result.Cofactor = cofactor;
-		result.FullyFactored = cofactor == 1UL;
-		result.Count = factorCount;
-		result.CofactorIsPrime = cofactorIsPrime;
-
-		pending.Clear();
-		ThreadStaticPools.ReturnPrimeOrderPendingEntryList(pending);
-		return result;
-	}
-
-	[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
-	private static bool Pow2EqualsOneHybrid(PrimeOrderCalculatorAccelerator gpu, ulong exponent, ulong prime, in MontgomeryDivisorData divisorData)
-	{
-		// if (exponent >= PerfectNumberConstants.MaxQForDivisorCycles || prime >= PerfectNumberConstants.MaxQForDivisorCycles)
-		// {
-		// 	// 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)
-		// 	// {
-		// 	return remainder == 1UL;
-		// 	// }
-		// }
-
-		// Atomic.Add(ref _pow2CpuHits, 1);
-		// Console.WriteLine($"pow2 CPU Hits {_pow2CpuHits}");
-		return exponent.Pow2MontgomeryModWindowedConvertToStandardCpu(divisorData) == 1UL;
-	}
-
-	[MethodImpl(MethodImplOptions.AggressiveOptimization)]
-	private static ulong RunHeuristicPipelineHybrid(
-		PrimeOrderCalculatorAccelerator gpu,
-		ulong prime,
-		ulong? previousOrder,
-		in PrimeOrderCalculatorConfig config,
-		in MontgomeryDivisorData divisorData,
-		ulong phi,
-		PartialFactorResult phiFactors)
-	{
-		if (phiFactors.FullyFactored && TrySpecialMaxHybrid(gpu, phi, prime, phiFactors, divisorData))
-		{
-			return phi;
-		}
-
-		ulong candidateOrder = InitializeStartingOrderHybrid(gpu, prime, phi, divisorData);
-		candidateOrder = ExponentLoweringCpu(candidateOrder, phiFactors, divisorData);
-
-		if (TryConfirmOrderHybrid(gpu, prime, candidateOrder, divisorData, config, out PartialFactorResult? orderFactors))
-		{
-			return candidateOrder;
-		}
-
-		if (config.StrictMode)
-		{
-			orderFactors?.Dispose();
-			return CalculateByFactorizationCpu(prime, divisorData);
-		}
-
-		if (TryHeuristicFinishHybrid(gpu, prime, candidateOrder, previousOrder, divisorData, config, phiFactors, orderFactors, out ulong order))
-		{
-			return order;
-		}
-
-		return candidateOrder;
-	}
-
-	private static int _cpuCount;
-
-	[MethodImpl(MethodImplOptions.AggressiveOptimization)]
-	private static bool RunOnCpu()
-	{
-		int gpuRatio = EnvironmentConfiguration.GpuRatio;
-		if (gpuRatio == 0)
-		{
-			return false;
-		}
-
-		if (gpuRatio == 1)
-		{
-			while (true)
-			{
-				if (Interlocked.CompareExchange(ref _cpuCount, 0, 1) == 0)
-				{
-					return true;
-				}
-
-				if (Interlocked.CompareExchange(ref _cpuCount, 1, 0) == 1)
-				{
-					return false;
-				}
-
-				Thread.Yield();
-			}
-		}
-
-		int cpuCount = Interlocked.Increment(ref _cpuCount);
-		if (cpuCount == gpuRatio)
-		{
-			Interlocked.Add(ref _cpuCount, -gpuRatio);
-		}
-		else if (cpuCount > gpuRatio)
-		{
-			cpuCount -= gpuRatio;
-		}
-
-		return cpuCount != gpuRatio;
-	}
-
-	[MethodImpl(MethodImplOptions.AggressiveOptimization)]
-	private static bool TryConfirmCandidateHybrid(PrimeOrderCalculatorAccelerator gpu, ulong prime, ulong candidate, in MontgomeryDivisorData divisorData, in PrimeOrderCalculatorConfig config, ref int powUsed, int powBudget)
-	{
-		PartialFactorResult factorization = PartialFactorHybrid(gpu, candidate, divisorData, config);
-
-		if (factorization.Factors is null)
-		{
-			factorization.Dispose();
-			return false;
-		}
-
-		if (!factorization.FullyFactored)
-		{
-			if (factorization.Cofactor <= 1UL || !factorization.CofactorIsPrime)
-			{
-				factorization.Dispose();
-				return false;
-			}
-
-			factorization.WithAdditionalPrime(factorization.Cofactor);
-		}
-
-		ReadOnlySpan<ulong> factorsSpan = factorization.Factors;
-		ReadOnlySpan<int> exponentsSpan = factorization.Exponents;
-		int length = factorization.Count;
-
-		const int StackExponentCapacity = 32;
-		const int ExponentHardLimit = 256;
-
-		Span<ulong> stackBuffer = stackalloc ulong[StackExponentCapacity];
-		ulong[]? heapCandidateArray = null;
-		ExponentRemainderStepperCpu stepper = ThreadStaticPools.RentExponentStepperCpu(divisorData);
-		bool violates = false;
-
-		for (int i = 0; i < length; i++)
-		{
-			ulong primeFactor = factorsSpan[i];
-			int exponent = exponentsSpan[i];
-
-			// Factorization entries for candidate confirmation are always positive here.
-			// if (exponent <= 0)
-			// {
-			// 	continue;
-			// }
-
-			if (exponent > ExponentHardLimit)
-			{
-				throw new InvalidOperationException($"Candidate factor exponent {exponent} exceeds the supported limit of {ExponentHardLimit}.");
-			}
-
-			if (exponent <= StackExponentCapacity)
-			{
-				if (CheckCandidateViolation(stackBuffer[..exponent], primeFactor, exponent, candidate, prime, ref powUsed, powBudget, ref stepper))
-				{
-					violates = true;
-					break;
-				}
-
-				continue;
-			}
-
-			heapCandidateArray ??= ThreadStaticPools.UlongPool.Rent(ExponentHardLimit);
-			if (CheckCandidateViolation(heapCandidateArray.AsSpan(0, exponent), primeFactor, exponent, candidate, prime, ref powUsed, powBudget, ref stepper))
-			{
-				violates = true;
-				break;
-			}
-		}
-
-		ThreadStaticPools.ReturnExponentStepperCpu(stepper);
-		if (heapCandidateArray is not null)
-		{
-			ThreadStaticPools.UlongPool.Return(heapCandidateArray);
-		}
-		factorization.Dispose();
-
-		return !violates;
-	}
-
-	[MethodImpl(MethodImplOptions.AggressiveOptimization)]
-	private static bool TryConfirmOrderHybrid(
-		PrimeOrderCalculatorAccelerator gpu,
-		ulong prime,
-		ulong order,
-		in MontgomeryDivisorData divisorData,
-		in PrimeOrderCalculatorConfig config,
-		out PartialFactorResult? reusableFactorization)
-	{
-		reusableFactorization = null;
-
-		if (order == 0UL)
-		{
-			return false;
-		}
-
-		if (!Pow2EqualsOneHybrid(gpu, order, prime, divisorData))
-		{
-			return false;
-		}
-
-		PartialFactorResult factorization = PartialFactorHybrid(gpu, order, divisorData, config);
-		if (factorization.Factors is null)
-		{
-			factorization.Dispose();
-			return false;
-		}
-
-		if (!factorization.FullyFactored)
-		{
-			if (factorization.Cofactor <= 1UL || !factorization.CofactorIsPrime)
-			{
-				factorization.Dispose();
-				return false;
-			}
-
-			factorization.WithAdditionalPrime(factorization.Cofactor);
-		}
-
-		if (!ValidateOrderAgainstFactors(prime, order, divisorData, factorization))
-		{
-			reusableFactorization = factorization;
-			return false;
-		}
-
-		factorization.Dispose();
-		return true;
-	}
-
-	[MethodImpl(MethodImplOptions.AggressiveOptimization)]
-	private static bool TryHeuristicFinishHybrid(
-		PrimeOrderCalculatorAccelerator gpu,
-		ulong prime,
-		ulong order,
-		ulong? previousOrder,
-		in MontgomeryDivisorData divisorData,
-		in PrimeOrderCalculatorConfig config,
-		PartialFactorResult phiFactors,
-		PartialFactorResult? cachedOrderFactors,
-		out ulong result)
-	{
-		result = 0UL;
-		if (order <= 1UL)
-		{
-			cachedOrderFactors?.Dispose();
-			return false;
-		}
-
-		// Reuse the partial factorization from TryConfirmOrderCpu when available.
-		PartialFactorResult orderFactors = cachedOrderFactors ?? PartialFactorHybrid(gpu, order, divisorData, config);
-		try
-		{
-			if (orderFactors.Factors is null)
-			{
-				return false;
-			}
-
-			if (!orderFactors.FullyFactored)
-			{
-				if (orderFactors.Cofactor <= 1UL || !orderFactors.CofactorIsPrime)
-				{
-					return false;
-				}
-
-				orderFactors.WithAdditionalPrime(orderFactors.Cofactor);
-			}
-
-			int capacity = config.MaxPowChecks <= 0 ? 64 : config.MaxPowChecksCapacity;
-			List<ulong> candidates = ThreadStaticPools.RentUlongList(capacity);
-			candidates.Clear();
-			ulong[] factorArray = orderFactors.Factors!;
-			int[] exponentsArray = orderFactors.Exponents!;
-
-			BuildCandidates(order, factorArray, exponentsArray, orderFactors.Count, candidates, capacity);
-			int candidateCount = candidates.Count;
-			if (candidateCount == 0)
-			{
-				ThreadStaticPools.ReturnUlongList(candidates);
-				return false;
-			}
-
-			SortCandidates(prime, previousOrder, candidates);
-
-			int powBudget = config.MaxPowChecks <= 0 ? candidateCount : config.MaxPowChecks;
-			int powUsed = 0;
-			Span<ulong> candidateSpan = CollectionsMarshal.AsSpan(candidates);
-			ExponentRemainderStepperCpu powStepper = ThreadStaticPools.RentExponentStepperCpu(divisorData);
-			bool powStepperInitialized = false;
-
-			int index = 0;
-			Span<ulong> stackGpuRemainders = stackalloc ulong[PerfectNumberConstants.DefaultSmallPrimeFactorSlotCount];
-			ArrayPool<ulong> pool = ThreadStaticPools.UlongPool;
-			while (index < candidateCount && powUsed < powBudget)
-			{
-				int remaining = candidateCount - index;
-				int budgetRemaining = powBudget - powUsed;
-				int batchSize = Math.Min(remaining, Math.Min(budgetRemaining, PrimeOrderConstants.MaxGpuBatchSize));
-				if (batchSize <= 0)
-				{
-					break;
-				}
-
-				ReadOnlySpan<ulong> batch = candidateSpan.Slice(index, batchSize);
-				int startIndex = 0;
-
-				if (!powStepperInitialized)
-				{
-					ulong candidate = batch[0];
-					powUsed++;
-
-					bool equalsOne = powStepper.InitializeCpuIsUnity(candidate);
-					powStepperInitialized = true;
-					if (equalsOne && TryConfirmCandidateHybrid(gpu, prime, candidate, divisorData, config, ref powUsed, powBudget))
-					{
-						candidates.Clear();
-						ThreadStaticPools.ReturnUlongList(candidates);
-						ThreadStaticPools.ReturnExponentStepperCpu(powStepper);
-						result = candidate;
-						return true;
-					}
-
-					startIndex = 1;
-				}
-
-				for (int i = startIndex; i < batchSize && powUsed < powBudget; i++)
-				{
-					ulong candidate = batch[i];
-					powUsed++;
-
-					bool equalsOne = powStepper.ComputeNextIsUnity(candidate);
-					if (!equalsOne)
-					{
-						continue;
-					}
-
-					if (!TryConfirmCandidateHybrid(gpu, prime, candidate, divisorData, config, ref powUsed, powBudget))
-					{
-						continue;
-					}
-
-					candidates.Clear();
-					ThreadStaticPools.ReturnUlongList(candidates);
-					ThreadStaticPools.ReturnExponentStepperCpu(powStepper);
-					result = candidate;
-					return true;
-				}
-
-				index += batchSize;
-			}
-
-			candidates.Clear();
-			ThreadStaticPools.ReturnUlongList(candidates);
-			ThreadStaticPools.ReturnExponentStepperCpu(powStepper);
-
-			return false;
-		}
-		finally
-		{
-			orderFactors.Dispose();
-		}
-	}
-
-	[MethodImpl(MethodImplOptions.AggressiveOptimization)]
-	private static bool TrySpecialMaxHybrid(PrimeOrderCalculatorAccelerator gpu, ulong phi, ulong prime, PartialFactorResult factors, in MontgomeryDivisorData divisorData)
-	{
-		int length = factors.Count;
-		// The phi factorization on the scanner path always yields at least one entry for phi >= 2,
-		// preventing the zero-length case from occurring outside synthetic tests.
-		// if (length == 0)
-		// {
-		//     return true;
-		// }
-
-		ReadOnlySpan<ulong> factorSpan = new(factors.Factors, 0, length);
-		Span<ulong> stackBuffer = stackalloc ulong[length];
-
-		if (length <= 8)
-		{
-			return EvaluateSpecialMaxCandidatesCpu(stackBuffer, factorSpan, phi, prime, divisorData);
-		}
-
-		return EvaluateSpecialMaxCandidatesGpu(gpu, factorSpan, phi, prime, divisorData);
-	}
-
-}

PerfectNumbers.Core/PrimeOrderCalculator.Shared.cs

@@ -1,631 +0,0 @@
-using System.Buffers;
-using System.Diagnostics;
-using System.Numerics;
-
-namespace PerfectNumbers.Core;
-
-internal static partial class PrimeOrderCalculator
-{
-    private static void SortCandidatesWide(UInt128 prime, in UInt128? previousOrder, List<UInt128> candidates)
-    {
-        UInt128 previous = previousOrder ?? UInt128.Zero;
-        int previousGroup = previousOrder.HasValue ? GetGroupWide(previousOrder.Value, prime) : 1;
-        bool hasPrevious = previousOrder.HasValue;
-
-        candidates.Sort((x, y) =>
-        {
-            CandidateKey128 keyX = BuildKeyWide(x, prime, previous, previousGroup, hasPrevious);
-            CandidateKey128 keyY = BuildKeyWide(y, prime, previous, previousGroup, hasPrevious);
-
-            int primary = keyX.Primary.CompareTo(keyY.Primary);
-            if (primary != 0)
-            {
-                return primary;
-            }
-
-            int secondary = CompareComponents(keyX.SecondaryDescending, keyX.Secondary, keyY.SecondaryDescending, keyY.Secondary);
-            if (secondary != 0)
-            {
-                return secondary;
-            }
-
-            return CompareComponents(keyX.TertiaryDescending, keyX.Tertiary, keyY.TertiaryDescending, keyY.Tertiary);
-        });
-    }
-
-    private static CandidateKey128 BuildKeyWide(
-        in UInt128 value,
-        in UInt128 prime,
-        in UInt128 previous,
-        int previousGroup,
-        bool hasPrevious)
-    {
-        int group = GetGroupWide(value, prime);
-        if (group == 0)
-        {
-            return new CandidateKey128(int.MaxValue, false, UInt128.Zero, false, UInt128.Zero);
-        }
-
-        bool isGe = !hasPrevious || value >= previous;
-        int primary = ComputePrimary(group, isGe, previousGroup);
-
-        if (group == 3)
-        {
-            return new CandidateKey128(primary, true, value, true, value);
-        }
-
-        UInt128 distance = hasPrevious ? (value > previous ? value - previous : previous - value) : value;
-        return new CandidateKey128(primary, false, distance, false, value);
-    }
-
-    private static int CompareComponents(bool descendingX, in UInt128 valueX, bool descendingY, in UInt128 valueY)
-    {
-        if (descendingX == descendingY)
-        {
-            if (valueX == valueY)
-            {
-                return 0;
-            }
-
-            if (descendingX)
-            {
-                return valueX > valueY ? -1 : 1;
-            }
-
-            return valueX > valueY ? 1 : -1;
-        }
-
-        if (valueX == valueY)
-        {
-            return 0;
-        }
-
-        return valueX > valueY ? 1 : -1;
-    }
-
-    private static int GetGroupWide(in UInt128 value, in UInt128 prime)
-    {
-        UInt128 threshold1 = prime >> 3;
-        if (value <= threshold1)
-        {
-            return 1;
-        }
-
-        UInt128 threshold2 = prime >> 2;
-        if (value <= threshold2)
-        {
-            return 2;
-        }
-
-        UInt128 threshold3 = (UInt128)(((BigInteger)prime * 3) >> 3);
-        if (value <= threshold3)
-        {
-            return 3;
-        }
-
-        return 0;
-    }
-
-    private static void BuildCandidatesWide(in UInt128 order, FactorEntry128[] factors, int count, List<UInt128> candidates, int limit)
-    {
-        if (count == 0)
-        {
-            return;
-        }
-
-        Span<FactorEntry128> buffer = factors.AsSpan(0, count);
-        buffer.Sort(static (a, b) => a.Value.CompareTo(b.Value));
-        BuildCandidatesRecursiveWide(order, buffer, 0, UInt128.One, candidates, limit);
-    }
-
-    private static void BuildCandidatesRecursiveWide(
-        in UInt128 order,
-        in ReadOnlySpan<FactorEntry128> factors,
-        int index,
-        in UInt128 divisorProduct,
-        List<UInt128> candidates,
-        int limit)
-    {
-        if (candidates.Count >= limit)
-        {
-            return;
-        }
-
-        if (index >= factors.Length)
-        {
-            if (divisorProduct == UInt128.One || divisorProduct == order)
-            {
-                return;
-            }
-
-            UInt128 candidate = order / divisorProduct;
-            if (candidate > UInt128.One && candidate < order)
-            {
-                candidates.Add(candidate);
-            }
-
-            return;
-        }
-
-        FactorEntry128 factor = factors[index];
-        UInt128 primeFactor = factor.Value;
-        UInt128 contribution = UInt128.One;
-        for (int exponent = 0; exponent <= factor.Exponent; exponent++)
-        {
-            UInt128 nextDivisor = divisorProduct * contribution;
-            if (nextDivisor > order)
-            {
-                break;
-            }
-
-            BuildCandidatesRecursiveWide(order, factors, index + 1, nextDivisor, candidates, limit);
-            if (candidates.Count >= limit)
-            {
-                return;
-            }
-
-            if (exponent == factor.Exponent)
-            {
-                break;
-            }
-
-            if (contribution > order / primeFactor)
-            {
-                break;
-            }
-
-            contribution *= primeFactor;
-        }
-    }
-
-    private static PartialFactorResult128 PartialFactorWide(in UInt128 value, in PrimeOrderCalculatorConfig config)
-    {
-        if (value <= UInt128.One)
-        {
-            return PartialFactorResult128.Empty;
-        }
-
-        Dictionary<UInt128, int> counts = new(capacity: 8);
-        uint limit = config.SmallFactorLimit == 0 ? uint.MaxValue : config.SmallFactorLimit;
-        UInt128 remaining;
-
-        // if (IsGpuPow2Allowed && value <= ulong.MaxValue)
-        // {
-        //     Dictionary<ulong, int> narrowCounts = new(capacity: 8);
-        //     if (TryPopulateSmallPrimeFactorsGpu((ulong)value, limit, narrowCounts, out ulong narrowRemaining))
-        //     {
-        //         foreach (KeyValuePair<ulong, int> entry in narrowCounts)
-        //         {
-        //             counts[(UInt128)entry.Key] = entry.Value;
-        //         }
-
-        //         remaining = (UInt128)narrowRemaining;
-        //     }
-        //     else
-        //     {
-        //         remaining = PopulateSmallPrimeFactorsCpuWide(value, limit, counts);
-        //     }
-        // }
-        // else
-        // {
-            remaining = PopulateSmallPrimeFactorsCpuWide(value, limit, counts);
-        // }
-
-        List<UInt128> pending = new();
-        if (remaining > UInt128.One)
-        {
-            pending.Add(remaining);
-        }
-
-        if (config.PollardRhoMilliseconds > 0 && pending.Count > 0)
-        {
-            long deadlineTimestamp = CreateDeadlineTimestamp(config.PollardRhoMilliseconds);
-            Stack<UInt128> stack = new();
-            stack.Push(remaining);
-            pending.Clear();
-
-            long timestamp = 0L; // reused for deadline checks.
-            while (stack.Count > 0)
-            {
-                UInt128 composite = stack.Pop();
-                if (composite <= UInt128.One)
-                {
-                    continue;
-                }
-
-                if (IsPrimeWide(composite))
-                {
-                    AddFactor(counts, composite, 1);
-                    continue;
-                }
-
-                timestamp = Stopwatch.GetTimestamp();
-                if (timestamp > deadlineTimestamp)
-                {
-                    pending.Add(composite);
-                    continue;
-                }
-
-                if (!TryPollardRhoWide(composite, deadlineTimestamp, out UInt128 factor))
-                {
-                    pending.Add(composite);
-                    continue;
-                }
-
-                UInt128 quotient = composite / factor;
-                stack.Push(factor);
-                stack.Push(quotient);
-            }
-        }
-
-        UInt128 cofactor = UInt128.One;
-        int pendingCount = pending.Count;
-        for (int i = 0; i < pendingCount; i++)
-        {
-            UInt128 composite = pending[i];
-            if (IsPrimeWide(composite))
-            {
-                AddFactor(counts, composite, 1);
-            }
-            else
-            {
-                BigInteger product = (BigInteger)cofactor * (BigInteger)composite;
-                cofactor = (UInt128)product;
-            }
-        }
-
-        if (counts.Count == 0 && cofactor == value)
-        {
-            return new PartialFactorResult128(null, value, false, 0);
-        }
-
-		ArrayPool<FactorEntry128>? pool = null;
-		FactorEntry128[]? rented = counts.Count > 0 ?  (pool = ThreadStaticPools.FactorEntry128Pool).Rent(counts.Count) : null;
-        int index = 0;
-        if (rented is not null)
-        {
-            foreach (KeyValuePair<UInt128, int> entry in counts)
-            {
-                rented[index] = new FactorEntry128(entry.Key, entry.Value);
-                index++;
-            }
-        }
-
-        FactorEntry128[]? resultArray = null;
-        if (pool 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);
-        }
-
-        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)
-    {
-        UInt128 remaining = value;
-        uint[] primes = PrimesGenerator.SmallPrimes;
-        ulong[] squares = PrimesGenerator.SmallPrimesPow2;
-        int primeCount = primes.Length;
-
-        for (int i = 0; i < primeCount; i++)
-        {
-            uint primeCandidate = primes[i];
-            if (primeCandidate > limit)
-            {
-                break;
-            }
-
-            UInt128 primeSquare = (UInt128)squares[i];
-            if (primeSquare > remaining)
-            {
-                break;
-            }
-
-            UInt128 primeValue = primeCandidate;
-            if ((remaining % primeValue) != UInt128.Zero)
-            {
-                continue;
-            }
-
-            int exponent = 0;
-            do
-            {
-                remaining /= primeValue;
-                exponent++;
-            }
-            while ((remaining % primeValue) == UInt128.Zero);
-
-            counts[primeValue] = exponent;
-        }
-
-        return remaining;
-    }
-    private static bool TryPollardRhoWide(in UInt128 n, long deadlineTimestamp, out UInt128 factor)
-    {
-        factor = UInt128.Zero;
-        if ((n & UInt128.One) == UInt128.Zero)
-        {
-            factor = (UInt128)2UL;
-            return true;
-        }
-
-        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)
-            {
-                return false;
-            }
-
-            x = AdvancePolynomialWide(x, c, n);
-            y = AdvancePolynomialWide(y, c, n);
-            y = AdvancePolynomialWide(y, c, n);
-
-            UInt128 diff = x > y ? x - y : y - x;
-            UInt128 d = BinaryGcdWide(diff, n);
-            if (d == n)
-            {
-                c += UInt128.One;
-                x = (UInt128)2UL;
-                y = x;
-                continue;
-            }
-
-            if (d > UInt128.One)
-            {
-                factor = d;
-                return true;
-            }
-        }
-    }
-
-    private static UInt128 AdvancePolynomialWide(in UInt128 x, in UInt128 c, in UInt128 modulus)
-    {
-        BigInteger value = (BigInteger)x;
-        value = (value * value + (BigInteger)c) % (BigInteger)modulus;
-        return (UInt128)value;
-    }
-
-    private static UInt128 BinaryGcdWide(UInt128 a, UInt128 b)
-    {
-        if (a == UInt128.Zero)
-        {
-            return b;
-        }
-
-        if (b == UInt128.Zero)
-        {
-            return a;
-        }
-
-        int shift = TrailingZeroCountWide(a | b);
-        a >>= TrailingZeroCountWide(a);
-
-        while (true)
-        {
-            b >>= TrailingZeroCountWide(b);
-            if (a > b)
-            {
-                (a, b) = (b, a);
-            }
-
-            b -= a;
-            if (b == UInt128.Zero)
-            {
-                return a << shift;
-            }
-        }
-    }
-
-    private static int TrailingZeroCountWide(in UInt128 value)
-    {
-        if (value == UInt128.Zero)
-        {
-            return 128;
-        }
-
-        ulong low = (ulong)value;
-        if (low != 0UL)
-        {
-            return BitOperations.TrailingZeroCount(low);
-        }
-
-        ulong high = (ulong)(value >> 64);
-        return 64 + BitOperations.TrailingZeroCount(high);
-    }
-
-    private static void FactorCompletelyWide(in UInt128 value, Dictionary<UInt128, int> counts)
-    {
-        if (value <= UInt128.One)
-        {
-            return;
-        }
-
-        if (IsPrimeWide(value))
-        {
-            AddFactor(counts, value, 1);
-            return;
-        }
-
-        UInt128 factor = PollardRhoWide(value);
-        FactorCompletelyWide(factor, counts);
-        FactorCompletelyWide(value / factor, counts);
-    }
-
-    private static UInt128 PollardRhoWide(in UInt128 n)
-    {
-        if ((n & UInt128.One) == UInt128.Zero)
-        {
-            return (UInt128)2UL;
-        }
-
-        UInt128 c = UInt128.One;
-        while (true)
-        {
-            UInt128 x = (UInt128)2UL;
-            UInt128 y = x;
-            UInt128 d = UInt128.One;
-
-            while (d == UInt128.One)
-            {
-                x = AdvancePolynomialWide(x, c, n);
-                y = AdvancePolynomialWide(y, c, n);
-                y = AdvancePolynomialWide(y, c, n);
-
-                UInt128 diff = x > y ? x - y : y - x;
-                d = BinaryGcdWide(diff, n);
-            }
-
-            if (d != n)
-            {
-                return d;
-            }
-
-            c += UInt128.One;
-        }
-    }
-
-    private static bool IsPrimeWide(in UInt128 value)
-    {
-        if (value <= ulong.MaxValue)
-        {
-            // return HeuristicPrimeTester.Exclusive.IsPrimeCpu((ulong)value, CancellationToken.None);
-            return PrimeTester.IsPrimeCpu((ulong)value);
-        }
-
-        if ((value & UInt128.One) == UInt128.Zero)
-        {
-            return false;
-        }
-
-        uint[] smallPrimes = PrimesGenerator.SmallPrimes;
-        int length = smallPrimes.Length;
-        for (int i = 0; i < length; i++)
-        {
-            uint prime = smallPrimes[i];
-            UInt128 primeValue = prime;
-            UInt128 primeSquare = primeValue * primeValue;
-            if (primeSquare > value)
-            {
-                break;
-            }
-
-            if ((value % primeValue) == UInt128.Zero)
-            {
-                return false;
-            }
-        }
-
-        BigInteger n = (BigInteger)value;
-        BigInteger d = n - BigInteger.One;
-        int s = 0;
-        while ((d & 1) == 0)
-        {
-            d >>= 1;
-            s++;
-        }
-
-        int[] bases = new[] { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37 };
-        for (int i = 0; i < bases.Length; i++)
-        {
-            int baseValue = bases[i];
-            if (baseValue <= 1)
-            {
-                continue;
-            }
-
-            BigInteger a = baseValue;
-            if (a >= n)
-            {
-                continue;
-            }
-
-            BigInteger x = BigInteger.ModPow(a, d, n);
-            if (x == BigInteger.One || x == n - BigInteger.One)
-            {
-                continue;
-            }
-
-            bool witnessFound = true;
-            for (int r = 1; r < s; r++)
-            {
-                x = BigInteger.ModPow(x, 2, n);
-                if (x == n - BigInteger.One)
-                {
-                    witnessFound = false;
-                    break;
-                }
-            }
-
-            if (witnessFound)
-            {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    private static void AddFactor(Dictionary<UInt128, int> counts, in UInt128 prime, int exponent)
-    {
-        if (counts.TryGetValue(prime, out int existing))
-        {
-            counts[prime] = existing + exponent;
-        }
-        else
-        {
-            counts[prime] = exponent;
-        }
-    }
-
-    private readonly struct CandidateKey128(int primary, bool secondaryDescending, in UInt128 secondary, bool tertiaryDescending, in UInt128 tertiary)
-	{
-		public int Primary { get; } = primary;
-
-		public bool SecondaryDescending { get; } = secondaryDescending;
-
-		public UInt128 Secondary { get; } = secondary;
-
-		public bool TertiaryDescending { get; } = tertiaryDescending;
-
-		public UInt128 Tertiary { get; } = tertiary;
-	}
-
-    private readonly struct PartialFactorResult128(FactorEntry128[]? factors, UInt128 cofactor, bool fullyFactored, int count)
-	{
-		public FactorEntry128[]? Factors { get; } = factors;
-
-		public UInt128 Cofactor { get; } = cofactor;
-
-		public bool FullyFactored { get; } = fullyFactored;
-
-		public int Count { get; } = 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[] extended = new FactorEntry128[Count + 1];
-            Array.Copy(Factors, extended, Count);
-            extended[Count] = new FactorEntry128(prime, 1);
-            return new PartialFactorResult128(extended, UInt128.One, true, Count + 1);
-        }
-    }
-}

PerfectNumbers.Core/PrimeOrderCalculatorConfig.cs

@@ -0,0 +1,34 @@
+using System.Runtime.CompilerServices;
+
+namespace PerfectNumbers.Core;
+
+public readonly struct PrimeOrderCalculatorConfig(uint smallFactorLimit, int pollardRhoMilliseconds, int maxPowChecks, bool strictMode, int maxSeconds = 0)
+{
+	private static PrimeOrderCalculatorConfig _heuristicDefault = CreateHeuristicDefault(UnboundedTaskScheduler.ConfiguredThreadCount);
+
+	public static PrimeOrderCalculatorConfig HeuristicDefault
+	{
+		[MethodImpl(MethodImplOptions.AggressiveInlining)]
+		get => _heuristicDefault;
+	}
+
+	public static readonly PrimeOrderCalculatorConfig StrictDefault = new(smallFactorLimit: 1_000_000, pollardRhoMilliseconds: 0, maxPowChecks: 0, true);
+
+	public static void ConfigureHeuristicDefault(int threadCount)
+	{
+		_heuristicDefault = CreateHeuristicDefault(threadCount);
+	}
+
+	public static PrimeOrderCalculatorConfig CreateHeuristicDefault(int threadCount)
+	{
+		int normalizedThreadCount = threadCount < 1 ? 1 : threadCount;
+		return new(smallFactorLimit: 100_000, pollardRhoMilliseconds: normalizedThreadCount * 24, maxPowChecks: 24, false);
+	}
+
+	public readonly uint SmallFactorLimit = smallFactorLimit;
+	public readonly int PollardRhoMilliseconds = pollardRhoMilliseconds;
+	public readonly int MaxPowChecks = maxPowChecks;
+	public readonly int MaxPowChecksCapacity = maxPowChecks << 2;
+	public readonly bool StrictMode = strictMode;
+	public readonly int MaxSeconds = maxSeconds;
+}

PerfectNumbers.Core/ThreadStaticPools.cs

@@ -100,6 +100,31 @@ namespace PerfectNumbers.Core
 		[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
 		public static void Return(this FixedCapacityStack<Dictionary<UInt128, int>> pool, Dictionary<UInt128, int> dictionary) => pool.Push(dictionary);
 
+		[ThreadStatic]
+		private static FixedCapacityStack<Dictionary<ulong, int>>? _ulongIntDictionaryPool;
+
+		public static FixedCapacityStack<Dictionary<ulong, int>> UlongIntDictionaryPool
+		{
+			[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+			get => _ulongIntDictionaryPool ??= new(PerfectNumberConstants.DefaultPoolCapacity);
+		}
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+		public static Dictionary<ulong, int> Rent(this FixedCapacityStack<Dictionary<ulong, int>> pool, int capacity)
+		{
+			if (pool.Pop() is { } pooled)
+			{
+				pooled.EnsureCapacity(capacity);
+				pooled.Clear();
+				return pooled;
+			}
+
+			return new(capacity);
+		}
+
+		[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+		public static void Return(this FixedCapacityStack<Dictionary<ulong, int>> pool, Dictionary<ulong, int> dictionary) => pool.Push(dictionary);
+
 		[ThreadStatic]
 		private static ArrayPool<FactorEntry>? _factorEntryPool;
 

PerfectNumbers.Core/UInt128Numbers.cs

@@ -5,6 +5,7 @@ namespace PerfectNumbers.Core
     public static class UInt128Numbers
     {
         public static readonly UInt128 Two = 2UL;
+        public static readonly UInt128 Three = 3UL;
         public static readonly UInt128 Four = 4UL;
         public static readonly UInt128 SixtyFour = 64UL;
         public static readonly UInt128 OneHundredTwentySeven = 127UL;

PerfectNumbers.Core/UnboundedTaskScheduler.cs

@@ -28,7 +28,7 @@ public sealed class UnboundedTaskScheduler : TaskScheduler
 	public static void ConfigureThreadCount(int threadCount)
 	{
 		_configuredThreadCount = threadCount;
-		PrimeOrderCalculator.PrimeOrderCalculatorConfig.ConfigureHeuristicDefault(threadCount);
+		PrimeOrderCalculatorConfig.ConfigureHeuristicDefault(threadCount);
 
 		// On EvenPerfectBitScanner's execution path the scheduler instance is created after configuration,
 		// so updating an existing pool would never run. Leave the update path disabled for now.