Optimizations. Unnecessary variables removed.

PerfectNumbers.Core/Gpu/MersenneNumberDivisorByDivisorGpuTester.cs

@@ -98,6 +98,7 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester
 
 	private bool CheckDivisors(ulong prime, ulong allowedMax, out ulong lastProcessed, out bool coveredRange)
 	{
+		// TODO: We should be able to calculate allowedMax outside in the parent method, unless it depends from some changing value.
 		allowedMax = Math.Min(allowedMax, _divisorLimit);
 		lastProcessed = 0UL;
 
@@ -107,53 +108,58 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester
 			return false;
 		}
 
+		// TODO: Rent these in the parent method before the loops - batch size doesn't change
 		var gpuLease = GpuContextPool.RentPreferred(preferCpu: false);
 		var accelerator = gpuLease.Accelerator;
 		var kernel = GetKernel(accelerator);
 
 		int batchCapacity = _gpuBatchSize;
+		// TODO: Rent buffers in the parent method before the loops - batch size doesn't change
 		var divisorsBuffer = accelerator.Allocate1D<MontgomeryDivisorData>(batchCapacity);
 		var hitsBuffer = accelerator.Allocate1D<byte>(batchCapacity);
-
 		ulong[] divisors = ArrayPool<ulong>.Shared.Rent(batchCapacity);
 		byte[] hits = ArrayPool<byte>.Shared.Rent(batchCapacity);
 		MontgomeryDivisorData[] divisorData = ArrayPool<MontgomeryDivisorData>.Shared.Rent(batchCapacity);
 
 		bool composite = false;
 		bool processedAll = false;
-		ulong divisor = 3UL;
+		ulong cycle, divisor = 3UL, next;
+		int batchSize, i;
+		bool reachedEndInBatch, useCycles = _useDivisorCycles;
+
+		Span<MontgomeryDivisorData> divisorDataSpan;
+		Span<ulong> divisorSpan;
+		Span<byte> hitsSpan;
+		MersenneDivisorCycles divisorCycles = MersenneDivisorCycles.Shared;
+		ArrayView1D<MontgomeryDivisorData, Stride1D.Dense> divisorView;
+		ArrayView1D<byte, Stride1D.Dense> hitsView;
 
-		try
-		{
-			bool useCycles = _useDivisorCycles;
-			MersenneDivisorCycles? divisorCycles = useCycles ? MersenneDivisorCycles.Shared : null;
 		while (divisor <= allowedMax)
 		{
-				int batchSize = 0;
+			batchSize = 0;
-				bool reachedEndInBatch = false;
+			reachedEndInBatch = false;
 
 			while (batchSize < batchCapacity && divisor <= allowedMax)
 			{
-					ulong current = divisor;
-					ulong next = current + 2UL;
-					bool include = true;
 				if (useCycles)
 				{
-						ulong cycle = divisorCycles!.GetCycle(current);
+					cycle = divisorCycles!.GetCycle(divisor);
 					if (cycle == 0UL || prime % cycle != 0UL)
 					{
-							include = false;
+						ReportStatus(divisor);
-							lastProcessed = current;
-							ReportStatus(lastProcessed);
 					}
-					}
+					else
-
-					if (include)
 					{
-						divisors[batchSize++] = current;
+						divisors[batchSize++] = divisor;
+					}
+				}
+				else
+				{
+					divisors[batchSize++] = divisor;
 				}
 
-					if (next <= current)
+				next = divisor + 2UL;
+				if (next <= divisor)
 				{
 					reachedEndInBatch = true;
 					break;
@@ -174,14 +180,14 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester
 				break;
 			}
 
-				Span<MontgomeryDivisorData> divisorDataSpan = divisorData.AsSpan(0, batchSize);
+			divisorDataSpan = divisorData.AsSpan(0, batchSize);
-				var divisorView = divisorsBuffer.View.SubView(0, batchSize);
+			divisorView = divisorsBuffer.View.SubView(0, batchSize);
-				var hitsView = hitsBuffer.View.SubView(0, batchSize);
+			hitsView = hitsBuffer.View.SubView(0, batchSize);
 
-				Span<ulong> divisorSpan = divisors.AsSpan(0, batchSize);
+			divisorSpan = divisors.AsSpan(0, batchSize);
-				Span<byte> hitsSpan = hits.AsSpan(0, batchSize);
+			hitsSpan = hits.AsSpan(0, batchSize);
 
-				for (int i = 0; i < batchSize; i++)
+			for (i = 0; i < batchSize; i++)
 			{
 				divisorDataSpan[i] = CreateMontgomeryDivisorData(divisorSpan[i]);
 			}
@@ -189,12 +195,10 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester
 			divisorView.CopyFromCPU(ref MemoryMarshal.GetReference(divisorDataSpan), batchSize);
 			kernel(batchSize, prime, divisorView, hitsView);
 			accelerator.Synchronize();
-
 			hitsView.CopyToCPU(ref MemoryMarshal.GetReference(hitsSpan), batchSize);
 
-				for (int i = 0; i < batchSize; i++)
+			for (i = 0; i < batchSize; i++)
 			{
-					lastProcessed = divisorSpan[i];
 				if (hitsSpan[i] != 0)
 				{
 					composite = true;
@@ -202,7 +206,7 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester
 				}
 			}
 
-				ReportStatus(lastProcessed);
+			ReportStatus(divisorSpan[i < batchSize ? i : i - 1]);
 			if (composite)
 			{
 				break;
@@ -216,16 +220,13 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester
 		}
 
 		coveredRange = composite || processedAll || divisor > allowedMax;
-		}
+
-		finally
-		{
 		ArrayPool<byte>.Shared.Return(hits, clearArray: true);
 		ArrayPool<ulong>.Shared.Return(divisors, clearArray: true);
 		ArrayPool<MontgomeryDivisorData>.Shared.Return(divisorData, clearArray: true);
 		hitsBuffer.Dispose();
 		divisorsBuffer.Dispose();
 		gpuLease.Dispose();
-		}
 
 		return composite;
 	}
