Additional logging added.

PerfectNumbers.Core/MersenneDivisorCycles.cs

@@ -360,6 +360,9 @@ public class MersenneDivisorCycles
         return true;
     }
 
+	// private static ulong _tryFactorIntoCountsInternalHits;
+	// private static ulong _tryCalculateCycleLengthHeuristicHits;
+
 	private static bool TryFactorIntoCountsInternal(ulong value, Dictionary<ulong, int> counts)
 	{
 		// The EvenPerfectBitScanner only requests factors for values >= 2 here. Leave the guard documented without executing it.
@@ -389,13 +392,12 @@ public class MersenneDivisorCycles
 			}
 		}
 
-        if (remaining == 1UL)
+		// TODO: Benchmark PrimeTester.IsPrimeInternal against Open.Numeric.Primes on the EvenPerfectBitScanner workloads to confirm the faster option for wide composites.
-        {
+		// if (HeuristicPrimeTester.Exclusive.IsPrime(remaining, CancellationToken.None))
-            return true;
+
-        }
+		// Atomic.Add(ref _tryFactorIntoCountsInternalHits, 1UL);
+		// Console.WriteLine($"MersenneDivisorCycles.TryFactorIntoCountsInternal hits {Volatile.Read(ref _tryFactorIntoCountsInternalHits)}");
 
-        // TODO: Benchmark PrimeTester.IsPrimeCpu against Open.Numeric.Primes on the EvenPerfectBitScanner workloads to confirm the faster option for wide composites.
-        // if (HeuristicPrimeTester.Exclusive.IsPrimeCpu(remaining, CancellationToken.None))
 		if (PrimeTester.IsPrimeCpu(remaining, CancellationToken.None))
 		{
 			AddFactor(counts, remaining);
@@ -928,6 +930,12 @@ public class MersenneDivisorCycles
             return true;
         }
 
