Refactor: use extractObjectData with copyToCpu instead of separate extractObjectDataToCpuBuffers method

Co-authored-by: chrxh <[email protected]>

Author: Copilot

source/EngineGpuKernels/CudaGeometryBuffers.cu

@@ -240,3 +240,55 @@ void CudaGeometryBuffers::copyToOpenGL(GeometryBuffers const& geometryBuffers, N
         geometryBuffers->uploadDetonationEventData(hostDetonationEventBuffer.data(), numObjects.detonationEventVertices);
     }
 }
+
+CpuGeometryBuffers CudaGeometryBuffers::copyToCpu(NumRenderObjects const& numObjects)
+{
+    CpuGeometryBuffers result;
+
+    if (numObjects.cells > 0) {
+        result.cells.resize(numObjects.cells);
+        CHECK_FOR_CUDA_ERROR(cudaMemcpy(result.cells.data(), deviceCellBuffer, numObjects.cells * sizeof(CellVertexData), cudaMemcpyDeviceToHost));
+    }
+
+    if (numObjects.energyParticles > 0) {
+        result.energyParticles.resize(numObjects.energyParticles);
+        CHECK_FOR_CUDA_ERROR(cudaMemcpy(result.energyParticles.data(), deviceEnergyParticleBuffer, numObjects.energyParticles * sizeof(EnergyParticleVertexData), cudaMemcpyDeviceToHost));
+    }
+
+    if (numObjects.locations > 0) {
+        result.locations.resize(numObjects.locations);
+        CHECK_FOR_CUDA_ERROR(cudaMemcpy(result.locations.data(), deviceLocationBuffer, numObjects.locations * sizeof(LocationVertexData), cudaMemcpyDeviceToHost));
+    }
+
+    if (numObjects.selectedObjects > 0) {
+        result.selectedObjects.resize(numObjects.selectedObjects);
+        CHECK_FOR_CUDA_ERROR(cudaMemcpy(result.selectedObjects.data(), deviceSelectedObjectBuffer, numObjects.selectedObjects * sizeof(SelectedObjectVertexData), cudaMemcpyDeviceToHost));
+    }
+
+    if (numObjects.lineIndices > 0) {
+        result.lineIndices.resize(numObjects.lineIndices);
+        CHECK_FOR_CUDA_ERROR(cudaMemcpy(result.lineIndices.data(), deviceLineIndexBuffer, numObjects.lineIndices * sizeof(unsigned int), cudaMemcpyDeviceToHost));
+    }
+
+    if (numObjects.triangleIndices > 0) {
+        result.triangleIndices.resize(numObjects.triangleIndices);
+        CHECK_FOR_CUDA_ERROR(cudaMemcpy(result.triangleIndices.data(), deviceTriangleIndexBuffer, numObjects.triangleIndices * sizeof(unsigned int), cudaMemcpyDeviceToHost));
+    }
+
+    if (numObjects.connectionArrowVertices > 0) {
+        result.connectionArrows.resize(numObjects.connectionArrowVertices);
+        CHECK_FOR_CUDA_ERROR(cudaMemcpy(result.connectionArrows.data(), deviceSelectedConnectionBuffer, numObjects.connectionArrowVertices * sizeof(ConnectionArrowVertexData), cudaMemcpyDeviceToHost));
+    }
+
+    if (numObjects.attackEventVertices > 0) {
+        result.attackEvents.resize(numObjects.attackEventVertices);
+        CHECK_FOR_CUDA_ERROR(cudaMemcpy(result.attackEvents.data(), deviceAttackEventBuffer, numObjects.attackEventVertices * sizeof(AttackEventVertexData), cudaMemcpyDeviceToHost));
+    }
+
+    if (numObjects.detonationEventVertices > 0) {
+        result.detonationEvents.resize(numObjects.detonationEventVertices);
+        CHECK_FOR_CUDA_ERROR(cudaMemcpy(result.detonationEvents.data(), deviceDetonationEventBuffer, numObjects.detonationEventVertices * sizeof(DetonationEventVertexData), cudaMemcpyDeviceToHost));
+    }
+
+    return result;
+}