@@ -317,7 +318,6 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester
 			}
 
 			int offset = 0;
-			int consoleStatus = 0;
 			MersenneNumberDivisorByDivisorGpuTester owner = _owner;
 			int gpuBatchSize = owner._gpuBatchSize;
 			bool useCycles = owner._useDivisorCycles;
@@ -335,23 +335,17 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester
 			MersenneDivisorCycles? divisorCycles = useCycles ? MersenneDivisorCycles.Shared : null;
 			ulong cycle = useCycles ? divisorCycles!.GetCycle(divisor) : 0UL, primeValue;
 			MontgomeryDivisorData divisorData = CreateMontgomeryDivisorData(divisor);
-                        Span<ulong> primeSpan = Span<ulong>.Empty;
+			Span<ulong> primeSpan = [];
-                        Span<int> indexSpan = Span<int>.Empty;
+			ReadOnlySpan<ulong> primesSlice;
-                        Span<byte> hitSpan = Span<byte>.Empty;
+			Span<int> indexSpan = [];
+			Span<byte> hitSpan = [];
 			Span<byte> hitsSlice;
 			int batchSize, currentSpanSize = -1, gpuCount, i, primesLength = primes.Length;
 
 			while (offset < primesLength)
 			{
 				batchSize = Math.Min(gpuBatchSize, primesLength - offset);
-                                ReadOnlySpan<ulong> primesSlice = primes.Slice(offset, batchSize);
+				primesSlice = primes.Slice(offset, batchSize);
-
-                                if (++consoleStatus == PerfectNumberConstants.ConsoleInterval)
-                                {
-                                        Console.WriteLine($"...processed by-divisor candidate = {primesSlice[0]}");
-                                        consoleStatus = 0;
-                                }
-
 				hitsSlice = hits.Slice(offset, batchSize);
 
 				if (useCycles)
@@ -364,8 +358,6 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester
 						currentSpanSize = batchSize;
 					}
 
-                                        ref ulong primesSpanRef = ref MemoryMarshal.GetReference(primeSpan);
-                                        ref byte hitSpanRef = ref MemoryMarshal.GetReference(hitSpan);
 					gpuCount = 0;
 
 					for (i = 0; i < batchSize; i++)
@@ -387,11 +379,11 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester
 						primesView = primesBufferView.SubView(0, gpuCount);
 						hitsView = hitsBufferView.SubView(0, gpuCount);
 
-                                                primesView.CopyFromCPU(ref primesSpanRef, gpuCount);
+						primesView.CopyFromCPU(ref MemoryMarshal.GetReference(primeSpan), gpuCount);
 						kernel(gpuCount, divisorData, primesView, hitsView);
 						accelerator.Synchronize();
 
-                                                hitsView.CopyToCPU(ref hitSpanRef, gpuCount);
+						hitsView.CopyToCPU(ref MemoryMarshal.GetReference(hitSpan), gpuCount);
 						for (i = 0; i < gpuCount; i++)
 						{
 							hitsSlice[indexSpan[i]] = hitSpan[i];
@@ -403,8 +395,7 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester
 					primesView = primesBufferView.SubView(0, batchSize);
 					hitsView = hitsBufferView.SubView(0, batchSize);
 
-                                        ref ulong primesSliceRef = ref MemoryMarshal.GetReference(primesSlice);
+					primesView.CopyFromCPU(ref MemoryMarshal.GetReference(primesSlice), batchSize);
-                                        primesView.CopyFromCPU(ref primesSliceRef, batchSize);
 					kernel(batchSize, divisorData, primesView, hitsView);
 					accelerator.Synchronize();