gpu-parity: FXC/D3D11 check of cultmath snoise and snoise_grad #1
5 changed files with 397 additions and 0 deletions
2
tools/gpu-parity/.gitignore
vendored
Normal file
2
tools/gpu-parity/.gitignore
vendored
Normal file
|
|
@ -0,0 +1,2 @@
|
|||
bin/
|
||||
obj/
|
||||
19
tools/gpu-parity/GpuParity.csproj
Normal file
19
tools/gpu-parity/GpuParity.csproj
Normal file
|
|
@ -0,0 +1,19 @@
|
|||
<Project Sdk="Microsoft.NET.Sdk">
|
||||
<PropertyGroup>
|
||||
<OutputType>Exe</OutputType>
|
||||
<TargetFramework>net10.0</TargetFramework>
|
||||
<ImplicitUsings>enable</ImplicitUsings>
|
||||
<Nullable>enable</Nullable>
|
||||
<!-- CultLib checkout; env CULTLIB_ROOT, else a sibling directory named CultLib. -->
|
||||
<CultLibRoot Condition="'$(CULTLIB_ROOT)' != ''">$(CULTLIB_ROOT)</CultLibRoot>
|
||||
<CultLibRoot Condition="'$(CultLibRoot)' == ''">$(MSBuildThisFileDirectory)../../../CultLib</CultLibRoot>
|
||||
</PropertyGroup>
|
||||
<ItemGroup>
|
||||
<PackageReference Include="Vortice.Direct3D11" Version="3.8.2" />
|
||||
<ProjectReference Include="$(CultLibRoot)/packages/cultmath/src/CultMath/CultMath.csproj" />
|
||||
<AssemblyAttribute Include="System.Reflection.AssemblyMetadataAttribute">
|
||||
<_Parameter1>CultLibRoot</_Parameter1>
|
||||
<_Parameter2>$([System.IO.Path]::GetFullPath('$(CultLibRoot)'))</_Parameter2>
|
||||
</AssemblyAttribute>
|
||||
</ItemGroup>
|
||||
</Project>
|
||||
284
tools/gpu-parity/Program.cs
Normal file
284
tools/gpu-parity/Program.cs
Normal file
|
|
@ -0,0 +1,284 @@
|
|||
using System.Diagnostics;
|
||||
using System.Reflection;
|
||||
using System.Runtime.InteropServices;
|
||||
using CultMath;
|
||||
using Vortice.Direct3D;
|
||||
using Vortice.Direct3D11;
|
||||
using Vortice.DXGI;
|
||||
|
||||
// GPU parity for cultmath_snoise(float2/float3) and cultmath_snoise_grad vs C# math.snoise / snoise_grad.
|
||||
// See README.md. Exit code 0 only if the pin holds and every flag's errors are inside Tolerance.
|
||||
internal static class Tolerance
|
||||
{
|
||||
// Absolute error bounds per input-magnitude tier (|p| <= 8, <= 128, above): 1.35x the maximum measured on
|
||||
// a GTX 1070 for both fxc flag sets (README.md, "Measured results"). The error scales with ulp(|p|).
|
||||
public static readonly float[] ValueAbs = { 4.2e-6f, 7.2e-5f, 1.65e-3f };
|
||||
public static readonly float[] GradAbs = { 3.3e-5f, 4.2e-4f, 6.8e-3f };
|
||||
public const float RelFloor = 0.01f; // relative error = |gpu - ref| / max(|ref|, RelFloor)
|
||||
}
|
||||
|
||||
internal static class Program
|
||||
{
|
||||
const string PinTag = "cultmath-unity-v0.5.0";
|
||||
|
||||
static int Main(string[] args)
|
||||
{
|
||||
string cultlib = typeof(Program).Assembly.GetCustomAttributes<AssemblyMetadataAttribute>()
|
||||
.First(a => a.Key == "CultLibRoot").Value!;
|
||||
string here = AppContext.BaseDirectory;
|
||||
string kernel = FindUp(here, "parity.hlsl");
|
||||
string shaderDir = Path.Combine(cultlib, "packages", "cultmath", "shaders");
|
||||
|
||||
string head = Git(cultlib, "rev-parse HEAD");
|
||||
string pin = Git(cultlib, $"rev-parse {PinTag}^{{commit}}");
|
||||
Console.WriteLine($"CultLib {cultlib}\n HEAD {head}\n {PinTag} {pin}");
|
||||
string dirty = Git(cultlib, "status --porcelain -- packages/cultmath");
|
||||
if (head.Length == 0 || head != pin || dirty.Length != 0)
|
||||
{ Console.Error.WriteLine("PIN FAILED: CultLib HEAD is not the pinned tag, or packages/cultmath is modified."); return 3; }
|
||||
|
||||
var pts = BuildPoints(out int tieCount);
|
||||
Console.WriteLine($"points: {pts.Length / 4} ({tieCount} tie-constructed, {pts.Length / 4 - tieCount} seeded random)");
|
||||
var cs = Reference(pts);
|
||||
|
||||
string fxc = Environment.GetEnvironmentVariable("FXC")
|
||||
?? @"C:\Program Files (x86)\Windows Kits\10\bin\10.0.26100.0\x64\fxc.exe";
|
||||
|
||||
using var device = CreateDevice(out string gpu);
|
||||
Console.WriteLine($"GPU: {gpu}");
|
||||
|
||||
bool ok = true;
|
||||
foreach (var (name, flags) in new[] { ("default", ""), ("/Gis", "/Gis") })
|
||||
{
|
||||
string cso = Path.Combine(Path.GetTempPath(), $"snoise-parity-{name.Trim('/')}.cso");
|
||||
Fxc(fxc, flags, shaderDir, kernel, cso);
|
||||
var gpuRes = Dispatch(device, File.ReadAllBytes(cso), pts);
|
||||
ok &= Report(name, pts, tieCount, cs, gpuRes);
|
||||
}
|
||||
Console.WriteLine(ok ? "RESULT: within tolerance" : "RESULT: OUT OF TOLERANCE");
|
||||
return ok ? 0 : 1;
|
||||
}
|
||||
|
||||
// ---- points ----
|
||||
static float[] BuildPoints(out int tieCount)
|
||||
{
|
||||
var list = new List<float>();
|
||||
void Add(float x, float y, float z) { list.Add(x); list.Add(y); list.Add(z); list.Add(0f); }
|
||||
// Tie boundaries: coordinates that are dyadic (multiples of 1/64) so that value.x - value.y = k
|
||||
// is exact, which makes x0.x == x0.y an exact float tie in every evaluation order. Each pattern
|
||||
// also gets 1 and 2 ulp neighbours of one coordinate, where the tie is decided by rounding.
|
||||
var a = Enumerable.Range(-16, 33).Select(i => i / 8f).Concat(new[] { 0.1015625f, 3.390625f, -7.703125f, 100.25f, 1000.140625f });
|
||||
var b = new[] { -3.5f, -0.25f, 0f, 0.3125f, 1.75f, 5.0f, 37.5f };
|
||||
foreach (float av in a) foreach (float bv in b) foreach (int k in new[] { -2, -1, 0, 1, 2 })
|
||||
{
|
||||
float t = av + k;
|
||||
for (int u = -2; u <= 2; u++)
|
||||
{
|
||||
float p = Ulps(av, u), q = Ulps(t, u);
|
||||
Add(t, p, bv); Add(bv, t, p); Add(t, bv, p); // x==y, y==z, x==z (offset by k)
|
||||
Add(q, av, bv); Add(bv, q, av); Add(q, bv, av);
|
||||
}
|
||||
Add(t, av, av); Add(av, t, av); Add(av, av, t);
|
||||
}
|
||||
foreach (float av in a) Add(av, av, av);
|
||||
tieCount = list.Count / 4;
|
||||
var rng = new System.Random(0x5A5E);
|
||||
foreach (float scale in new[] { 4f, 64f, 1024f })
|
||||
for (int i = 0; i < 40000; i++)
|
||||
Add((float)(rng.NextDouble() * 2 - 1) * scale, (float)(rng.NextDouble() * 2 - 1) * scale, (float)(rng.NextDouble() * 2 - 1) * scale);
|
||||
return list.ToArray();
|
||||
}
|
||||
|
||||
static float Ulps(float v, int n)
|
||||
{
|
||||
for (; n > 0; n--) v = MathF.BitIncrement(v);
|
||||
for (; n < 0; n++) v = MathF.BitDecrement(v);
|
||||
return v;
|
||||
}
|
||||
|
||||
// ---- C# reference ----
|
||||
record struct Result(float[] Grad4, float[] Value3, float[] Value2, uint[] Code3, uint[] Code2);
|
||||
|
||||
static Result Reference(float[] pts)
|
||||
{
|
||||
int n = pts.Length / 4;
|
||||
var r = new Result(new float[n * 4], new float[n], new float[n], new uint[n], new uint[n]);
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
var p = new float3(pts[4 * i], pts[4 * i + 1], pts[4 * i + 2]);
|
||||
var g = math.snoise_grad(p);
|
||||
r.Grad4[4 * i] = g.x; r.Grad4[4 * i + 1] = g.y; r.Grad4[4 * i + 2] = g.z; r.Grad4[4 * i + 3] = g.w;
|
||||
r.Value3[i] = math.snoise(p);
|
||||
r.Value2[i] = math.snoise(new float2(p.x, p.y));
|
||||
// same expressions as parity.hlsl's probe, through CultMath's own operators
|
||||
var i0 = math.floor(p + math.dot(p, new float3(1f / 3f, 1f / 3f, 1f / 3f)));
|
||||
var x0 = p - i0 + math.dot(i0, new float3(1f / 6f, 1f / 6f, 1f / 6f));
|
||||
r.Code3[i] = (math.step(x0.y, x0.x) > 0.5f ? 1u : 0u) | (math.step(x0.z, x0.y) > 0.5f ? 2u : 0u) | (math.step(x0.z, x0.x) > 0.5f ? 4u : 0u);
|
||||
var q = new float2(p.x, p.y);
|
||||
var j = math.floor(q + math.dot(q, new float2(0.366025403784439f, 0.366025403784439f)));
|
||||
var y0 = q - j + math.dot(j, new float2(0.211324865405187f, 0.211324865405187f));
|
||||
r.Code2[i] = y0.x > y0.y ? 1u : 0u;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
// ---- D3D11 ----
|
||||
static ID3D11Device CreateDevice(out string name)
|
||||
{
|
||||
var res = D3D11.D3D11CreateDevice(null, DriverType.Hardware, DeviceCreationFlags.None,
|
||||
new[] { FeatureLevel.Level_11_0 }, out ID3D11Device? dev);
|
||||
if (res.Failure || dev is null) throw new Exception($"D3D11CreateDevice failed: {res}");
|
||||
using var dxgi = dev.QueryInterface<IDXGIDevice>();
|
||||
using var adapter = dxgi.GetAdapter();
|
||||
name = adapter.Description.Description;
|
||||
return dev;
|
||||
}
|
||||
|
||||
static Result Dispatch(ID3D11Device dev, byte[] cso, float[] pts)
|
||||
{
|
||||
int n = pts.Length / 4;
|
||||
var ctx = dev.ImmediateContext;
|
||||
using var cs = dev.CreateComputeShader(cso);
|
||||
|
||||
using var inBuf = dev.CreateBuffer(pts, new BufferDescription((uint)(n * 16), BindFlags.ShaderResource, ResourceUsage.Default,
|
||||
CpuAccessFlags.None, ResourceOptionFlags.BufferStructured, 16));
|
||||
using var inSrv = dev.CreateShaderResourceView(inBuf, new ShaderResourceViewDescription
|
||||
{
|
||||
Format = Format.Unknown,
|
||||
ViewDimension = ShaderResourceViewDimension.Buffer,
|
||||
Buffer = new BufferShaderResourceView { FirstElement = 0, NumElements = (uint)n },
|
||||
});
|
||||
|
||||
(ID3D11Buffer buf, ID3D11UnorderedAccessView uav, ID3D11Buffer staging) Out()
|
||||
{
|
||||
var b = dev.CreateBuffer(new BufferDescription((uint)(n * 16), BindFlags.UnorderedAccess, ResourceUsage.Default,
|
||||
CpuAccessFlags.None, ResourceOptionFlags.BufferStructured, 16));
|
||||
var u = dev.CreateUnorderedAccessView(b, new UnorderedAccessViewDescription
|
||||
{
|
||||
Format = Format.Unknown,
|
||||
ViewDimension = UnorderedAccessViewDimension.Buffer,
|
||||
Buffer = new BufferUnorderedAccessView { FirstElement = 0, NumElements = (uint)n },
|
||||
});
|
||||
var s = dev.CreateBuffer(new BufferDescription((uint)(n * 16), BindFlags.None, ResourceUsage.Staging,
|
||||
CpuAccessFlags.Read, ResourceOptionFlags.None, 0));
|
||||
return (b, u, s);
|
||||
}
|
||||
var (gBuf, gUav, gStage) = Out();
|
||||
var (vBuf, vUav, vStage) = Out();
|
||||
|
||||
ctx.CSSetShader(cs);
|
||||
ctx.CSSetShaderResource(0, inSrv);
|
||||
ctx.CSSetUnorderedAccessView(0, gUav);
|
||||
ctx.CSSetUnorderedAccessView(1, vUav);
|
||||
ctx.Dispatch((uint)((n + 63) / 64), 1, 1);
|
||||
ctx.CopyResource(gStage, gBuf);
|
||||
ctx.CopyResource(vStage, vBuf);
|
||||
ctx.Flush();
|
||||
|
||||
float[] Read(ID3D11Buffer stage)
|
||||
{
|
||||
var o = new float[n * 4];
|
||||
var m = ctx.Map(stage, 0, MapMode.Read, Vortice.Direct3D11.MapFlags.None);
|
||||
Marshal.Copy(m.DataPointer, o, 0, o.Length);
|
||||
ctx.Unmap(stage, 0);
|
||||
return o;
|
||||
}
|
||||
var g = Read(gStage);
|
||||
var v = Read(vStage);
|
||||
var r = new Result(g, new float[n], new float[n], new uint[n], new uint[n]);
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
r.Value3[i] = v[4 * i]; r.Value2[i] = v[4 * i + 1];
|
||||
r.Code3[i] = (uint)v[4 * i + 2]; r.Code2[i] = (uint)v[4 * i + 3];
|
||||
}
|
||||
foreach (var d in new IDisposable[] { gBuf, gUav, gStage, vBuf, vUav, vStage }) d.Dispose();
|
||||
return r;
|
||||
}
|
||||
|
||||
// ---- compare ----
|
||||
sealed class Stat
|
||||
{
|
||||
public double MaxAbs, MaxRel; public int Nan; public long Over; readonly List<float> errs = new();
|
||||
public void Add(float gpu, float refv, float tolAbs)
|
||||
{
|
||||
if (float.IsNaN(gpu) || float.IsInfinity(gpu)) { Nan++; return; }
|
||||
double d = Math.Abs((double)gpu - refv);
|
||||
errs.Add((float)d);
|
||||
MaxAbs = Math.Max(MaxAbs, d);
|
||||
MaxRel = Math.Max(MaxRel, d / Math.Max(Math.Abs(refv), Tolerance.RelFloor));
|
||||
if (d > tolAbs) Over++;
|
||||
}
|
||||
string Pct()
|
||||
{
|
||||
if (errs.Count == 0) return "";
|
||||
errs.Sort();
|
||||
float P(double q) => errs[(int)Math.Min(errs.Count - 1, q * errs.Count)];
|
||||
return $" p50 {P(.5):E1} p99 {P(.99):E1} p99.9 {P(.999):E1} p99.99 {P(.9999):E1}";
|
||||
}
|
||||
public override string ToString() => $"maxAbs {MaxAbs:E3} maxRel {MaxRel:E3} NaN/Inf {Nan} over-tol {Over}{Pct()}";
|
||||
}
|
||||
|
||||
// Tiers by max |coordinate|: x0 = value - i + ... cancels, so the input's own ulp scales the error.
|
||||
static readonly (string Name, float Max)[] Tiers = { ("|p|<=8", 8f), ("8<|p|<=128", 128f), ("128<|p|", float.MaxValue) };
|
||||
|
||||
static bool Report(string flag, float[] pts, int tieCount, Result cs, Result gpu)
|
||||
{
|
||||
int n = pts.Length / 4;
|
||||
Console.WriteLine($"\n== fxc flags: {flag} ({n} points) ==");
|
||||
bool ok = true;
|
||||
foreach (var (set, lo, hi) in new[] { ("ties", 0, tieCount), ("random", tieCount, n) })
|
||||
for (int t = 0; t < Tiers.Length; t++)
|
||||
{
|
||||
var idx = Enumerable.Range(lo, hi - lo).Where(i =>
|
||||
{
|
||||
float m = Math.Max(Math.Abs(pts[4 * i]), Math.Max(Math.Abs(pts[4 * i + 1]), Math.Abs(pts[4 * i + 2])));
|
||||
return m <= Tiers[t].Max && (t == 0 || m > Tiers[t - 1].Max);
|
||||
}).ToArray();
|
||||
if (idx.Length == 0) continue;
|
||||
var s3 = new Stat(); var s2 = new Stat(); var gv = new Stat(); var gg = new Stat();
|
||||
int m3 = 0, m2 = 0;
|
||||
float va = Tolerance.ValueAbs[t], ga = Tolerance.GradAbs[t];
|
||||
foreach (int i in idx)
|
||||
{
|
||||
s3.Add(gpu.Value3[i], cs.Value3[i], va);
|
||||
s2.Add(gpu.Value2[i], cs.Value2[i], va);
|
||||
for (int c = 0; c < 3; c++) gg.Add(gpu.Grad4[4 * i + c], cs.Grad4[4 * i + c], ga);
|
||||
gv.Add(gpu.Grad4[4 * i + 3], cs.Grad4[4 * i + 3], va);
|
||||
if (gpu.Code3[i] != cs.Code3[i]) m3++;
|
||||
if (gpu.Code2[i] != cs.Code2[i]) m2++;
|
||||
}
|
||||
Console.WriteLine($"-- {set} {Tiers[t].Name}: {idx.Length} points, tol value {va:E1} grad {ga:E1}\n snoise(float3) {s3}\n snoise(float2) {s2}\n snoise_grad .w value {gv}\n snoise_grad .xyz {gg}\n branch mismatches (informational): float3 {m3}, float2 {m2}");
|
||||
ok &= s3.Over + s2.Over + gv.Over + gg.Over == 0 && s3.Nan + s2.Nan + gv.Nan + gg.Nan == 0;
|
||||
}
|
||||
return ok;
|
||||
}
|
||||
|
||||
// ---- plumbing ----
|
||||
static void Fxc(string fxc, string flags, string includeDir, string kernel, string cso)
|
||||
{
|
||||
var psi = new ProcessStartInfo(fxc) { RedirectStandardOutput = true, RedirectStandardError = true };
|
||||
foreach (var a in new[] { "/nologo", "/T", "cs_5_0", "/E", "main", "/I", includeDir, "/Fo", cso }) psi.ArgumentList.Add(a);
|
||||
if (flags != "") psi.ArgumentList.Add(flags);
|
||||
psi.ArgumentList.Add(kernel);
|
||||
using var p = Process.Start(psi)!;
|
||||
string o = p.StandardOutput.ReadToEnd() + p.StandardError.ReadToEnd();
|
||||
p.WaitForExit();
|
||||
if (p.ExitCode != 0) throw new Exception($"fxc {flags} failed:\n{o}");
|
||||
Console.WriteLine($"fxc {(flags == "" ? "(default)" : flags)} ok -> {cso}");
|
||||
}
|
||||
|
||||
static string Git(string dir, string args)
|
||||
{
|
||||
var psi = new ProcessStartInfo("git", $"-C \"{dir}\" {args}") { RedirectStandardOutput = true };
|
||||
using var p = Process.Start(psi)!;
|
||||
string o = p.StandardOutput.ReadToEnd().Trim();
|
||||
p.WaitForExit();
|
||||
return o;
|
||||
}
|
||||
|
||||
static string FindUp(string dir, string file)
|
||||
{
|
||||
for (var d = new DirectoryInfo(dir); d != null; d = d.Parent)
|
||||
if (File.Exists(Path.Combine(d.FullName, file))) return Path.Combine(d.FullName, file);
|
||||
throw new FileNotFoundException(file);
|
||||
}
|
||||
}
|
||||
62
tools/gpu-parity/README.md
Normal file
62
tools/gpu-parity/README.md
Normal file
|
|
@ -0,0 +1,62 @@
|
|||
# GPU parity: CultMath simplex noise on D3D11
|
||||
|
||||
Checks that `cultmath_snoise(float2)`, `cultmath_snoise(float3)` and `cultmath_snoise_grad`
|
||||
(`float4`: gradient in `.xyz`, value in `.w`) from CultLib's `packages/cultmath/shaders/CultMath.hlsl`,
|
||||
compiled by FXC and run as a D3D11 compute shader, match C# `math.snoise` / `math.snoise_grad`
|
||||
(`packages/cultmath`) within a stated tolerance. The shader text under test is CultLib's own file:
|
||||
`parity.hlsl` `#include`s it through `fxc /I`. Nothing is copied.
|
||||
|
||||
Windows only (D3D11 hardware device, `fxc.exe`). Needs a CultLib checkout at tag `cultmath-unity-v0.5.0`;
|
||||
the run fails its pin check if CultLib `HEAD` is not that tag's commit.
|
||||
|
||||
```powershell
|
||||
git clone https://eureka.gamecult.org/forge/GameCult/CultLib.git
|
||||
git -C CultLib checkout cultmath-unity-v0.5.0
|
||||
$env:CULTLIB_ROOT = "$PWD\CultLib" # default: a sibling directory named CultLib
|
||||
# optional: $env:FXC = "...\fxc.exe" # default: Windows Kits 10.0.26100.0 x64
|
||||
dotnet run -c Release --project tools/gpu-parity/GpuParity.csproj
|
||||
```
|
||||
|
||||
It compiles the kernel twice (default flags, where FMA contraction is allowed, and `/Gis` IEEE strict),
|
||||
dispatches once per flag (about 164k threads), and prints max abs / max relative error per function,
|
||||
split into tie-constructed points and a seeded random sweep. Exit code 0 means within `Tolerance`
|
||||
(in `Program.cs`). Branch mismatches are reported, not failed.
|
||||
|
||||
Points: dyadic coordinates on the simplex tie planes (`x0.x == x0.y`, `y == z`, `x == z`, offsets
|
||||
k in -2..2) with 0, 1 and 2 ulp neighbours, plus 3 x 40000 seeded uniform points at scales 4, 64, 1024.
|
||||
`parity.hlsl` also reads back the ordering comparisons (a re-derivation of the `step`/`>` tests, so it
|
||||
witnesses the comparison, not the compiled noise body); a mismatch against C# is reported.
|
||||
Relative error is `|gpu - ref| / max(|ref|, 0.01)`.
|
||||
|
||||
The GPU is shared: the run is one short dispatch per flag.
|
||||
|
||||
## Measured results
|
||||
|
||||
Run 2026-11-11 on Starfire, NVIDIA GeForce GTX 1070, D3D11 feature level 11_0, fxc 10.0.26100.0
|
||||
(`cs_5_0`), CultLib `7a8933b0` (`cultmath-unity-v0.5.0`). 163928 points: 43928 tie-constructed, 120000
|
||||
seeded random (3 x 40000 at scales 4, 64, 1024). Default and `/Gis` produced the same maxima to three
|
||||
digits; no NaN or Inf.
|
||||
|
||||
Maximum absolute error, both flag sets, by max |coordinate| of the input:
|
||||
|
||||
| tier | snoise(float3) | snoise(float2) | grad `.w` | grad `.xyz` |
|
||||
| --- | --- | --- | --- | --- |
|
||||
| <= 8 | 3.1e-6 | 3.1e-6 | 3.1e-6 | 2.4e-5 |
|
||||
| 8 to 128 | 5.3e-5 | 4.2e-5 | 5.3e-5 | 3.1e-4 |
|
||||
| > 128 (to 1024) | 1.2e-3 | 4.9e-4 | 1.2e-3 | 5.0e-3 |
|
||||
|
||||
Max relative error (floor 0.01): 4.8e-2 for values and 2.1e-1 for gradients, both at |p| > 128 near zero
|
||||
crossings. Median absolute error is 0 to 2e-7 in every tier.
|
||||
|
||||
Stated tolerance (`Tolerance` in `Program.cs`): absolute error <= 4.2e-6, 7.2e-5, 1.65e-3 for values and
|
||||
<= 3.3e-5, 4.2e-4, 6.8e-3 for gradient components, per tier above (1.35x the measured maximum). Basis:
|
||||
the error scales with ulp of the input magnitude (x0 = value - i + ... cancels, and GPU and CPU round
|
||||
the first steps differently), not with the noise: 16x more input magnitude gave 17x more error between
|
||||
the first two tiers. Single GPU and driver; a different driver may need the bounds re-measured.
|
||||
|
||||
Tie handling: under both flag sets the GPU took a different simplex ordering branch than C# at
|
||||
190 of 35814 tie points (float3) and 39 (float2) with |p| <= 8, 2 and 4 in the middle tier, 0 above among tie points (the random sweep above 128 had 1 float3 mismatch)
|
||||
(the same counts under `/Gis`, so it is not FMA contraction; the probe is a separate expression tree,
|
||||
so it is evidence of a GPU/CPU rounding difference in x0, not of the noise body's own path). Every one of
|
||||
those points is inside the value and gradient tolerance: the noise is continuous across the tie, so a
|
||||
flipped branch costs at most the ulp-scale error above. Branch mismatches are reported, not failed.
|
||||
30
tools/gpu-parity/parity.hlsl
Normal file
30
tools/gpu-parity/parity.hlsl
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
// Parity kernel. CultMath.hlsl is included, not copied: fxc is run with /I pointing at the pinned
|
||||
// CultLib checkout. The only code here is buffer plumbing plus the branch probe below.
|
||||
#include "CultMath.hlsl"
|
||||
|
||||
StructuredBuffer<float4> points : register(t0); // xyz = 3D point, xy = 2D point
|
||||
RWStructuredBuffer<float4> grad_out : register(u0); // cultmath_snoise_grad: xyz = gradient, w = value
|
||||
RWStructuredBuffer<float4> value_out : register(u1); // x = snoise(float3), y = snoise(float2), z/w = branch codes as small floats (denormal bit patterns would flush to zero)
|
||||
|
||||
[numthreads(64, 1, 1)]
|
||||
void main(uint3 id : SV_DispatchThreadID)
|
||||
{
|
||||
uint n, stride;
|
||||
points.GetDimensions(n, stride);
|
||||
if (id.x >= n) return;
|
||||
float3 p = points[id.x].xyz;
|
||||
|
||||
grad_out[id.x] = cultmath_snoise_grad(p);
|
||||
|
||||
// Branch probe: re-derives the simplex-ordering comparisons exactly as cultmath_snoise(float3) and
|
||||
// cultmath_snoise(float2) write them, to read back which side of each float-decided tie was taken.
|
||||
// It is a separate expression tree, so it witnesses the comparison, not the compiled noise body.
|
||||
float3 x0 = p - floor(p + dot(p, (1.0 / 3.0).xxx)) + dot(floor(p + dot(p, (1.0 / 3.0).xxx)), (1.0 / 6.0).xxx);
|
||||
uint code3 = (step(x0.y, x0.x) > 0.5 ? 1u : 0u) | (step(x0.z, x0.y) > 0.5 ? 2u : 0u) | (step(x0.z, x0.x) > 0.5 ? 4u : 0u);
|
||||
float2 q = p.xy;
|
||||
float2 i2 = floor(q + dot(q, (0.366025403784439).xx));
|
||||
float2 y0 = q - i2 + dot(i2, (0.211324865405187).xx);
|
||||
uint code2 = y0.x > y0.y ? 1u : 0u;
|
||||
|
||||
value_out[id.x] = float4(cultmath_snoise(p), cultmath_snoise(q), (float)code3, (float)code2);
|
||||
}
|
||||
Loading…
Reference in a new issue