Add GPU kernel for small prime factoring

PerfectNumbers.Core/PrimeOrderCalculator.Gpu.cs

@@ -1,3 +1,8 @@
+using System;
+using System.Runtime.InteropServices;
+using ILGPU;
+using ILGPU.Runtime;
+using ILGPU.Runtime.OpenCL;
 using PerfectNumbers.Core.Gpu;
 
 namespace PerfectNumbers.Core;
@@ -16,30 +21,88 @@ internal static partial class PrimeOrderCalculator
                 Span<int> exponentBuffer = exponentBufferArray.AsSpan(0, GpuSmallPrimeFactorSlots);
                 primeBuffer.Clear();
                 exponentBuffer.Clear();
+                remaining = value;
 
-                if (!PrimeOrderGpuHeuristics.TryPartialFactor(value, limit, primeBuffer, exponentBuffer, out int factorCount, out ulong gpuRemaining, out _))
+                try
+                {
+                        var lease = GpuKernelPool.GetKernel(useGpuOrder: true);
+                        try
+                        {
+                                var execution = lease.EnterExecutionScope();
+                                try
+                                {
+                                        Accelerator accelerator = lease.Accelerator;
+                                        AcceleratorStream stream = lease.Stream;
+
+                                        SmallPrimeFactorTables tables = GpuKernelPool.EnsureSmallPrimeFactorTables(accelerator);
+                                        SmallPrimeFactorScratch scratch = GpuKernelPool.EnsureSmallPrimeFactorScratch(accelerator, GpuSmallPrimeFactorSlots);
+                                        scratch.Clear();
+
+                                        var kernel = lease.SmallPrimeFactorKernel;
+                                        kernel(
+                                            stream,
+                                            1,
+                                            value,
+                                            limit,
+                                            tables.PrimesView,
+                                            tables.SquaresView,
+                                            tables.Count,
+                                            scratch.PrimeSlots.View,
+                                            scratch.ExponentSlots.View,
+                                            scratch.CountSlot.View,
+                                            scratch.RemainingSlot.View);
+
+                                        stream.Synchronize();
+
+                                        int factorCount = 0;
+                                        scratch.CountSlot.View.CopyToCPU(ref factorCount, 1);
+                                        factorCount = Math.Min(factorCount, GpuSmallPrimeFactorSlots);
+
+                                        if (factorCount > 0)
+                                        {
+                                                scratch.PrimeSlots.View.CopyToCPU(ref MemoryMarshal.GetReference(primeBuffer), factorCount);
+                                                scratch.ExponentSlots.View.CopyToCPU(ref MemoryMarshal.GetReference(exponentBuffer), factorCount);
+                                        }
+                                        scratch.RemainingSlot.View.CopyToCPU(ref remaining, 1);
+
+                                        for (int i = 0; i < factorCount; i++)
+                                        {
+                                                ulong primeValue = primeBuffer[i];
+                                                int exponent = exponentBuffer[i];
+                                                if (primeValue == 0UL || exponent == 0)
+                                                {
+                                                        continue;
+                                                }
+
+                                                counts[primeValue] = exponent;
+                                        }
+
+                                        return true;
+                                }
+                                finally
+                                {
+                                        execution.Dispose();
+                                }
+                        }
+                        finally
+                        {
+                                lease.Dispose();
+                        }
+                }
+                catch (CLException)
                 {
                         remaining = value;
-                        ThreadStaticPools.UlongPool.Return(primeBufferArray);
-                        ThreadStaticPools.IntPool.Return(exponentBufferArray);
                         return false;
                 }
-
-                remaining = gpuRemaining;
-                for (int i = 0; i < factorCount; i++)
+                catch (Exception ex) when (ex is AcceleratorException or InternalCompilerException or NotSupportedException or InvalidOperationException or AggregateException)
                 {
-                        ulong primeValue = primeBuffer[i];
-                        int exponent = exponentBuffer[i];
-                        if (primeValue == 0UL || exponent == 0)
-                        {
-                                continue;
-                        }
-
-                        counts[primeValue] = exponent;
+                        remaining = value;
+                        return false;
+                }
+                finally
+                {
+                        ThreadStaticPools.UlongPool.Return(primeBufferArray);
+                        ThreadStaticPools.IntPool.Return(exponentBufferArray);
                 }
-
-                ThreadStaticPools.UlongPool.Return(primeBufferArray);
-                ThreadStaticPools.IntPool.Return(exponentBufferArray);
-                return true;
         }
 }