Unify frame-based ring buffering logic (swapchain, staging buffers, and GpuMemoryAllocator)

Author: floppyhammer

demo/android/app/src/main/cpp/native_engine.cpp

@@ -12,6 +12,8 @@ void NativeEngine::draw_frame() {
         return;
     }
 
+    pf_device->begin_frame();
+
     auto current_window_size = pf_window->get_logical_size();
 
     if (current_window_size != pf_app->canvas_->get_dst_texture()->get_size() && current_window_size.area() != 0) {

demo/native/main.cpp

@@ -49,6 +49,8 @@ int main() {
             continue;
         }
 
+        device->begin_frame();
+
         auto current_window_size = window->get_physical_size();
 
         if (current_window_size != app.canvas_->get_dst_texture()->get_size() && current_window_size.area() != 0) {

pathfinder/gpu/command_encoder.cpp

@@ -214,11 +214,6 @@ void CommandEncoder::write_buffer(const std::shared_ptr<Buffer> &buffer,
     auto device = device_.lock();
     auto allocation = device->allocate_staging(data_size);
 
-    if (!used_staging_buffer_) {
-        used_staging_buffer_ = true;
-        device->increment_staging_encoder();
-    }
-
     void *mapped_ptr = device->map_staging(allocation);
     memcpy(mapped_ptr, data, data_size);
     device->unmap_staging(allocation);
@@ -255,11 +250,6 @@ void CommandEncoder::read_buffer(const std::shared_ptr<Buffer> &buffer,
     auto device = device_.lock();
     auto allocation = device->allocate_staging(data_size);
 
-    if (!used_staging_buffer_) {
-        used_staging_buffer_ = true;
-        device->increment_staging_encoder();
-    }
-
     Command cmd{};
     cmd.type = CommandType::WriteBuffer;
 
@@ -298,11 +288,6 @@ void CommandEncoder::write_texture(const std::shared_ptr<Texture> &texture, Rect
     auto device = device_.lock();
     auto allocation = device->allocate_staging(data_size);
 
-    if (!used_staging_buffer_) {
-        used_staging_buffer_ = true;
-        device->increment_staging_encoder();
-    }
-
     void *mapped_ptr = device->map_staging(allocation);
     memcpy(mapped_ptr, src, data_size);
     device->unmap_staging(allocation);
@@ -340,11 +325,6 @@ void CommandEncoder::read_texture(const std::shared_ptr<Texture> &texture, RectI
     auto device = device_.lock();
     auto allocation = device->allocate_staging(data_size);
 
-    if (!used_staging_buffer_) {
-        used_staging_buffer_ = true;
-        device->increment_staging_encoder();
-    }
-
     Command cmd{};
     cmd.type = CommandType::ReadTexture;
 
@@ -376,12 +356,6 @@ void CommandEncoder::invoke_callbacks() {
 
     callbacks_.clear();
     temp_buffers_.clear();
-
-    if (used_staging_buffer_) {
-        if (auto device = device_.lock()) {
-            device_.lock()->decrement_staging_encoder();
-        }
-    }
 }
 
 } // namespace Pathfinder

pathfinder/gpu/command_encoder.h

@@ -270,8 +270,6 @@ class CommandEncoder {
     std::weak_ptr<Device> device_;
 
     std::vector<std::shared_ptr<Framebuffer>> framebuffers_;
-
-    bool used_staging_buffer_ = false;
 };
 
 } // namespace Pathfinder

pathfinder/gpu/device.cpp

@@ -14,7 +14,9 @@ StagingAllocation Device::allocate_staging(size_t size) {
         return alloc;
     }
 
-    for (auto &block : staging_blocks_) {
+    auto &bucket = staging_buckets_[current_frame_index_ % frames_in_flight_];
+
+    for (auto &block : bucket.blocks) {
         size_t aligned_offset = (block.used_size + 15) & ~15;
 
         if (aligned_offset + size <= STAGING_BLOCK_SIZE) {
@@ -34,7 +36,7 @@ StagingAllocation Device::allocate_staging(size_t size) {
     StagingBlock new_block;
     new_block.buffer = buffer;
     new_block.used_size = size;
-    staging_blocks_.push_back(new_block);
+    bucket.blocks.push_back(new_block);
 
     StagingAllocation alloc;
     alloc.buffer = buffer;
@@ -46,8 +48,10 @@ StagingAllocation Device::allocate_staging(size_t size) {
 }
 
 void Device::reset_staging() {
-    for (auto &block : staging_blocks_) {
-        block.used_size = 0;
+    for (auto &bucket : staging_buckets_) {
+        for (auto &block : bucket.blocks) {
+            block.used_size = 0;
+        }
     }
 }
 

pathfinder/gpu/device.h

@@ -89,30 +89,46 @@ class Device : public std::enable_shared_from_this<Device> {
     }
 
 public:
-    void increment_staging_encoder() {
-        pending_staging_encoders_++;
-    }
+    void begin_frame() {
+        current_frame_index_++;
 
-    void decrement_staging_encoder() {
-        pending_staging_encoders_--;
-        if (pending_staging_encoders_ == 0) {
-            reset_staging();
+        auto &bucket = staging_buckets_[current_frame_index_ % frames_in_flight_];
+        for (auto &block : bucket.blocks) {
+            block.used_size = 0;
         }
     }
 
+    int get_frames_in_flight() const {
+        return frames_in_flight_;
+    }
+
+    uint32_t get_current_frame_index() const {
+        return current_frame_index_;
+    }
+
 protected:
+    Device(int frames_in_flight) : frames_in_flight_(frames_in_flight) {
+        staging_buckets_.resize(frames_in_flight_);
+    }
+
     BackendType backend_type = BackendType::Vulkan;
 
     struct StagingBlock {
         std::shared_ptr<Buffer> buffer;
         size_t used_size = 0;
     };
 
+    struct StagingBucket {
+        std::vector<StagingBlock> blocks;
+    };
+
     const size_t STAGING_BLOCK_SIZE = 4 * 1024 * 1024;
 
-    std::vector<StagingBlock> staging_blocks_;
+    std::vector<StagingBucket> staging_buckets_;
+
+    int frames_in_flight_;
 
-    uint32_t pending_staging_encoders_ = 0;
+    uint32_t current_frame_index_ = 0;
 
     virtual std::shared_ptr<Buffer> create_staging_buffer(size_t size) = 0;
 };

pathfinder/gpu/gl/device.cpp

@@ -12,7 +12,7 @@
 
 namespace Pathfinder {
 
-DeviceGl::DeviceGl() {
+DeviceGl::DeviceGl(int frames_in_flight) : Device(frames_in_flight) {
     backend_type = BackendType::Opengl;
 
     glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &min_uniform_alignment_);

pathfinder/gpu/gl/device.h

@@ -12,7 +12,7 @@ namespace Pathfinder {
 
 class DeviceGl : public Device {
 public:
-    DeviceGl();
+    DeviceGl(int frames_in_flight);
 
     std::shared_ptr<Framebuffer> create_framebuffer(const std::shared_ptr<RenderPass> &render_pass,
                                                     const std::shared_ptr<Texture> &texture,

pathfinder/gpu/gl/window_builder.cpp

@@ -232,8 +232,10 @@ uint8_t WindowBuilderGl::create_window(const Vec2I &size, const std::string &tit
 #endif
 }
 
+constexpr int MAX_FRAMES_IN_FLIGHT = 2;
+
 std::shared_ptr<Device> WindowBuilderGl::request_device() {
-    return std::make_shared<DeviceGl>();
+    return std::make_shared<DeviceGl>(MAX_FRAMES_IN_FLIGHT);
 }
 
 std::shared_ptr<Queue> WindowBuilderGl::create_queue() {

pathfinder/gpu/mtl/device.h

@@ -13,7 +13,7 @@ class QueueMtl;
 
 class DeviceMtl final : public Device {
 public:
-    DeviceMtl(id<MTLDevice> device, id<MTLCommandQueue> mtl_cmd_queue);
+    DeviceMtl(id<MTLDevice> device, id<MTLCommandQueue> mtl_cmd_queue, int frames_in_flight);
 
     ~DeviceMtl() override;