Fix staging performance

floppyhammer · floppyhammer · commit de54186ffdf5 · 2026-07-15T21:37:28.000+08:00
diff --git a/pathfinder/gpu/command_encoder.cpp b/pathfinder/gpu/command_encoder.cpp
@@ -214,6 +214,11 @@ 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);
@@ -250,8 +255,13 @@ 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::ReadBuffer;
+    cmd.type = CommandType::WriteBuffer;
 
     auto &args = cmd.args.read_buffer;
     args.buffer = buffer.get();
@@ -288,6 +298,11 @@ 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);
@@ -325,6 +340,11 @@ 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;
 
@@ -349,4 +369,19 @@ void CommandEncoder::read_texture(const std::shared_ptr<Texture> &texture, RectI
     track_temporary_resource(allocation.buffer);
 }
 
+void CommandEncoder::invoke_callbacks() {
+    for (auto &callback : callbacks_) {
+        callback();
+    }
+
+    callbacks_.clear();
+    temp_buffers_.clear();
+
+    if (used_staging_buffer_) {
+        if (auto device = device_.lock()) {
+            device_.lock()->decrement_staging_encoder();
+        }
+    }
+}
+
 } // namespace Pathfinder
diff --git a/pathfinder/gpu/command_encoder.h b/pathfinder/gpu/command_encoder.h
@@ -55,6 +55,7 @@ enum class CommandType {
 struct StagingAllocation {
     std::shared_ptr<Buffer> buffer;
     size_t offset = 0;
+    size_t data_size = 0;
     void *mapped_ptr = nullptr;
 };
 
@@ -236,14 +237,7 @@ class CommandEncoder {
         temp_buffers_.push_back(buffer);
     }
 
-    void invoke_callbacks() {
-        for (auto &callback : callbacks_) {
-            callback();
-        }
-
-        callbacks_.clear();
-        temp_buffers_.clear();
-    }
+    void invoke_callbacks();
 
 protected:
     CommandEncoder() = default;
@@ -276,6 +270,8 @@ class CommandEncoder {
     std::weak_ptr<Device> device_;
 
     std::vector<std::shared_ptr<Framebuffer>> framebuffers_;
+
+    bool used_staging_buffer_ = false;
 };
 
 } // namespace Pathfinder
diff --git a/pathfinder/gpu/device.cpp b/pathfinder/gpu/device.cpp
@@ -0,0 +1,54 @@
+#include "device.h"
+
+namespace Pathfinder {
+
+StagingAllocation Device::allocate_staging(size_t size) {
+    if (size > STAGING_BLOCK_SIZE) {
+        auto buffer = create_staging_buffer(size);
+
+        StagingAllocation alloc;
+        alloc.buffer = buffer;
+        alloc.offset = 0;
+        alloc.data_size = size;
+        alloc.mapped_ptr = nullptr;
+        return alloc;
+    }
+
+    for (auto &block : staging_blocks_) {
+        size_t aligned_offset = (block.used_size + 15) & ~15;
+
+        if (aligned_offset + size <= STAGING_BLOCK_SIZE) {
+            StagingAllocation alloc;
+            alloc.buffer = block.buffer;
+            alloc.offset = aligned_offset;
+            alloc.data_size = size;
+            alloc.mapped_ptr = nullptr;
+
+            block.used_size = aligned_offset + size;
+            return alloc;
+        }
+    }
+
+    auto buffer = create_staging_buffer(STAGING_BLOCK_SIZE);
+
+    StagingBlock new_block;
+    new_block.buffer = buffer;
+    new_block.used_size = size;
+    staging_blocks_.push_back(new_block);
+
+    StagingAllocation alloc;
+    alloc.buffer = buffer;
+    alloc.offset = 0;
+    alloc.data_size = size;
+    alloc.mapped_ptr = nullptr;
+
+    return alloc;
+}
+
+void Device::reset_staging() {
+    for (auto &block : staging_blocks_) {
+        block.used_size = 0;
+    }
+}
+
+} // namespace Pathfinder
diff --git a/pathfinder/gpu/device.h b/pathfinder/gpu/device.h
@@ -72,22 +72,49 @@ class Device : public std::enable_shared_from_this<Device> {
 
     virtual std::shared_ptr<Fence> create_fence(const std::string &label) = 0;
 
-    virtual StagingAllocation allocate_staging(size_t size) = 0;
+    StagingAllocation allocate_staging(size_t size);
 
-    virtual void *map_staging(const StagingAllocation &allocation) { return nullptr; }
+    virtual void *map_staging(const StagingAllocation &allocation) {
+        return nullptr;
+    }
 
     virtual void unmap_staging(const StagingAllocation &allocation) {}
 
-    virtual void reset_staging() {}
+    virtual void reset_staging();
 
     virtual size_t get_aligned_uniform_size(size_t original_size) = 0;
 
     BackendType get_backend_type() const {
         return backend_type;
     }
 
+public:
+    void increment_staging_encoder() {
+        pending_staging_encoders_++;
+    }
+
+    void decrement_staging_encoder() {
+        pending_staging_encoders_--;
+        if (pending_staging_encoders_ == 0) {
+            reset_staging();
+        }
+    }
+
 protected:
     BackendType backend_type = BackendType::Vulkan;
+
+    struct StagingBlock {
+        std::shared_ptr<Buffer> buffer;
+        size_t used_size = 0;
+    };
+
+    const size_t STAGING_BLOCK_SIZE = 4 * 1024 * 1024;
+
+    std::vector<StagingBlock> staging_blocks_;
+
+    uint32_t pending_staging_encoders_ = 0;
+
+    virtual std::shared_ptr<Buffer> create_staging_buffer(size_t size) = 0;
 };
 
 } // namespace Pathfinder
