296 lines
9.6 KiB
C#
296 lines
9.6 KiB
C#
using System.IO;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using FluentAssertions;
|
|
using PerfectNumbers.Core;
|
|
using PerfectNumbers.Core.Cpu;
|
|
using PerfectNumbers.Core.Gpu;
|
|
using Xunit;
|
|
using UInt128 = System.UInt128;
|
|
|
|
namespace PerfectNumbers.Core.Tests;
|
|
|
|
public class MersenneNumberResidueGpuTesterTests
|
|
{
|
|
private static bool LastDigitIsSeven(ulong exponent) => (exponent & 3UL) == 3UL;
|
|
|
|
[Theory]
|
|
[InlineData(false)]
|
|
[InlineData(true)]
|
|
[Trait("Category", "Fast")]
|
|
public void Scan_handles_various_prime_exponents(bool useGpuOrder)
|
|
{
|
|
var tester = new MersenneNumberResidueGpuTester(useGpuOrder);
|
|
|
|
RunCase(tester, 23UL, 2UL, expectedPrime: false);
|
|
RunCase(tester, 29UL, 37UL, expectedPrime: false);
|
|
RunCase(tester, 31UL, 1_000UL, expectedPrime: true);
|
|
RunCase(tester, 89UL, 1_001UL, expectedPrime: true);
|
|
RunCase(tester, 107UL, 1_001UL, expectedPrime: true);
|
|
RunCase(tester, 127UL, 1_001UL, expectedPrime: true);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(false)]
|
|
[InlineData(true)]
|
|
[Trait("Category", "Fast")]
|
|
public void Gpu_residue_scan_matches_cpu_for_small_configurations(bool useGpuOrder)
|
|
{
|
|
var gpuTester = new MersenneNumberResidueGpuTester(useGpuOrder);
|
|
var cpuTester = new MersenneNumberResidueCpuTester();
|
|
|
|
var configurations = new (ulong Exponent, UInt128 PerSetLimit, UInt128 SetCount, UInt128 OverallLimit)[]
|
|
{
|
|
(31UL, 8UL, 6UL, 48UL),
|
|
(61UL, 9UL, 9UL, 81UL),
|
|
(89UL, 12UL, 8UL, 96UL),
|
|
(107UL, 16UL, 8UL, 128UL),
|
|
};
|
|
|
|
foreach (var (exponent, perSetLimit, setCount, overallLimit) in configurations)
|
|
{
|
|
bool gpuPrime = true;
|
|
bool gpuExhausted = false;
|
|
gpuTester.Scan(
|
|
exponent,
|
|
(UInt128)exponent << 1,
|
|
LastDigitIsSeven(exponent),
|
|
perSetLimit,
|
|
setCount,
|
|
overallLimit,
|
|
ref gpuPrime,
|
|
ref gpuExhausted);
|
|
|
|
bool cpuPrime = true;
|
|
bool cpuExhausted = false;
|
|
cpuTester.Scan(
|
|
exponent,
|
|
(UInt128)exponent << 1,
|
|
LastDigitIsSeven(exponent),
|
|
perSetLimit,
|
|
setCount,
|
|
overallLimit,
|
|
ref cpuPrime,
|
|
ref cpuExhausted);
|
|
|
|
gpuPrime.Should().Be(cpuPrime, $"GPU residue scan should match CPU for exponent {exponent}");
|
|
gpuExhausted.Should().Be(cpuExhausted, $"GPU residue scan should report identical exhaustion for exponent {exponent}");
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
[Trait("Category", "Fast")]
|
|
public void Scan_residue_gpu_handles_inaccurate_small_cycle_entries()
|
|
{
|
|
const ulong exponent = 23UL;
|
|
const ulong divisor = 47UL; // 47 | M_23
|
|
|
|
string tempPath = Path.GetTempFileName();
|
|
try
|
|
{
|
|
using (var writer = new BinaryWriter(File.Open(tempPath, FileMode.Create, FileAccess.Write, FileShare.Read)))
|
|
{
|
|
writer.Write(divisor);
|
|
writer.Write((ulong)uint.MaxValue);
|
|
}
|
|
|
|
var cycles = MersenneDivisorCycles.Shared;
|
|
var tableField = typeof(MersenneDivisorCycles).GetField("_table", BindingFlags.NonPublic | BindingFlags.Instance)!;
|
|
var smallCyclesField = typeof(MersenneDivisorCycles).GetField("_smallCycles", BindingFlags.NonPublic | BindingFlags.Instance)!;
|
|
|
|
var originalTable = ((List<(ulong Divisor, ulong Cycle)>)tableField.GetValue(cycles)!).Select(x => x).ToList();
|
|
var originalSmall = (uint[]?)smallCyclesField.GetValue(cycles);
|
|
uint[]? backupSmall = originalSmall is null ? null : (uint[])originalSmall.Clone();
|
|
|
|
cycles.LoadFrom(tempPath);
|
|
GpuContextPool.DisposeAll();
|
|
|
|
try
|
|
{
|
|
var tester = new MersenneNumberResidueGpuTester(useGpuOrder: false);
|
|
|
|
bool isPrime = true;
|
|
bool exhausted = false;
|
|
|
|
tester.Scan(
|
|
exponent,
|
|
(UInt128)exponent << 1,
|
|
lastIsSeven: true,
|
|
perSetLimit: (UInt128)10UL,
|
|
setCount: UInt128.One,
|
|
overallLimit: (UInt128)10UL,
|
|
ref isPrime,
|
|
ref exhausted);
|
|
|
|
isPrime.Should().BeFalse();
|
|
exhausted.Should().BeTrue();
|
|
}
|
|
finally
|
|
{
|
|
tableField.SetValue(cycles, originalTable);
|
|
smallCyclesField.SetValue(cycles, backupSmall);
|
|
GpuContextPool.DisposeAll();
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
File.Delete(tempPath);
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(false)]
|
|
[InlineData(true)]
|
|
[Trait("Category", "Fast")]
|
|
public void Mersenne_tester_residue_gpu_handles_known_primes_with_many_sets(bool useGpuOrder)
|
|
{
|
|
var tester = new MersenneNumberTester(
|
|
useIncremental: true,
|
|
useOrderCache: false,
|
|
kernelType: GpuKernelType.Pow2Mod,
|
|
useModuloWorkaround: false,
|
|
useOrder: false,
|
|
useGpuLucas: false,
|
|
useGpuScan: true,
|
|
useGpuOrder: useGpuOrder,
|
|
useResidue: true,
|
|
maxK: (UInt128)2_400_000UL,
|
|
residueDivisorSets: (UInt128)512UL);
|
|
|
|
try
|
|
{
|
|
bool isPrime = tester.IsMersennePrime(127UL, out bool divisorsExhausted);
|
|
|
|
isPrime.Should().BeTrue();
|
|
divisorsExhausted.Should().BeTrue();
|
|
}
|
|
finally
|
|
{
|
|
GpuContextPool.DisposeAll();
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(false)]
|
|
[InlineData(true)]
|
|
[Trait("Category", "Fast")]
|
|
public void Scan_recognizes_all_known_small_mersenne_primes(bool useGpuOrder)
|
|
{
|
|
var tester = new MersenneNumberResidueGpuTester(useGpuOrder);
|
|
|
|
foreach (ulong exponent in MersennePrimeTestData.Exponents)
|
|
{
|
|
RunCase(tester, exponent, 1UL, expectedPrime: true);
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(31UL)]
|
|
[Trait("Category", "Fast")]
|
|
public void Scan_matches_cli_residue_configuration_for_primes(ulong exponent)
|
|
{
|
|
RunCliCase(useGpuOrder: false, exponent);
|
|
RunCliCase(useGpuOrder: true, exponent);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(31UL, 1_024UL, 1UL)]
|
|
[InlineData(31UL, 256UL, 4UL)]
|
|
[InlineData(107UL, 512UL, 1UL)]
|
|
[InlineData(107UL, 128UL, 4UL)]
|
|
[InlineData(107UL, 15_625UL, 64UL)]
|
|
[InlineData(127UL, 512UL, 1UL)]
|
|
[InlineData(127UL, 128UL, 4UL)]
|
|
[Trait("Category", "Fast")]
|
|
public void Scan_handles_multiple_residue_sets_for_known_primes(ulong exponent, ulong perSetLimit, ulong setCount)
|
|
{
|
|
ulong overallLimit = perSetLimit * setCount;
|
|
|
|
RunCase(new MersenneNumberResidueGpuTester(useGpuOrder: false), exponent, perSetLimit, setCount, overallLimit, expectedPrime: true);
|
|
RunCase(new MersenneNumberResidueGpuTester(useGpuOrder: true), exponent, perSetLimit, setCount, overallLimit, expectedPrime: true);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(107UL, 1UL, 1_024UL)]
|
|
[Trait("Category", "Fast")]
|
|
public void Scan_handles_single_lane_sets_for_known_primes(ulong exponent, ulong perSetLimit, ulong overallLimit)
|
|
{
|
|
ulong setCount = overallLimit;
|
|
|
|
RunCase(new MersenneNumberResidueGpuTester(useGpuOrder: false), exponent, perSetLimit, setCount, overallLimit, expectedPrime: true);
|
|
RunCase(new MersenneNumberResidueGpuTester(useGpuOrder: true), exponent, perSetLimit, setCount, overallLimit, expectedPrime: true);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(false)]
|
|
[InlineData(true)]
|
|
[Trait("Category", "Fast")]
|
|
public void Scan_handles_multiple_sets_without_false_positives(bool useGpuOrder)
|
|
{
|
|
var tester = new MersenneNumberResidueGpuTester(useGpuOrder);
|
|
|
|
bool isPrime = true;
|
|
bool exhausted = false;
|
|
UInt128 perSetLimit = 1_666_667UL;
|
|
UInt128 setCount = 3UL;
|
|
UInt128 overallLimit = 5_000_000UL;
|
|
|
|
tester.Scan(
|
|
127UL,
|
|
(UInt128)127UL << 1,
|
|
LastDigitIsSeven(127UL),
|
|
perSetLimit,
|
|
setCount,
|
|
overallLimit,
|
|
ref isPrime,
|
|
ref exhausted);
|
|
|
|
isPrime.Should().BeTrue();
|
|
exhausted.Should().BeTrue();
|
|
|
|
isPrime = true;
|
|
exhausted = false;
|
|
perSetLimit = 20_000_000UL;
|
|
setCount = 5UL;
|
|
overallLimit = 100_000_000UL;
|
|
|
|
tester.Scan(
|
|
107UL,
|
|
(UInt128)107UL << 1,
|
|
LastDigitIsSeven(107UL),
|
|
perSetLimit,
|
|
setCount,
|
|
overallLimit,
|
|
ref isPrime,
|
|
ref exhausted);
|
|
|
|
isPrime.Should().BeTrue();
|
|
exhausted.Should().BeTrue();
|
|
}
|
|
|
|
private static void RunCliCase(bool useGpuOrder, ulong exponent)
|
|
{
|
|
var tester = new MersenneNumberResidueGpuTester(useGpuOrder);
|
|
RunCase(tester, exponent, 8UL, expectedPrime: true);
|
|
}
|
|
|
|
private static void RunCase(MersenneNumberResidueGpuTester tester, ulong exponent, ulong maxK, bool expectedPrime)
|
|
{
|
|
RunCase(tester, exponent, maxK, 1UL, maxK, expectedPrime);
|
|
}
|
|
|
|
private static void RunCase(
|
|
MersenneNumberResidueGpuTester tester,
|
|
ulong exponent,
|
|
ulong perSetLimit,
|
|
ulong setCount,
|
|
ulong overallLimit,
|
|
bool expectedPrime)
|
|
{
|
|
bool isPrime = true;
|
|
tester.Scan(exponent, (UInt128)exponent << 1, LastDigitIsSeven(exponent), (UInt128)maxK, ref isPrime);
|
|
isPrime.Should().Be(expectedPrime);
|
|
}
|
|
}
|
|
|