wip(assembler): round L7 -- shared column cache across workers: whole view 16-19% faster, world unchanged

SharedColumnCache.h: a world-owned, bounded 4-way second-tier cache of exact column values (heightfield and floating islands), keyed by recipe/plan identity plus content hash, XY and island id. Lock-free seqlock reads; set-local spin lock on misses. The FLazy thread-local tier stays first. 83.6% of repeated column work was cross-worker; formula evaluations -60.9%. W12 L1 view: Luna 2.165 -> 1.754 s; reviewer interleaved 2.059 -> 1.722 s. 8 m crossing new tiles 82 -> 52 ms. +66 MiB peak RSS. All hashes (whole view, per-LOD, exact queries, islands seed 0) identical at W1/W8/W12, Clang off and GCC default. MSVC/UBT not compiled here. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01CSFYgsdW8ejZSyiMf4qRSX
2026-10-19 21:46:15 +02:00
1 parent 9898e057fd
commit 4b1108bf86
@@ -137,7 +137,8 @@ namespace StandaloneStreamBenchmark
        std::chrono::steady_clock::time_point ColdStart,bool bProfileColumnOverlap,
        int32 FarHorizonLOD8InteriorStepVoxels,bool bReportMeshCoverage=false,
        const std::filesystem::path& MeshExportPath={},float CameraYawDegrees=0.0f,
-        float CameraPitchDegrees=0.0f,bool bScreenSpaceGate=false)
+        float CameraPitchDegrees=0.0f,bool bScreenSpaceGate=false,
+        bool bUseSharedColumnCache=true,FVector CameraStepVoxels=FVector::ZeroVector)
    {
        using Clock=std::chrono::steady_clock;
        FStandaloneOwnerWorld& World=*OwnerWorld;
@@ -167,6 +168,21 @@ namespace StandaloneStreamBenchmark
        if(MaxLevel>=0)
            Desired.Tiles.erase(std::remove_if(Desired.Tiles.begin(),Desired.Tiles.end(),
                [&](const FVoxelTileKey& Tile){return Tile.Level>MaxLevel;}),Desired.Tiles.end());
+        const bool bHasCameraStep=std::abs(CameraStepVoxels.X)+std::abs(CameraStepVoxels.Y)
+            +std::abs(CameraStepVoxels.Z)>1.0e-6f;
+        FStandaloneDesiredTileSet MovedDesired;
+        if(bHasCameraStep)
+        {
+            const FVector MovedCamera=CameraPositionVoxels+CameraStepVoxels;
+            MovedDesired=StandaloneWorldMesher::BuildDesiredSet(World,MovedCamera);
+            const auto MovedCoreTiles=Shape.desiredTiles({MovedCamera.X,MovedCamera.Y,MovedCamera.Z});
+            MovedDesired.Tiles.clear();MovedDesired.Tiles.reserve(MovedCoreTiles.size());
+            for(const auto& Key:MovedCoreTiles)
+                MovedDesired.Tiles.emplace_back(FIntVector(Key.coordinate.x,Key.coordinate.y,Key.coordinate.z),Key.lod);
+            if(MaxLevel>=0)
+                MovedDesired.Tiles.erase(std::remove_if(MovedDesired.Tiles.begin(),MovedDesired.Tiles.end(),
+                    [&](const FVoxelTileKey& Tile){return Tile.Level>MaxLevel;}),MovedDesired.Tiles.end());
+        }
        if(!Desired.Tiles.empty())
        {
            FIntVector volumeMin(INT32_MAX,INT32_MAX,INT32_MAX);
@@ -191,17 +207,22 @@ namespace StandaloneStreamBenchmark
        }
        FIntVector FineMin(INT32_MAX,INT32_MAX,INT32_MAX),FineMax(INT32_MIN,INT32_MIN,INT32_MIN);
        FIntVector ClipMin(INT32_MAX,INT32_MAX,INT32_MAX),ClipMax(INT32_MIN,INT32_MIN,INT32_MIN);
-        for(const FVoxelTileKey& Tile:Desired.Tiles)
+        const auto AccumulateBounds=[&](const std::vector<FVoxelTileKey>& Tiles)
        {
-            const FIntVector Origin=Tile.OriginVoxels();const int32 Extent=Tile.ExtentVoxels();
-            ClipMin.X=std::min(ClipMin.X,Origin.X);ClipMin.Y=std::min(ClipMin.Y,Origin.Y);ClipMin.Z=std::min(ClipMin.Z,Origin.Z);
-            ClipMax.X=std::max(ClipMax.X,Origin.X+Extent);ClipMax.Y=std::max(ClipMax.Y,Origin.Y+Extent);ClipMax.Z=std::max(ClipMax.Z,Origin.Z+Extent);
-            if(Tile.Level<World.FullResClipLevels)
+            for(const FVoxelTileKey& Tile:Tiles)
            {
-                FineMin.X=std::min(FineMin.X,Origin.X);FineMin.Y=std::min(FineMin.Y,Origin.Y);FineMin.Z=std::min(FineMin.Z,Origin.Z);
-                FineMax.X=std::max(FineMax.X,Origin.X+Extent);FineMax.Y=std::max(FineMax.Y,Origin.Y+Extent);FineMax.Z=std::max(FineMax.Z,Origin.Z+Extent);
+                const FIntVector Origin=Tile.OriginVoxels();const int32 Extent=Tile.ExtentVoxels();
+                ClipMin.X=std::min(ClipMin.X,Origin.X);ClipMin.Y=std::min(ClipMin.Y,Origin.Y);ClipMin.Z=std::min(ClipMin.Z,Origin.Z);
+                ClipMax.X=std::max(ClipMax.X,Origin.X+Extent);ClipMax.Y=std::max(ClipMax.Y,Origin.Y+Extent);ClipMax.Z=std::max(ClipMax.Z,Origin.Z+Extent);
+                if(Tile.Level<World.FullResClipLevels)
+                {
+                    FineMin.X=std::min(FineMin.X,Origin.X);FineMin.Y=std::min(FineMin.Y,Origin.Y);FineMin.Z=std::min(FineMin.Z,Origin.Z);
+                    FineMax.X=std::max(FineMax.X,Origin.X+Extent);FineMax.Y=std::max(FineMax.Y,Origin.Y+Extent);FineMax.Z=std::max(FineMax.Z,Origin.Z+Extent);
+                }
            }
-        }
+        };
+        AccumulateBounds(Desired.Tiles);
+        if(bHasCameraStep)AccumulateBounds(MovedDesired.Tiles);
        if(FineMin.X==INT32_MAX||ClipMin.X==INT32_MAX)
        {std::fprintf(stderr,"[StreamPipeline] no desired detail or clipmap tiles.\n");return 7;}

