From 2e4d3eff983f71c221ad5302809948d1112b21bc Mon Sep 17 00:00:00 2001
From: Adam Sawicki <Adam.Sawicki@amd.com>
Date: Wed, 3 Oct 2018 15:48:17 +0200
Subject: [PATCH] Added BasicTestAllocatePages() - test for
 vmaAllocateMemoryPages, vmaFreeMemoryPages.

---
 src/Tests.cpp | 98 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 98 insertions(+)

diff --git a/src/Tests.cpp b/src/Tests.cpp
index a5378a5..e1e3650 100644
--- a/src/Tests.cpp
+++ b/src/Tests.cpp
@@ -4213,6 +4213,103 @@ static void BasicTestBuddyAllocator()
     vmaDestroyPool(g_hAllocator, pool);
 }
 
+static void BasicTestAllocatePages()
+{
+    wprintf(L"Basic test allocate pages\n");
+
+    RandomNumberGenerator rand{765461};
+
+    VkBufferCreateInfo sampleBufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
+    sampleBufCreateInfo.size = 1024; // Whatever.
+    sampleBufCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
+
+    VmaAllocationCreateInfo sampleAllocCreateInfo = {};
+    sampleAllocCreateInfo.usage = VMA_MEMORY_USAGE_CPU_ONLY;
+
+    VmaPoolCreateInfo poolCreateInfo = {};
+    VkResult res = vmaFindMemoryTypeIndexForBufferInfo(g_hAllocator, &sampleBufCreateInfo, &sampleAllocCreateInfo, &poolCreateInfo.memoryTypeIndex);
+    assert(res == VK_SUCCESS);
+
+    // 1 block of 1 MB.
+    poolCreateInfo.blockSize = 1024 * 1024;
+    poolCreateInfo.minBlockCount = poolCreateInfo.maxBlockCount = 1;
+
+    // Create pool.
+    VmaPool pool = nullptr;
+    res = vmaCreatePool(g_hAllocator, &poolCreateInfo, &pool);
+    assert(res == VK_SUCCESS);
+
+    // Make 100 allocations of 4 KB - they should fit into the pool.
+    VkMemoryRequirements memReq;
+    memReq.memoryTypeBits = UINT32_MAX;
+    memReq.alignment = 4 * 1024;
+    memReq.size = 4 * 1024;
+
+    VmaAllocationCreateInfo allocCreateInfo = {};
+    allocCreateInfo.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
+    allocCreateInfo.pool = pool;
+
+    constexpr uint32_t allocCount = 100;
+
+    std::vector<VmaAllocation> alloc{allocCount};
+    std::vector<VmaAllocationInfo> allocInfo{allocCount};
+    res = vmaAllocateMemoryPages(g_hAllocator, &memReq, &allocCreateInfo, allocCount, alloc.data(), allocInfo.data());
+    assert(res == VK_SUCCESS);
+    for(uint32_t i = 0; i < allocCount; ++i)
+    {
+        assert(alloc[i] != VK_NULL_HANDLE &&
+            allocInfo[i].pMappedData != nullptr &&
+            allocInfo[i].deviceMemory == allocInfo[0].deviceMemory &&
+            allocInfo[i].memoryType == allocInfo[0].memoryType);
+    }
+
+    // Free the allocations.
+    vmaFreeMemoryPages(g_hAllocator, allocCount, alloc.data());
+    std::fill(alloc.begin(), alloc.end(), nullptr);
+    std::fill(allocInfo.begin(), allocInfo.end(), VmaAllocationInfo{});
+
+    // Try to make 100 allocations of 100 KB. This call should fail due to not enough memory.
+    // Also test optional allocationInfo = null.
+    memReq.size = 100 * 1024;
+    res = vmaAllocateMemoryPages(g_hAllocator, &memReq, &allocCreateInfo, allocCount, alloc.data(), nullptr);
+    assert(res != VK_SUCCESS);
+    assert(std::find_if(alloc.begin(), alloc.end(), [](VmaAllocation alloc){ return alloc != VK_NULL_HANDLE; }) == alloc.end());
+
+    // Make 100 allocations of 4 KB, but with required alignment of 128 KB. This should also fail.
+    memReq.size = 4 * 1024;
+    memReq.alignment = 128 * 1024;
+    res = vmaAllocateMemoryPages(g_hAllocator, &memReq, &allocCreateInfo, allocCount, alloc.data(), allocInfo.data());
+    assert(res != VK_SUCCESS);
+
+    // Make 100 dedicated allocations of 4 KB.
+    memReq.alignment = 4 * 1024;
+    memReq.size = 4 * 1024;
+
+    VmaAllocationCreateInfo dedicatedAllocCreateInfo = {};
+    dedicatedAllocCreateInfo.usage = VMA_MEMORY_USAGE_CPU_ONLY;
+    dedicatedAllocCreateInfo.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT | VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
+    res = vmaAllocateMemoryPages(g_hAllocator, &memReq, &dedicatedAllocCreateInfo, allocCount, alloc.data(), allocInfo.data());
+    assert(res == VK_SUCCESS);
+    for(uint32_t i = 0; i < allocCount; ++i)
+    {
+        assert(alloc[i] != VK_NULL_HANDLE &&
+            allocInfo[i].pMappedData != nullptr &&
+            allocInfo[i].memoryType == allocInfo[0].memoryType &&
+            allocInfo[i].offset == 0);
+        if(i > 0)
+        {
+            assert(allocInfo[i].deviceMemory != allocInfo[0].deviceMemory);
+        }
+    }
+
+    // Free the allocations.
+    vmaFreeMemoryPages(g_hAllocator, allocCount, alloc.data());
+    std::fill(alloc.begin(), alloc.end(), nullptr);
+    std::fill(allocInfo.begin(), allocInfo.end(), VmaAllocationInfo{});
+
+    vmaDestroyPool(g_hAllocator, pool);
+}
+
 void Test()
 {
     wprintf(L"TESTING:\n");
@@ -4246,6 +4343,7 @@ void Test()
     TestLinearAllocatorMultiBlock();
 
     BasicTestBuddyAllocator();
+    BasicTestAllocatePages();
 
     {
         FILE* file;