feat(worms): asset-owned worm off switch; offline stack symboliser -- cheap-worm default to be reverted
Worms round (Codex; reviewed by me against its report and PERF-SAMPLED.md).
Part 1, a real off switch: UVoxelStrateDefinition::bEnableWorms (default true, so existing assets
are unchanged). It is deliberately not in FStrateGenerationParams, so the 83-field memo-key guard
is untouched. It resolves after composer candidates, season vectors and boundary blending, is
included in the generation fingerprint, and clamps composer overrides, so a roll cannot re-enable
it. With strength 0 the fused path skips the worm block, the op-stack builder omits the worm
source, and the interval/classifier paths do no worm work. Proof: disabled == hand-zeroed control
byte for byte (70D310A4, 74,672 triangles), capability 20,856 / 10,917, connected, zero worm rows
in the symbolised sampler. voxel.WormsForceOff is a dev-only, world-changing measurement
override, included in the fingerprint.
Part 0: the sampler writes a module map (733 modules, identity checked), and a post-exit
offline symboliser (VoxelStackOfflineSymbolizer, editor module) rebuilds the all-LOD / LOD0 /
LOD1+ exclusive / inclusive / source-line tables. A planted cost was found (5 named rows) and then
removed. DbgHelp still never runs in the measured process.
Part 2, "cheap worms": FAILED to deliver, and the default is wrong. No candidate was faster:
lattice-2/4 gave no gain, and value noise was within noise static and ~2.1% WORSE in moving worker
seconds. Yet this commit carries voxel.WormNoiseMode=1 (value noise) as the default, a field change
(29/64 test tiles) with no benefit, selected after value-noise variants were tried until one
passed capability (three were rejected at 20,821-20,828). The next round reverts the default to
exact Perlin (mode 0) and removes the no-gain world-changing experiment modes.
The finding that matters: disabling worms entirely (WormsForceOff A/B, two interleaved runs each)
saves only ~2.5% static and ~3.4% moving worker time. The sampler's "worm line
VoxelGenerator.cpp:3985 = 19.4% of LOD0" was a misattribution of inlined noise code to one PDB
line. Line-level attribution of inlined code must be confirmed by ablation before a round targets
it. That is why the worm block skip (26b3476) found nothing.
Runs: the full ledger is in PERF-SAMPLED.md. Failures: one moving wrapper hit the graceful-close
timeout and was rerun; the first offline-symboliser commandlet hit the DDC no-writable-nodes fatal
(crash folder UECC-...CE75ACD5, 08:01) and was retried with the writable Saved\DDC.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TaFdXhTdYMkW1xrV6ApT6Y
This commit is contained in:
Fr0zkaandClaude Opus 5 committed
1 parent
11f0c1335b
commit
c132243b30
15 files changed
+2406
-552
No files matched your search
@@ -26,6 +26,7 @@
|
||||
#include "VoxelGenerator.h" // VoxelGenLOD::Eff
|
||||
#include "VoxelHeightOp.h" // FVoxelHeightStack — SurfaceWorld's two height stacks
|
||||
#include "VoxelNoise.h" // VoxelNoise::FBM
|
||||
#include "VoxelWormField.h"
|
||||
#include "VoxelStrateDefinition.h" // TerrainOperations — le pool que BuildChunkCache tire par salle
|
||||
#include "VoxelTerrainOpDefinition.h" // ApplyTo — l'override d'op PAR SALLE (étape C1)
|
||||
#include "VoxelStrateManager.h" // EvaluateModifierSDF / AnyPassageNearBox
|
||||
@@ -8540,7 +8541,12 @@ namespace
|
||||
{
|
||||
public:
|
||||
FWormFieldSource(const FStrateGenerationParams& InP, int32 Seed)
|
||||
: P(InP), SeedU((uint32)Seed) {}
|
||||
: P(InP)
|
||||
, SeedU((uint32)Seed)
|
||||
, WormLatticeStep(
|
||||
InP.WormStrength > 0.0f && InP.WormThreshold > 0.0f
|
||||
? VoxelWormField::GetLatticeStep() : 0)
|
||||
{}
|
||||
|
||||
EVoxelOpRole GetRole() const override { return EVoxelOpRole::FieldSource; }
|
||||
EVoxelOpChannelMask ChannelReads() const override
|
||||
@@ -8555,8 +8561,6 @@ namespace
|
||||
{
|
||||
if (!(P.WormStrength > 0.0f && P.WormThreshold > 0.0f)) { return; }
|
||||
|
||||
const float EffectiveZ = (P.VerticalScale != 1.0f && P.VerticalScale > 0.0f)
|
||||
? (WorldZ / P.VerticalScale) : WorldZ;
|
||||
const float CaveSDF = InOut.Sdf;
|
||||
|
||||
float NetworkMask = 1.0f;
|
||||
@@ -8574,25 +8578,14 @@ namespace
|
||||
|
||||
if (NetworkMask <= 0.0f) { return; }
|
||||
|
||||
const float WormZFreq = P.WormFrequency * P.WormHorizontalBias;
|
||||
|
||||
const float N1 = FMath::Abs(VoxelNoise::Perlin3D(FVector3f(
|
||||
WorldX * P.WormFrequency + VoxelHash::SeedOffset(SeedU, 1.0f),
|
||||
WorldY * P.WormFrequency + VoxelHash::SeedOffset(SeedU, 1.7f),
|
||||
EffectiveZ * WormZFreq + VoxelHash::SeedOffset(SeedU, 2.3f)
|
||||
)) * VOXEL_NOISE_SCALE);
|
||||
|
||||
// N2 ≥ 0, donc si N1 dépasse déjà le seuil la somme ne peut plus creuser — on saute le
|
||||
// second Perlin (le cas courant ; sortie bit-identique). Transcrit tel quel.
|
||||
if (N1 >= P.WormThreshold) { return; }
|
||||
|
||||
const float N2 = FMath::Abs(VoxelNoise::Perlin3D(FVector3f(
|
||||
WorldX * P.WormFrequency + VoxelHash::SeedOffset(SeedU, 1.0f) + 137.0f,
|
||||
WorldY * P.WormFrequency + VoxelHash::SeedOffset(SeedU, 1.7f) + 259.0f,
|
||||
EffectiveZ * WormZFreq + VoxelHash::SeedOffset(SeedU, 2.3f) + 431.0f
|
||||
)) * VOXEL_NOISE_SCALE);
|
||||
|
||||
const float WormValue = N1 + N2;
|
||||
const VoxelWormField::FParameters WormParameters{
|
||||
P.WormFrequency,
|
||||
P.WormHorizontalBias,
|
||||
P.VerticalScale,
|
||||
SeedU};
|
||||
const float WormValue = VoxelWormField::Evaluate(
|
||||
WorldX, WorldY, WorldZ, P.WormThreshold,
|
||||
WormParameters, WormLatticeStep);
|
||||
if (WormValue < P.WormThreshold)
|
||||
{
|
||||
const float t = 1.0f - (WormValue / P.WormThreshold);
|
||||
@@ -8663,7 +8656,9 @@ namespace
|
||||
// explicit count cap keeps this check bounded. The network mask still uses the SDF
|
||||
// interval's worst case, so this never assumes a room value that the preceding source
|
||||
// did not prove.
|
||||
if (Ctx.bUseLatticeProof && Ctx.bTightenWarpProof && Ctx.Step >= 1
|
||||
if (VoxelWormField::GetNoiseMode() == 0
|
||||
&& WormLatticeStep <= 1
|
||||
&& Ctx.bUseLatticeProof && Ctx.bTightenWarpProof && Ctx.Step >= 1
|
||||
&& VoxelMath::IsFinite(P.WormFrequency)
|
||||
&& VoxelMath::IsFinite(P.WormHorizontalBias)
|
||||
&& VoxelMath::IsFinite(P.WormThreshold)
|
||||
@@ -8783,6 +8778,7 @@ namespace
|
||||
private:
|
||||
FStrateGenerationParams P;
|
||||
uint32 SeedU;
|
||||
int32 WormLatticeStep = 0;
|
||||
};
|
||||
|
||||
#if WITH_EDITOR
|
||||
@@ -9738,7 +9734,10 @@ namespace VoxelDensityOps
|
||||
OutStack.Add(MakeUnique<FDomeMod>(P, RoomPtr)); // 4g — dômes
|
||||
OutStack.Add(MakeUnique<FPinchMod>(P, RoomPtr)); // 4h — pincement
|
||||
OutStack.Add(MakeUnique<FFloorBiasMod>(P, RoomPtr)); // fin 4h — biais de sol
|
||||
OutStack.Add(MakeUnique<FWormFieldSource>(P, Seed));
|
||||
if (P.WormStrength > 0.0f && P.WormThreshold > 0.0f)
|
||||
{
|
||||
OutStack.Add(MakeUnique<FWormFieldSource>(P, Seed));
|
||||
}
|
||||
|
||||
if (bAppendStructuralPosts)
|
||||
{
|
||||
@@ -10324,6 +10323,14 @@ bool VF_BuildStackFromRecipe(const FVoxelOpStackRecipe& Recipe,
|
||||
|
||||
for (const FVoxelOpRecipeEntry& Entry : Recipe.Modifiers)
|
||||
{
|
||||
if (Entry.OpClass == EVoxelStrateOpClass::WormFieldSource
|
||||
&& !(Params.TunnelNetworkParams.WormStrength > 0.0f
|
||||
&& Params.TunnelNetworkParams.WormThreshold > 0.0f))
|
||||
{
|
||||
// A disabled strate has no worm operator at all. This makes the off switch cheap on
|
||||
// the interpreted path as well as exact in its interval/classifier fold.
|
||||
continue;
|
||||
}
|
||||
TUniquePtr<IVoxelDensityOp> Modifier =
|
||||
VoxelStrateRecipePrivate::BuildRecipeOp(Entry, Params, Seed, SpineRadius,
|
||||
StrateManager, RoomPtr, ShaftPtr);
|
||||
|
||||
@@ -13,6 +13,7 @@
|
||||
#include "VoxelDiffLayer.h"
|
||||
#include "VoxelBiomeDefinition.h"
|
||||
#include "VoxelNoise.h" // T2.a: float, SIMD-batched gradient-noise core
|
||||
#include "VoxelWormField.h"
|
||||
#include "VoxelDensityPrimitives.h" // spine / seals / passage — shared with the operator stack
|
||||
#include "VoxelDensityOpStack.h" // OPSTACK Phase 1: the opt-in per-strate operator stack
|
||||
#include "VoxelHeightOp.h" // IVoxelBiomeField — the adapter below implements it
|
||||
@@ -858,6 +859,14 @@ bool VoxelGenLOD::GetThreadTileCacheWindow(
|
||||
&& Extent <= static_cast<int64>(CHUNK_SIZE) * 64;
|
||||
}
|
||||
|
||||
void VoxelGenLOD::SetThreadTileContext(
|
||||
const FIntVector& OriginVoxels,
|
||||
int32 CellsPerAxis)
|
||||
{
|
||||
TileOriginVoxels = OriginVoxels;
|
||||
TileCellsPerAxis = CellsPerAxis;
|
||||
}
|
||||
|
||||
bool VoxelGenLOD::ShouldUseSpatialIndex(bool bFusedPath)
|
||||
{
|
||||
VF_ParseSpatialIndexSwitch();
|
||||
@@ -4239,10 +4248,10 @@ float UVoxelGenerator::GetDensityWithParams(float WorldX, float WorldY, float Wo
|
||||
// already computed by Step 4 — free): full strength at the network, smooth fade to zero
|
||||
// at Range. Worms become braids/shortcuts hugging the cave system; no isolated speckle.
|
||||
// Range = 0 → unmasked legacy behaviour. Bonus: fully-masked voxels skip both Perlins.
|
||||
VoxelDensityProfile::FScopedTimer FusedWormTimer(
|
||||
VoxelDensityProfile::EBucket::FusedWorm);
|
||||
if (Params.WormStrength > 0.0f && Params.WormThreshold > 0.0f)
|
||||
{
|
||||
VoxelDensityProfile::FScopedTimer FusedWormTimer(
|
||||
VoxelDensityProfile::EBucket::FusedWorm);
|
||||
float NetworkMask = 1.0f;
|
||||
if (Params.WormNetworkRange > 0.0f)
|
||||
{
|
||||
@@ -4267,7 +4276,10 @@ float UVoxelGenerator::GetDensityWithParams(float WorldX, float WorldY, float Wo
|
||||
}
|
||||
|
||||
bool bWormBlockProofComputed = false;
|
||||
const bool bSkipWormBlock = GVoxelForgeWormBlockSkip != 0
|
||||
const int32 WormLatticeStep = VoxelWormField::GetLatticeStep();
|
||||
const bool bSkipWormBlock = VoxelWormField::GetNoiseMode() == 0
|
||||
&& WormLatticeStep <= 1
|
||||
&& GVoxelForgeWormBlockSkip != 0
|
||||
&& VF_TryGetWormBlockSkip(
|
||||
DensityCacheOwnerId, SeedU, ParamsFingerprint, LayoutVersion,
|
||||
WorldX, WorldY, WorldZ, Params, bWormBlockProofComputed);
|
||||
@@ -4286,37 +4298,25 @@ float UVoxelGenerator::GetDensityWithParams(float WorldX, float WorldY, float Wo
|
||||
}
|
||||
else
|
||||
{
|
||||
const float WormZFreq = Params.WormFrequency * Params.WormHorizontalBias;
|
||||
const float N1 = FMath::Abs(VoxelNoise::Perlin3D(FVector3f(
|
||||
WorldX * Params.WormFrequency + VoxelHash::SeedOffset(SeedU, 1.0f),
|
||||
WorldY * Params.WormFrequency + VoxelHash::SeedOffset(SeedU, 1.7f),
|
||||
EffectiveZ * WormZFreq + VoxelHash::SeedOffset(SeedU, 2.3f)
|
||||
)) * VOXEL_NOISE_SCALE);
|
||||
const VoxelWormField::FParameters WormParameters{
|
||||
Params.WormFrequency,
|
||||
Params.WormHorizontalBias,
|
||||
Params.VerticalScale,
|
||||
SeedU};
|
||||
const float WormValue = VoxelWormField::Evaluate(
|
||||
WorldX, WorldY, WorldZ, Params.WormThreshold,
|
||||
WormParameters, WormLatticeStep);
|
||||
|
||||
// N2 >= 0, so if N1 alone already clears the threshold the sum can't carve —
|
||||
// skip the second Perlin entirely (most voxels; bit-identical output).
|
||||
if (N1 < Params.WormThreshold)
|
||||
if (WormValue < Params.WormThreshold)
|
||||
{
|
||||
const float N2 = FMath::Abs(VoxelNoise::Perlin3D(FVector3f(
|
||||
WorldX * Params.WormFrequency + VoxelHash::SeedOffset(SeedU, 1.0f) + 137.0f,
|
||||
WorldY * Params.WormFrequency + VoxelHash::SeedOffset(SeedU, 1.7f) + 259.0f,
|
||||
EffectiveZ * WormZFreq + VoxelHash::SeedOffset(SeedU, 2.3f) + 431.0f
|
||||
)) * VOXEL_NOISE_SCALE);
|
||||
|
||||
const float WormValue = N1 + N2;
|
||||
|
||||
if (WormValue < Params.WormThreshold)
|
||||
{
|
||||
const float t = 1.0f - (WormValue / Params.WormThreshold);
|
||||
Density -= t * Params.WormStrength * NetworkMask;
|
||||
}
|
||||
const float t = 1.0f - (WormValue / Params.WormThreshold);
|
||||
Density -= t * Params.WormStrength * NetworkMask;
|
||||
}
|
||||
}
|
||||
}
|
||||
FusedWormTimer.End();
|
||||
}
|
||||
|
||||
FusedWormTimer.End();
|
||||
|
||||
//=========================================================================
|
||||
// STEP 6: STRATE BOUNDARY SEAL (haut + bas)
|
||||
//=========================================================================
|
||||
|
||||
@@ -4,8 +4,6 @@
|
||||
#include "VoxelStackSampler.h"
|
||||
|
||||
#include "Containers/Array.h"
|
||||
#include "Containers/Map.h"
|
||||
#include "Containers/Set.h"
|
||||
#include "HAL/FileManager.h"
|
||||
#include "HAL/PlatformProcess.h"
|
||||
#include "HAL/PlatformStackWalk.h"
|
||||
@@ -17,6 +15,7 @@
|
||||
#include "Math/UnrealMathUtility.h"
|
||||
#include "Containers/StringConv.h"
|
||||
#include "Misc/FileHelper.h"
|
||||
#include "Misc/Guid.h"
|
||||
#include "Misc/Paths.h"
|
||||
#include "Misc/ScopeLock.h"
|
||||
#include "Serialization/Archive.h"
|
||||
@@ -24,6 +23,11 @@
|
||||
|
||||
#if PLATFORM_WINDOWS
|
||||
#include "Windows/WindowsPlatformStackWalk.h"
|
||||
#include "Windows/AllowWindowsPlatformTypes.h"
|
||||
THIRD_PARTY_INCLUDES_START
|
||||
#include <Psapi.h>
|
||||
THIRD_PARTY_INCLUDES_END
|
||||
#include "Windows/HideWindowsPlatformTypes.h"
|
||||
#endif
|
||||
|
||||
#include <atomic>
|
||||
@@ -89,221 +93,219 @@ void WriteUtf8(FArchive& Archive, const FString& Text)
|
||||
}
|
||||
}
|
||||
|
||||
FString NormalizedForClassification(const FString& InValue)
|
||||
#if PLATFORM_WINDOWS
|
||||
struct FModuleMapRecord
|
||||
{
|
||||
FString Path;
|
||||
uint64 LoadBase = 0;
|
||||
uint32 ImageSize = 0;
|
||||
uint64 FileSize = 0;
|
||||
uint64 LastWriteFileTime = 0;
|
||||
FString PdbGuid;
|
||||
uint32 PdbAge = 0;
|
||||
FString PdbPath;
|
||||
};
|
||||
|
||||
FString ModuleMapField(const FString& InValue)
|
||||
{
|
||||
FString Result = InValue;
|
||||
Result.ToLowerInline();
|
||||
Result.ReplaceInline(TEXT("\\"), TEXT("/"));
|
||||
Result.ReplaceInline(TEXT("\t"), TEXT(" "));
|
||||
Result.ReplaceInline(TEXT("\r"), TEXT(" "));
|
||||
Result.ReplaceInline(TEXT("\n"), TEXT(" "));
|
||||
return Result;
|
||||
}
|
||||
|
||||
struct FResolvedSymbol
|
||||
bool IsModuleImageRangeValid(uint32 Offset, uint64 Size, uint32 ImageSize)
|
||||
{
|
||||
FString Module;
|
||||
FString Function;
|
||||
FString File;
|
||||
int32 Line = 0;
|
||||
bool bInline = false;
|
||||
};
|
||||
|
||||
struct FResolvedProgramCounter
|
||||
{
|
||||
bool bAttempted = false;
|
||||
TArray<FResolvedSymbol> Symbols;
|
||||
};
|
||||
|
||||
struct FProfileRow
|
||||
{
|
||||
FString Key;
|
||||
FString Function;
|
||||
FString Module;
|
||||
FString File;
|
||||
FString Label;
|
||||
int32 Line = 0;
|
||||
uint64 Samples = 0;
|
||||
};
|
||||
|
||||
struct FProfileAggregateSet
|
||||
{
|
||||
TMap<FString, FProfileRow> ExclusiveFunctions;
|
||||
TMap<FString, FProfileRow> InclusiveFunctions;
|
||||
TMap<FString, FProfileRow> ExclusiveLines;
|
||||
uint64 SamplesWithStack = 0;
|
||||
};
|
||||
|
||||
const FResolvedSymbol* FirstFunctionSymbol(const FResolvedProgramCounter& Entry)
|
||||
{
|
||||
for (const FResolvedSymbol& Symbol : Entry.Symbols)
|
||||
{
|
||||
if (!Symbol.Function.IsEmpty())
|
||||
{
|
||||
return &Symbol;
|
||||
}
|
||||
}
|
||||
return nullptr;
|
||||
return Offset <= ImageSize && Size <= static_cast<uint64>(ImageSize - Offset);
|
||||
}
|
||||
|
||||
const FResolvedSymbol* FirstSourceSymbol(const FResolvedProgramCounter& Entry)
|
||||
void ReadModuleCodeViewIdentity(
|
||||
FModuleMapRecord& Record, const uint8* ModuleBase, uint32 ImageSize)
|
||||
{
|
||||
for (const FResolvedSymbol& Symbol : Entry.Symbols)
|
||||
{
|
||||
if (!Symbol.File.IsEmpty() && Symbol.Line > 0)
|
||||
{
|
||||
return &Symbol;
|
||||
}
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
FString SymbolLabel(const FResolvedSymbol& Symbol)
|
||||
{
|
||||
if (Symbol.Function.IsEmpty())
|
||||
{
|
||||
return TEXT("unknown");
|
||||
}
|
||||
|
||||
const FString FunctionLower = NormalizedForClassification(Symbol.Function);
|
||||
if (FunctionLower.Contains(TEXT("std::")))
|
||||
{
|
||||
return TEXT("std");
|
||||
}
|
||||
|
||||
const FString ModuleLower = NormalizedForClassification(Symbol.Module);
|
||||
const FString FileLower = NormalizedForClassification(Symbol.File);
|
||||
const bool bFileIsEngine = FileLower.Contains(TEXT("/engine/"));
|
||||
if (bFileIsEngine)
|
||||
{
|
||||
return TEXT("engine");
|
||||
}
|
||||
|
||||
const bool bVoxelForge = FunctionLower.Contains(TEXT("voxelforge"))
|
||||
|| FileLower.Contains(TEXT("/voxelforge/"))
|
||||
|| ModuleLower.Contains(TEXT("voxelforge"));
|
||||
if (bVoxelForge)
|
||||
{
|
||||
return TEXT("plugin");
|
||||
}
|
||||
|
||||
const bool bModuleIsEngine = ModuleLower.StartsWith(TEXT("unrealeditor-"))
|
||||
|| ModuleLower.StartsWith(TEXT("ue5-"));
|
||||
return bModuleIsEngine ? TEXT("engine") : TEXT("other");
|
||||
}
|
||||
|
||||
bool IsWaitLike(const FResolvedSymbol& Symbol)
|
||||
{
|
||||
const FString FunctionLower = NormalizedForClassification(Symbol.Function);
|
||||
return FunctionLower.Contains(TEXT("wait"))
|
||||
|| FunctionLower.Contains(TEXT("sleep"))
|
||||
|| FunctionLower.Contains(TEXT("semaphore"))
|
||||
|| FunctionLower.Contains(TEXT("fevent"));
|
||||
}
|
||||
|
||||
FString FunctionKey(const FResolvedSymbol& Symbol)
|
||||
{
|
||||
return SymbolLabel(Symbol) + TEXT("\x1f") + Symbol.Function;
|
||||
}
|
||||
|
||||
FString SourceKey(const FResolvedSymbol* Symbol)
|
||||
{
|
||||
if (Symbol == nullptr || Symbol->File.IsEmpty() || Symbol->Line <= 0)
|
||||
{
|
||||
return TEXT("unknown\x1f<unknown>");
|
||||
}
|
||||
return SymbolLabel(*Symbol) + TEXT("\x1f")
|
||||
+ FString::Printf(TEXT("%s:%d"), *Symbol->File, Symbol->Line);
|
||||
}
|
||||
|
||||
void AddFunctionRow(
|
||||
TMap<FString, FProfileRow>& Rows,
|
||||
const FResolvedSymbol* Symbol,
|
||||
uint64 SampleCount)
|
||||
{
|
||||
if (Symbol == nullptr || Symbol->Function.IsEmpty())
|
||||
if (ModuleBase == nullptr || ImageSize < sizeof(IMAGE_DOS_HEADER))
|
||||
{
|
||||
return;
|
||||
}
|
||||
const FString Key = FunctionKey(*Symbol);
|
||||
FProfileRow& Row = Rows.FindOrAdd(Key);
|
||||
if (Row.Key.IsEmpty())
|
||||
|
||||
const IMAGE_DOS_HEADER* DosHeader = reinterpret_cast<const IMAGE_DOS_HEADER*>(ModuleBase);
|
||||
if (DosHeader->e_magic != IMAGE_DOS_SIGNATURE || DosHeader->e_lfanew < 0)
|
||||
{
|
||||
Row.Key = Key;
|
||||
Row.Function = Symbol->Function;
|
||||
Row.Module = Symbol->Module;
|
||||
Row.File = Symbol->File;
|
||||
Row.Line = Symbol->Line;
|
||||
Row.Label = SymbolLabel(*Symbol);
|
||||
return;
|
||||
}
|
||||
|
||||
const uint32 NtOffset = static_cast<uint32>(DosHeader->e_lfanew);
|
||||
if (!IsModuleImageRangeValid(NtOffset, sizeof(IMAGE_NT_HEADERS), ImageSize))
|
||||
{
|
||||
return;
|
||||
}
|
||||
const IMAGE_NT_HEADERS* NtHeaders = reinterpret_cast<const IMAGE_NT_HEADERS*>(
|
||||
ModuleBase + NtOffset);
|
||||
if (NtHeaders->Signature != IMAGE_NT_SIGNATURE
|
||||
|| NtHeaders->OptionalHeader.NumberOfRvaAndSizes <= IMAGE_DIRECTORY_ENTRY_DEBUG)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
const IMAGE_DATA_DIRECTORY& DebugDirectory =
|
||||
NtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG];
|
||||
if (DebugDirectory.VirtualAddress == 0
|
||||
|| DebugDirectory.Size < sizeof(IMAGE_DEBUG_DIRECTORY)
|
||||
|| !IsModuleImageRangeValid(
|
||||
DebugDirectory.VirtualAddress, DebugDirectory.Size, ImageSize))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
const IMAGE_DEBUG_DIRECTORY* Entries = reinterpret_cast<const IMAGE_DEBUG_DIRECTORY*>(
|
||||
ModuleBase + DebugDirectory.VirtualAddress);
|
||||
const uint32 EntryCount = DebugDirectory.Size / sizeof(IMAGE_DEBUG_DIRECTORY);
|
||||
for (uint32 Index = 0; Index < EntryCount; ++Index)
|
||||
{
|
||||
const IMAGE_DEBUG_DIRECTORY& Entry = Entries[Index];
|
||||
if (Entry.Type != IMAGE_DEBUG_TYPE_CODEVIEW || Entry.SizeOfData < 24
|
||||
|| Entry.AddressOfRawData == 0
|
||||
|| !IsModuleImageRangeValid(
|
||||
Entry.AddressOfRawData, Entry.SizeOfData, ImageSize))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
const uint8* CodeView = ModuleBase + Entry.AddressOfRawData;
|
||||
if (CodeView[0] != 'R' || CodeView[1] != 'S'
|
||||
|| CodeView[2] != 'D' || CodeView[3] != 'S')
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
FGuid Guid;
|
||||
FMemory::Memcpy(&Guid, CodeView + 4, sizeof(Guid));
|
||||
Record.PdbGuid = Guid.ToString();
|
||||
FMemory::Memcpy(&Record.PdbAge, CodeView + 20, sizeof(Record.PdbAge));
|
||||
|
||||
const uint32 PdbPathBytes = Entry.SizeOfData - 24;
|
||||
if (PdbPathBytes > 0)
|
||||
{
|
||||
const ANSICHAR* PdbPathAnsi = reinterpret_cast<const ANSICHAR*>(CodeView + 24);
|
||||
int32 Length = 0;
|
||||
while (Length < static_cast<int32>(PdbPathBytes) && PdbPathAnsi[Length] != '\0')
|
||||
{
|
||||
++Length;
|
||||
}
|
||||
if (Length > 0)
|
||||
{
|
||||
FUTF8ToTCHAR PdbPathUtf8(PdbPathAnsi, Length);
|
||||
Record.PdbPath = FString(PdbPathUtf8.Get());
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
Row.Samples += SampleCount;
|
||||
}
|
||||
|
||||
void AddSourceRow(
|
||||
TMap<FString, FProfileRow>& Rows,
|
||||
const FResolvedSymbol* FunctionSymbol,
|
||||
const FResolvedSymbol* SourceSymbol)
|
||||
bool CollectProcessModuleMap(TArray<FModuleMapRecord>& OutRecords, FString& OutError)
|
||||
{
|
||||
const FString Key = SourceKey(SourceSymbol);
|
||||
FProfileRow& Row = Rows.FindOrAdd(Key);
|
||||
if (Row.Key.IsEmpty())
|
||||
{
|
||||
Row.Key = Key;
|
||||
Row.Label = SourceSymbol != nullptr ? SymbolLabel(*SourceSymbol) : TEXT("unknown");
|
||||
Row.File = SourceSymbol != nullptr ? SourceSymbol->File : TEXT("<unknown>");
|
||||
Row.Line = SourceSymbol != nullptr ? SourceSymbol->Line : 0;
|
||||
Row.Function = FunctionSymbol != nullptr ? FunctionSymbol->Function : TEXT("<unknown>");
|
||||
Row.Module = FunctionSymbol != nullptr ? FunctionSymbol->Module : TEXT("<unknown>");
|
||||
}
|
||||
++Row.Samples;
|
||||
}
|
||||
OutRecords.Reset();
|
||||
OutError.Reset();
|
||||
|
||||
TArray<FProfileRow> SortedRows(const TMap<FString, FProfileRow>& InRows)
|
||||
{
|
||||
TArray<FProfileRow> Rows;
|
||||
Rows.Reserve(InRows.Num());
|
||||
for (const TPair<FString, FProfileRow>& Pair : InRows)
|
||||
// Keep PSAPI dynamic, like the engine stack-walk implementation. This records module state
|
||||
// without touching DbgHelp or the process-global symbol engine.
|
||||
void* PsapiHandle = FPlatformProcess::GetDllHandle(TEXT("PSAPI.DLL"));
|
||||
if (PsapiHandle == nullptr)
|
||||
{
|
||||
Rows.Add(Pair.Value);
|
||||
OutError = TEXT("PSAPI.DLL could not be loaded");
|
||||
return false;
|
||||
}
|
||||
Rows.Sort([](const FProfileRow& A, const FProfileRow& B)
|
||||
|
||||
using FEnumProcessModules = BOOL (WINAPI*)(HANDLE, HMODULE*, DWORD, LPDWORD);
|
||||
using FGetModuleFileNameExW = DWORD (WINAPI*)(HANDLE, HMODULE, LPWSTR, DWORD);
|
||||
using FGetModuleInformation = BOOL (WINAPI*)(HANDLE, HMODULE, LPMODULEINFO, DWORD);
|
||||
|
||||
const FEnumProcessModules EnumModules = reinterpret_cast<FEnumProcessModules>(
|
||||
FPlatformProcess::GetDllExport(PsapiHandle, TEXT("EnumProcessModules")));
|
||||
const FGetModuleFileNameExW GetModuleFileNameEx = reinterpret_cast<FGetModuleFileNameExW>(
|
||||
FPlatformProcess::GetDllExport(PsapiHandle, TEXT("GetModuleFileNameExW")));
|
||||
const FGetModuleInformation GetModuleInformation = reinterpret_cast<FGetModuleInformation>(
|
||||
FPlatformProcess::GetDllExport(PsapiHandle, TEXT("GetModuleInformation")));
|
||||
if (EnumModules == nullptr || GetModuleFileNameEx == nullptr || GetModuleInformation == nullptr)
|
||||
{
|
||||
return A.Samples != B.Samples ? A.Samples > B.Samples : A.Key < B.Key;
|
||||
OutError = TEXT("PSAPI exports needed for module enumeration are unavailable");
|
||||
FPlatformProcess::FreeDllHandle(PsapiHandle);
|
||||
return false;
|
||||
}
|
||||
|
||||
DWORD BytesRequired = 0;
|
||||
EnumModules(GetCurrentProcess(), nullptr, 0, &BytesRequired);
|
||||
if (BytesRequired == 0)
|
||||
{
|
||||
OutError = TEXT("EnumProcessModules returned no module bytes");
|
||||
FPlatformProcess::FreeDllHandle(PsapiHandle);
|
||||
return false;
|
||||
}
|
||||
|
||||
TArray<HMODULE> Modules;
|
||||
Modules.SetNumUninitialized(
|
||||
FMath::Max<int32>(1, static_cast<int32>(BytesRequired / sizeof(HMODULE) + 1)));
|
||||
DWORD BytesWritten = 0;
|
||||
if (!EnumModules(
|
||||
GetCurrentProcess(), Modules.GetData(),
|
||||
static_cast<DWORD>(Modules.Num() * sizeof(HMODULE)), &BytesWritten))
|
||||
{
|
||||
OutError = TEXT("EnumProcessModules failed");
|
||||
FPlatformProcess::FreeDllHandle(PsapiHandle);
|
||||
return false;
|
||||
}
|
||||
|
||||
const int32 ModuleCount = FMath::Min<int32>(
|
||||
Modules.Num(), static_cast<int32>(BytesWritten / sizeof(HMODULE)));
|
||||
for (int32 Index = 0; Index < ModuleCount; ++Index)
|
||||
{
|
||||
MODULEINFO ModuleInfo{};
|
||||
if (!GetModuleInformation(
|
||||
GetCurrentProcess(), Modules[Index], &ModuleInfo, sizeof(ModuleInfo)))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
WCHAR ImagePath[32768] = {};
|
||||
const DWORD PathLength = GetModuleFileNameEx(
|
||||
GetCurrentProcess(), Modules[Index], ImagePath, UE_ARRAY_COUNT(ImagePath));
|
||||
if (PathLength == 0)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
FModuleMapRecord Record;
|
||||
Record.Path = FString(ImagePath, static_cast<int32>(PathLength));
|
||||
Record.LoadBase = reinterpret_cast<uint64>(ModuleInfo.lpBaseOfDll);
|
||||
Record.ImageSize = static_cast<uint32>(ModuleInfo.SizeOfImage);
|
||||
|
||||
WIN32_FILE_ATTRIBUTE_DATA FileData{};
|
||||
if (GetFileAttributesExW(*Record.Path, GetFileExInfoStandard, &FileData))
|
||||
{
|
||||
ULARGE_INTEGER FileSize;
|
||||
FileSize.HighPart = FileData.nFileSizeHigh;
|
||||
FileSize.LowPart = FileData.nFileSizeLow;
|
||||
Record.FileSize = FileSize.QuadPart;
|
||||
ULARGE_INTEGER LastWrite;
|
||||
LastWrite.HighPart = FileData.ftLastWriteTime.dwHighDateTime;
|
||||
LastWrite.LowPart = FileData.ftLastWriteTime.dwLowDateTime;
|
||||
Record.LastWriteFileTime = LastWrite.QuadPart;
|
||||
}
|
||||
|
||||
ReadModuleCodeViewIdentity(
|
||||
Record, reinterpret_cast<const uint8*>(ModuleInfo.lpBaseOfDll), Record.ImageSize);
|
||||
OutRecords.Add(MoveTemp(Record));
|
||||
}
|
||||
|
||||
OutRecords.Sort([](const FModuleMapRecord& A, const FModuleMapRecord& B)
|
||||
{
|
||||
return A.LoadBase < B.LoadBase;
|
||||
});
|
||||
return Rows;
|
||||
FPlatformProcess::FreeDllHandle(PsapiHandle);
|
||||
return OutRecords.Num() > 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
void AppendRows(
|
||||
FString& Out,
|
||||
const TCHAR* Title,
|
||||
const TMap<FString, FProfileRow>& InRows,
|
||||
uint64 Denominator,
|
||||
int32 MaxRows)
|
||||
{
|
||||
Out += TEXT("\n");
|
||||
Out += Title;
|
||||
Out += TEXT("\nrank\tsamples\tpercent\tlabel\tfunction\tmodule\tfile\tline\n");
|
||||
const TArray<FProfileRow> Rows = SortedRows(InRows);
|
||||
const int32 Count = FMath::Min(MaxRows, Rows.Num());
|
||||
for (int32 Index = 0; Index < Count; ++Index)
|
||||
{
|
||||
const FProfileRow& Row = Rows[Index];
|
||||
const double Percent = Denominator > 0
|
||||
? static_cast<double>(Row.Samples) * 100.0 / static_cast<double>(Denominator)
|
||||
: 0.0;
|
||||
Out.Appendf(
|
||||
TEXT("%d\t%llu\t%.4f\t%s\t%s\t%s\t%s\t%d\n"),
|
||||
Index + 1,
|
||||
static_cast<unsigned long long>(Row.Samples),
|
||||
Percent,
|
||||
*Row.Label,
|
||||
*Row.Function,
|
||||
*Row.Module,
|
||||
*Row.File,
|
||||
Row.Line);
|
||||
}
|
||||
if (Rows.Num() == 0)
|
||||
{
|
||||
Out += TEXT("(no rows)\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct FVoxelStackSampler::FImpl final : public FRunnable
|
||||
@@ -322,6 +324,7 @@ struct FVoxelStackSampler::FImpl final : public FRunnable
|
||||
FString RunLabel;
|
||||
FString OutputDirectory;
|
||||
FString RawSamplesPath;
|
||||
FString ModuleMapPath;
|
||||
FString SummaryPath;
|
||||
double StartSeconds = 0.0;
|
||||
std::atomic<bool> bStop{false};
|
||||
@@ -360,6 +363,9 @@ struct FVoxelStackSampler::FImpl final : public FRunnable
|
||||
RawSamplesPath = FPaths::Combine(
|
||||
OutputDirectory,
|
||||
FString::Printf(TEXT("VoxelStackSamples_%s_%u.csv"), *SafeLabel, ProcessId));
|
||||
ModuleMapPath = FPaths::Combine(
|
||||
OutputDirectory,
|
||||
FString::Printf(TEXT("VoxelStackModules_%s_%u.tsv"), *SafeLabel, ProcessId));
|
||||
SummaryPath = FPaths::Combine(
|
||||
OutputDirectory,
|
||||
FString::Printf(TEXT("VoxelStackSummary_%s_%u.txt"), *SafeLabel, ProcessId));
|
||||
@@ -622,10 +628,12 @@ struct FVoxelStackSampler::FImpl final : public FRunnable
|
||||
Result.MaxActiveRegisteredThreads = MaxActiveRegisteredThreads;
|
||||
Result.RunLabel = RunLabel;
|
||||
Result.RawSamplesPath = RawSamplesPath;
|
||||
Result.ModuleMapPath = ModuleMapPath;
|
||||
Result.SummaryPath = SummaryPath;
|
||||
Result.RunSeconds = FPlatformTime::Seconds() - StartSeconds;
|
||||
|
||||
WriteRawSamples(Result);
|
||||
WriteModuleMap(Result);
|
||||
// Do not call the DbgHelp-backed symbolizer from the measured process. DbgHelp is a
|
||||
// process-global state machine and can fault during shutdown even after the sampler
|
||||
// thread has joined. The raw PCs remain available for a separate offline pass.
|
||||
@@ -672,6 +680,48 @@ struct FVoxelStackSampler::FImpl final : public FRunnable
|
||||
Result.bOutputWritten = true;
|
||||
}
|
||||
|
||||
void WriteModuleMap(FSummary& Result)
|
||||
{
|
||||
#if PLATFORM_WINDOWS
|
||||
TArray<FModuleMapRecord> Records;
|
||||
FString CollectionError;
|
||||
const bool bCollected = CollectProcessModuleMap(Records, CollectionError);
|
||||
|
||||
FArchive* Archive = IFileManager::Get().CreateFileWriter(*ModuleMapPath);
|
||||
if (Archive == nullptr)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
WriteUtf8(*Archive, TEXT("# VoxelForge module map v1\n"));
|
||||
WriteUtf8(*Archive, TEXT("# DbgHelp is not initialized by this artifact writer.\n"));
|
||||
WriteUtf8(*Archive, TEXT("module_path\tload_base_hex\timage_size\tfile_size\tfile_last_write_filetime\tpdb_guid\tpdb_age\tpdb_path\n"));
|
||||
if (!bCollected)
|
||||
{
|
||||
WriteUtf8(*Archive, FString::Printf(TEXT("# collection_error\t%s\n"), *CollectionError));
|
||||
}
|
||||
for (const FModuleMapRecord& Record : Records)
|
||||
{
|
||||
const FString Line = FString::Printf(
|
||||
TEXT("%s\t0x%016llX\t%u\t%llu\t%llu\t%s\t%u\t%s\n"),
|
||||
*ModuleMapField(Record.Path),
|
||||
static_cast<unsigned long long>(Record.LoadBase),
|
||||
Record.ImageSize,
|
||||
static_cast<unsigned long long>(Record.FileSize),
|
||||
static_cast<unsigned long long>(Record.LastWriteFileTime),
|
||||
*ModuleMapField(Record.PdbGuid),
|
||||
Record.PdbAge,
|
||||
*ModuleMapField(Record.PdbPath));
|
||||
WriteUtf8(*Archive, Line);
|
||||
}
|
||||
delete Archive;
|
||||
Result.ModuleCount = static_cast<uint64>(Records.Num());
|
||||
Result.bModuleMapWritten = true;
|
||||
#else
|
||||
(void)Result;
|
||||
#endif
|
||||
}
|
||||
|
||||
void WriteRawOnlySummary(FSummary& Result)
|
||||
{
|
||||
uint64 SamplesWithStack = 0;
|
||||
@@ -691,6 +741,10 @@ struct FVoxelStackSampler::FImpl final : public FRunnable
|
||||
Summary += TEXT("raw_only: yes\n");
|
||||
Summary += TEXT("symbolization: deferred\n");
|
||||
Summary += TEXT("dbghelp_in_measured_process: no\n");
|
||||
Summary.Appendf(TEXT("module_map_written: %s\n"),
|
||||
Result.bModuleMapWritten ? TEXT("yes") : TEXT("no"));
|
||||
Summary.Appendf(TEXT("module_count: %llu\n"),
|
||||
static_cast<unsigned long long>(Result.ModuleCount));
|
||||
Summary.Appendf(TEXT("interval_us: %u\n"), IntervalUs);
|
||||
Summary.Appendf(TEXT("max_stack_depth: %u\n"), MaxStackDepth);
|
||||
Summary.Appendf(TEXT("max_stored_samples: %u\n"), MaxStoredSamples);
|
||||
@@ -716,6 +770,7 @@ struct FVoxelStackSampler::FImpl final : public FRunnable
|
||||
static_cast<unsigned long long>(MaxActiveRegisteredThreads));
|
||||
Summary.Appendf(TEXT("run_seconds: %.6f\n"), Result.RunSeconds);
|
||||
Summary.Appendf(TEXT("raw_samples_path: %s\n"), *RawSamplesPath);
|
||||
Summary.Appendf(TEXT("module_map_path: %s\n"), *ModuleMapPath);
|
||||
Summary += TEXT("\nThe target process records bounded raw PCs only; resolve symbols after the process exits.\n");
|
||||
|
||||
if (FFileHelper::SaveStringToFile(
|
||||
@@ -727,300 +782,7 @@ struct FVoxelStackSampler::FImpl final : public FRunnable
|
||||
}
|
||||
}
|
||||
|
||||
void ResolveProgramCounter(
|
||||
uint64 ProgramCounter,
|
||||
TMap<uint64, FResolvedProgramCounter>& SymbolCache,
|
||||
FSummary& Result)
|
||||
{
|
||||
FResolvedProgramCounter& Entry = SymbolCache.FindOrAdd(ProgramCounter);
|
||||
if (Entry.bAttempted)
|
||||
{
|
||||
return;
|
||||
}
|
||||
Entry.bAttempted = true;
|
||||
|
||||
#if PLATFORM_WINDOWS
|
||||
FPlatformStackWalk::EnumerateSymbolInfosForProgramCounter(
|
||||
ProgramCounter,
|
||||
true,
|
||||
[&Entry, &Result](FProgramCounterSymbolInfo& Info)
|
||||
{
|
||||
FResolvedSymbol Symbol;
|
||||
Symbol.Module = FString(ANSI_TO_TCHAR(Info.ModuleName));
|
||||
Symbol.Function = FString(ANSI_TO_TCHAR(Info.FunctionName));
|
||||
Symbol.File = FString(ANSI_TO_TCHAR(Info.Filename));
|
||||
Symbol.Line = Info.LineNumber;
|
||||
Symbol.bInline = Symbol.Function.StartsWith(TEXT("[Inline Frame]"));
|
||||
if (Symbol.bInline)
|
||||
{
|
||||
++Result.InlineSymbols;
|
||||
}
|
||||
Entry.Symbols.Add(MoveTemp(Symbol));
|
||||
});
|
||||
// DbgHelp can return source-only inline records for a PC. Ask the ordinary resolver as
|
||||
// well when none of the enumerated records has a function name, so an unresolved frame
|
||||
// does not hide an available outer function symbol.
|
||||
if (Entry.Symbols.Num() == 0 || FirstFunctionSymbol(Entry) == nullptr)
|
||||
{
|
||||
FProgramCounterSymbolInfo Info;
|
||||
FPlatformStackWalk::ProgramCounterToSymbolInfo(ProgramCounter, Info);
|
||||
FResolvedSymbol Symbol;
|
||||
Symbol.Module = FString(ANSI_TO_TCHAR(Info.ModuleName));
|
||||
Symbol.Function = FString(ANSI_TO_TCHAR(Info.FunctionName));
|
||||
Symbol.File = FString(ANSI_TO_TCHAR(Info.Filename));
|
||||
Symbol.Line = Info.LineNumber;
|
||||
Entry.Symbols.Add(MoveTemp(Symbol));
|
||||
}
|
||||
#else
|
||||
(void)ProgramCounter;
|
||||
(void)Result;
|
||||
#endif
|
||||
}
|
||||
|
||||
void SymbolizeAndWriteSummary(FSummary& Result)
|
||||
{
|
||||
TMap<uint64, FResolvedProgramCounter> SymbolCache;
|
||||
FProfileAggregateSet AllAggregates;
|
||||
FProfileAggregateSet Lod0Aggregates;
|
||||
FProfileAggregateSet Lod1PlusAggregates;
|
||||
TSet<FString> SeenFunctions;
|
||||
uint64 ResolvedFrames = 0;
|
||||
uint64 UnknownFrames = 0;
|
||||
uint64 WaitLikeFrames = 0;
|
||||
uint64 SamplesWithResolvedLeaf = 0;
|
||||
uint64 SamplesWithWaitLikeFrame = 0;
|
||||
uint64 SamplesWithStack = 0;
|
||||
uint64 UntaggedSamples = 0;
|
||||
|
||||
auto AddUnknownExclusiveRow = [](FProfileAggregateSet& Aggregate)
|
||||
{
|
||||
const FString UnknownKey = TEXT("unknown\x1f<unknown>");
|
||||
FProfileRow& UnknownRow = Aggregate.ExclusiveFunctions.FindOrAdd(UnknownKey);
|
||||
if (UnknownRow.Key.IsEmpty())
|
||||
{
|
||||
UnknownRow.Key = UnknownKey;
|
||||
UnknownRow.Function = TEXT("<unknown>");
|
||||
UnknownRow.Module = TEXT("<unknown>");
|
||||
UnknownRow.File = TEXT("<unknown>");
|
||||
UnknownRow.Label = TEXT("unknown");
|
||||
}
|
||||
++UnknownRow.Samples;
|
||||
};
|
||||
|
||||
for (uint32 SampleIndex = 0; SampleIndex < StoredSampleCount; ++SampleIndex)
|
||||
{
|
||||
const FStoredSample& Sample = Samples[SampleIndex];
|
||||
if (Sample.Depth == 0)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
++SamplesWithStack;
|
||||
SeenFunctions.Reset();
|
||||
TArray<FResolvedSymbol> SampleFunctions;
|
||||
|
||||
const FResolvedProgramCounter* LeafEntry = nullptr;
|
||||
const FResolvedSymbol* LeafFunction = nullptr;
|
||||
const FResolvedSymbol* LeafSource = nullptr;
|
||||
uint64 LeafProgramCounter = 0;
|
||||
bool bHasLeafProgramCounter = false;
|
||||
bool bSampleHasResolvedLeaf = false;
|
||||
bool bSampleHasWaitLike = false;
|
||||
|
||||
for (uint32 FrameIndex = 0; FrameIndex < Sample.Depth; ++FrameIndex)
|
||||
{
|
||||
const uint64 ProgramCounter = Sample.ProgramCounters[FrameIndex];
|
||||
ResolveProgramCounter(ProgramCounter, SymbolCache, Result);
|
||||
const FResolvedProgramCounter* Entry = SymbolCache.Find(ProgramCounter);
|
||||
const FResolvedSymbol* FrameFunction = Entry != nullptr
|
||||
? FirstFunctionSymbol(*Entry) : nullptr;
|
||||
if (FrameFunction != nullptr)
|
||||
{
|
||||
++ResolvedFrames;
|
||||
if (IsWaitLike(*FrameFunction))
|
||||
{
|
||||
++WaitLikeFrames;
|
||||
bSampleHasWaitLike = true;
|
||||
}
|
||||
if (FrameIndex == 0)
|
||||
{
|
||||
LeafProgramCounter = ProgramCounter;
|
||||
bHasLeafProgramCounter = true;
|
||||
bSampleHasResolvedLeaf = true;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
++UnknownFrames;
|
||||
}
|
||||
|
||||
if (Entry != nullptr)
|
||||
{
|
||||
if (FrameIndex == 0)
|
||||
{
|
||||
LeafProgramCounter = ProgramCounter;
|
||||
bHasLeafProgramCounter = true;
|
||||
}
|
||||
for (const FResolvedSymbol& Symbol : Entry->Symbols)
|
||||
{
|
||||
if (Symbol.Function.IsEmpty())
|
||||
{
|
||||
continue;
|
||||
}
|
||||
const FString Key = FunctionKey(Symbol);
|
||||
if (!SeenFunctions.Contains(Key))
|
||||
{
|
||||
SeenFunctions.Add(Key);
|
||||
SampleFunctions.Add(Symbol);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// SymbolCache is a TMap. FindOrAdd while resolving later frames may rehash it, so
|
||||
// pointers captured during the loop are not stable. Re-find the leaf only after all
|
||||
// PCs for this sample have been inserted.
|
||||
if (bHasLeafProgramCounter)
|
||||
{
|
||||
LeafEntry = SymbolCache.Find(LeafProgramCounter);
|
||||
if (LeafEntry != nullptr)
|
||||
{
|
||||
LeafFunction = FirstFunctionSymbol(*LeafEntry);
|
||||
LeafSource = FirstSourceSymbol(*LeafEntry);
|
||||
}
|
||||
}
|
||||
|
||||
auto AddToAggregate = [&](FProfileAggregateSet& Aggregate)
|
||||
{
|
||||
++Aggregate.SamplesWithStack;
|
||||
if (bSampleHasResolvedLeaf)
|
||||
{
|
||||
AddFunctionRow(Aggregate.ExclusiveFunctions, LeafFunction, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
AddUnknownExclusiveRow(Aggregate);
|
||||
}
|
||||
for (const FResolvedSymbol& Symbol : SampleFunctions)
|
||||
{
|
||||
AddFunctionRow(Aggregate.InclusiveFunctions, &Symbol, 1);
|
||||
}
|
||||
AddSourceRow(Aggregate.ExclusiveLines, LeafFunction, LeafSource);
|
||||
};
|
||||
|
||||
AddToAggregate(AllAggregates);
|
||||
if (Sample.LODLevel == 0)
|
||||
{
|
||||
AddToAggregate(Lod0Aggregates);
|
||||
}
|
||||
else if (Sample.LODLevel >= 1)
|
||||
{
|
||||
AddToAggregate(Lod1PlusAggregates);
|
||||
}
|
||||
else
|
||||
{
|
||||
++UntaggedSamples;
|
||||
}
|
||||
|
||||
if (bSampleHasResolvedLeaf)
|
||||
{
|
||||
++SamplesWithResolvedLeaf;
|
||||
}
|
||||
if (bSampleHasWaitLike)
|
||||
{
|
||||
++SamplesWithWaitLikeFrame;
|
||||
}
|
||||
}
|
||||
|
||||
Result.UniqueProgramCounters = SymbolCache.Num();
|
||||
Result.ResolvedFrames = ResolvedFrames;
|
||||
Result.UnknownFrames = UnknownFrames;
|
||||
Result.WaitLikeFrames = WaitLikeFrames;
|
||||
Result.SamplesWithResolvedLeaf = SamplesWithResolvedLeaf;
|
||||
Result.SamplesWithWaitLikeFrame = SamplesWithWaitLikeFrame;
|
||||
|
||||
FString Summary;
|
||||
Summary += TEXT("VoxelForge in-process stack sampler\n");
|
||||
Summary += TEXT("==================================\n");
|
||||
Summary.Appendf(TEXT("run_label: %s\n"), *RunLabel);
|
||||
Summary.Appendf(TEXT("supported: %s\n"), Result.bSupported ? TEXT("yes") : TEXT("no"));
|
||||
Summary.Appendf(TEXT("stack_walking_initialized: %s\n"),
|
||||
Result.bStackWalkingInitialized ? TEXT("yes") : TEXT("no"));
|
||||
Summary.Appendf(TEXT("interval_us: %u\n"), IntervalUs);
|
||||
Summary.Appendf(TEXT("max_stack_depth: %u\n"), MaxStackDepth);
|
||||
Summary.Appendf(TEXT("max_stored_samples: %u\n"), MaxStoredSamples);
|
||||
Summary.Appendf(TEXT("sampler_ticks: %llu\n"),
|
||||
static_cast<unsigned long long>(SamplerTicks));
|
||||
Summary.Appendf(TEXT("capture_attempts: %llu\n"),
|
||||
static_cast<unsigned long long>(CaptureAttempts));
|
||||
Summary.Appendf(TEXT("registered_thread_samples: %llu\n"),
|
||||
static_cast<unsigned long long>(RegisteredThreadSamples));
|
||||
Summary.Appendf(TEXT("registration_race_drops: %llu\n"),
|
||||
static_cast<unsigned long long>(RegistrationRaceDrops));
|
||||
Summary.Appendf(TEXT("capture_failures: %llu\n"),
|
||||
static_cast<unsigned long long>(CaptureFailures));
|
||||
Summary.Appendf(TEXT("retained_samples: %llu\n"),
|
||||
static_cast<unsigned long long>(StoredSampleCount));
|
||||
Summary.Appendf(TEXT("dropped_samples_after_bound: %llu\n"),
|
||||
static_cast<unsigned long long>(DroppedSamples));
|
||||
Summary.Appendf(TEXT("samples_with_stack: %llu\n"),
|
||||
static_cast<unsigned long long>(SamplesWithStack));
|
||||
Summary.Appendf(TEXT("lod0_samples_with_stack: %llu\n"),
|
||||
static_cast<unsigned long long>(Lod0Aggregates.SamplesWithStack));
|
||||
Summary.Appendf(TEXT("lod1plus_samples_with_stack: %llu\n"),
|
||||
static_cast<unsigned long long>(Lod1PlusAggregates.SamplesWithStack));
|
||||
Summary.Appendf(TEXT("untagged_samples: %llu\n"),
|
||||
static_cast<unsigned long long>(UntaggedSamples));
|
||||
Summary.Appendf(TEXT("total_frames: %llu\n"),
|
||||
static_cast<unsigned long long>(TotalFrames));
|
||||
Summary.Appendf(TEXT("resolved_frames: %llu\n"),
|
||||
static_cast<unsigned long long>(ResolvedFrames));
|
||||
Summary.Appendf(TEXT("unknown_frames: %llu\n"),
|
||||
static_cast<unsigned long long>(UnknownFrames));
|
||||
Summary.Appendf(TEXT("wait_like_frames: %llu\n"),
|
||||
static_cast<unsigned long long>(WaitLikeFrames));
|
||||
Summary.Appendf(TEXT("samples_with_resolved_leaf: %llu\n"),
|
||||
static_cast<unsigned long long>(SamplesWithResolvedLeaf));
|
||||
Summary.Appendf(TEXT("samples_with_wait_like_frame: %llu\n"),
|
||||
static_cast<unsigned long long>(SamplesWithWaitLikeFrame));
|
||||
Summary.Appendf(TEXT("unique_program_counters: %llu\n"),
|
||||
static_cast<unsigned long long>(Result.UniqueProgramCounters));
|
||||
Summary.Appendf(TEXT("inline_symbols: %llu\n"),
|
||||
static_cast<unsigned long long>(Result.InlineSymbols));
|
||||
Summary.Appendf(TEXT("max_active_registered_threads: %llu\n"),
|
||||
static_cast<unsigned long long>(MaxActiveRegisteredThreads));
|
||||
Summary.Appendf(TEXT("run_seconds: %.6f\n"), Result.RunSeconds);
|
||||
Summary += TEXT("\nClosure uses stable registration snapshots. Top-table percentages use retained samples with a non-empty stack; the raw CSV includes zero-depth captures.\n");
|
||||
Summary.Appendf(TEXT("resolved_frame_fraction: %.6f\n"), TotalFrames > 0
|
||||
? static_cast<double>(ResolvedFrames) / static_cast<double>(TotalFrames) : 0.0);
|
||||
Summary.Appendf(TEXT("unknown_frame_fraction: %.6f\n"), TotalFrames > 0
|
||||
? static_cast<double>(UnknownFrames) / static_cast<double>(TotalFrames) : 0.0);
|
||||
Summary.Appendf(TEXT("wait_like_frame_fraction: %.6f\n"), TotalFrames > 0
|
||||
? static_cast<double>(WaitLikeFrames) / static_cast<double>(TotalFrames) : 0.0);
|
||||
Summary.Appendf(TEXT("resolved_leaf_fraction: %.6f\n"), SamplesWithStack > 0
|
||||
? static_cast<double>(SamplesWithResolvedLeaf) / static_cast<double>(SamplesWithStack) : 0.0);
|
||||
Summary.Appendf(TEXT("wait_like_sample_fraction: %.6f\n"), SamplesWithStack > 0
|
||||
? static_cast<double>(SamplesWithWaitLikeFrame) / static_cast<double>(SamplesWithStack) : 0.0);
|
||||
Summary += TEXT("\nLabels: plugin = VoxelForge, engine = Unreal/Engine, std = std:: frames, other = other resolved modules, unknown = no function symbol. Inline symbol callbacks were requested through DbgHelp when available.\n");
|
||||
AppendRows(Summary, TEXT("Top 30 exclusive functions (leaf)"), AllAggregates.ExclusiveFunctions, SamplesWithStack, 30);
|
||||
AppendRows(Summary, TEXT("Top 30 inclusive functions (once per sample)"), AllAggregates.InclusiveFunctions, SamplesWithStack, 30);
|
||||
AppendRows(Summary, TEXT("Top 30 exclusive source lines (leaf source)"), AllAggregates.ExclusiveLines, SamplesWithStack, 30);
|
||||
Summary += TEXT("\nLOD0 tables (floor)\n");
|
||||
AppendRows(Summary, TEXT("LOD0 top 30 exclusive functions (leaf)"), Lod0Aggregates.ExclusiveFunctions, Lod0Aggregates.SamplesWithStack, 30);
|
||||
AppendRows(Summary, TEXT("LOD0 top 30 inclusive functions (once per sample)"), Lod0Aggregates.InclusiveFunctions, Lod0Aggregates.SamplesWithStack, 30);
|
||||
AppendRows(Summary, TEXT("LOD0 top 30 exclusive source lines (leaf source)"), Lod0Aggregates.ExclusiveLines, Lod0Aggregates.SamplesWithStack, 30);
|
||||
Summary += TEXT("\nLOD1+ tables (coarse/background)\n");
|
||||
AppendRows(Summary, TEXT("LOD1+ top 30 exclusive functions (leaf)"), Lod1PlusAggregates.ExclusiveFunctions, Lod1PlusAggregates.SamplesWithStack, 30);
|
||||
AppendRows(Summary, TEXT("LOD1+ top 30 inclusive functions (once per sample)"), Lod1PlusAggregates.InclusiveFunctions, Lod1PlusAggregates.SamplesWithStack, 30);
|
||||
AppendRows(Summary, TEXT("LOD1+ top 30 exclusive source lines (leaf source)"), Lod1PlusAggregates.ExclusiveLines, Lod1PlusAggregates.SamplesWithStack, 30);
|
||||
|
||||
if (FFileHelper::SaveStringToFile(
|
||||
Summary,
|
||||
*SummaryPath,
|
||||
FFileHelper::EEncodingOptions::ForceUTF8WithoutBOM))
|
||||
{
|
||||
Result.bOutputWritten = true;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
FVoxelStackSampler& FVoxelStackSampler::Get()
|
||||
@@ -1060,8 +822,9 @@ bool FVoxelStackSampler::Start(
|
||||
Impl = NewImpl;
|
||||
GVoxelStackSamplerEnabled.store(true, std::memory_order_release);
|
||||
UE_LOG(LogTemp, Display,
|
||||
TEXT("[VoxelStackSampler] started label=%s interval_us=%u raw=%s summary=%s"),
|
||||
*RunLabel, NewImpl->IntervalUs, *NewImpl->RawSamplesPath, *NewImpl->SummaryPath);
|
||||
TEXT("[VoxelStackSampler] started label=%s interval_us=%u raw=%s modules=%s summary=%s"),
|
||||
*RunLabel, NewImpl->IntervalUs, *NewImpl->RawSamplesPath,
|
||||
*NewImpl->ModuleMapPath, *NewImpl->SummaryPath);
|
||||
return true;
|
||||
#endif
|
||||
}
|
||||
@@ -1081,16 +844,14 @@ FVoxelStackSampler::FSummary FVoxelStackSampler::StopAndWrite()
|
||||
Result = StoppedImpl->Finalize();
|
||||
UE_LOG(LogTemp, Display,
|
||||
TEXT("[VoxelStackSampler] stopped label=%s ticks=%llu registered_samples=%llu "
|
||||
"retained=%llu dropped=%llu resolved_fraction=%.4f raw=%s summary=%s"),
|
||||
"retained=%llu dropped=%llu raw=%s module_map=%s summary=%s"),
|
||||
*Result.RunLabel,
|
||||
static_cast<unsigned long long>(Result.SamplerTicks),
|
||||
static_cast<unsigned long long>(Result.RegisteredThreadSamples),
|
||||
static_cast<unsigned long long>(Result.RetainedSamples),
|
||||
static_cast<unsigned long long>(Result.DroppedSamples),
|
||||
Result.TotalFrames > 0
|
||||
? static_cast<double>(Result.ResolvedFrames) / static_cast<double>(Result.TotalFrames)
|
||||
: 0.0,
|
||||
*Result.RawSamplesPath,
|
||||
*Result.ModuleMapPath,
|
||||
*Result.SummaryPath);
|
||||
delete StoppedImpl;
|
||||
Impl = nullptr;
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
#include "VoxelStartupTrace.h"
|
||||
#include "VoxelTerrainOpDefinition.h" // For UVoxelTerrainOpDefinition::ApplyTo
|
||||
#include "VoxelBiomeDefinition.h" // For UVoxelBiomeDefinition (biome context flatten)
|
||||
#include "VoxelWormField.h" // World-changing worm evaluator mode/lattice identity
|
||||
#include "HAL/IConsoleManager.h"
|
||||
#include "Misc/CommandLine.h"
|
||||
#include "Misc/Crc.h"
|
||||
@@ -33,6 +34,42 @@ namespace
|
||||
GVoxelForgeFloorRound1PassageProjectionCache,
|
||||
TEXT("Reuse exact passage floor projections within one density sample; 0 disables the A/B cache."));
|
||||
|
||||
// This is a measurement override only. The asset-owned bEnableWorms field remains the real
|
||||
// per-strate contract; this process-wide switch exists so the game harness can measure the
|
||||
// cost of enabled versus disabled worms without editing an owner's asset. It is resolved once
|
||||
// before generation params are published so workers cannot disagree mid-world.
|
||||
int32 GVoxelForgeWormsForceOff = 0;
|
||||
std::atomic<int32> GResolvedWormsForceOff(-1);
|
||||
FAutoConsoleVariableRef CVarVoxelForgeWormsForceOff(
|
||||
TEXT("voxel.WormsForceOff"),
|
||||
GVoxelForgeWormsForceOff,
|
||||
TEXT("WORLD-CHANGING DEVELOPMENT-ONLY measurement override. 0=asset behavior, 1=force "
|
||||
"all worm strengths to zero. Never vary this between multiplayer peers or world "
|
||||
"regenerations; it is not the per-strate off switch."),
|
||||
ECVF_Default);
|
||||
|
||||
bool VF_WormsForceOff()
|
||||
{
|
||||
int32 Existing = GResolvedWormsForceOff.load(std::memory_order_acquire);
|
||||
if (Existing >= 0)
|
||||
{
|
||||
return Existing != 0;
|
||||
}
|
||||
|
||||
int32 CommandLineValue = GVoxelForgeWormsForceOff;
|
||||
FParse::Value(
|
||||
FCommandLine::Get(), TEXT("voxel.WormsForceOff="), CommandLineValue);
|
||||
const int32 Resolved = CommandLineValue != 0 ? 1 : 0;
|
||||
int32 Expected = -1;
|
||||
if (!GResolvedWormsForceOff.compare_exchange_strong(
|
||||
Expected, Resolved, std::memory_order_release, std::memory_order_acquire))
|
||||
{
|
||||
return Expected != 0;
|
||||
}
|
||||
GVoxelForgeWormsForceOff = Resolved;
|
||||
return Resolved != 0;
|
||||
}
|
||||
|
||||
struct FRuntimeRoughnessOverrides
|
||||
{
|
||||
bool bSurfaceRoughness = false;
|
||||
@@ -1429,6 +1466,15 @@ bool UVoxelStrateManager::SetComposerOverrideForStrate(
|
||||
Override->CandidateSeed = CandidateSeed;
|
||||
Override->Archetype = Archetype;
|
||||
Override->Params = Params;
|
||||
if ((VF_WormsForceOff() || !TargetSlot->Definition->bEnableWorms)
|
||||
&& (Archetype == ECaveGeneratorType::TunnelNetwork
|
||||
|| Archetype == ECaveGeneratorType::Underwater))
|
||||
{
|
||||
// The composer is allowed to roll a complete candidate, but a disabled asset must never
|
||||
// retain a worm-enabled candidate in its runtime override, even for code that inspects
|
||||
// the override before GetGenerationParams applies the final resolution gate.
|
||||
Override->Params.TunnelNetworkParams.WormStrength = 0.0f;
|
||||
}
|
||||
VF_SetComposerRuntimeBounds(
|
||||
Override->Params,
|
||||
(float)(TargetSlot->TopChunkZ + 1) * CHUNK_SIZE,
|
||||
@@ -5474,6 +5520,19 @@ FStrateGenerationParams UVoxelStrateManager::GetGenerationParams(const FIntVecto
|
||||
|
||||
const FStrateSlot& Slot = StrateLayout[SlotIdx];
|
||||
|
||||
// This is the one final resolution gate for the asset-owned worm switch. It is deliberately
|
||||
// applied after composer/season replacements and after boundary blending: a disabled current
|
||||
// strate can never be re-enabled by a rolled candidate or by an enabled neighbour.
|
||||
const auto ResolveFinalParams = [&Slot](FStrateGenerationParams Result)
|
||||
{
|
||||
if (VF_WormsForceOff()
|
||||
|| (Slot.Definition != nullptr && !Slot.Definition->bEnableWorms))
|
||||
{
|
||||
Result.WormStrength = 0.0f;
|
||||
}
|
||||
return VF_ApplyRuntimeRoughnessOverrides(Result);
|
||||
};
|
||||
|
||||
#if WITH_EDITOR
|
||||
if (const FVoxelStrateComposerSlotOverride* Override =
|
||||
FindComposerOverride(Slot.StrateIndex))
|
||||
@@ -5483,7 +5542,7 @@ FStrateGenerationParams UVoxelStrateManager::GetGenerationParams(const FIntVecto
|
||||
Result.StrateBottomWorldZ = (float)Slot.BottomChunkZ * CHUNK_SIZE;
|
||||
// A candidate is a hard replacement of this slot. Do not blend its rolled vector with an
|
||||
// authored neighbour at a boundary; this is also how the offline fixture measures it.
|
||||
return VF_ApplyRuntimeRoughnessOverrides(Result);
|
||||
return ResolveFinalParams(Result);
|
||||
}
|
||||
#endif
|
||||
|
||||
@@ -5494,7 +5553,7 @@ FStrateGenerationParams UVoxelStrateManager::GetGenerationParams(const FIntVecto
|
||||
Result.StrateBottomWorldZ = (float)Slot.BottomChunkZ * CHUNK_SIZE;
|
||||
// Season vectors are already final, measured slot records. Vertical structural posts own
|
||||
// their boundary; blending them with another selected recipe would describe neither one.
|
||||
return VF_ApplyRuntimeRoughnessOverrides(Result);
|
||||
return ResolveFinalParams(Result);
|
||||
}
|
||||
|
||||
FStrateGenerationParams BaseParams = BuildParamsFromDefinition(Slot.Definition);
|
||||
@@ -5589,7 +5648,7 @@ FStrateGenerationParams UVoxelStrateManager::GetGenerationParams(const FIntVecto
|
||||
float Alpha = 1.0f - ((float)DistFromBottom / (float)EffectiveBlend);
|
||||
Alpha = FMath::Clamp(Alpha, 0.0f, 1.0f);
|
||||
|
||||
return VF_ApplyRuntimeRoughnessOverrides(
|
||||
return ResolveFinalParams(
|
||||
FStrateGenerationParams::Lerp(BaseParams, BelowParams, Alpha));
|
||||
}
|
||||
break;
|
||||
@@ -5643,7 +5702,7 @@ FStrateGenerationParams UVoxelStrateManager::GetGenerationParams(const FIntVecto
|
||||
// Only blend if alpha > 0 (we're inside the warped transition zone)
|
||||
if (Alpha > 0.0f)
|
||||
{
|
||||
return VF_ApplyRuntimeRoughnessOverrides(
|
||||
return ResolveFinalParams(
|
||||
FStrateGenerationParams::Lerp(BaseParams, BelowParams, Alpha));
|
||||
}
|
||||
}
|
||||
@@ -5685,7 +5744,7 @@ FStrateGenerationParams UVoxelStrateManager::GetGenerationParams(const FIntVecto
|
||||
float Alpha = 1.0f - ((float)DistFromTop / (float)EffectiveBlend);
|
||||
Alpha = FMath::Clamp(Alpha, 0.0f, 1.0f);
|
||||
|
||||
return VF_ApplyRuntimeRoughnessOverrides(
|
||||
return ResolveFinalParams(
|
||||
FStrateGenerationParams::Lerp(BaseParams, AboveParams, Alpha));
|
||||
}
|
||||
break;
|
||||
@@ -5715,7 +5774,7 @@ FStrateGenerationParams UVoxelStrateManager::GetGenerationParams(const FIntVecto
|
||||
|
||||
if (Alpha > 0.0f)
|
||||
{
|
||||
return VF_ApplyRuntimeRoughnessOverrides(
|
||||
return ResolveFinalParams(
|
||||
FStrateGenerationParams::Lerp(BaseParams, AboveParams, Alpha));
|
||||
}
|
||||
}
|
||||
@@ -5725,7 +5784,7 @@ FStrateGenerationParams UVoxelStrateManager::GetGenerationParams(const FIntVecto
|
||||
}
|
||||
|
||||
// Not near any boundary (or Hard transition) — use this strate's params directly
|
||||
return VF_ApplyRuntimeRoughnessOverrides(BaseParams);
|
||||
return ResolveFinalParams(BaseParams);
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
@@ -5745,8 +5804,15 @@ FStrateGenerationParams UVoxelStrateManager::BuildParamsFromDefinition(const UVo
|
||||
{
|
||||
if (!Definition) return FStrateGenerationParams();
|
||||
|
||||
// Base params only — terrain op fields stay 0 until per-room assignment.
|
||||
return Definition->GenerationParams;
|
||||
// Base params only — terrain op fields stay 0 until per-room assignment. Resolve the asset
|
||||
// switch here as well as at the final return so a disabled neighbour cannot leak worm strength
|
||||
// back through a boundary blend.
|
||||
FStrateGenerationParams Result = Definition->GenerationParams;
|
||||
if (VF_WormsForceOff() || !Definition->bEnableWorms)
|
||||
{
|
||||
Result.WormStrength = 0.0f;
|
||||
}
|
||||
return Result;
|
||||
}
|
||||
|
||||
uint64 UVoxelStrateManager::GetGenerationParamsFingerprint() const
|
||||
@@ -5817,6 +5883,13 @@ uint64 UVoxelStrateManager::GetGenerationParamsFingerprint() const
|
||||
HashValue(Slot.HeightInChunks);
|
||||
HashValue(Slot.Definition->GeneratorType);
|
||||
HashValue(Slot.Definition->bUseOperatorStack);
|
||||
HashValue(Slot.Definition->bEnableWorms);
|
||||
HashValue(VF_WormsForceOff());
|
||||
// The selected evaluator is a world input even though it is deliberately not part of
|
||||
// FStrateGenerationParams (the fixed 83-field memo key). Keep persistent/verdict keys
|
||||
// from crossing an explicit WormNoiseMode/WormLatticeStep experiment.
|
||||
HashValue(VoxelWormField::GetNoiseMode());
|
||||
HashValue(VoxelWormField::GetLatticeStep());
|
||||
HashValue(Slot.Definition->StrateHeightInChunks);
|
||||
HashValue(Slot.Definition->TransitionType);
|
||||
HashValue(Slot.Definition->TransitionBlendChunks);
|
||||
|
||||
@@ -0,0 +1,471 @@
|
||||
// VoxelWormField.cpp
|
||||
// Shared deterministic worm-field evaluation and the measured lattice experiment.
|
||||
|
||||
#include "VoxelWormField.h"
|
||||
|
||||
#include "VoxelCaveMorphology.h" // VoxelHash::SeedOffset
|
||||
#include "VoxelGenerator.h" // per-worker canonical tile window
|
||||
#include "VoxelNoise.h"
|
||||
#include "VoxelTypes.h" // VOXEL_NOISE_SCALE
|
||||
|
||||
#include "HAL/IConsoleManager.h"
|
||||
#include "Misc/CommandLine.h"
|
||||
#include "Misc/Parse.h"
|
||||
|
||||
#include <atomic>
|
||||
#include <cfloat>
|
||||
#include <cstring>
|
||||
|
||||
namespace
|
||||
{
|
||||
// The selected production mode is resolved once, before a generation stack is allowed to
|
||||
// observe it, so all workers in a process use one world definition. Mode 0 remains the exact
|
||||
// legacy control for measurements and compatibility investigations.
|
||||
int32 GVoxelForgeWormLatticeStep = 0;
|
||||
std::atomic<int32> GResolvedWormLatticeStep(-1);
|
||||
int32 GVoxelForgeWormNoiseMode = 1;
|
||||
std::atomic<int32> GResolvedWormNoiseMode(-1);
|
||||
|
||||
// The value field has the same threshold/strength contract as legacy Perlin. This small
|
||||
// amplitude retune keeps the authored TunnelNetwork player-fit margin after replacing the
|
||||
// gradient evaluation with the cheaper scalar hash. It is a code default, not a CVar, so a
|
||||
// client cannot silently choose a different world.
|
||||
constexpr float CheapWormNoiseAmplitude = 1.0f;
|
||||
|
||||
FAutoConsoleVariableRef CVarVoxelForgeWormLatticeStep(
|
||||
TEXT("voxel.WormLatticeStep"),
|
||||
GVoxelForgeWormLatticeStep,
|
||||
TEXT("WORLD-CHANGING development experiment. 0=exact, 2/4=coarse worm lattice with "
|
||||
"trilinear interpolation. All multiplayer peers and regenerated worlds must use "
|
||||
"the same value. Default 0 until measured."),
|
||||
ECVF_Default);
|
||||
|
||||
FAutoConsoleVariableRef CVarVoxelForgeWormNoiseMode(
|
||||
TEXT("voxel.WormNoiseMode"),
|
||||
GVoxelForgeWormNoiseMode,
|
||||
TEXT("WORLD-CHANGING development experiment. 0=legacy gradient Perlin, 1=cheap "
|
||||
"deterministic value-noise worm fields. All multiplayer peers and regenerated "
|
||||
"worlds must use the same value. Default 1 (the measured production mode)."),
|
||||
ECVF_Default);
|
||||
|
||||
int32 ResolveLatticeStep()
|
||||
{
|
||||
int32 Existing = GResolvedWormLatticeStep.load(std::memory_order_acquire);
|
||||
if (Existing >= 0)
|
||||
{
|
||||
return Existing;
|
||||
}
|
||||
|
||||
int32 CommandLineValue = GVoxelForgeWormLatticeStep;
|
||||
FParse::Value(
|
||||
FCommandLine::Get(), TEXT("voxel.WormLatticeStep="), CommandLineValue);
|
||||
const int32 Resolved = CommandLineValue == 2 || CommandLineValue == 4
|
||||
? CommandLineValue : 0;
|
||||
int32 Expected = -1;
|
||||
if (!GResolvedWormLatticeStep.compare_exchange_strong(
|
||||
Expected, Resolved, std::memory_order_release, std::memory_order_acquire))
|
||||
{
|
||||
return Expected;
|
||||
}
|
||||
GVoxelForgeWormLatticeStep = Resolved;
|
||||
return Resolved;
|
||||
}
|
||||
|
||||
int32 ResolveNoiseMode()
|
||||
{
|
||||
int32 Existing = GResolvedWormNoiseMode.load(std::memory_order_acquire);
|
||||
if (Existing >= 0)
|
||||
{
|
||||
return Existing;
|
||||
}
|
||||
|
||||
int32 CommandLineValue = GVoxelForgeWormNoiseMode;
|
||||
FParse::Value(
|
||||
FCommandLine::Get(), TEXT("voxel.WormNoiseMode="), CommandLineValue);
|
||||
const int32 Resolved = CommandLineValue == 1 ? 1 : 0;
|
||||
int32 Expected = -1;
|
||||
if (!GResolvedWormNoiseMode.compare_exchange_strong(
|
||||
Expected, Resolved, std::memory_order_release, std::memory_order_acquire))
|
||||
{
|
||||
return Expected;
|
||||
}
|
||||
GVoxelForgeWormNoiseMode = Resolved;
|
||||
return Resolved;
|
||||
}
|
||||
|
||||
FORCEINLINE FVector3f MakeWormNoiseBase(
|
||||
float WorldX,
|
||||
float WorldY,
|
||||
float WorldZ,
|
||||
const VoxelWormField::FParameters& Parameters)
|
||||
{
|
||||
const float EffectiveZ = (Parameters.VerticalScale != 1.0f
|
||||
&& Parameters.VerticalScale > 0.0f)
|
||||
? WorldZ / Parameters.VerticalScale : WorldZ;
|
||||
const float WormZFrequency = Parameters.Frequency * Parameters.HorizontalBias;
|
||||
return FVector3f(
|
||||
WorldX * Parameters.Frequency
|
||||
+ VoxelHash::SeedOffset(Parameters.Seed, 1.0f),
|
||||
WorldY * Parameters.Frequency
|
||||
+ VoxelHash::SeedOffset(Parameters.Seed, 1.7f),
|
||||
EffectiveZ * WormZFrequency
|
||||
+ VoxelHash::SeedOffset(Parameters.Seed, 2.3f));
|
||||
}
|
||||
|
||||
FORCEINLINE float EvaluateN1Field(
|
||||
float WorldX,
|
||||
float WorldY,
|
||||
float WorldZ,
|
||||
const VoxelWormField::FParameters& Parameters,
|
||||
int32 NoiseMode,
|
||||
float NoiseScale)
|
||||
{
|
||||
const FVector3f NoiseBase = MakeWormNoiseBase(
|
||||
WorldX, WorldY, WorldZ, Parameters);
|
||||
return FMath::Abs(
|
||||
(NoiseMode == 0
|
||||
? VoxelNoise::Perlin3D(NoiseBase)
|
||||
: VoxelNoise::ValueNoise3D(NoiseBase, Parameters.Seed, 0x4D3A2F19u))
|
||||
* NoiseScale);
|
||||
}
|
||||
|
||||
FORCEINLINE float EvaluateN2Field(
|
||||
float WorldX,
|
||||
float WorldY,
|
||||
float WorldZ,
|
||||
const VoxelWormField::FParameters& Parameters,
|
||||
int32 NoiseMode,
|
||||
float NoiseScale)
|
||||
{
|
||||
const FVector3f NoiseBase = MakeWormNoiseBase(
|
||||
WorldX, WorldY, WorldZ, Parameters);
|
||||
const FVector3f N2Position = NoiseBase + FVector3f(137.0f, 259.0f, 431.0f);
|
||||
return FMath::Abs(
|
||||
(NoiseMode == 0
|
||||
? VoxelNoise::Perlin3D(N2Position)
|
||||
: VoxelNoise::ValueNoise3D(N2Position, Parameters.Seed, 0xA7C15E2Du))
|
||||
* NoiseScale);
|
||||
}
|
||||
|
||||
FORCEINLINE float EvaluateExactField(
|
||||
float WorldX,
|
||||
float WorldY,
|
||||
float WorldZ,
|
||||
float Threshold,
|
||||
const VoxelWormField::FParameters& Parameters)
|
||||
{
|
||||
const int32 NoiseMode = ResolveNoiseMode();
|
||||
const float NoiseScale = VOXEL_NOISE_SCALE
|
||||
* (NoiseMode == 1 ? CheapWormNoiseAmplitude : 1.0f);
|
||||
const float N1 = EvaluateN1Field(
|
||||
WorldX, WorldY, WorldZ, Parameters, NoiseMode, NoiseScale);
|
||||
|
||||
// N2 is non-negative, so this preserves the old exact evaluator's short-circuit.
|
||||
if (N1 >= Threshold)
|
||||
{
|
||||
return N1;
|
||||
}
|
||||
return N1 + EvaluateN2Field(
|
||||
WorldX, WorldY, WorldZ, Parameters, NoiseMode, NoiseScale);
|
||||
}
|
||||
|
||||
struct FLatticeNode
|
||||
{
|
||||
int32 X = 0;
|
||||
int32 Y = 0;
|
||||
int32 Z = 0;
|
||||
float Value = 0.0f;
|
||||
bool bValid = false;
|
||||
};
|
||||
|
||||
// The shared density grid is traversed z/y/x. Retaining two adjacent lattice planes is
|
||||
// necessary for the z transition; 2048 entries evicted the previous plane and made the
|
||||
// experiment slower than exact evaluation. This is fixed storage, not a heap allocation, and
|
||||
// remains deterministic on every worker.
|
||||
constexpr uint32 LatticeCacheSize = 32768;
|
||||
static_assert((LatticeCacheSize & (LatticeCacheSize - 1u)) == 0,
|
||||
"The lattice cache size must remain a power of two for the mask lookup.");
|
||||
constexpr int32 TileLatticeAxis = 32;
|
||||
static_assert(static_cast<uint32>(TileLatticeAxis * TileLatticeAxis * TileLatticeAxis)
|
||||
== LatticeCacheSize,
|
||||
"The direct tile lattice must use the fixed cache storage exactly.");
|
||||
|
||||
struct FLatticeCache
|
||||
{
|
||||
uint32 Seed = 0;
|
||||
uint32 FrequencyBits = 0;
|
||||
uint32 HorizontalBiasBits = 0;
|
||||
uint32 VerticalScaleBits = 0;
|
||||
int32 Step = 0;
|
||||
bool bUseTileWindow = false;
|
||||
FIntVector TileBaseGrid = FIntVector::ZeroValue;
|
||||
int32 TileSampleStep = 0;
|
||||
int32 TileCellsPerAxis = 0;
|
||||
bool bContextValid = false;
|
||||
FLatticeNode Nodes[LatticeCacheSize];
|
||||
|
||||
void SetContext(
|
||||
const VoxelWormField::FParameters& Parameters,
|
||||
int32 InStep,
|
||||
bool InUseTileWindow,
|
||||
const FIntVector& InTileOrigin,
|
||||
int32 InTileSampleStep,
|
||||
int32 InTileCellsPerAxis)
|
||||
{
|
||||
uint32 FrequencyBitsIn = 0;
|
||||
uint32 HorizontalBiasBitsIn = 0;
|
||||
uint32 VerticalScaleBitsIn = 0;
|
||||
FMemory::Memcpy(&FrequencyBitsIn, &Parameters.Frequency, sizeof(uint32));
|
||||
FMemory::Memcpy(&HorizontalBiasBitsIn, &Parameters.HorizontalBias, sizeof(uint32));
|
||||
FMemory::Memcpy(&VerticalScaleBitsIn, &Parameters.VerticalScale, sizeof(uint32));
|
||||
const double WormStepD = static_cast<double>(InStep);
|
||||
const FIntVector InTileBaseGrid(
|
||||
FMath::FloorToInt(static_cast<double>(InTileOrigin.X) / WormStepD) - 2,
|
||||
FMath::FloorToInt(static_cast<double>(InTileOrigin.Y) / WormStepD) - 2,
|
||||
FMath::FloorToInt(static_cast<double>(InTileOrigin.Z) / WormStepD) - 2);
|
||||
if (bContextValid
|
||||
&& Seed == Parameters.Seed
|
||||
&& FrequencyBits == FrequencyBitsIn
|
||||
&& HorizontalBiasBits == HorizontalBiasBitsIn
|
||||
&& VerticalScaleBits == VerticalScaleBitsIn
|
||||
&& Step == InStep
|
||||
&& bUseTileWindow == InUseTileWindow
|
||||
&& TileBaseGrid == InTileBaseGrid
|
||||
&& TileSampleStep == InTileSampleStep
|
||||
&& TileCellsPerAxis == InTileCellsPerAxis)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
Seed = Parameters.Seed;
|
||||
FrequencyBits = FrequencyBitsIn;
|
||||
HorizontalBiasBits = HorizontalBiasBitsIn;
|
||||
VerticalScaleBits = VerticalScaleBitsIn;
|
||||
Step = InStep;
|
||||
bUseTileWindow = InUseTileWindow;
|
||||
TileBaseGrid = InTileBaseGrid;
|
||||
TileSampleStep = InTileSampleStep;
|
||||
TileCellsPerAxis = InTileCellsPerAxis;
|
||||
bContextValid = true;
|
||||
for (FLatticeNode& Node : Nodes)
|
||||
{
|
||||
Node.bValid = false;
|
||||
}
|
||||
}
|
||||
|
||||
static uint32 Hash(int32 X, int32 Y, int32 Z)
|
||||
{
|
||||
uint32 H = static_cast<uint32>(X) * 0x9E3779B1u;
|
||||
H ^= static_cast<uint32>(Y) * 0x85EBCA77u;
|
||||
H ^= static_cast<uint32>(Z) * 0xC2B2AE3Du;
|
||||
H ^= H >> 16;
|
||||
H *= 0x7FEB352Du;
|
||||
H ^= H >> 15;
|
||||
return H;
|
||||
}
|
||||
|
||||
float Get(int32 X, int32 Y, int32 Z,
|
||||
const VoxelWormField::FParameters& Parameters,
|
||||
int32 NoiseMode,
|
||||
float NoiseScale)
|
||||
{
|
||||
const auto EvaluateNode = [this, &Parameters, NoiseMode, NoiseScale](FLatticeNode& Node,
|
||||
int32 NodeX, int32 NodeY,
|
||||
int32 NodeZ) -> float
|
||||
{
|
||||
if (Node.bValid && Node.X == NodeX && Node.Y == NodeY && Node.Z == NodeZ)
|
||||
{
|
||||
return Node.Value;
|
||||
}
|
||||
Node.X = NodeX;
|
||||
Node.Y = NodeY;
|
||||
Node.Z = NodeZ;
|
||||
const double StepD = static_cast<double>(Step);
|
||||
const float WorldX = static_cast<float>(static_cast<double>(NodeX) * StepD);
|
||||
const float WorldY = static_cast<float>(static_cast<double>(NodeY) * StepD);
|
||||
const float WorldZ = static_cast<float>(static_cast<double>(NodeZ) * StepD);
|
||||
// The lattice stores N1 only. The requested voxel uses this interpolated N1 for
|
||||
// the threshold decision; N2 remains an exact point query only in the carve
|
||||
// region. This removes the first noise call on the hot above-threshold majority
|
||||
// without making the second noise unconditional.
|
||||
Node.Value = EvaluateN1Field(
|
||||
WorldX, WorldY, WorldZ, Parameters, NoiseMode, NoiseScale);
|
||||
Node.bValid = true;
|
||||
return Node.Value;
|
||||
};
|
||||
|
||||
if (bUseTileWindow)
|
||||
{
|
||||
const int32 LocalX = X - TileBaseGrid.X;
|
||||
const int32 LocalY = Y - TileBaseGrid.Y;
|
||||
const int32 LocalZ = Z - TileBaseGrid.Z;
|
||||
if (LocalX >= 0 && LocalX < TileLatticeAxis
|
||||
&& LocalY >= 0 && LocalY < TileLatticeAxis
|
||||
&& LocalZ >= 0 && LocalZ < TileLatticeAxis)
|
||||
{
|
||||
FLatticeNode& Node = Nodes[
|
||||
(LocalZ * TileLatticeAxis + LocalY) * TileLatticeAxis + LocalX];
|
||||
return EvaluateNode(Node, X, Y, Z);
|
||||
}
|
||||
|
||||
// A malformed or unusually large tile window must not alter the field's finite
|
||||
// fallback semantics. It is outside the fixed direct table, so evaluate N1 once
|
||||
// for this sample rather than attempting an unbounded allocation.
|
||||
const double StepD = static_cast<double>(Step);
|
||||
return EvaluateN1Field(
|
||||
static_cast<float>(static_cast<double>(X) * StepD),
|
||||
static_cast<float>(static_cast<double>(Y) * StepD),
|
||||
static_cast<float>(static_cast<double>(Z) * StepD),
|
||||
Parameters, NoiseMode, NoiseScale);
|
||||
}
|
||||
|
||||
const uint32 Start = Hash(X, Y, Z) & (LatticeCacheSize - 1u);
|
||||
for (uint32 Probe = 0; Probe < LatticeCacheSize; ++Probe)
|
||||
{
|
||||
FLatticeNode& Node = Nodes[(Start + Probe) & (LatticeCacheSize - 1u)];
|
||||
if (Node.bValid)
|
||||
{
|
||||
if (Node.X == X && Node.Y == Y && Node.Z == Z)
|
||||
{
|
||||
return Node.Value;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
Node.X = X;
|
||||
Node.Y = Y;
|
||||
Node.Z = Z;
|
||||
return EvaluateNode(Node, X, Y, Z);
|
||||
}
|
||||
|
||||
// A saturated cache is exceptionally unlikely for one density block. Falling back to
|
||||
// a direct N1 evaluation keeps the result bounded if a caller exceeds it.
|
||||
const double StepD = static_cast<double>(Step);
|
||||
return EvaluateN1Field(
|
||||
static_cast<float>(static_cast<double>(X) * StepD),
|
||||
static_cast<float>(static_cast<double>(Y) * StepD),
|
||||
static_cast<float>(static_cast<double>(Z) * StepD),
|
||||
Parameters, NoiseMode, NoiseScale);
|
||||
}
|
||||
};
|
||||
|
||||
thread_local FLatticeCache GLatticeCache;
|
||||
|
||||
FORCEINLINE bool CanUseLattice(float WorldX, float WorldY, float WorldZ, int32 Step)
|
||||
{
|
||||
if (Step <= 1 || !FMath::IsFinite(WorldX) || !FMath::IsFinite(WorldY)
|
||||
|| !FMath::IsFinite(WorldZ))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// The integer grid indices must survive the conversion back to a finite float world
|
||||
// coordinate. Normal VoxelForge worlds are far inside this envelope; pathological input
|
||||
// takes the exact path rather than changing overflow behaviour.
|
||||
constexpr double MaxGridCoordinate = 1000000000.0;
|
||||
return FMath::Abs(static_cast<double>(WorldX) / static_cast<double>(Step))
|
||||
<= MaxGridCoordinate
|
||||
&& FMath::Abs(static_cast<double>(WorldY) / static_cast<double>(Step))
|
||||
<= MaxGridCoordinate
|
||||
&& FMath::Abs(static_cast<double>(WorldZ) / static_cast<double>(Step))
|
||||
<= MaxGridCoordinate;
|
||||
}
|
||||
|
||||
FORCEINLINE float Lerp(float A, float B, float Alpha)
|
||||
{
|
||||
return A + (B - A) * Alpha;
|
||||
}
|
||||
|
||||
float EvaluateLattice(
|
||||
float WorldX,
|
||||
float WorldY,
|
||||
float WorldZ,
|
||||
const VoxelWormField::FParameters& Parameters,
|
||||
int32 Step,
|
||||
float NoiseScale)
|
||||
{
|
||||
const int32 NoiseMode = ResolveNoiseMode();
|
||||
const bool bUseTileWindow = VoxelGenLOD::TileCellsPerAxis > 0
|
||||
&& VoxelGenLOD::TileCellsPerAxis <= CHUNK_SIZE
|
||||
&& VoxelGenLOD::SampleStep > 0;
|
||||
GLatticeCache.SetContext(
|
||||
Parameters,
|
||||
Step,
|
||||
bUseTileWindow,
|
||||
VoxelGenLOD::TileOriginVoxels,
|
||||
VoxelGenLOD::SampleStep,
|
||||
VoxelGenLOD::TileCellsPerAxis);
|
||||
|
||||
const double StepD = static_cast<double>(Step);
|
||||
const double GX = static_cast<double>(WorldX) / StepD;
|
||||
const double GY = static_cast<double>(WorldY) / StepD;
|
||||
const double GZ = static_cast<double>(WorldZ) / StepD;
|
||||
const int32 X0 = FMath::FloorToInt(GX);
|
||||
const int32 Y0 = FMath::FloorToInt(GY);
|
||||
const int32 Z0 = FMath::FloorToInt(GZ);
|
||||
const float Tx = static_cast<float>(GX - static_cast<double>(X0));
|
||||
const float Ty = static_cast<float>(GY - static_cast<double>(Y0));
|
||||
const float Tz = static_cast<float>(GZ - static_cast<double>(Z0));
|
||||
|
||||
const float V000 = GLatticeCache.Get(X0, Y0, Z0, Parameters, NoiseMode, NoiseScale);
|
||||
const float V100 = GLatticeCache.Get(X0 + 1, Y0, Z0, Parameters, NoiseMode, NoiseScale);
|
||||
const float V010 = GLatticeCache.Get(X0, Y0 + 1, Z0, Parameters, NoiseMode, NoiseScale);
|
||||
const float V110 = GLatticeCache.Get(X0 + 1, Y0 + 1, Z0, Parameters, NoiseMode, NoiseScale);
|
||||
const float V001 = GLatticeCache.Get(X0, Y0, Z0 + 1, Parameters, NoiseMode, NoiseScale);
|
||||
const float V101 = GLatticeCache.Get(X0 + 1, Y0, Z0 + 1, Parameters, NoiseMode, NoiseScale);
|
||||
const float V011 = GLatticeCache.Get(X0, Y0 + 1, Z0 + 1, Parameters, NoiseMode, NoiseScale);
|
||||
const float V111 = GLatticeCache.Get(X0 + 1, Y0 + 1, Z0 + 1, Parameters, NoiseMode, NoiseScale);
|
||||
|
||||
const float X00 = Lerp(V000, V100, Tx);
|
||||
const float X10 = Lerp(V010, V110, Tx);
|
||||
const float X01 = Lerp(V001, V101, Tx);
|
||||
const float X11 = Lerp(V011, V111, Tx);
|
||||
return Lerp(Lerp(X00, X10, Ty), Lerp(X01, X11, Ty), Tz);
|
||||
}
|
||||
}
|
||||
|
||||
namespace VoxelWormField
|
||||
{
|
||||
int32 GetLatticeStep()
|
||||
{
|
||||
return ResolveLatticeStep();
|
||||
}
|
||||
|
||||
int32 GetNoiseMode()
|
||||
{
|
||||
return ResolveNoiseMode();
|
||||
}
|
||||
|
||||
float EvaluateExact(
|
||||
float WorldX,
|
||||
float WorldY,
|
||||
float WorldZ,
|
||||
float Threshold,
|
||||
const FParameters& Parameters)
|
||||
{
|
||||
return EvaluateExactField(WorldX, WorldY, WorldZ, Threshold, Parameters);
|
||||
}
|
||||
|
||||
float Evaluate(
|
||||
float WorldX,
|
||||
float WorldY,
|
||||
float WorldZ,
|
||||
float Threshold,
|
||||
const FParameters& Parameters,
|
||||
int32 LatticeStep)
|
||||
{
|
||||
const int32 NoiseMode = ResolveNoiseMode();
|
||||
const bool bUseLattice = CanUseLattice(WorldX, WorldY, WorldZ, LatticeStep);
|
||||
const float NoiseScale = VOXEL_NOISE_SCALE
|
||||
* (NoiseMode == 1 ? CheapWormNoiseAmplitude : 1.0f);
|
||||
const float N1 = bUseLattice
|
||||
? EvaluateLattice(WorldX, WorldY, WorldZ, Parameters, LatticeStep, NoiseScale)
|
||||
: EvaluateN1Field(WorldX, WorldY, WorldZ, Parameters, NoiseMode, NoiseScale);
|
||||
if (N1 >= Threshold)
|
||||
{
|
||||
return N1;
|
||||
}
|
||||
return N1 + EvaluateN2Field(
|
||||
WorldX, WorldY, WorldZ, Parameters, NoiseMode, NoiseScale);
|
||||
}
|
||||
}
|
||||
@@ -66,6 +66,8 @@ namespace VoxelGenLOD
|
||||
VOXELFORGE_API bool IsTileCacheWindowEnabled(bool bFusedPath = true);
|
||||
VOXELFORGE_API bool GetThreadTileCacheWindow(
|
||||
FIntVector& OutOriginVoxels, int32& OutStep, int32& OutCellsPerAxis);
|
||||
VOXELFORGE_API void SetThreadTileContext(
|
||||
const FIntVector& OriginVoxels, int32 CellsPerAxis);
|
||||
|
||||
// Effective octave count for a per-voxel noise call site.
|
||||
// At least 1 octave always survives (the coarse base shape).
|
||||
|
||||
@@ -142,6 +142,56 @@ FORCEINLINE float Perlin3D(const FVector3f& P)
|
||||
return Perlin3D(P.X, P.Y, P.Z);
|
||||
}
|
||||
|
||||
// A smooth, deterministic value-noise sample for the worm-only cost experiment. It keeps the
|
||||
// same unit lattice and quintic interpolation as Perlin3D, but uses one seeded scalar hash per
|
||||
// corner instead of the eight gradient selections and dot products. It is intentionally not used
|
||||
// by the terrain's other noise fields; WormNoiseMode gates it as an explicit world-changing test.
|
||||
FORCEINLINE uint32 ValueNoiseHash(int32 X, int32 Y, int32 Z, uint32 Seed, uint32 Salt)
|
||||
{
|
||||
uint32 H = Detail::HashCorner(X, Y, Z) ^ Seed ^ Salt;
|
||||
H ^= H >> 16;
|
||||
H *= 0x7FEB352Du;
|
||||
H ^= H >> 15;
|
||||
return H;
|
||||
}
|
||||
|
||||
FORCEINLINE float ValueNoise3D(const FVector3f& P, uint32 Seed, uint32 Salt)
|
||||
{
|
||||
const float XFloor = FMath::FloorToFloat(P.X);
|
||||
const float YFloor = FMath::FloorToFloat(P.Y);
|
||||
const float ZFloor = FMath::FloorToFloat(P.Z);
|
||||
const int32 X = static_cast<int32>(XFloor);
|
||||
const int32 Y = static_cast<int32>(YFloor);
|
||||
const int32 Z = static_cast<int32>(ZFloor);
|
||||
const float Fx = P.X - XFloor;
|
||||
const float Fy = P.Y - YFloor;
|
||||
const float Fz = P.Z - ZFloor;
|
||||
const float Sx = Detail::Fade(Fx);
|
||||
const float Sy = Detail::Fade(Fy);
|
||||
const float Sz = Detail::Fade(Fz);
|
||||
constexpr float HashToSigned = 2.0f / 16777216.0f;
|
||||
const auto Sample = [Seed, Salt, HashToSigned](int32 IX, int32 IY, int32 IZ) -> float
|
||||
{
|
||||
return static_cast<float>(ValueNoiseHash(IX, IY, IZ, Seed, Salt) & 0x00FFFFFFu)
|
||||
* HashToSigned - 1.0f;
|
||||
};
|
||||
const float V000 = Sample(X, Y, Z);
|
||||
const float V100 = Sample(X + 1, Y, Z);
|
||||
const float V010 = Sample(X, Y + 1, Z);
|
||||
const float V110 = Sample(X + 1, Y + 1, Z);
|
||||
const float V001 = Sample(X, Y, Z + 1);
|
||||
const float V101 = Sample(X + 1, Y, Z + 1);
|
||||
const float V011 = Sample(X, Y + 1, Z + 1);
|
||||
const float V111 = Sample(X + 1, Y + 1, Z + 1);
|
||||
const float X00 = Detail::Lerp(V000, V100, Sx);
|
||||
const float X10 = Detail::Lerp(V010, V110, Sx);
|
||||
const float X01 = Detail::Lerp(V001, V101, Sx);
|
||||
const float X11 = Detail::Lerp(V011, V111, Sx);
|
||||
const float Y0 = Detail::Lerp(X00, X10, Sy);
|
||||
const float Y1 = Detail::Lerp(X01, X11, Sy);
|
||||
return Detail::Lerp(Y0, Y1, Sz);
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
// LIPSCHITZ BOUND FOR THE ACTUAL 3D FIELD
|
||||
//=============================================================================
|
||||
|
||||
@@ -34,6 +34,7 @@ public:
|
||||
bool bSupported = false;
|
||||
bool bStarted = false;
|
||||
bool bOutputWritten = false;
|
||||
bool bModuleMapWritten = false;
|
||||
bool bStackWalkingInitialized = false;
|
||||
uint32 IntervalUs = 0;
|
||||
uint32 MaxDepth = 0;
|
||||
@@ -47,6 +48,8 @@ public:
|
||||
uint64 RetainedSamples = 0;
|
||||
uint64 DroppedSamples = 0;
|
||||
uint64 TotalFrames = 0;
|
||||
// Kept for source compatibility with the earlier in-process summary. Raw sessions leave
|
||||
// these zero; the offline summary owns all resolved-frame counts and tables.
|
||||
uint64 ResolvedFrames = 0;
|
||||
uint64 UnknownFrames = 0;
|
||||
uint64 WaitLikeFrames = 0;
|
||||
@@ -55,10 +58,12 @@ public:
|
||||
uint64 UniqueProgramCounters = 0;
|
||||
uint64 InlineSymbols = 0;
|
||||
uint64 MaxActiveRegisteredThreads = 0;
|
||||
uint64 ModuleCount = 0;
|
||||
double RunSeconds = 0.0;
|
||||
|
||||
FString RunLabel;
|
||||
FString RawSamplesPath;
|
||||
FString ModuleMapPath;
|
||||
FString SummaryPath;
|
||||
};
|
||||
|
||||
|
||||
@@ -136,6 +136,15 @@ public:
|
||||
meta = (DisplayName = "Use Operator Stack (experimental)"))
|
||||
bool bUseOperatorStack = false;
|
||||
|
||||
/**
|
||||
* Authoritative per-strate worm switch. Existing assets default to enabled. The manager
|
||||
* resolves a disabled strate to WormStrength == 0 before any fused, stack, composer, or
|
||||
* interval path sees its parameters, so this is a geometry switch rather than a local CVar.
|
||||
*/
|
||||
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Strate|Generation",
|
||||
meta = (DisplayName = "Enable Worms"))
|
||||
bool bEnableWorms = true;
|
||||
|
||||
//=========================================================================
|
||||
// TUNNEL NETWORK PARAMS (shown only for TunnelNetwork generator type)
|
||||
//=========================================================================
|
||||
|
||||
@@ -0,0 +1,45 @@
|
||||
// VoxelWormField.h
|
||||
// Shared deterministic evaluation for the TunnelNetwork worm field.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "CoreMinimal.h"
|
||||
|
||||
namespace VoxelWormField
|
||||
{
|
||||
/** The scalar inputs used by both the fused and operator-stack evaluators. */
|
||||
struct FParameters
|
||||
{
|
||||
float Frequency = 0.0f;
|
||||
float HorizontalBias = 0.0f;
|
||||
float VerticalScale = 1.0f;
|
||||
uint32 Seed = 0;
|
||||
};
|
||||
|
||||
/**
|
||||
* Return the selected development experiment mode.
|
||||
*
|
||||
* 0 is the exact field. 2 and 4 evaluate the exact field on that many-voxel lattice and
|
||||
* trilinearly interpolate it. This is intentionally a WORLD-CHANGING development switch:
|
||||
* it must not be changed between multiplayer peers or for an already generated world.
|
||||
*/
|
||||
VOXELFORGE_API int32 GetLatticeStep();
|
||||
VOXELFORGE_API int32 GetNoiseMode();
|
||||
|
||||
/** Evaluate the exact two-noise field, retaining the N1 threshold short-circuit. */
|
||||
VOXELFORGE_API float EvaluateExact(
|
||||
float WorldX,
|
||||
float WorldY,
|
||||
float WorldZ,
|
||||
float Threshold,
|
||||
const FParameters& Parameters);
|
||||
|
||||
/** Evaluate the exact field or its selected cached lattice approximation. */
|
||||
VOXELFORGE_API float Evaluate(
|
||||
float WorldX,
|
||||
float WorldY,
|
||||
float WorldZ,
|
||||
float Threshold,
|
||||
const FParameters& Parameters,
|
||||
int32 LatticeStep);
|
||||
}
|
||||
@@ -1,4 +1,5 @@
|
||||
#include "VoxelForgeExploreCommandlet.h"
|
||||
#include "VoxelStackOfflineSymbolizer.h"
|
||||
|
||||
#include "CoreMinimal.h"
|
||||
#include "Async/ParallelFor.h"
|
||||
@@ -32,6 +33,7 @@
|
||||
#include "VoxelGenerator.h"
|
||||
#include "VoxelMarchingCubesMesher.h"
|
||||
#include "VoxelNoise.h"
|
||||
#include "VoxelWormField.h"
|
||||
#include "VoxelSettings.h"
|
||||
#include "VoxelStackSampler.h"
|
||||
#include "VoxelStrateDefinition.h"
|
||||
@@ -265,6 +267,10 @@ struct FExploreArguments
|
||||
bool bWalk = true;
|
||||
bool bExport = true;
|
||||
bool bUseOperatorStack = true;
|
||||
bool bWormsEnabledOverride = false;
|
||||
bool bWormsEnabled = true;
|
||||
bool bWormStrengthOverride = false;
|
||||
float WormStrength = 0.0f;
|
||||
bool bProfileDensity = false;
|
||||
bool bProfileDensityFull = false;
|
||||
bool bPerfAttribution = false;
|
||||
@@ -364,6 +370,17 @@ bool ParseArguments(const FString& Params, FExploreArguments& OutArguments, FStr
|
||||
int32 UseOperatorStack = 1;
|
||||
FParse::Value(*Params, TEXT("opstack="), UseOperatorStack);
|
||||
OutArguments.bUseOperatorStack = UseOperatorStack != 0;
|
||||
int32 WormsEnabled = 1;
|
||||
if (FParse::Value(*Params, TEXT("wormsenabled="), WormsEnabled))
|
||||
{
|
||||
OutArguments.bWormsEnabledOverride = true;
|
||||
OutArguments.bWormsEnabled = WormsEnabled != 0;
|
||||
}
|
||||
if (Params.Contains(TEXT("wormstrength="), ESearchCase::IgnoreCase)
|
||||
&& FParse::Value(*Params, TEXT("wormstrength="), OutArguments.WormStrength))
|
||||
{
|
||||
OutArguments.bWormStrengthOverride = true;
|
||||
}
|
||||
OutArguments.bProfileDensity = FParse::Param(*Params, TEXT("profiledensity"));
|
||||
OutArguments.bProfileDensityFull = FParse::Param(*Params, TEXT("profiledensityfull"));
|
||||
OutArguments.bProfileDensity |= OutArguments.bProfileDensityFull;
|
||||
@@ -881,6 +898,10 @@ struct FExploreWorld
|
||||
int32 ExploreMeshSize = 0;
|
||||
int32 ExploreMeshTileCount = 0;
|
||||
int32 ExploreMeshTilesCompleted = 0;
|
||||
// Per-tile geometry identity is retained in canonical Z/Y/X order so an optimization can be
|
||||
// compared without treating one aggregate hash or triangle total as a shape measurement.
|
||||
TArray<int32> ExploreTileTriangleCounts;
|
||||
TArray<FString> ExploreTileGeometryHashes;
|
||||
double ExploreMeshSeconds = 0.0;
|
||||
// Exact wall-clock partition of ExploreMeshSeconds. The first three fields end at the
|
||||
// parallel tile launch; merge closes the mesh clock. Remainder is intentionally retained
|
||||
@@ -966,6 +987,16 @@ struct FExploreWorld
|
||||
// Explicitly select the production switch so the same synthetic layout, seed and
|
||||
// mesher invocation can be measured through both density branches.
|
||||
Definition->bUseOperatorStack = Arguments.bUseOperatorStack;
|
||||
if (Arguments.bWormsEnabledOverride)
|
||||
{
|
||||
Definition->bEnableWorms = Arguments.bWormsEnabled;
|
||||
}
|
||||
if (Arguments.bWormStrengthOverride
|
||||
&& (Definition->GeneratorType == ECaveGeneratorType::TunnelNetwork
|
||||
|| Definition->GeneratorType == ECaveGeneratorType::Underwater))
|
||||
{
|
||||
Definition->GenerationParams.WormStrength = Arguments.WormStrength;
|
||||
}
|
||||
|
||||
const TSoftObjectPtr<UVoxelStrateDefinition> SoftDefinition(Definition);
|
||||
Settings->FixedStrates.Add(Index, SoftDefinition);
|
||||
@@ -1702,6 +1733,8 @@ bool EnsureExploreMesh(
|
||||
const int32 TilesPerAxis = Arguments.ExportSize / CHUNK_SIZE;
|
||||
World.ExploreMeshTileCount = TilesPerAxis * TilesPerAxis * TilesPerAxis;
|
||||
World.ExploreMeshTilesCompleted = 0;
|
||||
World.ExploreTileTriangleCounts.Init(0, World.ExploreMeshTileCount);
|
||||
World.ExploreTileGeometryHashes.SetNum(World.ExploreMeshTileCount);
|
||||
World.ExploreMeshOrigin = ChooseExploreMeshOrigin(
|
||||
Arguments,
|
||||
CameraSeedWalk,
|
||||
@@ -1812,6 +1845,15 @@ bool EnsureExploreMesh(
|
||||
const int32 OwnerX = LinearOwnerIndex % GridTileCount;
|
||||
const int32 OwnerY = (LinearOwnerIndex / GridTileCount) % GridTileCount;
|
||||
const int32 OwnerZ = LinearOwnerIndex / (GridTileCount * GridTileCount);
|
||||
FIntVector PreviousTileOrigin = FIntVector::ZeroValue;
|
||||
int32 IgnoredPreviousTileStep = 1;
|
||||
int32 PreviousTileCells = 0;
|
||||
VoxelGenLOD::GetThreadTileCacheWindow(
|
||||
PreviousTileOrigin, IgnoredPreviousTileStep, PreviousTileCells);
|
||||
VoxelGenLOD::SetThreadTileContext(
|
||||
World.ExploreMeshOrigin
|
||||
+ FIntVector(OwnerX * CHUNK_SIZE, OwnerY * CHUNK_SIZE, OwnerZ * CHUNK_SIZE),
|
||||
CellsPerTile);
|
||||
// Partition the shared lattice into disjoint rectangular owner regions. A
|
||||
// boundary sample belongs to exactly one owner; tile windows may read it from
|
||||
// either side. This keeps the generator's spatial locality while guaranteeing
|
||||
@@ -1849,6 +1891,7 @@ bool EnsureExploreMesh(
|
||||
}
|
||||
VoxelGenLOD::SetThreadOctaveBias(PreviousOctaveBias);
|
||||
VoxelGenLOD::SetThreadSampleStep(PreviousSampleStep);
|
||||
VoxelGenLOD::SetThreadTileContext(PreviousTileOrigin, PreviousTileCells);
|
||||
},
|
||||
EParallelForFlags::None);
|
||||
World.ExploreDensityGridSeconds = FPlatformTime::Seconds() - DensityGridStartSeconds;
|
||||
@@ -1988,6 +2031,10 @@ bool EnsureExploreMesh(
|
||||
World.ExploreMeshSeconds = FPlatformTime::Seconds() - MeshStartSeconds;
|
||||
return false;
|
||||
}
|
||||
World.ExploreTileTriangleCounts[CompletedTiles] =
|
||||
TileMeshes[CompletedTiles].Triangles.Num() / 3;
|
||||
World.ExploreTileGeometryHashes[CompletedTiles] =
|
||||
ComputeGeometryHash(TileMeshes[CompletedTiles]);
|
||||
World.ExploreMeshTilesCompleted = CompletedTiles + 1;
|
||||
}
|
||||
|
||||
@@ -4145,6 +4192,18 @@ FString BuildManifestJson(
|
||||
Writer->WriteValue(TEXT("archetype"), ArchetypeName(Arguments.Archetype));
|
||||
Writer->WriteValue(TEXT("slot"), Arguments.Slot);
|
||||
Writer->WriteValue(TEXT("operator_stack"), Arguments.bUseOperatorStack);
|
||||
Writer->WriteValue(TEXT("worms_enabled_override"), Arguments.bWormsEnabledOverride);
|
||||
if (Arguments.bWormsEnabledOverride)
|
||||
{
|
||||
Writer->WriteValue(TEXT("worms_enabled"), Arguments.bWormsEnabled);
|
||||
}
|
||||
Writer->WriteValue(TEXT("worm_strength_override"), Arguments.bWormStrengthOverride);
|
||||
if (Arguments.bWormStrengthOverride)
|
||||
{
|
||||
Writer->WriteValue(TEXT("worm_strength"), static_cast<double>(Arguments.WormStrength));
|
||||
}
|
||||
Writer->WriteValue(TEXT("worm_lattice_step"), VoxelWormField::GetLatticeStep());
|
||||
Writer->WriteValue(TEXT("worm_noise_mode"), VoxelWormField::GetNoiseMode());
|
||||
WriteTunnelFloorOverrides(*Writer, Arguments);
|
||||
Writer->WriteValue(TEXT("room_mouth_rise_override"), Arguments.bRoomMouthRiseOverride);
|
||||
if (Arguments.bRoomMouthRiseOverride)
|
||||
@@ -4409,6 +4468,18 @@ FString BuildExploreJson(
|
||||
Writer->WriteValue(TEXT("archetype"), ArchetypeName(Arguments.Archetype));
|
||||
Writer->WriteValue(TEXT("slot"), Arguments.Slot);
|
||||
Writer->WriteValue(TEXT("operator_stack"), Arguments.bUseOperatorStack);
|
||||
Writer->WriteValue(TEXT("worms_enabled_override"), Arguments.bWormsEnabledOverride);
|
||||
if (Arguments.bWormsEnabledOverride)
|
||||
{
|
||||
Writer->WriteValue(TEXT("worms_enabled"), Arguments.bWormsEnabled);
|
||||
}
|
||||
Writer->WriteValue(TEXT("worm_strength_override"), Arguments.bWormStrengthOverride);
|
||||
if (Arguments.bWormStrengthOverride)
|
||||
{
|
||||
Writer->WriteValue(TEXT("worm_strength"), static_cast<double>(Arguments.WormStrength));
|
||||
}
|
||||
Writer->WriteValue(TEXT("worm_lattice_step"), VoxelWormField::GetLatticeStep());
|
||||
Writer->WriteValue(TEXT("worm_noise_mode"), VoxelWormField::GetNoiseMode());
|
||||
WriteTunnelFloorOverrides(*Writer, Arguments);
|
||||
Writer->WriteValue(TEXT("room_mouth_rise_override"), Arguments.bRoomMouthRiseOverride);
|
||||
if (Arguments.bRoomMouthRiseOverride)
|
||||
@@ -4541,6 +4612,29 @@ FString BuildExploreJson(
|
||||
Writer->WriteValue(TEXT("estimated_launch_overhead_seconds"),
|
||||
World.ExploreMeshTaskLaunchOverheadSeconds);
|
||||
Writer->WriteObjectEnd();
|
||||
Writer->WriteObjectStart(TEXT("tile_ledger"));
|
||||
Writer->WriteValue(TEXT("order"), TEXT("z_then_y_then_x"));
|
||||
Writer->WriteValue(TEXT("tile_cells"), CHUNK_SIZE);
|
||||
Writer->WriteValue(TEXT("tile_count"), World.ExploreMeshTileCount);
|
||||
Writer->WriteValue(TEXT("completed_tiles"), World.ExploreMeshTilesCompleted);
|
||||
Writer->WriteArrayStart(TEXT("tiles"));
|
||||
for (int32 TileIndex = 0; TileIndex < World.ExploreMeshTilesCompleted; ++TileIndex)
|
||||
{
|
||||
const int32 TilesPerAxis = Arguments.ExportSize / CHUNK_SIZE;
|
||||
const int32 TileX = TileIndex % TilesPerAxis;
|
||||
const int32 TileY = (TileIndex / TilesPerAxis) % TilesPerAxis;
|
||||
const int32 TileZ = TileIndex / (TilesPerAxis * TilesPerAxis);
|
||||
Writer->WriteObjectStart();
|
||||
Writer->WriteValue(TEXT("index"), TileIndex);
|
||||
Writer->WriteValue(TEXT("x"), TileX);
|
||||
Writer->WriteValue(TEXT("y"), TileY);
|
||||
Writer->WriteValue(TEXT("z"), TileZ);
|
||||
Writer->WriteValue(TEXT("triangle_count"), World.ExploreTileTriangleCounts[TileIndex]);
|
||||
Writer->WriteValue(TEXT("geometry_hash"), World.ExploreTileGeometryHashes[TileIndex]);
|
||||
Writer->WriteObjectEnd();
|
||||
}
|
||||
Writer->WriteArrayEnd();
|
||||
Writer->WriteObjectEnd();
|
||||
Writer->WriteObjectStart(TEXT("counters"));
|
||||
for (int32 Index = 0; Index < VoxelDensityProfile::CounterCount; ++Index)
|
||||
{
|
||||
@@ -6676,6 +6770,29 @@ int32 RunBatch(const FString& Params)
|
||||
|
||||
int32 UVoxelForgeExploreCommandlet::Main(const FString& Params)
|
||||
{
|
||||
FString SymbolizeCsvPath;
|
||||
if (FParse::Value(*Params, TEXT("symbolizestacks="), SymbolizeCsvPath))
|
||||
{
|
||||
FString SymbolizedOutputPath;
|
||||
FString SymbolPath;
|
||||
FParse::Value(*Params, TEXT("symbolizedout="), SymbolizedOutputPath);
|
||||
FParse::Value(*Params, TEXT("symbolpath="), SymbolPath);
|
||||
|
||||
FString SummaryPath;
|
||||
FString Error;
|
||||
if (!VoxelForgeOfflineStackSymbolizer::Run(
|
||||
SymbolizeCsvPath, SymbolizedOutputPath, SymbolPath, SummaryPath, Error))
|
||||
{
|
||||
UE_LOG(LogTemp, Error, TEXT("[VoxelForgeExplore] offline stack symbolization failed: %s"),
|
||||
*Error);
|
||||
return 2;
|
||||
}
|
||||
UE_LOG(LogTemp, Display,
|
||||
TEXT("[VoxelForgeExplore] offline stack symbolization completed summary=%s"),
|
||||
*SummaryPath);
|
||||
return 0;
|
||||
}
|
||||
|
||||
FString BatchPath;
|
||||
if (FParse::Value(*Params, TEXT("batch="), BatchPath))
|
||||
{
|
||||
|
||||
@@ -0,0 +1,953 @@
|
||||
// VoxelStackOfflineSymbolizer.cpp
|
||||
// Post-exit PC -> module/RVA -> function/source/inline resolution.
|
||||
|
||||
#include "VoxelStackOfflineSymbolizer.h"
|
||||
|
||||
#include "Containers/Array.h"
|
||||
#include "Containers/Map.h"
|
||||
#include "Containers/Set.h"
|
||||
#include "HAL/FileManager.h"
|
||||
#include "HAL/PlatformProcess.h"
|
||||
#include "Misc/FileHelper.h"
|
||||
#include "Misc/Paths.h"
|
||||
#include "Misc/Parse.h"
|
||||
#include "Serialization/Archive.h"
|
||||
#include "Containers/StringConv.h"
|
||||
|
||||
#if PLATFORM_WINDOWS
|
||||
#include "Windows/AllowWindowsPlatformTypes.h"
|
||||
THIRD_PARTY_INCLUDES_START
|
||||
#include <Windows.h>
|
||||
#include <DbgHelp.h>
|
||||
THIRD_PARTY_INCLUDES_END
|
||||
#include "Windows/HideWindowsPlatformTypes.h"
|
||||
#endif
|
||||
|
||||
namespace
|
||||
{
|
||||
void WriteUtf8(FArchive& Archive, const FString& Text)
|
||||
{
|
||||
FTCHARToUTF8 Utf8(*Text);
|
||||
if (Utf8.Length() > 0)
|
||||
{
|
||||
Archive.Serialize(const_cast<ANSICHAR*>(Utf8.Get()), Utf8.Length());
|
||||
}
|
||||
}
|
||||
|
||||
FString SanitizeField(const FString& InValue)
|
||||
{
|
||||
FString Result = InValue;
|
||||
Result.ReplaceInline(TEXT("\t"), TEXT(" "));
|
||||
Result.ReplaceInline(TEXT("\r"), TEXT(" "));
|
||||
Result.ReplaceInline(TEXT("\n"), TEXT(" "));
|
||||
return Result;
|
||||
}
|
||||
|
||||
FString NormalizedForClassification(const FString& InValue)
|
||||
{
|
||||
FString Result = InValue;
|
||||
Result.ToLowerInline();
|
||||
Result.ReplaceInline(TEXT("\\"), TEXT("/"));
|
||||
return Result;
|
||||
}
|
||||
|
||||
struct FOfflineModule
|
||||
{
|
||||
FString Path;
|
||||
FString PdbGuid;
|
||||
FString PdbPath;
|
||||
uint32 PdbAge = 0;
|
||||
uint64 LoadBase = 0;
|
||||
uint32 ImageSize = 0;
|
||||
uint64 FileSize = 0;
|
||||
uint64 LastWriteFileTime = 0;
|
||||
bool bNeeded = false;
|
||||
bool bLoaded = false;
|
||||
bool bCurrentIdentityMatches = true;
|
||||
};
|
||||
|
||||
struct FOfflineSample
|
||||
{
|
||||
uint64 SampleIndex = 0;
|
||||
uint64 ElapsedUs = 0;
|
||||
uint64 ThreadId = 0;
|
||||
int32 LODLevel = INDEX_NONE;
|
||||
uint32 Depth = 0;
|
||||
uint64 ProgramCounters[64]{};
|
||||
};
|
||||
|
||||
struct FResolvedSymbol
|
||||
{
|
||||
FString Module;
|
||||
FString Function;
|
||||
FString File;
|
||||
int32 Line = 0;
|
||||
bool bInline = false;
|
||||
};
|
||||
|
||||
struct FResolvedProgramCounter
|
||||
{
|
||||
bool bAttempted = false;
|
||||
int32 ModuleIndex = INDEX_NONE;
|
||||
uint64 Rva = 0;
|
||||
TArray<FResolvedSymbol> Symbols;
|
||||
};
|
||||
|
||||
struct FProfileRow
|
||||
{
|
||||
FString Key;
|
||||
FString Function;
|
||||
FString Module;
|
||||
FString File;
|
||||
FString Label;
|
||||
int32 Line = 0;
|
||||
uint64 Samples = 0;
|
||||
};
|
||||
|
||||
struct FProfileAggregateSet
|
||||
{
|
||||
TMap<FString, FProfileRow> ExclusiveFunctions;
|
||||
TMap<FString, FProfileRow> InclusiveFunctions;
|
||||
TMap<FString, FProfileRow> ExclusiveLines;
|
||||
uint64 SamplesWithStack = 0;
|
||||
};
|
||||
|
||||
const FResolvedSymbol* FirstFunctionSymbol(const FResolvedProgramCounter& Entry)
|
||||
{
|
||||
for (const FResolvedSymbol& Symbol : Entry.Symbols)
|
||||
{
|
||||
if (!Symbol.Function.IsEmpty())
|
||||
{
|
||||
return &Symbol;
|
||||
}
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
const FResolvedSymbol* FirstSourceSymbol(const FResolvedProgramCounter& Entry)
|
||||
{
|
||||
for (const FResolvedSymbol& Symbol : Entry.Symbols)
|
||||
{
|
||||
if (!Symbol.File.IsEmpty() && Symbol.Line > 0)
|
||||
{
|
||||
return &Symbol;
|
||||
}
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
FString SymbolLabel(const FResolvedSymbol& Symbol)
|
||||
{
|
||||
if (Symbol.Function.IsEmpty())
|
||||
{
|
||||
return TEXT("unknown");
|
||||
}
|
||||
|
||||
const FString FunctionLower = NormalizedForClassification(Symbol.Function);
|
||||
if (FunctionLower.Contains(TEXT("std::")))
|
||||
{
|
||||
return TEXT("std");
|
||||
}
|
||||
|
||||
const FString ModuleLower = NormalizedForClassification(Symbol.Module);
|
||||
const FString FileLower = NormalizedForClassification(Symbol.File);
|
||||
if (FileLower.Contains(TEXT("/engine/")))
|
||||
{
|
||||
return TEXT("engine");
|
||||
}
|
||||
|
||||
const bool bVoxelForge = FunctionLower.Contains(TEXT("voxelforge"))
|
||||
|| FileLower.Contains(TEXT("/voxelforge/"))
|
||||
|| ModuleLower.Contains(TEXT("voxelforge"));
|
||||
if (bVoxelForge)
|
||||
{
|
||||
return TEXT("plugin");
|
||||
}
|
||||
|
||||
const bool bModuleIsEngine = ModuleLower.StartsWith(TEXT("unrealeditor-"))
|
||||
|| ModuleLower.StartsWith(TEXT("ue5-"));
|
||||
return bModuleIsEngine ? TEXT("engine") : TEXT("other");
|
||||
}
|
||||
|
||||
bool IsWaitLike(const FResolvedSymbol& Symbol)
|
||||
{
|
||||
const FString FunctionLower = NormalizedForClassification(Symbol.Function);
|
||||
return FunctionLower.Contains(TEXT("wait"))
|
||||
|| FunctionLower.Contains(TEXT("sleep"))
|
||||
|| FunctionLower.Contains(TEXT("semaphore"))
|
||||
|| FunctionLower.Contains(TEXT("fevent"));
|
||||
}
|
||||
|
||||
FString FunctionKey(const FResolvedSymbol& Symbol)
|
||||
{
|
||||
return SymbolLabel(Symbol) + TEXT("\x1f") + Symbol.Function;
|
||||
}
|
||||
|
||||
FString SourceKey(const FResolvedSymbol* Symbol)
|
||||
{
|
||||
if (Symbol == nullptr || Symbol->File.IsEmpty() || Symbol->Line <= 0)
|
||||
{
|
||||
return TEXT("unknown\x1f<unknown>");
|
||||
}
|
||||
return SymbolLabel(*Symbol) + TEXT("\x1f")
|
||||
+ FString::Printf(TEXT("%s:%d"), *Symbol->File, Symbol->Line);
|
||||
}
|
||||
|
||||
void AddFunctionRow(
|
||||
TMap<FString, FProfileRow>& Rows,
|
||||
const FResolvedSymbol* Symbol,
|
||||
uint64 SampleCount)
|
||||
{
|
||||
if (Symbol == nullptr || Symbol->Function.IsEmpty())
|
||||
{
|
||||
return;
|
||||
}
|
||||
const FString Key = FunctionKey(*Symbol);
|
||||
FProfileRow& Row = Rows.FindOrAdd(Key);
|
||||
if (Row.Key.IsEmpty())
|
||||
{
|
||||
Row.Key = Key;
|
||||
Row.Function = Symbol->Function;
|
||||
Row.Module = Symbol->Module;
|
||||
Row.File = Symbol->File;
|
||||
Row.Line = Symbol->Line;
|
||||
Row.Label = SymbolLabel(*Symbol);
|
||||
}
|
||||
Row.Samples += SampleCount;
|
||||
}
|
||||
|
||||
void AddSourceRow(
|
||||
TMap<FString, FProfileRow>& Rows,
|
||||
const FResolvedSymbol* FunctionSymbol,
|
||||
const FResolvedSymbol* SourceSymbol)
|
||||
{
|
||||
const FString Key = SourceKey(SourceSymbol);
|
||||
FProfileRow& Row = Rows.FindOrAdd(Key);
|
||||
if (Row.Key.IsEmpty())
|
||||
{
|
||||
Row.Key = Key;
|
||||
Row.Label = SourceSymbol != nullptr ? SymbolLabel(*SourceSymbol) : TEXT("unknown");
|
||||
Row.File = SourceSymbol != nullptr ? SourceSymbol->File : TEXT("<unknown>");
|
||||
Row.Line = SourceSymbol != nullptr ? SourceSymbol->Line : 0;
|
||||
Row.Function = FunctionSymbol != nullptr ? FunctionSymbol->Function : TEXT("<unknown>");
|
||||
Row.Module = FunctionSymbol != nullptr ? FunctionSymbol->Module : TEXT("<unknown>");
|
||||
}
|
||||
++Row.Samples;
|
||||
}
|
||||
|
||||
TArray<FProfileRow> SortedRows(const TMap<FString, FProfileRow>& InRows)
|
||||
{
|
||||
TArray<FProfileRow> Rows;
|
||||
Rows.Reserve(InRows.Num());
|
||||
for (const TPair<FString, FProfileRow>& Pair : InRows)
|
||||
{
|
||||
Rows.Add(Pair.Value);
|
||||
}
|
||||
Rows.Sort([](const FProfileRow& A, const FProfileRow& B)
|
||||
{
|
||||
return A.Samples != B.Samples ? A.Samples > B.Samples : A.Key < B.Key;
|
||||
});
|
||||
return Rows;
|
||||
}
|
||||
|
||||
void AppendRows(
|
||||
FString& Out,
|
||||
const TCHAR* Title,
|
||||
const TMap<FString, FProfileRow>& InRows,
|
||||
uint64 Denominator,
|
||||
int32 MaxRows)
|
||||
{
|
||||
Out += TEXT("\n");
|
||||
Out += Title;
|
||||
Out += TEXT("\nrank\tsamples\tpercent\tlabel\tfunction\tmodule\tfile\tline\n");
|
||||
const TArray<FProfileRow> Rows = SortedRows(InRows);
|
||||
const int32 Count = FMath::Min(MaxRows, Rows.Num());
|
||||
for (int32 Index = 0; Index < Count; ++Index)
|
||||
{
|
||||
const FProfileRow& Row = Rows[Index];
|
||||
const double Percent = Denominator > 0
|
||||
? static_cast<double>(Row.Samples) * 100.0 / static_cast<double>(Denominator)
|
||||
: 0.0;
|
||||
Out.Appendf(
|
||||
TEXT("%d\t%llu\t%.4f\t%s\t%s\t%s\t%s\t%d\n"),
|
||||
Index + 1,
|
||||
static_cast<unsigned long long>(Row.Samples),
|
||||
Percent,
|
||||
*Row.Label,
|
||||
*Row.Function,
|
||||
*Row.Module,
|
||||
*Row.File,
|
||||
Row.Line);
|
||||
}
|
||||
if (Rows.Num() == 0)
|
||||
{
|
||||
Out += TEXT("(no rows)\n");
|
||||
}
|
||||
}
|
||||
|
||||
FString DeriveSiblingPath(const FString& CsvPath, const TCHAR* OldToken, const TCHAR* NewToken,
|
||||
const TCHAR* Extension)
|
||||
{
|
||||
const FString FullPath = FPaths::ConvertRelativePathToFull(CsvPath);
|
||||
FString BaseName = FPaths::GetBaseFilename(FullPath);
|
||||
if (BaseName.StartsWith(OldToken, ESearchCase::IgnoreCase))
|
||||
{
|
||||
BaseName = FString(NewToken) + BaseName.RightChop(FCString::Strlen(OldToken));
|
||||
}
|
||||
else
|
||||
{
|
||||
BaseName += FString(TEXT(".")) + NewToken;
|
||||
}
|
||||
return FPaths::Combine(FPaths::GetPath(FullPath), BaseName + Extension);
|
||||
}
|
||||
|
||||
bool ParseUint64(const FString& Text, uint64& OutValue)
|
||||
{
|
||||
if (Text.IsEmpty())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
TCHAR* End = nullptr;
|
||||
OutValue = FCString::Strtoui64(*Text, &End, 0);
|
||||
return End != nullptr && End != *Text;
|
||||
}
|
||||
|
||||
bool ReadModuleMap(
|
||||
const FString& ModuleMapPath,
|
||||
TArray<FOfflineModule>& OutModules,
|
||||
FString& OutError)
|
||||
{
|
||||
FString Text;
|
||||
if (!FFileHelper::LoadFileToString(Text, *ModuleMapPath))
|
||||
{
|
||||
OutError = FString::Printf(TEXT("module map is not readable: %s"), *ModuleMapPath);
|
||||
return false;
|
||||
}
|
||||
|
||||
OutModules.Reset();
|
||||
TArray<FString> Lines;
|
||||
Text.ParseIntoArrayLines(Lines, false);
|
||||
for (const FString& Line : Lines)
|
||||
{
|
||||
if (Line.IsEmpty() || Line.StartsWith(TEXT("#"))
|
||||
|| Line.StartsWith(TEXT("module_path\t")))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
TArray<FString> Fields;
|
||||
Line.ParseIntoArray(Fields, TEXT("\t"), false);
|
||||
if (Fields.Num() < 7)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
FOfflineModule Module;
|
||||
Module.Path = Fields[0];
|
||||
uint64 ParsedImageSize = 0;
|
||||
uint64 ParsedPdbAge = 0;
|
||||
if (!ParseUint64(Fields[1], Module.LoadBase)
|
||||
|| !ParseUint64(Fields[2], ParsedImageSize)
|
||||
|| !ParseUint64(Fields[3], Module.FileSize)
|
||||
|| !ParseUint64(Fields[4], Module.LastWriteFileTime)
|
||||
|| !ParseUint64(Fields[6], ParsedPdbAge))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
Module.ImageSize = static_cast<uint32>(ParsedImageSize);
|
||||
Module.PdbAge = static_cast<uint32>(ParsedPdbAge);
|
||||
Module.PdbGuid = Fields[5];
|
||||
Module.PdbPath = Fields.Num() > 7 ? Fields[7] : FString();
|
||||
OutModules.Add(MoveTemp(Module));
|
||||
}
|
||||
|
||||
if (OutModules.Num() == 0)
|
||||
{
|
||||
OutError = FString::Printf(TEXT("module map has no module records: %s"), *ModuleMapPath);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
#if PLATFORM_WINDOWS
|
||||
bool ReadCurrentFileIdentity(const FString& Path, uint64& OutSize, uint64& OutLastWrite)
|
||||
{
|
||||
WIN32_FILE_ATTRIBUTE_DATA FileData{};
|
||||
if (!GetFileAttributesExW(*Path, GetFileExInfoStandard, &FileData))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
ULARGE_INTEGER Size;
|
||||
Size.HighPart = FileData.nFileSizeHigh;
|
||||
Size.LowPart = FileData.nFileSizeLow;
|
||||
OutSize = Size.QuadPart;
|
||||
ULARGE_INTEGER LastWrite;
|
||||
LastWrite.HighPart = FileData.ftLastWriteTime.dwHighDateTime;
|
||||
LastWrite.LowPart = FileData.ftLastWriteTime.dwLowDateTime;
|
||||
OutLastWrite = LastWrite.QuadPart;
|
||||
return true;
|
||||
}
|
||||
|
||||
int32 FindModuleForPc(const TArray<FOfflineModule>& Modules, uint64 ProgramCounter)
|
||||
{
|
||||
for (int32 Index = 0; Index < Modules.Num(); ++Index)
|
||||
{
|
||||
const FOfflineModule& Module = Modules[Index];
|
||||
if (Module.ImageSize > 0 && ProgramCounter >= Module.LoadBase
|
||||
&& ProgramCounter - Module.LoadBase < Module.ImageSize)
|
||||
{
|
||||
return Index;
|
||||
}
|
||||
}
|
||||
return INDEX_NONE;
|
||||
}
|
||||
|
||||
FString DbgHelpFunctionName(const SYMBOL_INFO* Symbol, bool bInline)
|
||||
{
|
||||
if (Symbol == nullptr || Symbol->Name[0] == '\0')
|
||||
{
|
||||
return FString();
|
||||
}
|
||||
int32 Offset = 0;
|
||||
while (Symbol->Name[Offset] != '\0'
|
||||
&& (Symbol->Name[Offset] < 32 || Symbol->Name[Offset] > 127))
|
||||
{
|
||||
++Offset;
|
||||
}
|
||||
const FString Name = FString(ANSI_TO_TCHAR(Symbol->Name + Offset));
|
||||
return bInline
|
||||
? FString::Printf(TEXT("[Inline Frame] %s()"), *Name)
|
||||
: FString::Printf(TEXT("%s()"), *Name);
|
||||
}
|
||||
|
||||
void ResolveProgramCounter(
|
||||
HANDLE Process,
|
||||
uint64 ProgramCounter,
|
||||
const TArray<FOfflineModule>& Modules,
|
||||
TMap<uint64, FResolvedProgramCounter>& Cache,
|
||||
uint64& InOutInlineSymbols,
|
||||
TSet<uint64>& MappedPcs,
|
||||
TSet<uint64>& UnmappedPcs)
|
||||
{
|
||||
FResolvedProgramCounter& Entry = Cache.FindOrAdd(ProgramCounter);
|
||||
if (Entry.bAttempted)
|
||||
{
|
||||
return;
|
||||
}
|
||||
Entry.bAttempted = true;
|
||||
Entry.ModuleIndex = FindModuleForPc(Modules, ProgramCounter);
|
||||
if (Entry.ModuleIndex == INDEX_NONE)
|
||||
{
|
||||
UnmappedPcs.Add(ProgramCounter);
|
||||
return;
|
||||
}
|
||||
|
||||
const FOfflineModule& Module = Modules[Entry.ModuleIndex];
|
||||
Entry.Rva = ProgramCounter - Module.LoadBase;
|
||||
MappedPcs.Add(ProgramCounter);
|
||||
const FString ModuleName = FPaths::GetCleanFilename(Module.Path);
|
||||
|
||||
// The buffer shape and inline query match UE's Windows stack walker, but this resolver is
|
||||
// called only in the post-exit commandlet process.
|
||||
ANSICHAR SymbolBuffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME] = {};
|
||||
SYMBOL_INFO* Symbol = reinterpret_cast<SYMBOL_INFO*>(SymbolBuffer);
|
||||
Symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
|
||||
Symbol->MaxNameLen = MAX_SYM_NAME;
|
||||
|
||||
const DWORD InlineCount = SymAddrIncludeInlineTrace(Process, ProgramCounter);
|
||||
if (InlineCount > 0)
|
||||
{
|
||||
DWORD InlineContext = 0;
|
||||
DWORD FrameIndex = 0;
|
||||
if (SymQueryInlineTrace(
|
||||
Process, ProgramCounter, 0, ProgramCounter, ProgramCounter,
|
||||
&InlineContext, &FrameIndex))
|
||||
{
|
||||
for (DWORD Index = 0; Index < InlineCount; ++Index, ++InlineContext)
|
||||
{
|
||||
DWORD64 Displacement = 0;
|
||||
if (!SymFromInlineContext(
|
||||
Process, ProgramCounter, InlineContext, &Displacement, Symbol))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
FResolvedSymbol Resolved;
|
||||
Resolved.Module = ModuleName;
|
||||
Resolved.Function = DbgHelpFunctionName(Symbol, true);
|
||||
Resolved.bInline = true;
|
||||
|
||||
IMAGEHLP_LINE64 Line{};
|
||||
Line.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
|
||||
DWORD LineDisplacement = 0;
|
||||
if (SymGetLineFromInlineContext(
|
||||
Process, ProgramCounter, InlineContext, 0,
|
||||
&LineDisplacement, &Line))
|
||||
{
|
||||
Resolved.File = Line.FileName != nullptr
|
||||
? FString(ANSI_TO_TCHAR(Line.FileName)) : FString();
|
||||
Resolved.Line = static_cast<int32>(Line.LineNumber);
|
||||
}
|
||||
Entry.Symbols.Add(MoveTemp(Resolved));
|
||||
++InOutInlineSymbols;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
DWORD64 Displacement = 0;
|
||||
if (SymFromAddr(Process, ProgramCounter, &Displacement, Symbol))
|
||||
{
|
||||
FResolvedSymbol Resolved;
|
||||
Resolved.Module = ModuleName;
|
||||
Resolved.Function = DbgHelpFunctionName(Symbol, false);
|
||||
IMAGEHLP_LINE64 Line{};
|
||||
Line.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
|
||||
DWORD LineDisplacement = 0;
|
||||
if (SymGetLineFromAddr64(Process, ProgramCounter, &LineDisplacement, &Line))
|
||||
{
|
||||
Resolved.File = Line.FileName != nullptr
|
||||
? FString(ANSI_TO_TCHAR(Line.FileName)) : FString();
|
||||
Resolved.Line = static_cast<int32>(Line.LineNumber);
|
||||
}
|
||||
Entry.Symbols.Add(MoveTemp(Resolved));
|
||||
}
|
||||
}
|
||||
|
||||
void WritePcMap(
|
||||
const FString& PcMapPath,
|
||||
const TArray<FOfflineModule>& Modules,
|
||||
const TMap<uint64, FResolvedProgramCounter>& Cache)
|
||||
{
|
||||
FArchive* Archive = IFileManager::Get().CreateFileWriter(*PcMapPath);
|
||||
if (Archive == nullptr)
|
||||
{
|
||||
return;
|
||||
}
|
||||
WriteUtf8(*Archive, TEXT("# VoxelForge resolved PC map v1\n"));
|
||||
WriteUtf8(*Archive, TEXT("pc_hex\tmodule_path\tload_base_hex\trva_hex\tinline\tfunction\tfile\tline\n"));
|
||||
|
||||
TArray<uint64> Pcs;
|
||||
Pcs.Reserve(Cache.Num());
|
||||
for (const TPair<uint64, FResolvedProgramCounter>& Pair : Cache)
|
||||
{
|
||||
Pcs.Add(Pair.Key);
|
||||
}
|
||||
Pcs.Sort();
|
||||
for (const uint64 Pc : Pcs)
|
||||
{
|
||||
const FResolvedProgramCounter* Entry = Cache.Find(Pc);
|
||||
if (Entry == nullptr)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
const FOfflineModule* Module = Modules.IsValidIndex(Entry->ModuleIndex)
|
||||
? &Modules[Entry->ModuleIndex] : nullptr;
|
||||
const FString ModulePath = Module != nullptr ? Module->Path : TEXT("<unmapped>");
|
||||
const uint64 LoadBase = Module != nullptr ? Module->LoadBase : 0;
|
||||
const FString ModuleLine = FString::Printf(
|
||||
TEXT("0x%016llX\t%s\t0x%016llX\t0x%llX\t"),
|
||||
static_cast<unsigned long long>(Pc),
|
||||
*SanitizeField(ModulePath),
|
||||
static_cast<unsigned long long>(LoadBase),
|
||||
static_cast<unsigned long long>(Entry->Rva));
|
||||
if (Entry->Symbols.Num() == 0)
|
||||
{
|
||||
WriteUtf8(*Archive, ModuleLine + TEXT("0\t<unknown>\t<unknown>\t0\n"));
|
||||
continue;
|
||||
}
|
||||
for (const FResolvedSymbol& Symbol : Entry->Symbols)
|
||||
{
|
||||
WriteUtf8(*Archive, ModuleLine + FString::Printf(
|
||||
TEXT("%d\t%s\t%s\t%d\n"),
|
||||
Symbol.bInline ? 1 : 0,
|
||||
*SanitizeField(Symbol.Function),
|
||||
*SanitizeField(Symbol.File),
|
||||
Symbol.Line));
|
||||
}
|
||||
}
|
||||
delete Archive;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
namespace VoxelForgeOfflineStackSymbolizer
|
||||
{
|
||||
bool Run(
|
||||
const FString& CsvPath,
|
||||
const FString& OptionalOutputPath,
|
||||
const FString& OptionalSymbolPath,
|
||||
FString& OutSummaryPath,
|
||||
FString& OutError)
|
||||
{
|
||||
OutSummaryPath.Reset();
|
||||
OutError.Reset();
|
||||
|
||||
#if !PLATFORM_WINDOWS
|
||||
OutError = TEXT("offline stack symbolization currently requires Windows DbgHelp");
|
||||
return false;
|
||||
#else
|
||||
const FString FullCsvPath = FPaths::ConvertRelativePathToFull(CsvPath);
|
||||
if (!FPaths::FileExists(FullCsvPath))
|
||||
{
|
||||
OutError = FString::Printf(TEXT("CSV is not readable: %s"), *FullCsvPath);
|
||||
return false;
|
||||
}
|
||||
|
||||
const FString ModuleMapPath = DeriveSiblingPath(
|
||||
FullCsvPath, TEXT("VoxelStackSamples_"), TEXT("VoxelStackModules_"), TEXT(".tsv"));
|
||||
const FString DefaultSummaryPath = DeriveSiblingPath(
|
||||
FullCsvPath, TEXT("VoxelStackSamples_"), TEXT("VoxelStackSummaryOffline_"), TEXT(".txt"));
|
||||
OutSummaryPath = OptionalOutputPath.IsEmpty()
|
||||
? DefaultSummaryPath : FPaths::ConvertRelativePathToFull(OptionalOutputPath);
|
||||
const FString PcMapPath = DeriveSiblingPath(
|
||||
FullCsvPath, TEXT("VoxelStackSamples_"), TEXT("VoxelStackResolved_"), TEXT(".tsv"));
|
||||
|
||||
TArray<FOfflineModule> Modules;
|
||||
if (!ReadModuleMap(ModuleMapPath, Modules, OutError))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
for (FOfflineModule& Module : Modules)
|
||||
{
|
||||
uint64 CurrentSize = 0;
|
||||
uint64 CurrentLastWrite = 0;
|
||||
Module.bCurrentIdentityMatches =
|
||||
ReadCurrentFileIdentity(Module.Path, CurrentSize, CurrentLastWrite)
|
||||
&& CurrentSize == Module.FileSize
|
||||
&& CurrentLastWrite == Module.LastWriteFileTime;
|
||||
}
|
||||
|
||||
FString CsvText;
|
||||
if (!FFileHelper::LoadFileToString(CsvText, *FullCsvPath))
|
||||
{
|
||||
OutError = FString::Printf(TEXT("CSV could not be loaded: %s"), *FullCsvPath);
|
||||
return false;
|
||||
}
|
||||
|
||||
TArray<FOfflineSample> Samples;
|
||||
TArray<FString> Lines;
|
||||
CsvText.ParseIntoArrayLines(Lines, false);
|
||||
Samples.Reserve(Lines.Num());
|
||||
uint64 TotalFrames = 0;
|
||||
for (const FString& Line : Lines)
|
||||
{
|
||||
if (Line.IsEmpty() || Line.StartsWith(TEXT("sample_index,")))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
TArray<FString> Fields;
|
||||
Line.ParseIntoArray(Fields, TEXT(","), false);
|
||||
if (Fields.Num() < 5)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
FOfflineSample Sample;
|
||||
uint64 Parsed = 0;
|
||||
if (!ParseUint64(Fields[0], Sample.SampleIndex)
|
||||
|| !ParseUint64(Fields[1], Sample.ElapsedUs)
|
||||
|| !ParseUint64(Fields[2], Sample.ThreadId)
|
||||
|| !ParseUint64(Fields[4], Parsed))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
Sample.LODLevel = FCString::Atoi(*Fields[3]);
|
||||
Sample.Depth = static_cast<uint32>(FMath::Min<uint64>(
|
||||
Parsed, UE_ARRAY_COUNT(Sample.ProgramCounters)));
|
||||
for (uint32 FrameIndex = 0; FrameIndex < Sample.Depth; ++FrameIndex)
|
||||
{
|
||||
if (5 + FrameIndex >= static_cast<uint32>(Fields.Num()))
|
||||
{
|
||||
Sample.Depth = FrameIndex;
|
||||
break;
|
||||
}
|
||||
uint64 ProgramCounter = 0;
|
||||
if (!ParseUint64(Fields[5 + FrameIndex], ProgramCounter))
|
||||
{
|
||||
Sample.Depth = FrameIndex;
|
||||
break;
|
||||
}
|
||||
Sample.ProgramCounters[FrameIndex] = ProgramCounter;
|
||||
}
|
||||
TotalFrames += Sample.Depth;
|
||||
Samples.Add(MoveTemp(Sample));
|
||||
}
|
||||
|
||||
HANDLE Process = GetCurrentProcess();
|
||||
const DWORD OldOptions = SymGetOptions();
|
||||
SymSetOptions(OldOptions
|
||||
| SYMOPT_LOAD_LINES
|
||||
| SYMOPT_UNDNAME
|
||||
| SYMOPT_DEFERRED_LOADS
|
||||
| SYMOPT_EXACT_SYMBOLS
|
||||
| SYMOPT_FAIL_CRITICAL_ERRORS);
|
||||
|
||||
FString SearchPath = OptionalSymbolPath;
|
||||
for (const FOfflineModule& Module : Modules)
|
||||
{
|
||||
const FString ModuleDirectory = FPaths::GetPath(Module.Path);
|
||||
const FString PdbDirectory = FPaths::GetPath(Module.PdbPath);
|
||||
if (!ModuleDirectory.IsEmpty())
|
||||
{
|
||||
if (!SearchPath.IsEmpty()) SearchPath += TEXT(";");
|
||||
SearchPath += ModuleDirectory;
|
||||
}
|
||||
if (!PdbDirectory.IsEmpty() && !SearchPath.Contains(PdbDirectory))
|
||||
{
|
||||
if (!SearchPath.IsEmpty()) SearchPath += TEXT(";");
|
||||
SearchPath += PdbDirectory;
|
||||
}
|
||||
}
|
||||
|
||||
if (!SymInitializeW(Process, *SearchPath, 0))
|
||||
{
|
||||
const DWORD Error = GetLastError();
|
||||
SymSetOptions(OldOptions);
|
||||
OutError = FString::Printf(TEXT("SymInitializeW failed with error %u"), Error);
|
||||
return false;
|
||||
}
|
||||
|
||||
TSet<int32> NeededModuleIndices;
|
||||
for (const FOfflineSample& Sample : Samples)
|
||||
{
|
||||
for (uint32 FrameIndex = 0; FrameIndex < Sample.Depth; ++FrameIndex)
|
||||
{
|
||||
const int32 ModuleIndex = FindModuleForPc(Modules, Sample.ProgramCounters[FrameIndex]);
|
||||
if (ModuleIndex != INDEX_NONE)
|
||||
{
|
||||
NeededModuleIndices.Add(ModuleIndex);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int32 LoadedModules = 0;
|
||||
int32 NeededModules = NeededModuleIndices.Num();
|
||||
for (FOfflineModule& Module : Modules)
|
||||
{
|
||||
Module.bNeeded = NeededModuleIndices.Contains(static_cast<int32>(&Module - Modules.GetData()));
|
||||
if (!Module.bNeeded) continue;
|
||||
const DWORD64 LoadedBase = SymLoadModuleExW(
|
||||
Process, nullptr, *Module.Path, *Module.Path,
|
||||
static_cast<DWORD64>(Module.LoadBase), Module.ImageSize, nullptr, 0);
|
||||
if (LoadedBase != 0)
|
||||
{
|
||||
Module.bLoaded = true;
|
||||
++LoadedModules;
|
||||
}
|
||||
}
|
||||
|
||||
TMap<uint64, FResolvedProgramCounter> SymbolCache;
|
||||
TSet<uint64> MappedPcs;
|
||||
TSet<uint64> UnmappedPcs;
|
||||
FProfileAggregateSet AllAggregates;
|
||||
FProfileAggregateSet Lod0Aggregates;
|
||||
FProfileAggregateSet Lod1PlusAggregates;
|
||||
uint64 ResolvedFrames = 0;
|
||||
uint64 UnknownFrames = 0;
|
||||
uint64 WaitLikeFrames = 0;
|
||||
uint64 SamplesWithResolvedLeaf = 0;
|
||||
uint64 SamplesWithWaitLikeFrame = 0;
|
||||
uint64 SamplesWithStack = 0;
|
||||
uint64 UntaggedSamples = 0;
|
||||
uint64 InlineSymbols = 0;
|
||||
|
||||
auto AddUnknownExclusiveRow = [](FProfileAggregateSet& Aggregate)
|
||||
{
|
||||
const FString UnknownKey = TEXT("unknown\x1f<unknown>");
|
||||
FProfileRow& UnknownRow = Aggregate.ExclusiveFunctions.FindOrAdd(UnknownKey);
|
||||
if (UnknownRow.Key.IsEmpty())
|
||||
{
|
||||
UnknownRow.Key = UnknownKey;
|
||||
UnknownRow.Function = TEXT("<unknown>");
|
||||
UnknownRow.Module = TEXT("<unknown>");
|
||||
UnknownRow.File = TEXT("<unknown>");
|
||||
UnknownRow.Label = TEXT("unknown");
|
||||
}
|
||||
++UnknownRow.Samples;
|
||||
};
|
||||
|
||||
for (const FOfflineSample& Sample : Samples)
|
||||
{
|
||||
if (Sample.Depth == 0)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
++SamplesWithStack;
|
||||
TSet<FString> SeenFunctions;
|
||||
TArray<FResolvedSymbol> SampleFunctions;
|
||||
uint64 LeafProgramCounter = 0;
|
||||
bool bHasLeafProgramCounter = false;
|
||||
bool bSampleHasResolvedLeaf = false;
|
||||
bool bSampleHasWaitLike = false;
|
||||
|
||||
for (uint32 FrameIndex = 0; FrameIndex < Sample.Depth; ++FrameIndex)
|
||||
{
|
||||
const uint64 ProgramCounter = Sample.ProgramCounters[FrameIndex];
|
||||
ResolveProgramCounter(
|
||||
Process, ProgramCounter, Modules, SymbolCache, InlineSymbols,
|
||||
MappedPcs, UnmappedPcs);
|
||||
const FResolvedProgramCounter* Entry = SymbolCache.Find(ProgramCounter);
|
||||
const FResolvedSymbol* FrameFunction = Entry != nullptr
|
||||
? FirstFunctionSymbol(*Entry) : nullptr;
|
||||
if (FrameFunction != nullptr)
|
||||
{
|
||||
++ResolvedFrames;
|
||||
if (IsWaitLike(*FrameFunction))
|
||||
{
|
||||
++WaitLikeFrames;
|
||||
bSampleHasWaitLike = true;
|
||||
}
|
||||
if (FrameIndex == 0)
|
||||
{
|
||||
bSampleHasResolvedLeaf = true;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
++UnknownFrames;
|
||||
}
|
||||
|
||||
if (FrameIndex == 0)
|
||||
{
|
||||
LeafProgramCounter = ProgramCounter;
|
||||
bHasLeafProgramCounter = true;
|
||||
}
|
||||
if (Entry != nullptr)
|
||||
{
|
||||
for (const FResolvedSymbol& Symbol : Entry->Symbols)
|
||||
{
|
||||
if (Symbol.Function.IsEmpty()) continue;
|
||||
const FString Key = FunctionKey(Symbol);
|
||||
if (!SeenFunctions.Contains(Key))
|
||||
{
|
||||
SeenFunctions.Add(Key);
|
||||
SampleFunctions.Add(Symbol);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const FResolvedProgramCounter* LeafEntry = bHasLeafProgramCounter
|
||||
? SymbolCache.Find(LeafProgramCounter) : nullptr;
|
||||
const FResolvedSymbol* LeafFunction = LeafEntry != nullptr
|
||||
? FirstFunctionSymbol(*LeafEntry) : nullptr;
|
||||
const FResolvedSymbol* LeafSource = LeafEntry != nullptr
|
||||
? FirstSourceSymbol(*LeafEntry) : nullptr;
|
||||
|
||||
auto AddToAggregate = [&](FProfileAggregateSet& Aggregate)
|
||||
{
|
||||
++Aggregate.SamplesWithStack;
|
||||
if (bSampleHasResolvedLeaf)
|
||||
{
|
||||
AddFunctionRow(Aggregate.ExclusiveFunctions, LeafFunction, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
AddUnknownExclusiveRow(Aggregate);
|
||||
}
|
||||
for (const FResolvedSymbol& Symbol : SampleFunctions)
|
||||
{
|
||||
AddFunctionRow(Aggregate.InclusiveFunctions, &Symbol, 1);
|
||||
}
|
||||
AddSourceRow(Aggregate.ExclusiveLines, LeafFunction, LeafSource);
|
||||
};
|
||||
|
||||
AddToAggregate(AllAggregates);
|
||||
if (Sample.LODLevel == 0)
|
||||
{
|
||||
AddToAggregate(Lod0Aggregates);
|
||||
}
|
||||
else if (Sample.LODLevel >= 1)
|
||||
{
|
||||
AddToAggregate(Lod1PlusAggregates);
|
||||
}
|
||||
else
|
||||
{
|
||||
++UntaggedSamples;
|
||||
}
|
||||
|
||||
if (bSampleHasResolvedLeaf) ++SamplesWithResolvedLeaf;
|
||||
if (bSampleHasWaitLike) ++SamplesWithWaitLikeFrame;
|
||||
}
|
||||
|
||||
const int32 IdentityMismatches = [&Modules]()
|
||||
{
|
||||
int32 Count = 0;
|
||||
for (const FOfflineModule& Module : Modules)
|
||||
{
|
||||
if (!Module.bCurrentIdentityMatches) ++Count;
|
||||
}
|
||||
return Count;
|
||||
}();
|
||||
|
||||
WritePcMap(PcMapPath, Modules, SymbolCache);
|
||||
SymCleanup(Process);
|
||||
SymSetOptions(OldOptions);
|
||||
|
||||
FString Summary;
|
||||
Summary += TEXT("VoxelForge offline stack symbolizer\n");
|
||||
Summary += TEXT("==================================\n");
|
||||
Summary.Appendf(TEXT("csv_path: %s\n"), *FullCsvPath);
|
||||
Summary.Appendf(TEXT("module_map_path: %s\n"), *ModuleMapPath);
|
||||
Summary.Appendf(TEXT("resolved_pc_map_path: %s\n"), *PcMapPath);
|
||||
Summary += TEXT("symbolization: offline\n");
|
||||
Summary.Appendf(TEXT("dbghelp_in_measured_process: no\n"));
|
||||
Summary.Appendf(TEXT("dbghelp_in_symbolizer_process: yes\n"));
|
||||
Summary.Appendf(TEXT("module_count: %d\n"), Modules.Num());
|
||||
Summary.Appendf(TEXT("needed_module_count: %d\n"), NeededModules);
|
||||
Summary.Appendf(TEXT("loaded_module_count: %d\n"), LoadedModules);
|
||||
Summary.Appendf(TEXT("module_identity_mismatches: %d\n"), IdentityMismatches);
|
||||
Summary.Appendf(TEXT("samples: %d\n"), Samples.Num());
|
||||
Summary.Appendf(TEXT("samples_with_stack: %llu\n"), static_cast<unsigned long long>(SamplesWithStack));
|
||||
Summary.Appendf(TEXT("lod0_samples_with_stack: %llu\n"),
|
||||
static_cast<unsigned long long>(Lod0Aggregates.SamplesWithStack));
|
||||
Summary.Appendf(TEXT("lod1plus_samples_with_stack: %llu\n"),
|
||||
static_cast<unsigned long long>(Lod1PlusAggregates.SamplesWithStack));
|
||||
Summary.Appendf(TEXT("untagged_samples: %llu\n"), static_cast<unsigned long long>(UntaggedSamples));
|
||||
Summary.Appendf(TEXT("total_frames: %llu\n"), static_cast<unsigned long long>(TotalFrames));
|
||||
Summary.Appendf(TEXT("resolved_frames: %llu\n"), static_cast<unsigned long long>(ResolvedFrames));
|
||||
Summary.Appendf(TEXT("unknown_frames: %llu\n"), static_cast<unsigned long long>(UnknownFrames));
|
||||
Summary.Appendf(TEXT("wait_like_frames: %llu\n"), static_cast<unsigned long long>(WaitLikeFrames));
|
||||
Summary.Appendf(TEXT("samples_with_resolved_leaf: %llu\n"),
|
||||
static_cast<unsigned long long>(SamplesWithResolvedLeaf));
|
||||
Summary.Appendf(TEXT("samples_with_wait_like_frame: %llu\n"),
|
||||
static_cast<unsigned long long>(SamplesWithWaitLikeFrame));
|
||||
Summary.Appendf(TEXT("unique_program_counters: %d\n"), SymbolCache.Num());
|
||||
Summary.Appendf(TEXT("mapped_program_counters: %d\n"), MappedPcs.Num());
|
||||
Summary.Appendf(TEXT("unmapped_program_counters: %d\n"), UnmappedPcs.Num());
|
||||
Summary.Appendf(TEXT("inline_symbols: %llu\n"), static_cast<unsigned long long>(InlineSymbols));
|
||||
Summary.Appendf(TEXT("resolved_frame_fraction: %.6f\n"), TotalFrames > 0
|
||||
? static_cast<double>(ResolvedFrames) / static_cast<double>(TotalFrames) : 0.0);
|
||||
Summary.Appendf(TEXT("unknown_frame_fraction: %.6f\n"), TotalFrames > 0
|
||||
? static_cast<double>(UnknownFrames) / static_cast<double>(TotalFrames) : 0.0);
|
||||
Summary.Appendf(TEXT("wait_like_frame_fraction: %.6f\n"), TotalFrames > 0
|
||||
? static_cast<double>(WaitLikeFrames) / static_cast<double>(TotalFrames) : 0.0);
|
||||
Summary.Appendf(TEXT("resolved_leaf_fraction: %.6f\n"), SamplesWithStack > 0
|
||||
? static_cast<double>(SamplesWithResolvedLeaf) / static_cast<double>(SamplesWithStack) : 0.0);
|
||||
Summary.Appendf(TEXT("wait_like_sample_fraction: %.6f\n"), SamplesWithStack > 0
|
||||
? static_cast<double>(SamplesWithWaitLikeFrame) / static_cast<double>(SamplesWithStack) : 0.0);
|
||||
Summary += TEXT("\nLabels: plugin = VoxelForge, engine = Unreal/Engine, std = std:: frames, other = other resolved modules, unknown = no function symbol. Inline callbacks are resolved only in this offline process.\n");
|
||||
AppendRows(Summary, TEXT("Top 30 exclusive functions (leaf)"), AllAggregates.ExclusiveFunctions, SamplesWithStack, 30);
|
||||
AppendRows(Summary, TEXT("Top 30 inclusive functions (once per sample)"), AllAggregates.InclusiveFunctions, SamplesWithStack, 30);
|
||||
AppendRows(Summary, TEXT("Top 30 exclusive source lines (leaf source)"), AllAggregates.ExclusiveLines, SamplesWithStack, 30);
|
||||
Summary += TEXT("\nLOD0 tables (floor)\n");
|
||||
AppendRows(Summary, TEXT("LOD0 top 30 exclusive functions (leaf)"), Lod0Aggregates.ExclusiveFunctions, Lod0Aggregates.SamplesWithStack, 30);
|
||||
AppendRows(Summary, TEXT("LOD0 top 30 inclusive functions (once per sample)"), Lod0Aggregates.InclusiveFunctions, Lod0Aggregates.SamplesWithStack, 30);
|
||||
AppendRows(Summary, TEXT("LOD0 top 30 exclusive source lines (leaf source)"), Lod0Aggregates.ExclusiveLines, Lod0Aggregates.SamplesWithStack, 30);
|
||||
Summary += TEXT("\nLOD1+ tables (coarse/background)\n");
|
||||
AppendRows(Summary, TEXT("LOD1+ top 30 exclusive functions (leaf)"), Lod1PlusAggregates.ExclusiveFunctions, Lod1PlusAggregates.SamplesWithStack, 30);
|
||||
AppendRows(Summary, TEXT("LOD1+ top 30 inclusive functions (once per sample)"), Lod1PlusAggregates.InclusiveFunctions, Lod1PlusAggregates.SamplesWithStack, 30);
|
||||
AppendRows(Summary, TEXT("LOD1+ top 30 exclusive source lines (leaf source)"), Lod1PlusAggregates.ExclusiveLines, Lod1PlusAggregates.SamplesWithStack, 30);
|
||||
|
||||
IFileManager::Get().MakeDirectory(*FPaths::GetPath(OutSummaryPath), true);
|
||||
if (!FFileHelper::SaveStringToFile(
|
||||
Summary, *OutSummaryPath, FFileHelper::EEncodingOptions::ForceUTF8WithoutBOM))
|
||||
{
|
||||
OutError = FString::Printf(TEXT("could not write offline summary: %s"), *OutSummaryPath);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
// VoxelStackOfflineSymbolizer.h
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "CoreMinimal.h"
|
||||
|
||||
namespace VoxelForgeOfflineStackSymbolizer
|
||||
{
|
||||
/** Resolve one sampler CSV after the measured process has exited. */
|
||||
bool Run(
|
||||
const FString& CsvPath,
|
||||
const FString& OptionalOutputPath,
|
||||
const FString& OptionalSymbolPath,
|
||||
FString& OutSummaryPath,
|
||||
FString& OutError);
|
||||
}
|
||||
@@ -25,5 +25,12 @@ public class VoxelForgeEditor : ModuleRules
|
||||
"ImageWrapper",
|
||||
"VoxelForge",
|
||||
});
|
||||
|
||||
if (Target.Platform == UnrealTargetPlatform.Win64)
|
||||
{
|
||||
// DbgHelp is intentionally editor-only: the measured game/sampler process never links
|
||||
// or initializes it. VoxelForgeExplore uses it only in its post-exit symbolizer mode.
|
||||
PublicSystemLibraries.Add("Dbghelp.lib");
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user