mirror/VulkanMemoryAllocator
1
0
Fork 0
mirror of https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator.git synced 2024-11-30 02:04:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Wrote basic test for sparse binding.

Browse Source
This commit is contained in:
Adam Sawicki 2018-10-03 13:44:29 +02:00
parent 5975c83402
commit 51fa96660e
4 changed files with 328 additions and 17 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

248
src/SparseBindingTest.cpp Normal file
View File

@ -0,0 +1,248 @@
#include "Common.h"
#include "SparseBindingTest.h"
#ifdef _WIN32
////////////////////////////////////////////////////////////////////////////////
// External imports
extern VkDevice g_hDevice;
extern VmaAllocator g_hAllocator;
extern uint32_t g_FrameIndex;
extern bool g_SparseBindingEnabled;
extern VkQueue g_hSparseBindingQueue;
extern VkFence g_ImmediateFence;
void SaveAllocatorStatsToFile(const wchar_t* filePath);
////////////////////////////////////////////////////////////////////////////////
// Class definitions
class BaseImage
{
public:
virtual VkResult Init(RandomNumberGenerator& rand) = 0;
virtual ~BaseImage();
protected:
VkImage m_Image = VK_NULL_HANDLE;
void FillImageCreateInfo(VkImageCreateInfo& outInfo, RandomNumberGenerator& rand);
};
class TraditionalImage : public BaseImage
{
public:
virtual VkResult Init(RandomNumberGenerator& rand);
virtual ~TraditionalImage();
private:
VmaAllocation m_Allocation = VK_NULL_HANDLE;
};
class SparseBindingImage : public BaseImage
{
public:
virtual VkResult Init(RandomNumberGenerator& rand);
virtual ~SparseBindingImage();
private:
std::vector<VmaAllocation> m_Allocations;
};
////////////////////////////////////////////////////////////////////////////////
// class BaseImage
BaseImage::~BaseImage()
{
if(m_Image)
{
vkDestroyImage(g_hDevice, m_Image, nullptr);
}
}
void BaseImage::FillImageCreateInfo(VkImageCreateInfo& outInfo, RandomNumberGenerator& rand)
{
constexpr uint32_t imageSizeMin = 8;
constexpr uint32_t imageSizeMax = 2048;
ZeroMemory(&outInfo, sizeof(outInfo));
outInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
outInfo.imageType = VK_IMAGE_TYPE_2D;
outInfo.extent.width = rand.Generate() % (imageSizeMax - imageSizeMin) + imageSizeMin;
outInfo.extent.height = rand.Generate() % (imageSizeMax - imageSizeMin) + imageSizeMin;
outInfo.extent.depth = 1;
outInfo.mipLevels = 1; // TODO ?
outInfo.arrayLayers = 1; // TODO ?
outInfo.format = VK_FORMAT_R8G8B8A8_UNORM;
outInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
outInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
outInfo.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
outInfo.samples = VK_SAMPLE_COUNT_1_BIT;
outInfo.flags = 0;
}
////////////////////////////////////////////////////////////////////////////////
// class TraditionalImage
VkResult TraditionalImage::Init(RandomNumberGenerator& rand)
{
VkImageCreateInfo imageCreateInfo;
FillImageCreateInfo(imageCreateInfo, rand);
VmaAllocationCreateInfo allocCreateInfo = {};
allocCreateInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY;
// Default BEST_FIT is clearly better.
//allocCreateInfo.flags |= VMA_ALLOCATION_CREATE_STRATEGY_WORST_FIT_BIT;
const VkResult res = vmaCreateImage(g_hAllocator, &imageCreateInfo, &allocCreateInfo,
&m_Image, &m_Allocation, nullptr);
return res;
}
TraditionalImage::~TraditionalImage()
{
if(m_Allocation)
{
vmaFreeMemory(g_hAllocator, m_Allocation);
}
}
////////////////////////////////////////////////////////////////////////////////
// class SparseBindingImage
VkResult SparseBindingImage::Init(RandomNumberGenerator& rand)
{
assert(g_SparseBindingEnabled && g_hSparseBindingQueue);
// Create image.
VkImageCreateInfo imageCreateInfo;
FillImageCreateInfo(imageCreateInfo, rand);
imageCreateInfo.flags |= VK_IMAGE_CREATE_SPARSE_BINDING_BIT;
VkResult res = vkCreateImage(g_hDevice, &imageCreateInfo, nullptr, &m_Image);
if(res != VK_SUCCESS)
{
return res;
}
// Get memory requirements.
VkMemoryRequirements imageMemReq;
vkGetImageMemoryRequirements(g_hDevice, m_Image, &imageMemReq);
// This is just to silence validation layer warning.
// But it doesn't help. Looks like a bug in Vulkan validation layers.
uint32_t sparseMemReqCount = 0;
vkGetImageSparseMemoryRequirements(g_hDevice, m_Image, &sparseMemReqCount, nullptr);
assert(sparseMemReqCount <= 8);
VkSparseImageMemoryRequirements sparseMemReq[8];
vkGetImageSparseMemoryRequirements(g_hDevice, m_Image, &sparseMemReqCount, sparseMemReq);
// According to Vulkan specification, for sparse resources memReq.alignment is also page size.
const VkDeviceSize pageSize = imageMemReq.alignment;
const uint32_t pageCount = (uint32_t)ceil_div<VkDeviceSize>(imageMemReq.size, pageSize);
VmaAllocationCreateInfo allocCreateInfo = {};
allocCreateInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY;
VkMemoryRequirements pageMemReq = imageMemReq;
pageMemReq.size = pageSize;
// Allocate and bind memory pages.
m_Allocations.resize(pageCount);
std::fill(m_Allocations.begin(), m_Allocations.end(), nullptr);
std::vector<VkSparseMemoryBind> binds{pageCount};
VmaAllocationInfo allocInfo;
for(uint32_t i = 0; i < pageCount; ++i)
{
res = vmaAllocateMemory(g_hAllocator, &pageMemReq, &allocCreateInfo, &m_Allocations[i], &allocInfo);
if(res != VK_SUCCESS)
{
return res;
}
binds[i] = {};
binds[i].resourceOffset = pageSize * i;
binds[i].size = pageSize;
binds[i].memory = allocInfo.deviceMemory;
binds[i].memoryOffset = allocInfo.offset;
}
VkSparseImageOpaqueMemoryBindInfo imageBindInfo;
imageBindInfo.image = m_Image;
imageBindInfo.bindCount = pageCount;
imageBindInfo.pBinds = binds.data();
VkBindSparseInfo bindSparseInfo = { VK_STRUCTURE_TYPE_BIND_SPARSE_INFO };
bindSparseInfo.pImageOpaqueBinds = &imageBindInfo;
bindSparseInfo.imageOpaqueBindCount = 1;
ERR_GUARD_VULKAN( vkResetFences(g_hDevice, 1, &g_ImmediateFence) );
ERR_GUARD_VULKAN( vkQueueBindSparse(g_hSparseBindingQueue, 1, &bindSparseInfo, g_ImmediateFence) );
ERR_GUARD_VULKAN( vkWaitForFences(g_hDevice, 1, &g_ImmediateFence, VK_TRUE, UINT64_MAX) );
return VK_SUCCESS;
}
SparseBindingImage::~SparseBindingImage()
{
for(size_t i = m_Allocations.size(); i--; )
{
vmaFreeMemory(g_hAllocator, m_Allocations[i]);
}
}
////////////////////////////////////////////////////////////////////////////////
// Private functions
////////////////////////////////////////////////////////////////////////////////
// Public functions
void TestSparseBinding()
{
struct ImageInfo
{
std::unique_ptr<BaseImage> image;
uint32_t endFrame;
};
std::vector<ImageInfo> images;
constexpr uint32_t frameCount = 2000;
constexpr uint32_t imageLifeFramesMin = 1;
constexpr uint32_t imageLifeFramesMax = 400;
RandomNumberGenerator rand(4652467);
for(uint32_t i = 0; i < frameCount; ++i)
{
// Bump frame index.
++g_FrameIndex;
vmaSetCurrentFrameIndex(g_hAllocator, g_FrameIndex);
// Create one new, random image.
ImageInfo imageInfo;
//imageInfo.image = std::make_unique<TraditionalImage>();
imageInfo.image = std::make_unique<SparseBindingImage>();
if(imageInfo.image->Init(rand) == VK_SUCCESS)
{
imageInfo.endFrame = g_FrameIndex + rand.Generate() % (imageLifeFramesMax - imageLifeFramesMin) + imageLifeFramesMin;
images.push_back(std::move(imageInfo));
}
// Delete all images that expired.
for(size_t i = images.size(); i--; )
{
if(g_FrameIndex >= images[i].endFrame)
{
images.erase(images.begin() + i);
}
}
}
SaveAllocatorStatsToFile(L"SparseBindingTest.json");
// Free remaining images.
images.clear();
}
#endif // #ifdef _WIN32