@@ -242,7 +263,7 @@ namespace StandaloneStreamBenchmark
        const double ShapeSeconds=std::chrono::duration<double>(ShapeReady-ShapeBuildStart).count();
        FStandaloneStreamingGenerator Streamer(World,WorkerCount,bHashDensity,nullptr,MaxLevel,
            bSkipUvAndColors,bSkipMaterialGroups,bSkipUV,bSkipColors,&Shape,bProfileColumnOverlap,
-            FarHorizonLOD8InteriorStepVoxels);
+            FarHorizonLOD8InteriorStepVoxels,bUseSharedColumnCache);
        if(bScreenSpaceGate)Streamer.SetMesherStageProfilingEnabled(true);
        const auto StreamStart=Clock::now();
        const FStandaloneStreamingUpdate Update=Streamer.StartWithDesired(Desired);
@@ -287,13 +308,19 @@ namespace StandaloneStreamBenchmark
                return X^(Y+static_cast<std::size_t>(0x9E3779B9u)+(X<<6)+(X>>2));
            }
        };
-        struct FFirstColumnUse
+        struct FColumnEvaluationEvent
        {
+            FColumnXY XY;
            FVoxelTileKey Tile;
            std::uint64_t WorkerHash=0;
+            std::uint64_t Sequence=0;
+            bool bOutsideTileFootprint=false;
        };
