Smaller optimizations. Division by zero fixed?

PerfectNumbers.Core/PrimeOrderCalculator.Cpu.cs

@@ -77,11 +77,17 @@ internal static partial class PrimeOrderCalculator
 
 	private static bool TrySpecialMaxCpu(ulong phi, ulong prime, PartialFactorResult factors, in MontgomeryDivisorData divisorData)
 	{
-		ReadOnlySpan<FactorEntry> factorSpan = factors.Factors;
 		int length = factors.Count;
+		ReadOnlySpan<FactorEntry> factorSpan = new(factors.Factors, 0, length);
 		for (int i = 0; i < length; i++)
 		{
 			ulong factor = factorSpan[i].Value;
+			// Don't uncomment this. If there is division by zero, that means something wrong.
+			// if (factor == 0UL)
+			// {
+			// 	continue;
+			// }
+
 			ulong reduced = phi / factor;
 			if (Pow2EqualsOneCpu(reduced, prime, divisorData))
 			{
@@ -638,7 +644,7 @@ internal static partial class PrimeOrderCalculator
 
 	private static bool Pow2EqualsOneCpu(ulong exponent, ulong prime, in MontgomeryDivisorData divisorData)
 	{
-		// if (IsGpuPow2Allowed)
+		if (IsGpuPow2Allowed)
 		{
 			ulong remainder = exponent.Pow2MontgomeryModWindowedGpu(divisorData, false);
 			// GpuPow2ModStatus status = PrimeOrderGpuHeuristics.TryPow2Mod(exponent, prime, out ulong remainder, divisorData);
@@ -741,26 +747,26 @@ internal static partial class PrimeOrderCalculator
 				remaining = PopulateSmallPrimeFactorsCpu(value, limit, counts);
 			// }
 
-			// int dictionaryCount = counts.Count;
+			int dictionaryCount = counts.Count;
-			// if (dictionaryCount <= FactorSlotCount)
+			if (dictionaryCount <= FactorSlotCount)
-			// {
+			{
-				// int copyIndex = 0;
+				int copyIndex = 0;
-				// foreach (KeyValuePair<ulong, int> entry in counts)
+				foreach (KeyValuePair<ulong, int> entry in counts)
-				// {
+				{
-				// 	primeSlots[copyIndex] = entry.Key;
+					primeSlots[copyIndex] = entry.Key;
-				// 	exponentSlots[copyIndex] = entry.Value;
+					exponentSlots[copyIndex] = entry.Value;
-				// 	copyIndex++;
+					copyIndex++;
-				// }
+				}
 
-				// factorCount = copyIndex;
+				factorCount = copyIndex;
-				// ThreadStaticPools.ReturnUlongIntDictionary(counts);
+				ThreadStaticPools.ReturnUlongIntDictionary(counts);
-				// counts = null;
+				counts = null;
-			// }
+			}
-			// else
+			else
-			// {
+			{
 				useDictionary = true;
-				// factorCount = dictionaryCount;
+				factorCount = dictionaryCount;
-			// }
+			}
 		}
 
 

PerfectNumbers.Core/ULongExtensions.cs

@@ -331,10 +331,11 @@ public static class ULongExtensions
     public static ulong Pow2MontgomeryModWindowedCpu(this ulong exponent, in MontgomeryDivisorData divisor, bool keepMontgomery)
     {
 		ulong modulus = divisor.Modulus;
-        if (exponent == 0UL)
+		// This should never happen in production code. If it does, we need to fix it.
-        {
+        // if (exponent == 0UL)
-            return keepMontgomery ? divisor.MontgomeryOne : 1UL % modulus;
+        // {
-        }
+        //     return keepMontgomery ? divisor.MontgomeryOne : 1UL % modulus;
+        // }
 
         if (exponent <= Pow2WindowFallbackThreshold)
         {

PerfectNumbers.Core/UnboundedTaskScheduler.cs

@@ -9,6 +9,8 @@ public sealed class UnboundedTaskScheduler : TaskScheduler
 
 	private UnboundedTaskScheduler()
 	{
+		ThreadPool.SetMaxThreads(100_000, 100_000);
+		ThreadPool.SetMinThreads(10_300, 100);
 	}
 
 	public override int MaximumConcurrencyLevel => int.MaxValue;