+		// if (!skipPrimeOrderHeuristic)
+		// {
+		// 	Atomic.Add(ref _tryCalculateCycleLengthHeuristicHits, 1UL);
+		// 	Console.WriteLine($"MersenneDivisorCycles.CalculateCycleLengthFallback hits {Volatile.Read(ref _tryCalculateCycleLengthHeuristicHits)}");			
+		// }
+
         // if (!skipPrimeOrderHeuristic && HeuristicPrimeTester.Exclusive.IsPrimeCpu(divisor, CancellationToken.None))
         if (!skipPrimeOrderHeuristic && PrimeTester.IsPrimeCpu(divisor, CancellationToken.None))
         {

PerfectNumbers.Core/MersennePrimeFactorTester.cs

@@ -2,11 +2,15 @@ using System.Collections.Concurrent;
 using System.Runtime.CompilerServices;
 using System.Numerics;
 using UInt128 = System.UInt128;
+using ILGPU;
 
 namespace PerfectNumbers.Core;
 
 public static class MersennePrimeFactorTester
 {
+	// private static ulong _isPrimeFactorHits;
+	// private static ulong _factor64Hits;
+
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool IsPrimeFactor(ulong p, ulong q, CancellationToken ct)
     {
@@ -25,7 +29,11 @@ public static class MersennePrimeFactorTester
             return false;
         }
 
-        // if (!HeuristicPrimeTester.Exclusive.IsPrimeCpu(q, ct))
+        // if (!HeuristicPrimeTester.Exclusive.IsPrime(q, ct))
+
+		// Atomic.Add(ref _isPrimeFactorHits, 1UL);
+		// Console.WriteLine($"MersennePrimeFactorTester.IsPrimeFactor hits {Volatile.Read(ref _isPrimeFactorHits)}");
+
         if (!PrimeTester.IsPrimeCpu(q, ct))
         {
             return false;
@@ -234,7 +242,11 @@ public static class MersennePrimeFactorTester
                 continue;
             }
 
-            // if (HeuristicPrimeTester.Exclusive.IsPrimeCpu(m, ct))
+
+			// Atomic.Add(ref _factor64Hits, 1UL);
+			// Console.WriteLine($"MersennePrimeFactorTester.Factor64 hits {Volatile.Read(ref _factor64Hits)}");
+
+            // if (HeuristicPrimeTester.Exclusive.IsPrime(m, ct))
             if (PrimeTester.IsPrimeCpu(m, ct))
             {
                 dict[m] = 1;

PerfectNumbers.Core/PrimeOrderCalculator.Cpu.cs

@@ -4,6 +4,7 @@ using System.Diagnostics;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using ILGPU;
 using PerfectNumbers.Core.Gpu;
 
 namespace PerfectNumbers.Core;
@@ -1019,6 +1020,10 @@ internal static partial class PrimeOrderCalculator
 		return exponent.Pow2MontgomeryModWindowedCpu(divisorData, keepMontgomery: false) == 1UL;
 	}
 
+	// private static ulong _partialFactorHits;
+	// private static ulong _partialFactorPendingHits;
+	// private static ulong _partialFactorCofactorHits;
+
 	private static PartialFactorResult PartialFactor(ulong value, in PrimeOrderSearchConfig config)
 	{
 		if (value <= 1UL)
@@ -1123,8 +1128,12 @@ internal static partial class PrimeOrderCalculator
 					// }
 
 					// bool isPrime = primeTester.HeuristicIsPrimeGpu(composite);
-					// bool isPrime = PrimeTester.IsPrimeCpu(composite, CancellationToken.None);
+					// bool isPrime = PrimeTester.IsPrimeInternal(composite, CancellationToken.None);
-					bool isPrime = PrimeTester.IsPrimeCpu(composite, CancellationToken.None);
+
+					// Atomic.Add(ref _partialFactorHits, 1UL);
+					// Console.WriteLine($"Partial factor hits {Volatile.Read(ref _partialFactorHits)}");
+
+					bool isPrime = PrimeTester.IsPrimeGpu(composite);
 					// bool isPrime = Open.Numeric.Primes.Prime.Numbers.IsPrime(composite);
 
 					if (isPrime)
@@ -1186,8 +1195,12 @@ internal static partial class PrimeOrderCalculator
 			if (!entry.HasKnownPrimality)
 			{
 				// bool isPrime = primeTester.HeuristicIsPrimeGpu(composite);
-				// bool isPrime = PrimeTester.IsPrimeCpu(composite, CancellationToken.None);
+				// bool isPrime = PrimeTester.IsPrimeInternal(composite, CancellationToken.None);
-				bool isPrime = PrimeTester.IsPrimeCpu(composite, CancellationToken.None);
+
+				// Atomic.Add(ref _partialFactorPendingHits, 1UL);
+				// Console.WriteLine($"Partial factor pending hits {Volatile.Read(ref _partialFactorPendingHits)}");
+
+				bool isPrime = PrimeTester.IsPrimeGpu(composite);
 				// bool isPrime = Open.Numeric.Primes.Prime.Numbers.IsPrime(composite);
 
 				entry = entry.WithPrimality(isPrime);
@@ -1219,7 +1232,11 @@ internal static partial class PrimeOrderCalculator
 		else
 		{
 			// cofactorIsPrime = primeTester.HeuristicIsPrimeGpu(cofactor);
-			// cofactorIsPrime = PrimeTester.IsPrimeCpu(cofactor, CancellationToken.None);
+			// cofactorIsPrime = PrimeTester.IsPrimeInternal(cofactor, CancellationToken.None);
+
+			// Atomic.Add(ref _partialFactorCofactorHits, 1UL);
+			// Console.WriteLine($"Partial factor cofactor hits {Volatile.Read(ref _partialFactorCofactorHits)}");
+
 			cofactorIsPrime = PrimeTester.IsPrimeCpu(cofactor, CancellationToken.None);
 			// cofactorIsPrime = Open.Numeric.Primes.Prime.Numbers.IsPrime(cofactor);
 		}
@@ -1742,6 +1759,9 @@ internal static partial class PrimeOrderCalculator
 		FactorCompletely(value, counts, knownComposite: false);
 	}
 	
+	// private static ulong _factorCompletelyHits;
+	// private static ulong _factorCompletelyPollardRhoHits;
+
 	private static void FactorCompletely(ulong value, Dictionary<ulong, int> counts, bool knownComposite)
 	{
 		if (value <= 1UL)
@@ -1749,7 +1769,9 @@ internal static partial class PrimeOrderCalculator
 			return;
 		}
 
-		PrimeTester primeTester = PrimeTester.Exclusive;
+		// Atomic.Add(ref _factorCompletelyHits, 1UL);
+		// Console.WriteLine($"Factor completely hits {Volatile.Read(ref _factorCompletelyHits)}");
+		// PrimeTester primeTester = PrimeTester.Exclusive;
 
 		// bool isPrime = primeTester.HeuristicIsPrimeGpu(value);
 		// bool isPrime = PrimeTester.IsPrimeCpu(value, CancellationToken.None);
@@ -1764,6 +1786,9 @@ internal static partial class PrimeOrderCalculator
 		ulong factor = PollardRhoStrict(value);
 		ulong quotient = value / factor;
 
+		// Atomic.Add(ref _factorCompletelyPollardRhoHits, 1UL);
+		// Console.WriteLine($"Factor completely after PollardRho hits {Volatile.Read(ref _factorCompletelyPollardRhoHits)}");
+
 		// isPrime = primeTester.HeuristicIsPrimeGpu(factor);
 		// isPrime = PrimeTester.IsPrimeCpu(factor, CancellationToken.None);
 		isPrime = PrimeTester.IsPrimeCpu(factor, CancellationToken.None);
@@ -1797,7 +1822,11 @@ internal static partial class PrimeOrderCalculator
 		else
 		{
 			// isPrime = primeTester.HeuristicIsPrimeGpu(quotient);
-			// isPrime = PrimeTester.IsPrimeCpu(quotient, CancellationToken.None);
+			// isPrime = PrimeTester.IsPrimeInternal(quotient, CancellationToken.None);
+
+			// Atomic.Add(ref _partialFactorCofactorHits, 1UL);
+			// Console.WriteLine($"Partial factor cofactor hits {Volatile.Read(ref _partialFactorCofactorHits)}");
+
 			isPrime = PrimeTester.IsPrimeCpu(quotient, CancellationToken.None);
 			// isPrime = Open.Numeric.Primes.Prime.Numbers.IsPrime(quotient);
 		}