diff --git a/pathfinder/gpu/gl/buffer.cpp b/pathfinder/gpu/gl/buffer.cpp
@@ -49,6 +49,11 @@ BufferGl::~BufferGl() {
 }
 
 void BufferGl::upload_via_mapping(size_t data_size, size_t offset, const void *data) {
+    if (mapped_ptr_) {
+        memcpy((uint8_t *)mapped_ptr_ + offset, data, data_size);
+        return;
+    }
+
     int gl_buffer_type = 0;
 
     switch (desc_.type) {
@@ -115,6 +120,10 @@ void BufferGl::set_label(const std::string &label) {
 }
 
 void *BufferGl::map() {
+    if (mapped_ptr_) {
+        return mapped_ptr_;
+    }
+
     GLint target = GL_NONE;
     switch (desc_.type) {
         case BufferType::Uniform:
@@ -135,8 +144,11 @@ void *BufferGl::map() {
         } break;
     }
     glBindBuffer(target, gl_id_);
-    void *ptr = glMapBufferRange(target, 0, desc_.size, GL_MAP_READ_BIT | GL_MAP_WRITE_BIT);
+    GLbitfield flags = GL_MAP_WRITE_BIT;
+    void *ptr = glMapBufferRange(target, 0, desc_.size, flags);
     glBindBuffer(target, 0);
+
+    mapped_ptr_ = ptr;
     return ptr;
 }
 
@@ -163,6 +175,7 @@ void BufferGl::unmap() {
     glBindBuffer(target, gl_id_);
     glUnmapBuffer(target);
     glBindBuffer(target, 0);
+    mapped_ptr_ = nullptr;
 }
 
 } // namespace Pathfinder
diff --git a/pathfinder/gpu/gl/buffer.h b/pathfinder/gpu/gl/buffer.h
@@ -26,8 +26,10 @@ class BufferGl : public Buffer {
 
 private:
     explicit BufferGl(const BufferDescriptor& desc);
-
     uint32_t gl_id_ = 0;
+
+    // Cache mapped pointer to improve performance.
+    void* mapped_ptr_ = nullptr;
 };
 
 } // namespace Pathfinder
diff --git a/pathfinder/gpu/gl/device.cpp b/pathfinder/gpu/gl/device.cpp
@@ -137,26 +137,17 @@ std::shared_ptr<Fence> DeviceGl::create_fence(const std::string &label) {
 
     return fence_gl;
 }
