From 1649ed14b8248fa4193f56e8207f1b3c4d6717b2 Mon Sep 17 00:00:00 2001 From: joe chu Date: Wed, 28 Oct 2026 09:11:22 -0700 Subject: [PATCH] optimization(vulkan): reuse mappings for uniform updates --- .../vulkan/DrawTextureDemo/RenderTexture.cpp | 5 +- tests/vulkan/CMakeLists.txt | 3 + tests/vulkan/VulkanBufferMappingTest.cpp | 107 ++++++++++++++++++ .../benchmarks/BufferMappingBenchmark.cpp | 94 +++++++++++++++ vulkan/include/VulkanBuffer.h | 3 + vulkan/src/VulkanBuffer.cpp | 40 ++++++- 6 files changed, 243 insertions(+), 9 deletions(-) create mode 100644 tests/vulkan/VulkanBufferMappingTest.cpp create mode 100644 tests/vulkan/benchmarks/BufferMappingBenchmark.cpp diff --git a/examples/vulkan/DrawTextureDemo/RenderTexture.cpp b/examples/vulkan/DrawTextureDemo/RenderTexture.cpp index 65cb2e3..9e001bc 100644 --- a/examples/vulkan/DrawTextureDemo/RenderTexture.cpp +++ b/examples/vulkan/DrawTextureDemo/RenderTexture.cpp @@ -24,7 +24,7 @@ void RenderTexture::Init() { index_buffer_staging_.MapData( [this](void* data) { memcpy(data, indices_.data(), sizeof(indices_[0]) * indices_.size()); }); - uniform_buffer_.MapData([this](void* data) { + uniform_buffer_.MapDataPersistent([this](void* data) { uniform_data_.model = glm::mat4(1.0f); uniform_data_.view = glm::mat4(1.0f); uniform_data_.project = glm::mat4(1.0f); @@ -148,8 +148,7 @@ void RenderTexture::UpdateUniformBuffer(const int width, const int height) { std::chrono::duration(current_time - start_time_) .count(); - // TODO: maintain a persistent mapping pointer to avoid mapping every time - uniform_buffer_.MapData([this, time, width, height](void* data) { + uniform_buffer_.MapDataPersistent([this, time, width, height](void* data) { uniform_data_.model = glm::rotate(glm::mat4(1.0f), time * glm::radians(-90.0f), glm::vec3(0.0f, 0.0f, 1.0f)); uniform_data_.view = glm::lookAt(glm::vec3(1.0f, 1.0f, 1.0f), glm::vec3(0.0f, 0.0f, 0.0f), diff --git a/tests/vulkan/CMakeLists.txt b/tests/vulkan/CMakeLists.txt index b5bf10e..5ec22a8 100644 --- a/tests/vulkan/CMakeLists.txt +++ b/tests/vulkan/CMakeLists.txt @@ -48,3 +48,6 @@ target_include_directories(vulkan_gaussian_benchmark PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/shaders) add_dependencies(vulkan_gaussian_benchmark vulkan_shaders) target_link_libraries(vulkan_gaussian_benchmark PRIVATE mat vulkan) + +add_executable(vulkan_mapping_benchmark benchmarks/BufferMappingBenchmark.cpp) +target_link_libraries(vulkan_mapping_benchmark PRIVATE vulkan) diff --git a/tests/vulkan/VulkanBufferMappingTest.cpp b/tests/vulkan/VulkanBufferMappingTest.cpp new file mode 100644 index 0000000..230575f --- /dev/null +++ b/tests/vulkan/VulkanBufferMappingTest.cpp @@ -0,0 +1,107 @@ +#include + +#include +#include +#include +#include + +#include "VulkanBuffer.h" +#include "VulkanContext.h" + +namespace core { +namespace test { + +TEST(VulkanBufferMappingTest, RepeatedUpdatesRemainVisibleToGpuAndHost) { + vulkan::VulkanContext context(true, vulkan::QueueFamilyType::Compute, VK_NULL_HANDLE); + context.Init(); + constexpr VkDeviceSize kBytes = 192; + constexpr VkMemoryPropertyFlags kHostMemory = + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; + vulkan::VulkanBuffer source( + &context, kBytes, VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, + kHostMemory); + vulkan::VulkanBuffer device( + &context, kBytes, VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); + vulkan::VulkanBuffer result(&context, kBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT, kHostMemory); + for (uint32_t iteration = 0; iteration < 8; ++iteration) { + source.MapDataPersistent([iteration](void* data) { + uint32_t* words = static_cast(data); + for (uint32_t index = 0; index < kBytes / sizeof(uint32_t); ++index) { + words[index] = iteration * 71 + index; + } + }); + const std::array copies = { + vulkan::BatchBufferCopy{.source = &source, + .destination = &device, + .source_offset = 0, + .destination_offset = 0, + .size = VK_WHOLE_SIZE}, + vulkan::BatchBufferCopy{.source = &device, + .destination = &result, + .source_offset = 0, + .destination_offset = 0, + .size = VK_WHOLE_SIZE}}; + vulkan::VulkanBuffer::CopyBuffers(copies); + result.MapDataPersistent([iteration](void* data) { + const uint32_t* words = static_cast(data); + for (uint32_t index = 0; index < kBytes / sizeof(uint32_t); ++index) { + EXPECT_EQ(words[index], iteration * 71 + index); + } + }); + } +} + +TEST(VulkanBufferMappingTest, MappingSurvivesCallbackFailureAndOwnershipTransfer) { + vulkan::VulkanContext context(true, vulkan::QueueFamilyType::Compute, VK_NULL_HANDLE); + context.Init(); + constexpr VkMemoryPropertyFlags kHostMemory = + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; + vulkan::VulkanBuffer destination( + &context, sizeof(uint32_t), VK_BUFFER_USAGE_TRANSFER_SRC_BIT, kHostMemory); + destination.MapDataPersistent([](void* data) { *static_cast(data) = 99; }); + { + vulkan::VulkanBuffer source( + &context, sizeof(uint32_t), VK_BUFFER_USAGE_TRANSFER_SRC_BIT, kHostMemory); + EXPECT_THROW( + source.MapDataPersistent([](void* data) { + *static_cast(data) = 42; + throw std::runtime_error("callback failure"); + }), + std::runtime_error); + source.MapDataPersistent([](void* data) { EXPECT_EQ(*static_cast(data), 42U); }); + destination = std::move(source); + EXPECT_THROW(source.MapDataPersistent([](void*) {}), std::runtime_error); + } + vulkan::VulkanBuffer* alias = &destination; + destination = std::move(*alias); + destination.MapDataPersistent([](void* data) { EXPECT_EQ(*static_cast(data), 42U); }); + vulkan::VulkanBuffer result( + &context, sizeof(uint32_t), VK_BUFFER_USAGE_TRANSFER_DST_BIT, kHostMemory); + destination.CopyToBuffer(result); + result.MapDataPersistent([](void* data) { EXPECT_EQ(*static_cast(data), 42U); }); + EXPECT_THROW(destination.MapData([](void*) { throw std::runtime_error("transient failure"); }), + std::runtime_error); + destination.MapDataPersistent([](void* data) { EXPECT_EQ(*static_cast(data), 42U); }); + destination.MapData([](void* data) { *static_cast(data) = 71; }); + destination.MapDataPersistent([](void* data) { EXPECT_EQ(*static_cast(data), 71U); }); +} + +TEST(VulkanBufferMappingTest, RejectsEmptyAndNonHostBuffersWithoutCallingCallback) { + vulkan::VulkanContext context(true, vulkan::QueueFamilyType::Compute, VK_NULL_HANDLE); + context.Init(); + vulkan::VulkanBuffer empty; + vulkan::VulkanBuffer device( + &context, sizeof(uint32_t), VK_BUFFER_USAGE_TRANSFER_DST_BIT, + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); + bool called = false; + const auto callback = [&called](void*) { called = true; }; + EXPECT_THROW(empty.MapData(callback), std::runtime_error); + EXPECT_THROW(empty.MapDataPersistent(callback), std::runtime_error); + EXPECT_THROW(device.MapData(callback), std::runtime_error); + EXPECT_THROW(device.MapDataPersistent(callback), std::runtime_error); + EXPECT_FALSE(called); +} + +} +} diff --git a/tests/vulkan/benchmarks/BufferMappingBenchmark.cpp b/tests/vulkan/benchmarks/BufferMappingBenchmark.cpp new file mode 100644 index 0000000..634e4cc --- /dev/null +++ b/tests/vulkan/benchmarks/BufferMappingBenchmark.cpp @@ -0,0 +1,94 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "VulkanBuffer.h" +#include "VulkanContext.h" + +namespace { + +void Benchmark(core::vulkan::VulkanContext& context, size_t count, size_t bytes, + size_t iterations) { + constexpr VkMemoryPropertyFlags kHostMemory = + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; + std::array>, 2> buffers; + for (std::vector>& group : buffers) { + for (size_t index = 0; index < count; ++index) { + group.push_back(std::make_unique( + &context, bytes, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT, + kHostMemory)); + } + } + core::vulkan::VulkanBuffer readback( + &context, bytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT, kHostMemory); + std::vector input(bytes); + std::array, 2> samples; + constexpr int kWarmups = 5; + constexpr int kSamples = 31; + for (int sample = -kWarmups; sample < kSamples; ++sample) { + for (size_t byte = 0; byte < bytes; ++byte) { + input[byte] = static_cast((byte * 17 + static_cast(sample + kWarmups)) % 251); + } + for (size_t turn = 0; turn < 2; ++turn) { + const size_t mode = (static_cast(sample + kWarmups) + turn) % 2; + const std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now(); + for (size_t iteration = 0; iteration < iterations; ++iteration) { + for (const std::unique_ptr& buffer : buffers[mode]) { + const auto update = [&input, bytes](void* data) { + std::memcpy(data, input.data(), bytes); + }; + if (mode == 0) { + buffer->MapData(update); + } else { + buffer->MapDataPersistent(update); + } + } + } + const double elapsed = + std::chrono::duration(std::chrono::steady_clock::now() - start).count(); + if (sample >= 0) { + samples[mode].push_back(elapsed / static_cast(iterations * count)); + } + for (const std::unique_ptr& buffer : buffers[mode]) { + buffer->CopyToBuffer(readback); + readback.MapData([&input, bytes](void* data) { + if (std::memcmp(data, input.data(), bytes) != 0) { + throw std::runtime_error("Mapped update GPU readback mismatch"); + } + }); + } + } + } + for (std::vector& mode_samples : samples) { + std::sort(mode_samples.begin(), mode_samples.end()); + } + std::printf("buffers=%zu bytes=%zu updates_per_buffer=%zu warmups=%d samples=%d " + "transient_ns[p10,median,p90]=[%.2f,%.2f,%.2f] " + "persistent_ns[p10,median,p90]=[%.2f,%.2f,%.2f] verified=yes\n", + count, bytes, iterations, kWarmups, kSamples, samples[0][3], samples[0][15], + samples[0][27], samples[1][3], samples[1][15], samples[1][27]); +} + +} + +int main() { + core::vulkan::VulkanContext context( + false, core::vulkan::QueueFamilyType::Compute, VK_NULL_HANDLE); + context.Init(); + VkPhysicalDeviceProperties properties{}; + vkGetPhysicalDeviceProperties(context.physical_device, &properties); + std::printf("GPU=%s; validation disabled; CPU wall time includes callback and memcpy; " + "allocation/input generation/GPU copy/readback excluded; warmed updates only\n", + properties.deviceName); + Benchmark(context, 1, 192, 10000); + Benchmark(context, 64, 192, 1000); + Benchmark(context, 1, 4096, 10000); + Benchmark(context, 1, 1048576, 32); + return 0; +} diff --git a/vulkan/include/VulkanBuffer.h b/vulkan/include/VulkanBuffer.h index 69e657e..0822298 100644 --- a/vulkan/include/VulkanBuffer.h +++ b/vulkan/include/VulkanBuffer.h @@ -53,6 +53,8 @@ class VulkanBuffer { void MapData(const std::function& func); + void MapDataPersistent(const std::function& func); + VkDeviceSize Size() const { return buffer_size_; } VkBuffer buffer = VK_NULL_HANDLE; @@ -64,6 +66,7 @@ class VulkanBuffer { VkMemoryPropertyFlags memory_properties_ = 0; VkBufferUsageFlags usage_ = 0; VkDeviceMemory buffer_memory_ = VK_NULL_HANDLE; + void* mapped_data_ = nullptr; }; } // namespace vulkan diff --git a/vulkan/src/VulkanBuffer.cpp b/vulkan/src/VulkanBuffer.cpp index 9e50b4f..af38952 100644 --- a/vulkan/src/VulkanBuffer.cpp +++ b/vulkan/src/VulkanBuffer.cpp @@ -34,6 +34,9 @@ VulkanBuffer::VulkanBuffer(VulkanContext* context, const VkDeviceSize size, } VulkanBuffer::~VulkanBuffer() { + if (mapped_data_ != nullptr) { + vkUnmapMemory(context_->logical_device, buffer_memory_); + } if (context_ && buffer != VK_NULL_HANDLE) { vkDestroyBuffer(context_->logical_device, buffer, nullptr); } @@ -47,6 +50,9 @@ VulkanBuffer& VulkanBuffer::operator=(VulkanBuffer&& rhs) { return *this; } + if (mapped_data_ != nullptr) { + vkUnmapMemory(context_->logical_device, buffer_memory_); + } if (context_ && buffer != VK_NULL_HANDLE) { vkDestroyBuffer(context_->logical_device, buffer, nullptr); } @@ -61,6 +67,9 @@ VulkanBuffer& VulkanBuffer::operator=(VulkanBuffer&& rhs) { buffer_memory_ = rhs.buffer_memory_; rhs.buffer_memory_ = VK_NULL_HANDLE; + mapped_data_ = rhs.mapped_data_; + rhs.mapped_data_ = nullptr; + buffer_size_ = rhs.buffer_size_; memory_properties_ = rhs.memory_properties_; usage_ = rhs.usage_; @@ -220,15 +229,34 @@ void VulkanBuffer::CopyToImage(VkCommandBuffer command_buffer, VulkanImage& dst_ } void VulkanBuffer::MapData(const std::function& func) { - const auto staging_buffer_property = + struct MappingReset { + VulkanBuffer& owner; + ~MappingReset() { + if (owner.mapped_data_ != nullptr) { + vkUnmapMemory(owner.context_->logical_device, owner.buffer_memory_); + owner.mapped_data_ = nullptr; + } + } + }; + const MappingReset reset{.owner = *this}; + MapDataPersistent(func); +} + +void VulkanBuffer::MapDataPersistent(const std::function& func) { + if (context_ == nullptr || buffer_memory_ == VK_NULL_HANDLE) { + throw std::runtime_error("Buffer is not initialized"); + } + constexpr VkMemoryPropertyFlags kMappableProperties = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; - if ((memory_properties_ & staging_buffer_property) != staging_buffer_property) { + if ((memory_properties_ & kMappableProperties) != kMappableProperties) { throw std::runtime_error("Buffer is not mappable"); } - void* data; - vkMapMemory(context_->logical_device, buffer_memory_, 0, buffer_size_, 0, &data); - func(data); - vkUnmapMemory(context_->logical_device, buffer_memory_); + if (mapped_data_ == nullptr) { + void* data = nullptr; + VK_CHECK(vkMapMemory(context_->logical_device, buffer_memory_, 0, buffer_size_, 0, &data)); + mapped_data_ = data; + } + func(mapped_data_); } } // namespace vulkan