Remove dead by-divisor cache fallback

PerfectNumbers.Core/Cpu/MersenneCpuDivisorScanSession.cs

@@ -27,7 +27,7 @@ internal sealed class MersenneCpuDivisorScanSession : IMersenneNumberDivisorByDi
         MontgomeryDivisorData cachedData = divisorData;
         if (cachedData.Modulus != divisor)
         {
-            cachedData = MontgomeryDivisorDataCache.Get(divisor);
+            cachedData = MontgomeryDivisorData.FromModulus(divisor);
         }
 
         if (divisorCycle == 0UL)

PerfectNumbers.Core/Cpu/MersenneNumberDivisorByDivisorCpuTester.cs

@@ -187,7 +187,7 @@ public sealed class MersenneNumberDivisorByDivisorCpuTester : IMersenneNumberDiv
 
             if (admissible && (remainder8 == 1 || remainder8 == 7) && remainder3 != 0 && remainder5 != 0 && remainder7 != 0 && remainder11 != 0)
             {
-                MontgomeryDivisorData divisorData = MontgomeryDivisorDataCache.Get(candidate);
+                MontgomeryDivisorData divisorData = MontgomeryDivisorData.FromModulus(candidate);
                 ulong divisorCycle;
                 // Divisors generated from 2 * k * p + 1 exceed the small-cycle snapshot when p >= 138,000,000, so the short path below never runs.
                 // if (candidate <= PerfectNumberConstants.MaxQForDivisorCycles)
@@ -209,7 +209,12 @@ public sealed class MersenneNumberDivisorByDivisorCpuTester : IMersenneNumberDiv
                             out ulong computedCycle,
                             out bool primeOrderFailed) || computedCycle == 0UL)
                     {
-                        divisorCycle = cycleCache.GetCycleLength(candidate, skipPrimeOrderHeuristic: primeOrderFailed);
+                        // Divisors produced by 2 * k * p + 1 always exceed PerfectNumberConstants.MaxQForDivisorCycles
+                        // for the exponents scanned here, so skip the unused cache fallback and compute directly.
+                        divisorCycle = MersenneDivisorCycles.CalculateCycleLength(
+                            candidate,
+                            divisorData,
+                            skipPrimeOrderHeuristic: primeOrderFailed);
                     }
                     else
                     {

PerfectNumbers.Core/MontgomeryDivisorData.cs

@@ -45,30 +45,3 @@ public readonly struct MontgomeryDivisorData(ulong modulus, ulong nPrime, ulong
     }
 
 }
-
-internal static class MontgomeryDivisorDataCache
-{
-    [ThreadStatic]
-    private static bool s_hasCachedValue;
-
-    [ThreadStatic]
-    private static ulong s_cachedModulus;
-
-    [ThreadStatic]
-    private static MontgomeryDivisorData s_cachedData;
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static MontgomeryDivisorData Get(ulong modulus)
-    {
-        if (s_hasCachedValue && s_cachedModulus == modulus)
-        {
-            return s_cachedData;
-        }
-
-        MontgomeryDivisorData computed = MontgomeryDivisorData.FromModulus(modulus);
-        s_cachedModulus = modulus;
-        s_cachedData = computed;
-        s_hasCachedValue = true;
-        return computed;
-    }
-}

PerfectNumbers.Core/PrimeOrderCalculator.Cpu.cs

@@ -673,8 +673,9 @@ internal static partial class PrimeOrderCalculator
 		return exponent.Pow2MontgomeryModWindowedCpu(divisorData, keepMontgomery: false) == 1UL;
 	}
 
+
 	// [ThreadStatic]
-	private static readonly Dictionary<ulong, bool> _primalityCache = new(16_777_216);
+	private static readonly Dictionary<ulong, bool> _primalityCache = new(4_096);
 	private static readonly ReaderWriterLockSlim _primalityCacheLock = new(LockRecursionPolicy.NoRecursion);
 
 	// [ThreadStatic]
@@ -683,6 +684,12 @@ internal static partial class PrimeOrderCalculator
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	private static bool TryGetCachedPrimality(ulong value, out bool isPrime)
 	{
+		if (value > (ulong)PerfectNumberConstants.MaxQForDivisorCycles)
+		{
+			isPrime = false;
+			return false;
+		}
+
 		_primalityCacheLock.EnterReadLock();
 		bool result = _primalityCache.TryGetValue(value, out isPrime);
 		_primalityCacheLock.ExitReadLock();
@@ -692,6 +699,11 @@ internal static partial class PrimeOrderCalculator
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	private static void CachePrimalityResult(ulong value, bool isPrime)
 	{
+		if (value > (ulong)PerfectNumberConstants.MaxQForDivisorCycles)
+		{
+			return;
+		}
+
 		_primalityCacheLock.EnterWriteLock();
 		_primalityCache[value] = isPrime;
 		_primalityCacheLock.ExitWriteLock();