-
-StagingAllocation DeviceGl::allocate_staging(size_t size) {
+std::shared_ptr<Buffer> DeviceGl::create_staging_buffer(size_t size) {
     BufferDescriptor desc;
     desc.type = BufferType::Storage;
     desc.size = size;
     desc.property = MemoryProperty::HostVisibleAndCoherent;
-
-    auto buffer = create_buffer(desc, "GL Staging Buffer");
-
-    StagingAllocation alloc;
-    alloc.buffer = buffer;
-    alloc.offset = 0;
-    alloc.mapped_ptr = nullptr;
-
-    return alloc;
+    return create_buffer(desc, "GL Staging Buffer");
 }
 
 void *DeviceGl::map_staging(const StagingAllocation &allocation) {
     auto buffer_gl = (BufferGl *)allocation.buffer.get();
-    return buffer_gl->map();
+    return (uint8_t *)buffer_gl->map() + allocation.offset;
 }
 
 void DeviceGl::unmap_staging(const StagingAllocation &allocation) {
diff --git a/pathfinder/gpu/gl/device.h b/pathfinder/gpu/gl/device.h
@@ -62,12 +62,12 @@ class DeviceGl : public Device {
 
     std::shared_ptr<Fence> create_fence(const std::string &label) override;
 
-    StagingAllocation allocate_staging(size_t size) override;
-
     void *map_staging(const StagingAllocation &allocation) override;
 
     void unmap_staging(const StagingAllocation &allocation) override;
 
+    std::shared_ptr<Buffer> create_staging_buffer(size_t size) override;
+
     size_t get_aligned_uniform_size(size_t original_size) override;
 
 private:
diff --git a/pathfinder/gpu/mtl/device.h b/pathfinder/gpu/mtl/device.h
@@ -66,12 +66,12 @@ class DeviceMtl final : public Device {
 
     std::shared_ptr<Fence> create_fence(const std::string &label) override;
 
-    StagingAllocation allocate_staging(size_t size) override;
-
     void *map_staging(const StagingAllocation &allocation) override;
 
     void unmap_staging(const StagingAllocation &allocation) override;
 
+    std::shared_ptr<Buffer> create_staging_buffer(size_t size) override;
+
     size_t get_aligned_uniform_size(size_t original_size) override;
 
     std::shared_ptr<TextureMtl> wrap_texture(id<MTLTexture> mtl_texture, bool has_resource_ownership);
diff --git a/pathfinder/gpu/mtl/device.mm b/pathfinder/gpu/mtl/device.mm
@@ -203,25 +203,17 @@
     return std::shared_ptr<Fence>(new Fence());
 }
 
-StagingAllocation DeviceMtl::allocate_staging(size_t size) {
+std::shared_ptr<Buffer> DeviceMtl::create_staging_buffer(size_t size) {
     BufferDescriptor desc;
     desc.type = BufferType::Storage;
     desc.size = size;
     desc.property = MemoryProperty::HostVisibleAndCoherent;
-
-    auto buffer = create_buffer(desc, "Metal Staging Buffer");
-
-    StagingAllocation alloc;
-    alloc.buffer = buffer;
-    alloc.offset = 0;
-    alloc.mapped_ptr = nullptr;
-
-    return alloc;
+    return create_buffer(desc, "Metal Staging Buffer");
 }
 
 void *DeviceMtl::map_staging(const StagingAllocation &allocation) {
     auto buffer_mtl = (BufferMtl *)allocation.buffer.get();
-    return buffer_mtl->contents();
+    return (uint8_t *)buffer_mtl->contents() + allocation.offset;
 }
 
 void DeviceMtl::unmap_staging(const StagingAllocation &allocation) {
diff --git a/pathfinder/gpu/vk/device.cpp b/pathfinder/gpu/vk/device.cpp
diff --git a/pathfinder/gpu/vk/device.h b/pathfinder/gpu/vk/device.h
diff --git a/pathfinder/gpu/vk/queue.cpp b/pathfinder/gpu/vk/queue.cpp
diff --git a/pathfinder/gpu/vk/queue.h b/pathfinder/gpu/vk/queue.h
