BuildDivisorCandidates moved to MersenneNumberDivisorGpuTester. Micro-optimizations.

EvenPerfectBitScanner/Program.cs

@@ -26,11 +26,9 @@ internal static class Program
 	private static int _primeCount;
 	private static bool _primeFoundAfterInit;
 	private static bool _useGcdFilter;
-	private static bool _useResidue;
 	private static bool _useDivisor;
 	private static ulong _divisor;
 	private static MersenneNumberDivisorGpuTester? _divisorTester;
-	private static (ulong divisor, uint cycle)[]? _divisorCandidates;
 	private static ulong? _orderWarmupLimitOverride;
 	private static unsafe delegate*<ulong, ref ulong, ulong> _transformP;
 	private static long _state;
@@ -367,7 +365,7 @@ internal static class Program
 
 		// Apply GPU prime sieve runtime configuration
 		GpuPrimeWorkLimiter.SetLimit(gpuPrimeThreads);
-		PerfectNumbers.Core.PrimeTester.GpuBatchSize = Math.Max(1, gpuPrimeBatch);
+		PrimeTester.GpuBatchSize = Math.Max(1, gpuPrimeBatch);
 
 		MersenneDivisorCycles mersenneDivisorCycles = new();
 		if (!File.Exists(cyclesPath) || continueCyclesGeneration)
@@ -412,7 +410,6 @@ internal static class Program
 
 		Console.WriteLine("Divisor cycles are ready");
 
-		_useResidue = useResidue;
 		_useDivisor = useDivisor;
 		_divisor = divisor;
 		_transformP = useBitTransform ? &TransformPBit : &TransformPAdd;
@@ -445,17 +442,18 @@ internal static class Program
 		}
 		else
 		{
-			_divisorTester = new MersenneNumberDivisorGpuTester();
 			if (divisor == 0UL)
 			{
-				_divisorCandidates = BuildDivisorCandidates();
+				MersenneNumberDivisorGpuTester.BuildDivisorCandidates();
 			}
+
+			_divisorTester = new MersenneNumberDivisorGpuTester();
 		}
 
 		// Load RLE blacklist (optional)
 		if (!string.IsNullOrEmpty(_rleBlacklistPath))
 		{
-			PerfectNumbers.Core.RleBlacklist.Load(_rleBlacklistPath!);
+			RleBlacklist.Load(_rleBlacklistPath!);
 		}
 
 		ulong remainder = currentP % 6UL;
@@ -552,7 +550,7 @@ internal static class Program
 		// Limit GPU concurrency only for prime checks (LL/NTT & GPU order scans).
 		GpuPrimeWorkLimiter.SetLimit(gpuPrimeThreads);
 		// Configure batch size for GPU primality sieve