-        std::array<std::unordered_map<FColumnXY,std::vector<FFirstColumnUse>,FColumnXYHash>,9> ColumnUsesByLOD;
-        std::array<std::uint64_t,9> ColumnDuplicateEventsByLOD{},NeighbourDuplicateEventsByLOD{};
+        std::array<std::vector<FColumnEvaluationEvent>,9> ColumnEventsByLOD;
+        std::array<std::uint64_t,9> ColumnEvaluationEventsByLOD{},UniqueColumnCoordinatesByLOD{};
+        std::array<std::uint64_t,9> ColumnDuplicateEventsByLOD{},SameWorkerEvictedRepeatsByLOD{};
+        std::array<std::uint64_t,9> DifferentWorkerRepeatsByLOD{},HaloNormalRepeatsByLOD{};
+        std::array<std::uint64_t,9> HaloNormalEvaluationsByLOD{},NeighbourDuplicateEventsByLOD{};
        std::array<std::uint64_t,9> CrossWorkerNeighbourDuplicateEventsByLOD{};
        std::array<std::uint64_t,9> ColumnCaptureTilesByLOD{},ExpectedTilesByLOD{};
        std::array<bool,9> ColumnCaptureCompleteByLOD{};
@@ -376,33 +403,12 @@ namespace StandaloneStreamBenchmark
                    ++ColumnCaptureTilesByLOD[LOD];
                    ColumnCaptureCompleteByLOD[LOD]=ColumnCaptureCompleteByLOD[LOD]
                        &&Tile.CoreDiagnostics.columnCoordinateCaptureComplete;
-                    std::vector<std::array<std::int64_t,2>> Coordinates=
-                        Tile.CoreDiagnostics.evaluatedColumnCoordinates;
-                    std::sort(Coordinates.begin(),Coordinates.end());
-                    Coordinates.erase(std::unique(Coordinates.begin(),Coordinates.end()),Coordinates.end());
-                    for(const auto& Coordinate:Coordinates)
+                    auto& Events=ColumnEventsByLOD[LOD];
+                    for(const auto& Coordinate:Tile.CoreDiagnostics.evaluatedColumnCoordinates)
                    {
-                        const FColumnXY XY{Coordinate[0],Coordinate[1]};
-                        auto [Uses,Inserted]=ColumnUsesByLOD[LOD].try_emplace(XY);
-                        std::vector<FFirstColumnUse>& PriorUses=Uses->second;
-                        if(Inserted)
-                        {
-                            PriorUses.push_back({Tile.Key,Tile.CoreDiagnostics.columnEvaluationWorkerHash});
-                            continue;
-                        }
-                        ++ColumnDuplicateEventsByLOD[LOD];
-                        bool bHasNeighbourDuplicate=false,bHasCrossWorkerNeighbourDuplicate=false;
-                        for(const FFirstColumnUse& Prior:PriorUses)
-                        {
-                            if(!AreSameLODNeighbours(Prior.Tile,Tile.Key))continue;
-                            bHasNeighbourDuplicate=true;
-                            bHasCrossWorkerNeighbourDuplicate=bHasCrossWorkerNeighbourDuplicate
-                                ||Prior.WorkerHash!=Tile.CoreDiagnostics.columnEvaluationWorkerHash;
-                        }
-                        if(bHasNeighbourDuplicate)++NeighbourDuplicateEventsByLOD[LOD];
-                        if(bHasCrossWorkerNeighbourDuplicate)
-                            ++CrossWorkerNeighbourDuplicateEventsByLOD[LOD];
-                        PriorUses.push_back({Tile.Key,Tile.CoreDiagnostics.columnEvaluationWorkerHash});
+                        Events.push_back({{Coordinate.x,Coordinate.y},Tile.Key,
+                            Tile.CoreDiagnostics.columnEvaluationWorkerHash,Coordinate.sequence,
+                            Coordinate.outsideTileFootprint});
                    }
                }
                WholeViewReady=std::max(WholeViewReady,Tile.CompletedAt);
@@ -449,6 +455,45 @@ namespace StandaloneStreamBenchmark
                bFullDetailReported=true;
            }
        }