source/EngineGpuKernels/CudaGeometryBuffers.cuh

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <EngineInterface/CpuGeometryBuffers.h>
 #include <EngineInterface/GeometryBuffers.h>
 
 #include "Base.cuh"
@@ -44,4 +45,5 @@ struct CudaGeometryBuffers
     void allocateBuffersForNoInterop(NumRenderObjects const& numObjects);
     void freeBuffersForNoInterop();
     void copyToOpenGL(GeometryBuffers const& geometryBuffers, NumRenderObjects const& numObjects);
+    CpuGeometryBuffers copyToCpu(NumRenderObjects const& numObjects);
 };

source/EngineGpuKernels/GeometryKernelsService.cu

@@ -208,177 +208,3 @@ void GeometryKernelsService::extractObjectData(
         KERNEL_CALL(cudaExtractDetonationEventData, data, renderingData.deviceDetonationEventBuffer, _numDetonationEventVertices);
     }
 }
-
-void GeometryKernelsService::extractObjectDataToCpuBuffers(
-    SettingsForSimulation const& settings,
-    SimulationData data,
-    CpuGeometryBuffers& cpuBuffers,
-    RealRect const& visibleWorldRect)
-{
-    auto const& gpuSettings = settings.cudaSettings;
-    float2 const visibleTopLeft{visibleWorldRect.topLeft.x, visibleWorldRect.topLeft.y};
-
-    // Get counts first
-    auto numCells = data.objects.cells.getNumEntries_host();
-    auto numParticles = data.objects.particles.getNumEntries_host();
-
-    setValueToDevice(_numLocations, static_cast<uint64_t>(0));
-    KERNEL_CALL_1_1(cudaExtractLocationData, data, nullptr, _numLocations, visibleTopLeft);
-    cudaDeviceSynchronize();
-    auto numLocations = copyToHost(_numLocations);
-
-    setValueToDevice(_numSelectedObjects, static_cast<uint64_t>(0));
-    KERNEL_CALL(cudaExtractSelectedObjectData, data, nullptr, _numSelectedObjects);
-    cudaDeviceSynchronize();
-    auto numSelectedObjects = copyToHost(_numSelectedObjects);
-
-    setValueToDevice(_numLineIndices, static_cast<uint64_t>(0));
-    KERNEL_CALL(cudaExtractLineIndices, data, nullptr, _numLineIndices);
-    cudaDeviceSynchronize();
-    auto numLineIndices = copyToHost(_numLineIndices);
-
-    setValueToDevice(_numTriangleIndices, static_cast<uint64_t>(0));
-    KERNEL_CALL(cudaExtractTriangleIndices, data, nullptr, _numTriangleIndices);
-    cudaDeviceSynchronize();
-    auto numTriangleIndices = copyToHost(_numTriangleIndices);
-
-    setValueToDevice(_numSelectedConnectionVertices, static_cast<uint64_t>(0));
-    KERNEL_CALL(cudaExtractSelectedConnectionData, data, nullptr, _numSelectedConnectionVertices);
-    cudaDeviceSynchronize();
-    auto numConnectionArrows = copyToHost(_numSelectedConnectionVertices);
-
-    setValueToDevice(_numAttackEventVertices, static_cast<uint64_t>(0));
-    KERNEL_CALL(cudaExtractAttackEventData, data, nullptr, _numAttackEventVertices);
-    cudaDeviceSynchronize();
-    auto numAttackEvents = copyToHost(_numAttackEventVertices);
-
-    setValueToDevice(_numDetonationEventVertices, static_cast<uint64_t>(0));
-    KERNEL_CALL(cudaExtractDetonationEventData, data, nullptr, _numDetonationEventVertices);
-    cudaDeviceSynchronize();
-    auto numDetonationEvents = copyToHost(_numDetonationEventVertices);
-
-    // Allocate device buffers
-    CellVertexData* deviceCellBuffer = nullptr;
-    EnergyParticleVertexData* deviceEnergyParticleBuffer = nullptr;
-    LocationVertexData* deviceLocationBuffer = nullptr;
-    SelectedObjectVertexData* deviceSelectedObjectBuffer = nullptr;
-    unsigned int* deviceLineIndexBuffer = nullptr;
-    unsigned int* deviceTriangleIndexBuffer = nullptr;
-    ConnectionArrowVertexData* deviceConnectionArrowBuffer = nullptr;
-    AttackEventVertexData* deviceAttackEventBuffer = nullptr;
-    DetonationEventVertexData* deviceDetonationEventBuffer = nullptr;
-
-    if (numCells > 0) {
-        CHECK_FOR_CUDA_ERROR(cudaMalloc(&deviceCellBuffer, numCells * sizeof(CellVertexData)));
-    }
-    if (numParticles > 0) {
-        CHECK_FOR_CUDA_ERROR(cudaMalloc(&deviceEnergyParticleBuffer, numParticles * sizeof(EnergyParticleVertexData)));
-    }
-    if (numLocations > 0) {
-        CHECK_FOR_CUDA_ERROR(cudaMalloc(&deviceLocationBuffer, numLocations * sizeof(LocationVertexData)));
-    }
-    if (numSelectedObjects > 0) {
-        CHECK_FOR_CUDA_ERROR(cudaMalloc(&deviceSelectedObjectBuffer, numSelectedObjects * sizeof(SelectedObjectVertexData)));
-    }
-    if (numLineIndices > 0) {
-        CHECK_FOR_CUDA_ERROR(cudaMalloc(&deviceLineIndexBuffer, numLineIndices * sizeof(unsigned int)));
-    }
-    if (numTriangleIndices > 0) {
-        CHECK_FOR_CUDA_ERROR(cudaMalloc(&deviceTriangleIndexBuffer, numTriangleIndices * sizeof(unsigned int)));
-    }
-    if (numConnectionArrows > 0) {
-        CHECK_FOR_CUDA_ERROR(cudaMalloc(&deviceConnectionArrowBuffer, numConnectionArrows * sizeof(ConnectionArrowVertexData)));
-    }
-    if (numAttackEvents > 0) {
-        CHECK_FOR_CUDA_ERROR(cudaMalloc(&deviceAttackEventBuffer, numAttackEvents * sizeof(AttackEventVertexData)));
-    }
-    if (numDetonationEvents > 0) {
-        CHECK_FOR_CUDA_ERROR(cudaMalloc(&deviceDetonationEventBuffer, numDetonationEvents * sizeof(DetonationEventVertexData)));
-    }
-
-    // Extract data to device buffers
-    if (numCells > 0) {
-        KERNEL_CALL(cudaExtractCellData, data, deviceCellBuffer);
-    }
-    if (numParticles > 0) {
-        KERNEL_CALL(cudaExtractEnergyParticleData, data, deviceEnergyParticleBuffer);
-    }
-    if (numLocations > 0) {
-        setValueToDevice(_numLocations, static_cast<uint64_t>(0));
-        KERNEL_CALL_1_1(cudaExtractLocationData, data, deviceLocationBuffer, _numLocations, visibleTopLeft);
-    }
-    if (numSelectedObjects > 0) {
-        setValueToDevice(_numSelectedObjects, static_cast<uint64_t>(0));
-        KERNEL_CALL(cudaExtractSelectedObjectData, data, deviceSelectedObjectBuffer, _numSelectedObjects);
-    }
-    if (numLineIndices > 0) {
-        setValueToDevice(_numLineIndices, static_cast<uint64_t>(0));
-        KERNEL_CALL(cudaExtractLineIndices, data, deviceLineIndexBuffer, _numLineIndices);
-    }
-    if (numTriangleIndices > 0) {
-        setValueToDevice(_numTriangleIndices, static_cast<uint64_t>(0));
-        KERNEL_CALL(cudaExtractTriangleIndices, data, deviceTriangleIndexBuffer, _numTriangleIndices);
-    }
-    if (numConnectionArrows > 0) {
-        setValueToDevice(_numSelectedConnectionVertices, static_cast<uint64_t>(0));
-        KERNEL_CALL(cudaExtractSelectedConnectionData, data, deviceConnectionArrowBuffer, _numSelectedConnectionVertices);
-    }
-    if (numAttackEvents > 0) {
-        setValueToDevice(_numAttackEventVertices, static_cast<uint64_t>(0));
-        KERNEL_CALL(cudaExtractAttackEventData, data, deviceAttackEventBuffer, _numAttackEventVertices);
-    }
-    if (numDetonationEvents > 0) {
-        setValueToDevice(_numDetonationEventVertices, static_cast<uint64_t>(0));
-        KERNEL_CALL(cudaExtractDetonationEventData, data, deviceDetonationEventBuffer, _numDetonationEventVertices);
-    }
-    cudaDeviceSynchronize();
-
-    // Resize CPU buffers
-    cpuBuffers.cells.resize(numCells);
-    cpuBuffers.energyParticles.resize(numParticles);
-    cpuBuffers.locations.resize(numLocations);
-    cpuBuffers.selectedObjects.resize(numSelectedObjects);
-    cpuBuffers.lineIndices.resize(numLineIndices);
-    cpuBuffers.triangleIndices.resize(numTriangleIndices);
-    cpuBuffers.connectionArrows.resize(numConnectionArrows);
-    cpuBuffers.attackEvents.resize(numAttackEvents);
-    cpuBuffers.detonationEvents.resize(numDetonationEvents);
-
-    // Copy from device to host
-    if (numCells > 0) {
-        CHECK_FOR_CUDA_ERROR(cudaMemcpy(cpuBuffers.cells.data(), deviceCellBuffer, numCells * sizeof(CellVertexData), cudaMemcpyDeviceToHost));
-        CHECK_FOR_CUDA_ERROR(cudaFree(deviceCellBuffer));
-    }
-    if (numParticles > 0) {
-        CHECK_FOR_CUDA_ERROR(cudaMemcpy(cpuBuffers.energyParticles.data(), deviceEnergyParticleBuffer, numParticles * sizeof(EnergyParticleVertexData), cudaMemcpyDeviceToHost));
-        CHECK_FOR_CUDA_ERROR(cudaFree(deviceEnergyParticleBuffer));
-    }
-    if (numLocations > 0) {
-        CHECK_FOR_CUDA_ERROR(cudaMemcpy(cpuBuffers.locations.data(), deviceLocationBuffer, numLocations * sizeof(LocationVertexData), cudaMemcpyDeviceToHost));
-        CHECK_FOR_CUDA_ERROR(cudaFree(deviceLocationBuffer));
-    }
-    if (numSelectedObjects > 0) {
-        CHECK_FOR_CUDA_ERROR(cudaMemcpy(cpuBuffers.selectedObjects.data(), deviceSelectedObjectBuffer, numSelectedObjects * sizeof(SelectedObjectVertexData), cudaMemcpyDeviceToHost));
-        CHECK_FOR_CUDA_ERROR(cudaFree(deviceSelectedObjectBuffer));
-    }
-    if (numLineIndices > 0) {
-        CHECK_FOR_CUDA_ERROR(cudaMemcpy(cpuBuffers.lineIndices.data(), deviceLineIndexBuffer, numLineIndices * sizeof(unsigned int), cudaMemcpyDeviceToHost));
-        CHECK_FOR_CUDA_ERROR(cudaFree(deviceLineIndexBuffer));
-    }
-    if (numTriangleIndices > 0) {
-        CHECK_FOR_CUDA_ERROR(cudaMemcpy(cpuBuffers.triangleIndices.data(), deviceTriangleIndexBuffer, numTriangleIndices * sizeof(unsigned int), cudaMemcpyDeviceToHost));
-        CHECK_FOR_CUDA_ERROR(cudaFree(deviceTriangleIndexBuffer));
-    }
-    if (numConnectionArrows > 0) {
-        CHECK_FOR_CUDA_ERROR(cudaMemcpy(cpuBuffers.connectionArrows.data(), deviceConnectionArrowBuffer, numConnectionArrows * sizeof(ConnectionArrowVertexData), cudaMemcpyDeviceToHost));
-        CHECK_FOR_CUDA_ERROR(cudaFree(deviceConnectionArrowBuffer));
-    }
-    if (numAttackEvents > 0) {
-        CHECK_FOR_CUDA_ERROR(cudaMemcpy(cpuBuffers.attackEvents.data(), deviceAttackEventBuffer, numAttackEvents * sizeof(AttackEventVertexData), cudaMemcpyDeviceToHost));
-        CHECK_FOR_CUDA_ERROR(cudaFree(deviceAttackEventBuffer));
-    }
-    if (numDetonationEvents > 0) {
-        CHECK_FOR_CUDA_ERROR(cudaMemcpy(cpuBuffers.detonationEvents.data(), deviceDetonationEventBuffer, numDetonationEvents * sizeof(DetonationEventVertexData), cudaMemcpyDeviceToHost));
-        CHECK_FOR_CUDA_ERROR(cudaFree(deviceDetonationEventBuffer));
-    }
-}