-		PerfectNumbers.Core.PrimeTester.GpuBatchSize = gpuPrimeBatch;
+		PrimeTester.GpuBatchSize = gpuPrimeBatch;
 
 		// Compose a results file name that encodes configuration
 		ResultsFileName = BuildResultsFileName(
@@ -739,17 +737,20 @@ internal static class Program
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	private static unsafe int ReserveBlock(ulong[] buffer, int blockSize)
 	{
+		Span<ulong> bufferSpan = new(buffer);
+		ulong p, remainder;
+		long state, newState, original;
+		int count;
 		while (true)
 		{
-                        long state = Volatile.Read(ref _state);
+			state = Volatile.Read(ref _state);
-                        ulong current = (ulong)state >> 3;
+			p = (ulong)state >> 3;
-                        ulong remainder = ((ulong)state) & 7UL;
+			remainder = ((ulong)state) & 7UL;
 
-                        ulong p = current;
+			count = 0;
-                        int count = 0;
 			while (count < blockSize && !Volatile.Read(ref _limitReached))
 			{
-                                buffer[count++] = p;
+				bufferSpan[count++] = p;
 				p = _transformP(p, ref remainder);
 			}
 
@@ -758,8 +759,8 @@ internal static class Program
 				return 0;
 			}
 
-                        long newState = ((long)p << 3) | (long)remainder;
+			newState = ((long)p << 3) | (long)remainder;
-                        long original = Interlocked.CompareExchange(ref _state, newState, state);
+			original = Interlocked.CompareExchange(ref _state, newState, state);
 			if (original == state)
 			{
 				return count;
@@ -913,46 +914,6 @@ internal static class Program
 		return next + value;
 	}
 
-	private static (ulong divisor, uint cycle)[] BuildDivisorCandidates()
-	{
-		uint[] snapshot = MersenneDivisorCycles.Shared.ExportSmallCyclesSnapshot();
-		Span<(ulong divisor, uint cycle)> list = stackalloc (ulong divisor, uint cycle)[snapshot.Length / 2];// new(snapshot.Length / 2);
-		uint cycle;
-		int count = 0, i, snapshotLength = snapshot.Length;
-		for (i = 3; i < snapshotLength; i += 2)
-		{
-			cycle = snapshot[i];
-			if (cycle == 0U)
-			{
-				continue;
-			}
-
-			list[count++] = ((ulong)i, cycle);
-		}
-
-		return list[..count].ToArray();
-	}
-
-	private static bool IsDivisible(ulong exponent, ulong divisor)
-	{
-		if (_divisorTester is not null)
-		{
-			return _divisorTester.IsDivisible(exponent, divisor);
-		}
-
-		ulong remainder = 1UL;
-		for (ulong i = 0; i < exponent; i++)
-		{
-			remainder <<= 1;
-			if (remainder >= divisor)
-			{
-				remainder -= divisor;
-			}
-		}
-
-		return remainder == 1UL;
-	}
-
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	internal static bool IsEvenPerfectCandidate(ulong p, int divisorCyclesSearchLimit)
 	{
@@ -974,7 +935,7 @@ internal static class Program
 		{
 			if (!_rleOnlyLast7 || (p % 10UL) == 7UL)
 			{
-				if (PerfectNumbers.Core.RleBlacklist.IsLoaded() && PerfectNumbers.Core.RleBlacklist.Matches(p))
+				if (RleBlacklist.IsLoaded() && RleBlacklist.Matches(p))
 				{
 					return false;
 				}
@@ -1025,59 +986,7 @@ internal static class Program
 		searchedMersenne = true;
 		if (_useDivisor)
 		{
-			if (_divisor != 0UL)
+			return _divisorTester!.IsPrime(p, _divisor, divisorCyclesSearchLimit, out detailedCheck);
-			{
-				if (IsDivisible(p, _divisor))
-				{
-					detailedCheck = true;
-					return false;
-				}
-
-				detailedCheck = false;
-				return true;
-			}
-
-			var candidates = _divisorCandidates!;
-			int len = candidates.Length;
-			for (int i = 0; i < len; i++)
-			{
-				var (d, cycle) = candidates[i];
-				if (p % cycle != 0UL)
-				{
-					continue;
-				}
-
-				if (IsDivisible(p, d))
-				{
-					detailedCheck = true;
-					return false;
-				}
-			}
-
-			for (int k = 1; k <= divisorCyclesSearchLimit; k++)
-			{
-				ulong kMul2 = 2UL * (ulong)k;
-				if (p > ulong.MaxValue / kMul2)
-				{
-					break;
-				}
-
-				ulong d = kMul2 * p + 1UL;
-				ulong cycle = MersenneDivisorCycles.Shared.GetCycle(d);
-				if (p % cycle != 0UL)
-				{
-					continue;
-				}
-
-				if (IsDivisible(p, d))
-				{
-					detailedCheck = true;
-					return false;
-				}
-			}
-
-			detailedCheck = false;
-			return true;
 		}
 
 		detailedCheck = MersenneTesters.Value!.IsMersennePrime(p);

PerfectNumbers.Core/Gpu/MersenneNumberDivisorGpuTester.cs

@@ -12,6 +12,26 @@ public sealed class MersenneNumberDivisorGpuTester
 	private Action<Index1D, ulong, ulong, ArrayView<byte>> GetKernel(Accelerator accelerator) =>
 		_kernelCache.GetOrAdd(accelerator, acc => acc.LoadAutoGroupedStreamKernel<Index1D, ulong, ulong, ArrayView<byte>>(Kernel));
 
+	public static void BuildDivisorCandidates()
+	{
+		uint[] snapshot = MersenneDivisorCycles.Shared.ExportSmallCyclesSnapshot();
+		Span<(ulong divisor, uint cycle)> list = stackalloc (ulong divisor, uint cycle)[snapshot.Length / 2];
+		uint cycle;
+		int count = 0, i, snapshotLength = snapshot.Length;
+		for (i = 3; i < snapshotLength; i += 2)
+		{
+			cycle = snapshot[i];
+			if (cycle == 0U)
+			{
+				continue;
+			}
+
+			list[count++] = ((ulong)i, cycle);
+		}
+
+		_divisorCandidates = list[..count].ToArray();
+	}
+
 	public bool IsDivisible(ulong exponent, ulong divisor)
 	{
 		var gpu = GpuContextPool.RentPreferred(preferCpu: false);
@@ -26,6 +46,71 @@ public sealed class MersenneNumberDivisorGpuTester
 		return divisible;
 	}
 
+	private static (ulong divisor, uint cycle)[]? _divisorCandidates;
+
+	public bool IsPrime(ulong p, ulong d, int divisorCyclesSearchLimit, out bool detailedCheck)
+	{
+		if (d != 0UL)
+		{
+			if (IsDivisible(p, d))
+			{
+				detailedCheck = true;
+				return false;
+			}
+
+			detailedCheck = false;
+			return true;
+		}
+
+		var candidates = _divisorCandidates!;
+		int k, len = candidates.Length;
+		uint cycle;
+		
+		// k is simple iterator here
+		for (k = 0; k < len; k++)
+		{
+			(d, cycle) = candidates[k];
+			if (p % cycle != 0UL)
+			{
+				continue;
+			}
+
+			if (IsDivisible(p, d))
+			{
+				detailedCheck = true;
+				return false;
+			}
+		}
+
+		ulong kMul2;
+		var divisorCycles = MersenneDivisorCycles.Shared;
+		for (k = 1; k <= divisorCyclesSearchLimit; k++)
+		{
+			kMul2 = (ulong)k << 1;
+			if (p > ulong.MaxValue / kMul2)
+			{
+				break;
+			}
+
+			d = kMul2 * p + 1UL;
+			// kkMul2 now becomes cycle. We're reusing existing variable for the best performance
+			kMul2 = divisorCycles.GetCycle(d);
+			if (p % kMul2 != 0UL)
+			{
+				continue;
+			}
+
+			if (IsDivisible(p, d))
+			{
+				detailedCheck = true;
+				return false;
+			}
+		}
+
+		detailedCheck = false;
+		return true;
+	}
+
 	private static void Kernel(Index1D _, ulong exponent, ulong divisor, ArrayView<byte> result)
 	{
 		if (divisor <= 1UL)

PerfectNumbers.Core/Gpu/MersenneNumberResidueGpuTester.cs

@@ -28,8 +28,7 @@ public class MersenneNumberResidueGpuTester(bool useGpuOrder)
 		UInt128 remaining;
 		int currentSize;
 		int i;
-                UInt128 batchSize128 = (UInt128)batchSize,
+		UInt128 batchSize128 = (UInt128)batchSize, q;
-                                q = UInt128.Zero;
 		Span<ulong> orders = orderArray.AsSpan(0, batchSize);
 		try
 		{
@@ -82,6 +81,5 @@ public class MersenneNumberResidueGpuTester(bool useGpuOrder)
 			orderBuffer.Dispose();
 			gpuLease.Dispose();
 		}
-
 	}
 }