+        if(bHasCameraStep)
+        {
+            const auto MovingStart=Clock::now();
+            const auto MovingUpdate=Streamer.UpdateDesiredWithSet(MovedDesired,Desired.Tiles,1);
+            std::array<std::uint64_t,9> MovingTilesByLOD{};
+            std::array<double,9> MovingWorkerSecondsByLOD{};
+            int32 MovingFinished=0;
+            while(MovingFinished<MovingUpdate.NewJobs)
+            {
+                std::vector<FStandaloneCpuTile> Ready=Streamer.TakeReady();
+                if(Ready.empty())
+                {std::this_thread::sleep_for(std::chrono::milliseconds(1));continue;}
+                for(const FStandaloneCpuTile& Tile:Ready)
+                {
+                    ++MovingFinished;
+                    if(Tile.Key.Level>=0&&Tile.Key.Level<static_cast<int32>(MovingTilesByLOD.size()))
+                    {
+                        const std::size_t LOD=static_cast<std::size_t>(Tile.Key.Level);
+                        ++MovingTilesByLOD[LOD];
+                        MovingWorkerSecondsByLOD[LOD]+=Tile.WorkerSeconds;
+                    }
+                }
+            }
+            const double MovingWallSeconds=std::chrono::duration<double>(Clock::now()-MovingStart).count();
+            const double StepDistanceMeters=std::sqrt(
+                static_cast<double>(CameraStepVoxels.X)*CameraStepVoxels.X
+                +static_cast<double>(CameraStepVoxels.Y)*CameraStepVoxels.Y
+                +static_cast<double>(CameraStepVoxels.Z)*CameraStepVoxels.Z)
+                *static_cast<double>(World.CoreVoxelSizeMicrons)/1000000.0;
+            std::printf("[MovingCameraStep] step_voxels=(%.3f,%.3f,%.3f) distance_m=%.3f desired_tiles=%zu new_tiles=%d completed=%d wall_s=%.6f shared_column_cache=%s\n",
+                CameraStepVoxels.X,CameraStepVoxels.Y,CameraStepVoxels.Z,StepDistanceMeters,
+                MovedDesired.Tiles.size(),MovingUpdate.NewJobs,MovingFinished,MovingWallSeconds,
+                bUseSharedColumnCache?"on":"off");
+            for(std::size_t LOD=0;LOD<MovingTilesByLOD.size();++LOD)
+                if(MovingTilesByLOD[LOD]!=0)
+                    std::printf("[MovingCameraStepLOD] lod=%zu tiles=%llu worker_sum_s=%.6f\n",
+                        LOD,static_cast<unsigned long long>(MovingTilesByLOD[LOD]),
+                        MovingWorkerSecondsByLOD[LOD]);
+        }
        Streamer.Stop();
        bool bScreenSpaceGatePassing=true;
        if(bScreenSpaceGate)
@@ -472,6 +517,58 @@ namespace StandaloneStreamBenchmark
                bSceneExportPassing?"PASS":"FAIL",MeshExportPath.string().c_str());
            bSceneExportPassing=bSceneExportPassing&&!FileSizeError;
        }