7
src/SparseBindingTest.h Normal file
View File

@ -0,0 +1,7 @@
#pragma once
#ifdef _WIN32
void TestSparseBinding();
#endif // #ifdef _WIN32

4
src/Tests.cpp
View File

@ -139,7 +139,7 @@ struct PoolTestResult
static const uint32_t IMAGE_BYTES_PER_PIXEL = 1;
static uint32_t g_FrameIndex = 0;
uint32_t g_FrameIndex = 0;
struct BufferInfo
{
@ -635,7 +635,7 @@ VkResult MainTest(Result& outResult, const Config& config)
return res;
}
static void SaveAllocatorStatsToFile(const wchar_t* filePath)
void SaveAllocatorStatsToFile(const wchar_t* filePath)
{
char* stats;
vmaBuildStatsString(g_hAllocator, &stats, VK_TRUE);

86
src/VulkanSample.cpp
View File

@ -22,6 +22,7 @@
#ifdef _WIN32
#include "SparseBindingTest.h"
#include "Tests.h"
#include "VmaUsage.h"
#include "Common.h"
@ -46,6 +47,7 @@ bool g_MemoryAliasingWarningEnabled = true;
static bool g_EnableValidationLayer = true;
static bool VK_KHR_get_memory_requirements2_enabled = false;
static bool VK_KHR_dedicated_allocation_enabled = false;
bool g_SparseBindingEnabled = false;
static HINSTANCE g_hAppInstance;
static HWND g_hWnd;
@ -62,11 +64,13 @@ static std::vector<VkFramebuffer> g_Framebuffers;
static VkCommandPool g_hCommandPool;
static VkCommandBuffer g_MainCommandBuffers[COMMAND_BUFFER_COUNT];
static VkFence g_MainCommandBufferExecutedFances[COMMAND_BUFFER_COUNT];
VkFence g_ImmediateFence;
static uint32_t g_NextCommandBufferIndex;
static VkSemaphore g_hImageAvailableSemaphore;
static VkSemaphore g_hRenderFinishedSemaphore;
static uint32_t g_GraphicsQueueFamilyIndex = UINT_MAX;
static uint32_t g_PresentQueueFamilyIndex = UINT_MAX;
static uint32_t g_SparseBindingQueueFamilyIndex = UINT_MAX;
static VkDescriptorSetLayout g_hDescriptorSetLayout;
static VkDescriptorPool g_hDescriptorPool;
static VkDescriptorSet g_hDescriptorSet; // Automatically destroyed with m_DescriptorPool.
@ -86,6 +90,7 @@ static PFN_vkDestroyDebugReportCallbackEXT g_pvkDestroyDebugReportCallbackEXT;
static VkDebugReportCallbackEXT g_hCallback;
static VkQueue g_hGraphicsQueue;
VkQueue g_hSparseBindingQueue;
static VkCommandBuffer g_hTemporaryCommandBuffer;
static VkPipelineLayout g_hPipelineLayout;
@ -1196,8 +1201,10 @@ static void InitializeApplication()
VkPhysicalDeviceProperties physicalDeviceProperties = {};
vkGetPhysicalDeviceProperties(g_hPhysicalDevice, &physicalDeviceProperties);
//VkPhysicalDeviceFeatures physicalDeviceFreatures = {};
//vkGetPhysicalDeviceFeatures(g_PhysicalDevice, &physicalDeviceFreatures);
VkPhysicalDeviceFeatures physicalDeviceFeatures = {};
vkGetPhysicalDeviceFeatures(g_hPhysicalDevice, &physicalDeviceFeatures);
g_SparseBindingEnabled = physicalDeviceFeatures.sparseBinding != 0;
// Find queue family index
@ -1208,7 +1215,9 @@ static void InitializeApplication()
vkGetPhysicalDeviceQueueFamilyProperties(g_hPhysicalDevice, &queueFamilyCount, queueFamilies.data());
for(uint32_t i = 0;
(i < queueFamilyCount) &&
(g_GraphicsQueueFamilyIndex == UINT_MAX || g_PresentQueueFamilyIndex == UINT_MAX);
(g_GraphicsQueueFamilyIndex == UINT_MAX ||
g_PresentQueueFamilyIndex == UINT_MAX ||
(g_SparseBindingEnabled && g_SparseBindingQueueFamilyIndex == UINT_MAX));
++i)
{
if(queueFamilies[i].queueCount > 0)
@ -1225,26 +1234,56 @@ static void InitializeApplication()
{
g_PresentQueueFamilyIndex = i;
}
if(g_SparseBindingEnabled &&
g_SparseBindingQueueFamilyIndex == UINT32_MAX &&
(queueFamilies[i].queueFlags & VK_QUEUE_SPARSE_BINDING_BIT) != 0)
{
g_SparseBindingQueueFamilyIndex = i;
}
}
}
assert(g_GraphicsQueueFamilyIndex != UINT_MAX);
g_SparseBindingEnabled = g_SparseBindingEnabled && g_SparseBindingQueueFamilyIndex != UINT32_MAX;
// Create logical device
const float queuePriority = 1.f;
VkDeviceQueueCreateInfo deviceQueueCreateInfo[2] = { VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO };
deviceQueueCreateInfo[0].queueFamilyIndex = g_GraphicsQueueFamilyIndex;
deviceQueueCreateInfo[0].queueCount = 1;
deviceQueueCreateInfo[0].pQueuePriorities = &queuePriority;
deviceQueueCreateInfo[1].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
deviceQueueCreateInfo[1].queueFamilyIndex = g_PresentQueueFamilyIndex;
deviceQueueCreateInfo[1].queueCount = 1;
deviceQueueCreateInfo[1].pQueuePriorities = &queuePriority;
VkDeviceQueueCreateInfo queueCreateInfo[3] = {};
uint32_t queueCount = 1;
queueCreateInfo[0].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queueCreateInfo[0].queueFamilyIndex = g_GraphicsQueueFamilyIndex;
queueCreateInfo[0].queueCount = 1;
queueCreateInfo[0].pQueuePriorities = &queuePriority;
if(g_PresentQueueFamilyIndex != g_GraphicsQueueFamilyIndex)
{
queueCreateInfo[queueCount].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queueCreateInfo[queueCount].queueFamilyIndex = g_PresentQueueFamilyIndex;
queueCreateInfo[queueCount].queueCount = 1;
queueCreateInfo[queueCount].pQueuePriorities = &queuePriority;
++queueCount;
}
if(g_SparseBindingEnabled &&
g_SparseBindingQueueFamilyIndex != g_GraphicsQueueFamilyIndex &&
g_SparseBindingQueueFamilyIndex != g_PresentQueueFamilyIndex)
{
queueCreateInfo[queueCount].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queueCreateInfo[queueCount].queueFamilyIndex = g_SparseBindingQueueFamilyIndex;
queueCreateInfo[queueCount].queueCount = 1;
queueCreateInfo[queueCount].pQueuePriorities = &queuePriority;
++queueCount;
}
VkPhysicalDeviceFeatures deviceFeatures = {};
deviceFeatures.fillModeNonSolid = VK_TRUE;
//deviceFeatures.fillModeNonSolid = VK_TRUE;
deviceFeatures.samplerAnisotropy = VK_TRUE;
deviceFeatures.sparseBinding = g_SparseBindingEnabled ? VK_TRUE : VK_FALSE;
// Determine list of device extensions to enable.
std::vector<const char*> enabledDeviceExtensions;
@ -1279,8 +1318,8 @@ static void InitializeApplication()
deviceCreateInfo.ppEnabledLayerNames = nullptr;
deviceCreateInfo.enabledExtensionCount = (uint32_t)enabledDeviceExtensions.size();
deviceCreateInfo.ppEnabledExtensionNames = !enabledDeviceExtensions.empty() ? enabledDeviceExtensions.data() : nullptr;
deviceCreateInfo.queueCreateInfoCount = g_PresentQueueFamilyIndex != g_GraphicsQueueFamilyIndex ? 2 : 1;
deviceCreateInfo.pQueueCreateInfos = deviceQueueCreateInfo;
deviceCreateInfo.queueCreateInfoCount = queueCount;
deviceCreateInfo.pQueueCreateInfos = queueCreateInfo;
deviceCreateInfo.pEnabledFeatures = &deviceFeatures;
ERR_GUARD_VULKAN( vkCreateDevice(g_hPhysicalDevice, &deviceCreateInfo, nullptr, &g_hDevice) );
@ -1308,13 +1347,19 @@ static void InitializeApplication()
ERR_GUARD_VULKAN( vmaCreateAllocator(&allocatorInfo, &g_hAllocator) );
// Retrieve queue (doesn't need to be destroyed)
// Retrieve queues (don't need to be destroyed).
vkGetDeviceQueue(g_hDevice, g_GraphicsQueueFamilyIndex, 0, &g_hGraphicsQueue);
vkGetDeviceQueue(g_hDevice, g_PresentQueueFamilyIndex, 0, &g_hPresentQueue);
assert(g_hGraphicsQueue);
assert(g_hPresentQueue);
if(g_SparseBindingEnabled)
{
vkGetDeviceQueue(g_hDevice, g_SparseBindingQueueFamilyIndex, 0, &g_hSparseBindingQueue);
assert(g_hSparseBindingQueue);
}
// Create command pool
VkCommandPoolCreateInfo commandPoolInfo = { VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO };
@ -1335,6 +1380,8 @@ static void InitializeApplication()
ERR_GUARD_VULKAN( vkCreateFence(g_hDevice, &fenceInfo, nullptr, &g_MainCommandBufferExecutedFances[i]) );
}
ERR_GUARD_VULKAN( vkCreateFence(g_hDevice, &fenceInfo, nullptr, &g_ImmediateFence) );
commandBufferInfo.commandBufferCount = 1;
ERR_GUARD_VULKAN( vkAllocateCommandBuffers(g_hDevice, &commandBufferInfo, &g_hTemporaryCommandBuffer) );
@ -1460,6 +1507,12 @@ static void FinalizeApplication()
g_hSampler = VK_NULL_HANDLE;
}
if(g_ImmediateFence)
{
vkDestroyFence(g_hDevice, g_ImmediateFence, nullptr);
g_ImmediateFence = VK_NULL_HANDLE;
}
for(size_t i = COMMAND_BUFFER_COUNT; i--; )
{
if(g_MainCommandBufferExecutedFances[i] != VK_NULL_HANDLE)
@ -1716,6 +1769,9 @@ static LRESULT WINAPI WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
case 'T':
Test();
break;
case 'S':
TestSparseBinding();
break;
}
return 0;