Skip to content
Closed
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
5 changes: 2 additions & 3 deletions examples/vulkan/DrawTextureDemo/RenderTexture.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -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);
Expand Down Expand Up @@ -148,8 +148,7 @@ void RenderTexture::UpdateUniformBuffer(const int width, const int height) {
std::chrono::duration<float, std::chrono::seconds::period>(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),
Expand Down
3 changes: 3 additions & 0 deletions tests/vulkan/CMakeLists.txt
Original file line number Diff line number Diff line change
Expand Up @@ -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)
107 changes: 107 additions & 0 deletions tests/vulkan/VulkanBufferMappingTest.cpp
Original file line number Diff line number Diff line change
@@ -0,0 +1,107 @@
#include <gtest/gtest.h>

#include <array>
#include <cstdint>
#include <stdexcept>
#include <utility>

#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<uint32_t*>(data);
for (uint32_t index = 0; index < kBytes / sizeof(uint32_t); ++index) {
words[index] = iteration * 71 + index;
}
});
const std::array<vulkan::BatchBufferCopy, 2> 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<const uint32_t*>(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<uint32_t*>(data) = 99; });
{
vulkan::VulkanBuffer source(
&context, sizeof(uint32_t), VK_BUFFER_USAGE_TRANSFER_SRC_BIT, kHostMemory);
EXPECT_THROW(
source.MapDataPersistent([](void* data) {
*static_cast<uint32_t*>(data) = 42;
throw std::runtime_error("callback failure");
}),
std::runtime_error);
source.MapDataPersistent([](void* data) { EXPECT_EQ(*static_cast<uint32_t*>(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<uint32_t*>(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<uint32_t*>(data), 42U); });
EXPECT_THROW(destination.MapData([](void*) { throw std::runtime_error("transient failure"); }),
std::runtime_error);
destination.MapDataPersistent([](void* data) { EXPECT_EQ(*static_cast<uint32_t*>(data), 42U); });
destination.MapData([](void* data) { *static_cast<uint32_t*>(data) = 71; });
destination.MapDataPersistent([](void* data) { EXPECT_EQ(*static_cast<uint32_t*>(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);
}

}
}
94 changes: 94 additions & 0 deletions tests/vulkan/benchmarks/BufferMappingBenchmark.cpp
Original file line number Diff line number Diff line change
@@ -0,0 +1,94 @@
#include <algorithm>
#include <array>
#include <chrono>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <memory>
#include <stdexcept>
#include <vector>

#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<std::vector<std::unique_ptr<core::vulkan::VulkanBuffer>>, 2> buffers;
for (std::vector<std::unique_ptr<core::vulkan::VulkanBuffer>>& group : buffers) {
for (size_t index = 0; index < count; ++index) {
group.push_back(std::make_unique<core::vulkan::VulkanBuffer>(
&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<uint8_t> input(bytes);
std::array<std::vector<double>, 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<uint8_t>((byte * 17 + static_cast<size_t>(sample + kWarmups)) % 251);
}
for (size_t turn = 0; turn < 2; ++turn) {
const size_t mode = (static_cast<size_t>(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<core::vulkan::VulkanBuffer>& 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<double, std::nano>(std::chrono::steady_clock::now() - start).count();
if (sample >= 0) {
samples[mode].push_back(elapsed / static_cast<double>(iterations * count));
}
for (const std::unique_ptr<core::vulkan::VulkanBuffer>& 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<double>& 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;
}
3 changes: 3 additions & 0 deletions vulkan/include/VulkanBuffer.h
Original file line number Diff line number Diff line change
Expand Up @@ -53,6 +53,8 @@ class VulkanBuffer {

void MapData(const std::function<void(void*)>& func);

void MapDataPersistent(const std::function<void(void*)>& func);

VkDeviceSize Size() const { return buffer_size_; }

VkBuffer buffer = VK_NULL_HANDLE;
Expand All @@ -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
Expand Down
40 changes: 34 additions & 6 deletions vulkan/src/VulkanBuffer.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -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);
}
Expand All @@ -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);
}
Expand All @@ -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_;
Expand Down Expand Up @@ -220,15 +229,34 @@ void VulkanBuffer::CopyToImage(VkCommandBuffer command_buffer, VulkanImage& dst_
}

void VulkanBuffer::MapData(const std::function<void(void*)>& 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<void(void*)>& 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
Expand Down
Loading