+        if(bProfileColumnOverlap)
+        {
+            struct FColumnPriorUse
+            {
+                FVoxelTileKey Tile;
+                std::uint64_t WorkerHash=0;
+            };
+            for(std::size_t LOD=0;LOD<ColumnEventsByLOD.size();++LOD)
+            {
+                auto& Events=ColumnEventsByLOD[LOD];
+                std::sort(Events.begin(),Events.end(),[](const FColumnEvaluationEvent& A,
+                    const FColumnEvaluationEvent& B){return A.Sequence<B.Sequence;});
+                std::unordered_map<FColumnXY,std::vector<FColumnPriorUse>,FColumnXYHash> UsesByXY;
+                UsesByXY.reserve(Events.size());
+                for(const FColumnEvaluationEvent& Event:Events)
+                {
+                    ++ColumnEvaluationEventsByLOD[LOD];
+                    if(Event.bOutsideTileFootprint)++HaloNormalEvaluationsByLOD[LOD];
+                    auto [Found,Inserted]=UsesByXY.try_emplace(Event.XY);
+                    auto& PriorUses=Found->second;
+                    if(Inserted)
+                    {
+                        ++UniqueColumnCoordinatesByLOD[LOD];
+                        PriorUses.push_back({Event.Tile,Event.WorkerHash});
+                        continue;
+                    }
+                    ++ColumnDuplicateEventsByLOD[LOD];
+                    if(Event.bOutsideTileFootprint)
+                        ++HaloNormalRepeatsByLOD[LOD];
+                    else
+                    {
+                        const bool bSameWorkerSeen=std::any_of(PriorUses.begin(),PriorUses.end(),
+                            [&](const FColumnPriorUse& Prior)
+                            {return Prior.WorkerHash==Event.WorkerHash;});
+                        if(bSameWorkerSeen)++SameWorkerEvictedRepeatsByLOD[LOD];
+                        else ++DifferentWorkerRepeatsByLOD[LOD];
+                    }
+                    bool bHasNeighbourDuplicate=false,bHasCrossWorkerNeighbourDuplicate=false;
+                    for(const FColumnPriorUse& Prior:PriorUses)
+                    {
+                        if(!AreSameLODNeighbours(Prior.Tile,Event.Tile))continue;
+                        bHasNeighbourDuplicate=true;
+                        bHasCrossWorkerNeighbourDuplicate=bHasCrossWorkerNeighbourDuplicate
+                            ||Prior.WorkerHash!=Event.WorkerHash;
+                    }
+                    if(bHasNeighbourDuplicate)++NeighbourDuplicateEventsByLOD[LOD];
+                    if(bHasCrossWorkerNeighbourDuplicate)
+                        ++CrossWorkerNeighbourDuplicateEventsByLOD[LOD];
+                    PriorUses.push_back({Event.Tile,Event.WorkerHash});
+                }
+            }
+        }
        bool bColumnOverlapCapturePassing=true;
        if(bProfileColumnOverlap)
        {
@@ -480,11 +577,16 @@ namespace StandaloneStreamBenchmark
                const bool bLODComplete=ColumnCaptureCompleteByLOD[LOD]
                    &&ColumnCaptureTilesByLOD[LOD]==ExpectedTilesByLOD[LOD];
                bColumnOverlapCapturePassing=bColumnOverlapCapturePassing&&bLODComplete;
-                std::printf("[WorldAssemblerLODColumnOverlap] lod=%zu tiles=%llu expected_tiles=%llu unique_xy_columns=%zu repeated_tile_evaluations=%llu neighbouring_duplicate_evaluations=%llu cross_worker_neighbouring_duplicates=%llu capture_complete=%d\n",
+                std::printf("[WorldAssemblerLODColumnOverlap] lod=%zu tiles=%llu expected_tiles=%llu total_column_evaluations=%llu unique_xy_columns=%llu repeated_column_evaluations=%llu same_worker_evicted_repeats=%llu different_worker_repeats=%llu halo_normal_repeats=%llu halo_normal_evaluations=%llu neighbouring_duplicate_evaluations=%llu cross_worker_neighbouring_duplicates=%llu capture_complete=%d\n",
                    LOD,static_cast<unsigned long long>(ColumnCaptureTilesByLOD[LOD]),
                    static_cast<unsigned long long>(ExpectedTilesByLOD[LOD]),
-                    ColumnUsesByLOD[LOD].size(),
+                    static_cast<unsigned long long>(ColumnEvaluationEventsByLOD[LOD]),
+                    static_cast<unsigned long long>(UniqueColumnCoordinatesByLOD[LOD]),
                    static_cast<unsigned long long>(ColumnDuplicateEventsByLOD[LOD]),
+                    static_cast<unsigned long long>(SameWorkerEvictedRepeatsByLOD[LOD]),
+                    static_cast<unsigned long long>(DifferentWorkerRepeatsByLOD[LOD]),
+                    static_cast<unsigned long long>(HaloNormalRepeatsByLOD[LOD]),
+                    static_cast<unsigned long long>(HaloNormalEvaluationsByLOD[LOD]),
                    static_cast<unsigned long long>(NeighbourDuplicateEventsByLOD[LOD]),
                    static_cast<unsigned long long>(CrossWorkerNeighbourDuplicateEventsByLOD[LOD]),
                    bLODComplete?1:0);