Fr0zka/VoxelForge
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

test: the Maze residue is /fp:fast, not port drift — encode the real bar

Browse Source 
The bisect settled it. The difference survives every stage removal down to
"corridors + carve ONLY", which is character-for-character transcribed code, so
it is not in anything the decomposition added.

Cause, read out of the engine rather than assumed (VCToolChain.cs):

    case FPSemanticsMode.Default: // Default is imprecise FP semantics.
    case FPSemanticsMode.Imprecise: Arguments.Add("/fp:fast"); break;

with UBT's own doc: "the compiler is allowed to transform math expressions in
ways that might result in differently rounded results". Identical source in two
translation units may reassociate differently, worth ~1 ULP. It shows up on
exactly the ~2% of samples inside the SDF blend shell, where Blend - Sdf
catastrophically cancels; outside it Carve is exactly 0 or 1 and both agree.

So MazeEquivalence now grades what it can actually assert:
  - hard fail  : any isosurface crossing (geometry moves)
  - info       : differences at ULP scale (the unavoidable floor)
  - warn       : anything larger, which IS port drift, and runs the bisect
A test that warns on every port would get ignored by the port that matters.

Recorded in OPSTACK-PLAN 2.6, and as AUDIT C9 for the part that outlives this
refactor: ARCHITECTURE 9.1's "every peer regenerates identically" holds only
between bit-identical binaries under /fp:fast. Fine for one build on one
platform; a real desync source for a Linux server plus Windows clients both
regenerating authoritative geometry. The FPSemantics::Precise knob exists but
must not be turned speculatively -- it blocks the vectorisation T2.a was chasing,
on the hot loop, for an unmeasured cost.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Fr0zka
2026-07-27 14:15:43 +02:00
parent 23605d5350
commit af5f2103b3
4 changed files with 184 additions and 8 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Source/VoxelForge/Private/Tests/VoxelForgeOpStackMazeTest.cpp
+58 -8
View File
@@ -128,8 +128,34 @@ bool FVoxelForgeOpStackMazeTest::RunTest(const FString& Parameters)
}
// ── L'ÉQUIVALENCE. ──
//
// ⚠️ CE QUE « ÉQUIVALENT » PEUT VOULOIR DIRE ICI — conclusion mesurée, 2026-07-27.
// Le plugin est compilé en **/fp:fast** : c'est le défaut d'UnrealBuildTool sur Windows
// (`VCToolChain.cs` : `case FPSemanticsMode.Default: // Default is imprecise FP semantics`),
// et la doc de UBT le dit noir sur blanc : « FP math isn't IEEE-754 compliant: the compiler is
// allowed to transform math expressions in ways that might result in differently rounded
// results ». Le compilateur a donc le DROIT de réassocier/contracter la MÊME expression
// différemment selon l'unité de compilation et le contexte d'inlining.
//
// Donc : deux transcriptions littérales du même calcul, l'une dans VoxelGenerator.cpp et
// l'autre dans VoxelDensityOpStack.cpp, peuvent légitimement différer de ~1 ULP.
// **L'identité binaire n'est PAS atteignable en principe pour ces portages**, et ce n'est pas
// un défaut de la décomposition. C'est mesuré, pas supposé : le bisect ci-dessous a montré
// l'écart survivant jusqu'à « corridors + carve ONLY », c'est-à-dire du code identique
// caractère pour caractère.
//
// Le critère d'acceptation est donc celui que OPSTACK-PLAN §2.6 demandait déjà :
// • DUR : aucun échantillon ne change de CÔTÉ de l'isosurface (sinon la géométrie bouge) ;
// • SOUPLE: les écarts restent à l'échelle de l'ULP. Un écart plus grand n'est PAS du bruit
// de compilateur — c'est une vraie dérive de portage, et là il faut chercher.
//
// The plugin builds with /fp:fast (UBT's Windows default), which explicitly licenses the
// compiler to reassociate identical source differently per translation unit. Bit-identity is
// therefore NOT achievable in principle for these ports. Hard gate: no isosurface crossings.
// Soft gate: differences stay at ULP scale — anything larger is real drift, not compiler noise.
int32 NumDiff = 0, WorstIdx = -1;
float WorstDelta = 0.0f;
int32 NumBeyondUlpNoise = 0; // écarts TROP GRANDS pour être du bruit de compilateur
int32 NumSolidDisagreements = 0; // le seul écart qui compte VRAIMENT : un côté d'iso différent
for (int32 i = 0; i < NumMazeSamples; ++i)
{
@@ -143,6 +169,12 @@ bool FVoxelForgeOpStackMazeTest::RunTest(const FString& Parameters)
++NumDiff;
const float Delta = FMath::Abs(Old - New);
if (Delta > WorstDelta) { WorstDelta = Delta; WorstIdx = i; }
// Tolérance : quelques ULP à la magnitude locale. `Blend - Sdf` amplifie fortement un
// écart d'ULP sur le SDF quand on est au bord de la zone de blend (annulation
// catastrophique), d'où une marge généreuse — mais bornée.
const float UlpNoise = 16.0f * FMath::Max(FMath::Abs(Old), 1.0f) * FLT_EPSILON;
if (Delta > UlpNoise) { ++NumBeyondUlpNoise; }
}
// Le mesher ne lit que le SIGNE (D >= IsoLevel ⇒ air). Deux valeurs peuvent différer d'un
// ULP sans changer un seul triangle ; un désaccord de CÔTÉ change la géométrie.
@@ -157,17 +189,35 @@ bool FVoxelForgeOpStackMazeTest::RunTest(const FString& Parameters)
TEXT("GetMazeDensity exactly, which is as strong a signal as Phase 1 can get that the ")
TEXT("source/modifier split is real and not imposed."), NumMazeSamples));
}
else if (NumBeyondUlpNoise == 0)
{
// Attendu, et compris. Pas un avertissement : crier au loup à chaque portage ferait
// ignorer le jour où l'écart est réel.
AddInfo(FString::Printf(
TEXT("%d of %d samples differ, ALL at ULP scale (largest |delta| %.9g at (%.0f, %.0f, ")
TEXT("%.0f)), and 0 cross the isosurface -- so not one triangle would move. This is the ")
TEXT("expected floor: the plugin builds with /fp:fast (UnrealBuildTool's Windows ")
TEXT("default -- VCToolChain.cs, \"Default is imprecise FP semantics\"), which lets the ")
TEXT("compiler reassociate identical source differently per translation unit. The ")
TEXT("bisect below confirmed it empirically: the residue survives into \"corridors + ")
TEXT("carve ONLY\", which is character-for-character transcribed code. Bit-identity is ")
TEXT("not achievable in principle here; OPSTACK-PLAN 2.6's bar (same PLACE, not same ")
TEXT("bits) is the right one and it is met."),
NumDiff, NumMazeSamples, WorstDelta,
WorstIdx >= 0 ? Points[WorstIdx].X : 0.0f,
WorstIdx >= 0 ? Points[WorstIdx].Y : 0.0f,
WorstIdx >= 0 ? Points[WorstIdx].Z : 0.0f));
}
else
{
AddWarning(FString::Printf(
TEXT("%d of %d samples differ (largest |delta| %.9g at (%.0f, %.0f, %.0f)); %d of them ")
TEXT("land on the OPPOSITE side of the isosurface. OPSTACK-PLAN section 2.6 does not ")
TEXT("require bit-identity, so this is a warning, not a failure -- but Maze SHOULD be ")
TEXT("reproducible exactly, so a nonzero count means the port drifted somewhere. Check, ")
TEXT("in order: the roughness apply-window (R + SurfaceRoughness + 2), the carve blend ")
TEXT("(2.0), the noise frequency (0.12) and octave count (3), and the order of the ")
TEXT("structural post ops."),
NumDiff, NumMazeSamples, WorstDelta,
TEXT("%d of %d samples differ and %d of them are TOO LARGE to be /fp:fast rounding ")
TEXT("noise (largest |delta| %.9g at (%.0f, %.0f, %.0f)); %d cross the isosurface. ")
TEXT("Unlike the ULP-scale floor, this IS port drift. Check, in order: the roughness ")
TEXT("apply-window (R + SurfaceRoughness + 2), the carve blend (2.0), the noise ")
TEXT("frequency (0.12) and octave count (3), and the order of the structural post ops. ")
TEXT("The bisect below narrows it to a stage."),
NumDiff, NumMazeSamples, NumBeyondUlpNoise, WorstDelta,
WorstIdx >= 0 ? Points[WorstIdx].X : 0.0f,
WorstIdx >= 0 ? Points[WorstIdx].Y : 0.0f,
WorstIdx >= 0 ? Points[WorstIdx].Z : 0.0f,