mlemanczyk/even-perfect-numbers-scanner
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #167 from mlemanczyk/codex/analyze-if-conditions-in-evenperfectbitscanner

Browse Source 
Document unreachable guards in GPU by-divisor pipeline
This commit is contained in:
Marek Lemańczyk authored and GitHub committed 2025-10-13 20:42:48 +02:00
2 parents 65e010ded5 f2eb6580c4
commit 305a489d6c
7 files changed
+292 -255
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

PerfectNumbers.Core/Cpu/MersenneNumberDivisorByDivisorCpuTester.cs
+122 -117
View File
@@ -3,6 +3,7 @@ using System.Buffers;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Numerics;
using System.Threading;
using PerfectNumbers.Core;
using PerfectNumbers.Core.Gpu;
@@ -10,14 +11,11 @@ namespace PerfectNumbers.Core.Cpu;
public sealed class MersenneNumberDivisorByDivisorCpuTester : IMersenneNumberDivisorByDivisorTester
{
private readonly object _sync = new();
private readonly ConcurrentBag<DivisorScanSession> _sessionPool = new();
private ulong _divisorLimit;
private ulong _lastStatusDivisor;
private int _lastStatusDivisor;
private bool _isConfigured;
private int _batchSize = 1_024;
private ulong _configuredMaxPrime;
private ByDivisorDeltasDevice _deltasDevice = ByDivisorDeltasDevice.Cpu;
private ByDivisorMontgomeryDevice _montgomeryDevice = ByDivisorMontgomeryDevice.Cpu;
@@ -34,79 +32,60 @@ public sealed class MersenneNumberDivisorByDivisorCpuTester : IMersenneNumberDiv
public ByDivisorDeltasDevice DeltasDevice
{
get => _deltasDevice;
set
{
lock (_sync)
{
_deltasDevice = value;
}
}
set => _deltasDevice = value;
}
public ByDivisorMontgomeryDevice MontgomeryDevice
{
get => _montgomeryDevice;
set
{
lock (_sync)
{
_montgomeryDevice = value;
}
}
set => _montgomeryDevice = value;
}
public void ConfigureFromMaxPrime(ulong maxPrime)
{
lock (_sync)
{
_configuredMaxPrime = maxPrime;
_divisorLimit = ComputeDivisorLimitFromMaxPrime(maxPrime);
_lastStatusDivisor = 0UL;
_isConfigured = true;
}
_divisorLimit = ComputeDivisorLimitFromMaxPrime(maxPrime);
_lastStatusDivisor = 0;
_isConfigured = true;
}
public ulong DivisorLimit
{
get
{
lock (_sync)
{
if (!_isConfigured)
{
throw new InvalidOperationException("ConfigureFromMaxPrime must be called before using the tester.");
}
// The by-divisor driver configures the tester during startup, so exposing the divisor limit never
// re-enters this method before initialization completes.
// if (!_isConfigured)
// {
// throw new InvalidOperationException("ConfigureFromMaxPrime must be called before using the tester.");
// }
return _divisorLimit;
}
return _divisorLimit;
}
}
public ulong GetAllowedMaxDivisor(ulong prime)
{
lock (_sync)
{
if (!_isConfigured)
{
throw new InvalidOperationException("ConfigureFromMaxPrime must be called before using the tester.");
}
// The CLI wires the tester through ConfigureFromMaxPrime before invoking query helpers, so the guard
// would never trigger in production runs.
// if (!_isConfigured)
// {
// throw new InvalidOperationException("ConfigureFromMaxPrime must be called before using the tester.");
// }
return ComputeAllowedMaxDivisor(prime, _divisorLimit);
}
return ComputeAllowedMaxDivisor(prime, _divisorLimit);
}
public bool IsPrime(ulong prime, out bool divisorsExhausted, TimeSpan? timeLimit = null)
{
ulong allowedMax;
lock (_sync)
{
if (!_isConfigured)
{
throw new InvalidOperationException("ConfigureFromMaxPrime must be called before using the tester.");
}
// The tester is configured once during startup, so runtime IsPrime calls always observe a ready
// configuration and the legacy guard can remain commented out.
// if (!_isConfigured)
// {
// throw new InvalidOperationException("ConfigureFromMaxPrime must be called before using the tester.");
// }
allowedMax = ComputeAllowedMaxDivisor(prime, _divisorLimit);
}
ulong divisorLimit = _divisorLimit;
ulong allowedMax = ComputeAllowedMaxDivisor(prime, divisorLimit);
if (allowedMax < 3UL)
{
@@ -128,10 +107,7 @@ public sealed class MersenneNumberDivisorByDivisorCpuTester : IMersenneNumberDiv
if (processedCount > 0UL)
{
lock (_sync)
{
UpdateStatusUnsafe(processedCount);
}
UpdateStatusUnsafe(processedCount);
}
if (composite)
@@ -146,22 +122,21 @@ public sealed class MersenneNumberDivisorByDivisorCpuTester : IMersenneNumberDiv
public void PrepareCandidates(ReadOnlySpan<ulong> primes, Span<ulong> allowedMaxValues)
{
if (allowedMaxValues.Length < primes.Length)
{
throw new ArgumentException("allowedMaxValues span must be at least as long as primes span.", nameof(allowedMaxValues));
}
// EvenPerfectBitScanner always provides equally sized spans here, so the historical guard never triggers.
// if (allowedMaxValues.Length < primes.Length)
// {
// throw new ArgumentException("allowedMaxValues span must be at least as long as primes span.", nameof(allowedMaxValues));
// }
ulong divisorLimit;
// PrepareCandidates is scheduled only after ConfigureFromMaxPrime succeeds, so the tester state is
// stable here and the defensive guard is no longer needed.
// if (!_isConfigured)
// {
// throw new InvalidOperationException("ConfigureFromMaxPrime must be called before using the tester.");
// }
lock (_sync)
{
if (!_isConfigured)
{
throw new InvalidOperationException("ConfigureFromMaxPrime must be called before using the tester.");
}
divisorLimit = _divisorLimit;
}
// Configuration is immutable after startup, so reading the cached limit does not require locking.
ulong divisorLimit = _divisorLimit;
for (int index = 0; index < primes.Length; index++)
{
@@ -171,21 +146,20 @@ public sealed class MersenneNumberDivisorByDivisorCpuTester : IMersenneNumberDiv
public IMersenneNumberDivisorByDivisorTester.IDivisorScanSession CreateDivisorSession()
{
lock (_sync)
// The session pool is populated only after configuration, so consumers never request a session before
// ConfigureFromMaxPrime completes.
// if (!_isConfigured)
// {
// throw new InvalidOperationException("ConfigureFromMaxPrime must be called before using the tester.");
// }
if (_sessionPool.TryTake(out DivisorScanSession? session))
{
if (!_isConfigured)
{
throw new InvalidOperationException("ConfigureFromMaxPrime must be called before using the tester.");
}
if (_sessionPool.TryTake(out DivisorScanSession? session))
{
session.Reset();
return session;
}
return new DivisorScanSession(this);
session.Reset();
return session;
}
return new DivisorScanSession(this);
}
private void ReturnSession(DivisorScanSession session)
@@ -236,11 +210,12 @@ public sealed class MersenneNumberDivisorByDivisorCpuTester : IMersenneNumberDiv
}
UInt128 step = (UInt128)prime << 1;
if (step == UInt128.Zero)
{
processedAll = true;
return false;
}
// EvenPerfectBitScanner only supplies primes greater than one here, so the shifted step never becomes zero.
// if (step == UInt128.Zero)
// {
// processedAll = true;
// return false;
// }
UInt128 limit = allowedMax;
UInt128 divisor = step + UInt128.One;
@@ -323,6 +298,7 @@ public sealed class MersenneNumberDivisorByDivisorCpuTester : IMersenneNumberDiv
if (divisorCycle == 0UL)
{
// Keep this guard active to surface mismatches between generated candidates and the snapshot cache.
Console.WriteLine($"Divisor cycle was not calculated for {prime}");
}
}
@@ -369,11 +345,13 @@ public sealed class MersenneNumberDivisorByDivisorCpuTester : IMersenneNumberDiv
GpuUInt128 step128 = new GpuUInt128(prime);
step128.ShiftLeft(1);
if (step128.IsZero)
{
processedAll = true;
return false;
}
// Primes above one yield a non-zero 2p value even after widening to GpuUInt128, so the defensive
// zero guard remains commented out to document the invariant without branching.
// if (step128.IsZero)
// {
// processedAll = true;
// return false;
// }
GpuUInt128 limit128 = new GpuUInt128(allowedMax);
GpuUInt128 divisor128 = step128;
@@ -449,10 +427,12 @@ public sealed class MersenneNumberDivisorByDivisorCpuTester : IMersenneNumberDiv
int chunkCount = remainingCandidates > (ulong)batchCapacity
? batchCapacity
: (int)remainingCandidates;
if (chunkCount <= 0)
{
break;
}
// batchCapacity and remainingCandidates are strictly positive in this path, so the zero-count
// shortcut never executes on production scans.
// if (chunkCount <= 0)
// {
// break;
// }
Span<ulong> candidateSpan = candidateBuffer.AsSpan(0, chunkCount);
Span<byte> maskSpan = maskBuffer.AsSpan(0, chunkCount);
@@ -603,17 +583,34 @@ public sealed class MersenneNumberDivisorByDivisorCpuTester : IMersenneNumberDiv
return;
}
ulong interval = PerfectNumberConstants.ConsoleInterval;
if (interval == 0UL)
int interval = PerfectNumberConstants.ConsoleInterval;
// PerfectNumberConstants.ConsoleInterval is a positive constant, so this guard never triggers on EvenPerfectBitScanner.
// if (interval <= 0)
// {
// Volatile.Write(ref _lastStatusDivisor, 0);
// return;
// }
int processedDelta = (int)(processedCount % (uint)interval);
if (processedDelta == 0)
{
_lastStatusDivisor = 0UL;
return;
}
ulong total = _lastStatusDivisor + processedCount;
// TODO: Replace this modulo with the ring-buffer style counter (subtract loop) used in the fast CLI
// status benchmarks so we avoid `%` in this hot loop while still wrapping progress correctly.
_lastStatusDivisor = total % interval;
while (true)
{
int previous = Volatile.Read(ref _lastStatusDivisor);
int total = previous + processedDelta;
if (total >= interval)
{
total -= interval;
}
if (previous == Interlocked.CompareExchange(ref _lastStatusDivisor, total, previous))
{
return;
}
}
}
private static ulong ComputeDivisorLimitFromMaxPrime(ulong maxPrime)
@@ -696,11 +693,14 @@ public sealed class MersenneNumberDivisorByDivisorCpuTester : IMersenneNumberDiv
}
ulong modulus = effectiveDivisorData.Modulus;
if (modulus <= 1UL || (modulus & 1UL) == 0UL)
{
hits.Clear();
return;
}
// EvenPerfectBitScanner only schedules odd divisors greater than one, and the fallback
// above rebuilds Montgomery data when the modulus mismatches, so this guard never
// triggers for production scans.
// if (modulus <= 1UL || (modulus & 1UL) == 0UL)
// {
// hits.Clear();
// return;
// }
if (divisorCycle == 0UL)
{
@@ -803,10 +803,12 @@ public sealed class MersenneNumberDivisorByDivisorCpuTester : IMersenneNumberDiv
private void EnsureCapacity(int requiredLength)
{
if (requiredLength <= 0)
{
return;
}
// Prime batches are never empty on the by-divisor scanner path, so the zero-length guard stays commented
// out to remove the redundant branch.
// if (requiredLength <= 0)
// {
// return;
// }
// Sessions release pooled buffers between scans; a single null check covers every array because buffers are rented and returned together.
if (requiredLength <= _bufferCapacity && _primeDeltas is not null)
@@ -817,7 +819,7 @@ public sealed class MersenneNumberDivisorByDivisorCpuTester : IMersenneNumberDiv
int newCapacity = _bufferCapacity;
if (newCapacity == 0)
{
// Fresh sessions start without buffers; seed the first rent with a single-slot array.
// EvenPerfectBitScanner hits this branch on the first batch of each session, so keep the seed allocation.
newCapacity = 1;
}
@@ -873,11 +875,13 @@ public sealed class MersenneNumberDivisorByDivisorCpuTester : IMersenneNumberDiv
private static void ComputeCycleRemainders(ulong cycleLength, ReadOnlySpan<ulong> primes, ReadOnlySpan<ulong> deltas, Span<ulong> remainders)
{
if (cycleLength == 0UL || primes.Length == 0)
{
remainders.Clear();
return;
}
// Divisor cycles are validated before reaching the GPU helper, and prime batches are non-empty, so
// the defensive zero checks remain commented out here.
// if (cycleLength == 0UL || primes.Length == 0)
// {
// remainders.Clear();
// return;
// }
ulong remainder = primes[0] % cycleLength;
remainders[0] = remainder;
@@ -893,6 +897,7 @@ public sealed class MersenneNumberDivisorByDivisorCpuTester : IMersenneNumberDiv
{
if (modulus == 0UL)
{
// A zero modulus indicates a missing cycle entry; preserve the fallback so snapshot regressions remain visible.
return 0UL;
}
PerfectNumbers.Core/Gpu/MersenneNumberDivisorByDivisorGpuTester.cs
+94 -91
View File
@@ -19,7 +19,6 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
private const int RemainderSlotCount = 4;
private int _gpuBatchSize = GpuConstants.ScanBatchSize;
private readonly object _sync = new();
private ulong _divisorLimit;
private bool _isConfigured;
@@ -64,34 +63,30 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
public void ConfigureFromMaxPrime(ulong maxPrime)
{
lock (_sync)
{
_divisorLimit = ComputeDivisorLimitFromMaxPrime(maxPrime);
_isConfigured = true;
}
// Configuration happens once during startup, so no synchronization is required to cache the divisor limit.
_divisorLimit = ComputeDivisorLimitFromMaxPrime(maxPrime);
_isConfigured = true;
}
public bool IsPrime(ulong prime, out bool divisorsExhausted, TimeSpan? timeLimit = null)
{
ulong allowedMax;
int batchCapacity;
// The CLI always configures the tester during startup, so the historical guard is commented out to avoid branching.
// if (!_isConfigured)
// {
// throw new InvalidOperationException("ConfigureFromMaxPrime must be called before using the tester.");
// }
lock (_sync)
{
if (!_isConfigured)
{
throw new InvalidOperationException("ConfigureFromMaxPrime must be called before using the tester.");
}
// Configuration is immutable, so the cached values can be read without locking.
ulong allowedMax = ComputeAllowedMaxDivisor(prime, _divisorLimit);
int batchCapacity = _gpuBatchSize;
allowedMax = ComputeAllowedMaxDivisor(prime, _divisorLimit);
batchCapacity = _gpuBatchSize;
}
if (allowedMax < 3UL)
{
divisorsExhausted = true;
return true;
}
// The GPU path always receives an allowed maximum well above the minimal divisor, so the legacy
// guard stays commented out to document the invariant without branching.
// if (allowedMax < 3UL)
// {
// divisorsExhausted = true;
// return true;
// }
bool composite;
bool coveredRange;
@@ -155,18 +150,14 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
throw new ArgumentException("allowedMaxValues span must be at least as long as primes span.", nameof(allowedMaxValues));
}
ulong divisorLimit;
lock (_sync)
{
if (!_isConfigured)
{
throw new InvalidOperationException("ConfigureFromMaxPrime must be called before using the tester.");
}
divisorLimit = _divisorLimit;
}
// The GPU pipeline calls ConfigureFromMaxPrime before preparing candidates, so the legacy guard
// remains commented out to document the invariant without branching.
// if (!_isConfigured)
// {
// throw new InvalidOperationException("ConfigureFromMaxPrime must be called before using the tester.");
// }
ulong divisorLimit = _divisorLimit;
for (int index = 0; index < primes.Length; index++)
{
allowedMaxValues[index] = ComputeAllowedMaxDivisor(primes[index], divisorLimit);
@@ -222,7 +213,8 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
ArrayView1D<ulong, Stride1D.Dense> exponentView;
ArrayView1D<byte, Stride1D.Dense> hitsView;
cycleCapacity = Math.Max(1, cycleCapacity);
// Batch resources expose a positive cycle capacity, so skip the redundant clamp here.
// cycleCapacity = Math.Max(1, cycleCapacity);
int chunkCapacity = Math.Min(batchCapacity, cycleCapacity);
int maxThreadsPerGroup = (int)accelerator.MaxNumThreadsPerGroup;
@@ -231,20 +223,22 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
chunkCapacity = Math.Min(chunkCapacity, maxThreadsPerGroup);
}
if (chunkCapacity <= 0)
{
chunkCapacity = cycleCapacity;
}
// cycleCapacity already bounds chunkCapacity above zero, so the fallback would never execute.
// if (chunkCapacity <= 0)
// {
// chunkCapacity = cycleCapacity;
// }
ulong[] filteredDivisors = ArrayPool<ulong>.Shared.Rent(chunkCapacity);
ulong[] divisorGaps = ArrayPool<ulong>.Shared.Rent(chunkCapacity);
UInt128 twoP128 = (UInt128)prime << 1;
if (twoP128 == UInt128.Zero)
{
coveredRange = true;
return false;
}
// Primes above one yield a non-zero 2p value, so the legacy zero guard remains commented out.
// if (twoP128 == UInt128.Zero)
// {
// coveredRange = true;
// return false;
// }
UInt128 allowedMax128 = allowedMax;
UInt128 firstDivisor128 = twoP128 + UInt128.One;
@@ -255,11 +249,13 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
}
UInt128 maxK128 = (allowedMax128 - UInt128.One) / twoP128;
if (maxK128 == UInt128.Zero)
{
coveredRange = true;
return false;
}
// Once the first divisor falls within the allowed range, at least one multiplier k is admissible,
// so keep the defensive zero check commented out.
// if (maxK128 == UInt128.Zero)
// {
// coveredRange = true;
// return false;
// }
ulong maxK = maxK128 > ulong.MaxValue ? ulong.MaxValue : (ulong)maxK128;
ulong currentK = 1UL;
@@ -301,10 +297,12 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
chunkCount = (int)remainingK;
}
if (chunkCount <= 0)
{
break;
}
// chunkCapacity and the remaining multiplier range are strictly positive here, so the zero
// chunk fallback never triggers on production scans.
// if (chunkCount <= 0)
// {
// break;
// }
Span<ulong> candidateSpan = cycleCandidates.AsSpan(0, chunkCount);
Span<ulong> gapSpan = divisorGaps.AsSpan(0, chunkCount);
@@ -465,10 +463,12 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
Action<Index1D, ArrayView<ulong>, ArrayView<byte>, byte> deltaKernel,
Action<KernelConfig, Index1D, ArrayView<byte>, ArrayView<byte>, byte, byte> scanKernel)
{
if (count <= 0)
{
return;
}
// GPU batches always contain at least one divisor gap, so the empty-count guard remains commented
// to eliminate redundant branching.
// if (count <= 0)
// {
// return;
// }
deltaKernel(count, gapView, deltaView, modulus);
SharedMemoryConfig sharedMemoryConfig = SharedMemoryConfig.RequestDynamic<int>(count);
@@ -491,11 +491,13 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
Span<byte> destination,
Action<Index1D, ArrayView<byte>, ArrayView<byte>, ArrayView<byte>, ArrayView<byte>, byte, ArrayView<byte>> maskKernel)
{
if (count <= 0)
{
destination.Clear();
return;
}
// Candidate batches always provide at least one entry, so the zero-count guard stays commented out
// to avoid clearing spans unnecessarily.
// if (count <= 0)
// {
// destination.Clear();
// return;
// }
maskKernel(count, remainder10View, remainder8View, remainder5View, remainder3View, lastIsSevenFlag, maskView);
maskView.CopyToCPU(ref MemoryMarshal.GetReference(destination), count);
@@ -503,10 +505,12 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
private static byte FetchLastRemainder(ArrayView1D<byte, Stride1D.Dense> remainderView, int count)
{
if (count <= 0)
{
return 0;
}
// Kernels always process at least one remainder in this path, so the empty-span guard remains
// commented to document the invariant.
// if (count <= 0)
// {
// return 0;
// }
byte value = 0;
remainderView.SubView(count - 1, 1).CopyToCPU(ref value, 1);
@@ -519,10 +523,11 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
if (result >= modulus)
{
result -= modulus;
if (result >= modulus)
{
result %= modulus;
}
// The step deltas remain below the modulus, so a single subtraction suffices on this path.
// if (result >= modulus)
// {
// result %= modulus;
// }
}
return (byte)result;
@@ -933,34 +938,32 @@ public sealed class MersenneNumberDivisorByDivisorGpuTester : IMersenneNumberDiv
public ulong GetAllowedMaxDivisor(ulong prime)
{
lock (_sync)
{
if (!_isConfigured)
{
throw new InvalidOperationException("ConfigureFromMaxPrime must be called before using the tester.");
}
// The CLI configures the GPU tester once at startup, so callers never request divisor limits before
// initialization completes.
// if (!_isConfigured)
// {
// throw new InvalidOperationException("ConfigureFromMaxPrime must be called before using the tester.");
// }
return ComputeAllowedMaxDivisor(prime, _divisorLimit);
}
return ComputeAllowedMaxDivisor(prime, _divisorLimit);
}
public DivisorScanSession CreateDivisorSession()
{
lock (_sync)
// Divisor sessions are handed out only after configuration, so this guard would never trigger on the
// production path.
// if (!_isConfigured)
// {
// throw new InvalidOperationException("ConfigureFromMaxPrime must be called before using the tester.");
// }
if (_sessionPool.TryTake(out DivisorScanSession? session))
{
if (!_isConfigured)
{
throw new InvalidOperationException("ConfigureFromMaxPrime must be called before using the tester.");
}
if (_sessionPool.TryTake(out DivisorScanSession? session))
{
session.Reset();
return session;
}
return new DivisorScanSession(this);
session.Reset();
return session;
}
return new DivisorScanSession(this);
}
IMersenneNumberDivisorByDivisorTester.IDivisorScanSession IMersenneNumberDivisorByDivisorTester.CreateDivisorSession() => CreateDivisorSession();
PerfectNumbers.Core/Gpu/MersenneNumberDivisorCandidateGpuEvaluator.cs
+21 -10
View File
@@ -68,12 +68,17 @@ internal sealed class MersenneNumberDivisorCandidateGpuEvaluator : IDisposable
}
int count = candidates.Length;
if (count == 0)
{
return;
}
// Candidate batches always carry at least one divisor on the by-divisor path, so the empty-count
// guard remains commented out to eliminate the branch.
// if (count == 0)
// {
// return;
// }
EnsureCapacity(count);
if (count > _capacity)
{
EnsureCapacity(count);
}
Span<ulong> hostCandidateSpan = _hostCandidates.AsSpan(0, count);
Span<byte> hostMaskSpan = _hostMask.AsSpan(0, count);
@@ -115,7 +120,12 @@ internal sealed class MersenneNumberDivisorCandidateGpuEvaluator : IDisposable
return;
}
int newCapacity = _capacity == 0 ? 1 : _capacity;
int newCapacity = _capacity;
// The evaluator always starts with a positive capacity, so the zero-capacity fallback remains commented.
// if (newCapacity == 0)
// {
// newCapacity = 1;
// }
while (newCapacity < required)
{
newCapacity <<= 1;
@@ -188,10 +198,11 @@ internal sealed class MersenneNumberDivisorCandidateGpuEvaluator : IDisposable
private static int ComputeRemainder(byte remainder, byte step, int index, int modulus)
{
if (modulus == 0)
{
return 0;
}
// Modulus lookups only cover {10, 8, 5, 3, 7, 11}, so the zero-modulus guard stays commented out.
// if (modulus == 0)
// {
// return 0;
// }
long value = remainder;
value += (long)step * index;
PerfectNumbers.Core/Gpu/MersenneNumberDivisorMontgomeryGpuBuilder.cs
+12 -5
View File
@@ -54,10 +54,12 @@ internal sealed class MersenneNumberDivisorMontgomeryGpuBuilder : IDisposable
}
int length = moduli.Length;
if (length == 0)
{
return;
}
// Montgomery batches always include at least one modulus on the by-divisor path, so the empty-length
// guard stays commented out to avoid branching.
// if (length == 0)
// {
// return;
// }
EnsureCapacity(length);
@@ -83,7 +85,12 @@ internal sealed class MersenneNumberDivisorMontgomeryGpuBuilder : IDisposable
return;
}
int newCapacity = _capacity == 0 ? 1 : _capacity;
int newCapacity = _capacity;
// The builder always starts with a positive capacity, so the zero-capacity fallback remains commented.
// if (newCapacity == 0)
// {
// newCapacity = 1;
// }
while (newCapacity < required)
{
newCapacity <<= 1;
PerfectNumbers.Core/Gpu/MersenneNumberDivisorRemainderGpuStepper.cs
+24 -18
View File
@@ -52,7 +52,7 @@ internal sealed class MersenneNumberDivisorRemainderGpuStepper : IDisposable
{
if (_disposed)
{
return;
throw new InvalidOperationException("MersenneNumberDivisorRemainderGpuStepper was disposed more than once.");
}
_disposed = true;
@@ -71,15 +71,18 @@ internal sealed class MersenneNumberDivisorRemainderGpuStepper : IDisposable
throw new ObjectDisposedException(nameof(MersenneNumberDivisorRemainderGpuStepper));
}
if (advanceCount <= 0 || remainders.Length == 0)
{
return;
}
// GPU remainder batches always advance by a positive chunk count and operate on fixed-size tables, so
// the defensive early-return remains commented out.
// if (advanceCount <= 0 || remainders.Length == 0)
// {
// return;
// }
if (remainders.Length != _length)
{
throw new ArgumentException("Remainder buffer length must match the configured length.");
}
// Production code always calls the stepper with a fixed-length table, so the historical length guard stays commented.
// if (remainders.Length != _length)
// {
// throw new ArgumentException("Remainder buffer length must match the configured length.");
// }
Span<byte> hostRemainderSpan = _hostRemainders.AsSpan(0, _length);
remainders.CopyTo(hostRemainderSpan);
@@ -99,17 +102,20 @@ internal sealed class MersenneNumberDivisorRemainderGpuStepper : IDisposable
private static void AdvanceRemaindersKernel(Index1D index, int advanceCount, ArrayView<byte> remainders, ArrayView<byte> steps, ArrayView<byte> results)
{
int idx = index;
if (idx >= remainders.Length)
{
return;
}
// Kernel launches match the remainder table length, so the bounds guard stays commented to avoid redundant branching.
// if (idx >= remainders.Length)
// {
// return;
// }
int modulus = GetModulus(idx);
if (modulus == 0)
{
results[idx] = remainders[idx];
return;
}
// The modulus selector only emits positive bases (10, 8, 5, 3, 7, 11) for the configured indices, so the zero-modulus
// fallback remains commented out.
// if (modulus == 0)
// {
// results[idx] = remainders[idx];
// return;
// }
int remainder = remainders[idx] % modulus;
int step = steps[idx] % modulus;
PerfectNumbers.Core/Gpu/MersenneNumberDivisorResidueGpuEvaluator.cs
+12 -9
View File
@@ -33,7 +33,7 @@ internal sealed class MersenneNumberDivisorResidueGpuEvaluator : IDisposable
{
if (_disposed)
{
return;
throw new InvalidOperationException("MersenneNumberDivisorResidueGpuEvaluator was disposed more than once.");
}
_disposed = true;
@@ -51,10 +51,12 @@ internal sealed class MersenneNumberDivisorResidueGpuEvaluator : IDisposable
}
int length = exponents.Length;
if (length == 0)
{
return;
}
// Residue batches always include at least one exponent when scheduled from the by-divisor scanner, so
// the empty-length guard remains commented out to avoid branching.
// if (length == 0)
// {
// return;
// }
EnsureCapacity(length);
@@ -79,10 +81,11 @@ internal sealed class MersenneNumberDivisorResidueGpuEvaluator : IDisposable
}
int newCapacity = _capacity;
if (newCapacity == 0)
{
newCapacity = 1;
}
// The evaluator always starts with a positive capacity, so the zero-capacity fallback stays commented.
// if (newCapacity == 0)
// {
// newCapacity = 1;
// }
while (newCapacity < required)
{
PerfectNumbers.Core/MersenneNumberDivisorByDivisorTester.cs
+7 -5
View File
@@ -180,11 +180,13 @@ public static class MersenneNumberDivisorByDivisorTester
return;
}
if (maxPrime <= 1UL)
{
Console.WriteLine("The filter specified by --filter-p must contain at least one prime exponent greater than 1 for --mersenne=bydivisor.");
return;
}
// EvenPerfectBitScanner removes candidates <= 1 before reaching this point,
// so this guard never triggers during production runs.
// if (maxPrime <= 1UL)
// {
// Console.WriteLine("The filter specified by --filter-p must contain at least one prime exponent greater than 1 for --mersenne=bydivisor.");
// return;
// }
tester.ConfigureFromMaxPrime(maxPrime);