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

diag: corrected passage-off ceiling + cold worker/tile timelines (L87); passages ARE the gate

Browse Source 
L86's switch left ApplyResolvedStratePassageCarves running (near-tile service unchanged at ~21
worker-s), so its "no change" ceiling was wrong. Corrected (bands + carves off): FI LOD0-2
2.34 -> 0.66 s, whole 3.47 -> 1.49 s @W12; TN 2.27 -> 0.74 / 3.28 -> 1.52 s. Near-tile service
15.6-22.5 -> 2.6-3.8 worker-s. Critical chain: shape/base compile -> LOD0-1 -> far-parent build
(107-153 ms, pipeline thread) -> LOD2. Workers 81-85% busy in the direct window.
No production scheduling change; hashes equal L85. Fast tier PASS.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016dhxM43dnWvUu2B5Ph1iG1
This commit is contained in:
Fr0zkaandClaude Opus 5.5 committed 2026-10-28 03:07:30 +01:00
1 parent 4f5f6667ae
commit 0fe7f371f7
8 files changed
+797 -20
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

Standalone/Source/StreamingWorld.h
+78 -9
View File
@@ -54,6 +54,8 @@ struct FStandaloneCpuTile
std::chrono::steady_clock::time_point QueuedAt{};
std::chrono::steady_clock::time_point StartedAt{};
std::chrono::steady_clock::time_point CompletedAt{};
std::chrono::steady_clock::time_point PublishedAt{};
std::chrono::steady_clock::time_point DrainedAt{};
uint64 DensityHash=14695981039346656037ull;
bool bHasDensityHash=false;
uint64 MeshHash=14695981039346656037ull;
@@ -362,8 +364,12 @@ struct FStandaloneTileJob
struct FStandaloneCpuTileTimelineEvent
{
enum class EType : uint8 { Queued, Dispatch, Finish };
EType Type=EType::Queued;
enum class EType : uint8
{
Requested, Admitted, Dispatch, Finish, Published, Drained,
WorkerStart, WorkerIdleBegin, WorkerIdleEnd, WorkerStop
};
EType Type=EType::Admitted;
FVoxelTileKey Key;
int32 WorkerId=-1;
size_t QueueDepth=0;
@@ -517,6 +523,15 @@ public:
bColdTimelineTrace=true;
}
void RecordColdTimelineRequests(const std::vector<FVoxelTileKey>& Keys,
std::chrono::steady_clock::time_point RequestedAt)
{
if(!bColdTimelineTrace)return;
for(const FVoxelTileKey& Key:Keys)
RecordTimelineEvent(FStandaloneCpuTileTimelineEvent::EType::Requested,Key,-1,
0,0,0,RequestedAt,RequestedAt);
}
void DumpColdTimelineTrace() const
{
if(!bColdTimelineTrace)return;
@@ -532,16 +547,14 @@ public:
Events.size(),WorkerCount);
for(const auto& Event:Events)
{
const char* Type=Event.Type==FStandaloneCpuTileTimelineEvent::EType::Queued
?"queued":Event.Type==FStandaloneCpuTileTimelineEvent::EType::Dispatch
?"dispatch":"finish";
const char* Type=TimelineEventName(Event.Type);
std::printf("[CpuTileTimeline] event=%s key=(%d,%d,%d,lod%d) at_ms=%.3f frame=%llu worker_id=%d queue_depth=%zu active_workers=%zu priority_rank=%zu queued_ms=%.3f dispatch_ms=%.3f finish_ms=%.3f service_ms=%.3f worker_ms=%.3f\n",
Type,Event.Key.Coord.X,Event.Key.Coord.Y,Event.Key.Coord.Z,Event.Key.Level,
TimelineMilliseconds(Event.At),static_cast<unsigned long long>(TimelineFrame()),
Event.WorkerId,Event.QueueDepth,Event.ActiveWorkers,Event.PriorityRank,
TimelineMilliseconds(Event.QueuedAt),TimelineMilliseconds(Event.StartedAt),
TimelineMilliseconds(Event.FinishedAt),
Event.StartedAt.time_since_epoch().count()!=0
Event.Type==FStandaloneCpuTileTimelineEvent::EType::Finish
?std::chrono::duration<double,std::milli>(Event.At-Event.StartedAt).count():-1.0,
Event.WorkerMilliseconds);
if(Event.Type==FStandaloneCpuTileTimelineEvent::EType::Finish)
@@ -747,7 +760,16 @@ public:
std::vector<FStandaloneCpuTile> Out;
std::lock_guard<std::mutex> Lock(Mutex);
Out.swap(Ready);
for(const FStandaloneCpuTile& Tile:Out)Outstanding.erase(Tile.Key);
const FClock::time_point DrainedAt=FClock::now();
for(FStandaloneCpuTile& Tile:Out)
{
Tile.DrainedAt=DrainedAt;
Outstanding.erase(Tile.Key);
if(bColdTimelineTrace)
RecordTimelineEvent(FStandaloneCpuTileTimelineEvent::EType::Drained,
Tile.Key,-1,Queue.size(),Running.size(),0,DrainedAt,
Tile.QueuedAt,Tile.StartedAt,Tile.CompletedAt,Tile.WorkerSeconds*1000.0);
}
return Out;
}
@@ -1083,7 +1105,7 @@ private:
Job.QueuedAt=FClock::now();
Queue.push_back(Job);
if(bColdTimelineTrace)
RecordTimelineEvent(FStandaloneCpuTileTimelineEvent::EType::Queued,Key,-1,
RecordTimelineEvent(FStandaloneCpuTileTimelineEvent::EType::Admitted,Key,-1,
Queue.size(),Running.size(),Job.PriorityRank,Job.QueuedAt,Job.QueuedAt);
Outstanding.insert(Key);++Stats.NewJobs;
if(Key.Level<=2)++NearOutstandingJobs;
@@ -1278,6 +1300,9 @@ private:
void WorkerLoop(int32 WorkerId)
{
if(bColdTimelineTrace)
RecordTimelineEvent(FStandaloneCpuTileTimelineEvent::EType::WorkerStart,{},
WorkerId,0,0,0,FClock::now());
constexpr uint32 PriorityTaskBurst=3;
uint32 ConsecutivePriorityTasks=0;
for(;;)
@@ -1295,8 +1320,21 @@ private:
return !Queue.empty()&&((SchedulerPolicy!=1&&!bStationaryNearGate)
||NearOutstandingJobs==0||Queue.front().Key.Level<=2);
};
const bool bEnteringIdle=!bStop&&PriorityTasks.empty()&&!HasEligibleTile();
if(bEnteringIdle&&bColdTimelineTrace)
RecordTimelineEvent(FStandaloneCpuTileTimelineEvent::EType::WorkerIdleBegin,
{},WorkerId,Queue.size(),Running.size(),0,FClock::now());
Wake.wait(Lock,[&](){return bStop||!PriorityTasks.empty()||HasEligibleTile();});
if(bStop)return;
if(bEnteringIdle&&bColdTimelineTrace)
RecordTimelineEvent(FStandaloneCpuTileTimelineEvent::EType::WorkerIdleEnd,
{},WorkerId,Queue.size(),Running.size(),0,FClock::now());
if(bStop)
{
if(bColdTimelineTrace)
RecordTimelineEvent(FStandaloneCpuTileTimelineEvent::EType::WorkerStop,{},
WorkerId,Queue.size(),Running.size(),0,FClock::now());
return;
}
const bool bTileEligible=HasEligibleTile();
const bool bPreferPriority=!PriorityTasks.empty()
&&(!bTileEligible||ConsecutivePriorityTasks<PriorityTaskBurst);
@@ -1335,7 +1373,20 @@ private:
Tile.QueuedAt,Tile.StartedAt,Tile.CompletedAt,Tile.WorkerSeconds*1000.0,
&Tile.CoreDiagnostics,Tile.DensitySamples,Tile.SkirtTriangleCount,
Tile.PayloadBuildMilliseconds);
const FVoxelTileKey PublishedKey=Tile.Key;
const auto PublishedQueuedAt=Tile.QueuedAt;
const auto PublishedStartedAt=Tile.StartedAt;
const auto PublishedCompletedAt=Tile.CompletedAt;
const double PublishedWorkerMs=Tile.WorkerSeconds*1000.0;
const int32 PublishedWorkerId=Tile.WorkerId;
Ready.push_back(std::move(Tile));
const FClock::time_point PublishedAt=FClock::now();
Ready.back().PublishedAt=PublishedAt;
if(bColdTimelineTrace)
RecordTimelineEvent(FStandaloneCpuTileTimelineEvent::EType::Published,
PublishedKey,PublishedWorkerId,Queue.size(),Running.size(),Job.PriorityRank,
PublishedAt,PublishedQueuedAt,PublishedStartedAt,PublishedCompletedAt,
PublishedWorkerMs);
}
Wake.notify_all();
}
@@ -1351,6 +1402,24 @@ private:
{
return TimelineFrameOrdinal?TimelineFrameOrdinal->load(std::memory_order_relaxed):0;
}
static const char* TimelineEventName(FStandaloneCpuTileTimelineEvent::EType Type)
{
using EType=FStandaloneCpuTileTimelineEvent::EType;
switch(Type)
{
case EType::Requested:return "requested";
case EType::Admitted:return "admitted";
case EType::Dispatch:return "started";
case EType::Finish:return "finished";
case EType::Published:return "published";
case EType::Drained:return "drained";
case EType::WorkerStart:return "worker_start";
case EType::WorkerIdleBegin:return "idle_begin";
case EType::WorkerIdleEnd:return "idle_end";
case EType::WorkerStop:return "worker_stop";
}
return "unknown";
}
std::size_t PassageOverlapScore(const FVoxelTileKey& Key) const
{
const FIntVector Origin=Key.OriginVoxels();