source/EngineGpuKernels/GeometryKernelsService.cuh

@@ -2,7 +2,6 @@
 
 #include <Base/Singleton.h>
 
-#include <EngineInterface/CpuGeometryBuffers.h>
 #include <EngineInterface/GeometryBuffers.h>
 
 #include "Base.cuh"
@@ -22,7 +21,6 @@ public:
     void restorePositions(SettingsForSimulation const& settings, SimulationData data);
     NumRenderObjects getNumRenderObjects(SettingsForSimulation const& settings, SimulationData data, RealRect const& visibleWorldRect);
     void extractObjectData(SettingsForSimulation const& settings, SimulationData data, CudaGeometryBuffers& renderingData, RealRect const& visibleWorldRect, bool useInterop);
-    void extractObjectDataToCpuBuffers(SettingsForSimulation const& settings, SimulationData data, CpuGeometryBuffers& cpuBuffers, RealRect const& visibleWorldRect);
 
 private:
     GeometryKernelsService() = default;

source/EngineGpuKernels/SimulationCudaFacade.cu

@@ -677,10 +677,17 @@ CpuGeometryBuffers _SimulationCudaFacade::testOnly_copyBuffersFromCudaToCpu()
     checkAndProcessSimulationParameterChanges();
     auto simulationData = getSimulationDataPtrCopy();
     RealRect visibleWorldRect = {{0, 0}, {static_cast<float>(_settings.worldSizeX), static_cast<float>(_settings.worldSizeY)}};
-    CpuGeometryBuffers cpuBuffers;
-    GeometryKernelsService::get().extractObjectDataToCpuBuffers(_settings, simulationData, cpuBuffers, visibleWorldRect);
+
+    // Get render object counts and allocate device buffers
+    auto numRenderObjects = GeometryKernelsService::get().getNumRenderObjects(_settings, simulationData, visibleWorldRect);
+    _cudaGeometryBuffers->allocateBuffersForNoInterop(numRenderObjects);
+
+    // Extract data to device buffers (useInterop=false)
+    GeometryKernelsService::get().extractObjectData(_settings, simulationData, *_cudaGeometryBuffers, visibleWorldRect, false);
     syncAndCheck();
-    return cpuBuffers;
+
+    // Convert to CPU buffers
+    return _cudaGeometryBuffers->copyToCpu(numRenderObjects);
 }
 
 void _SimulationCudaFacade::initCuda()