src/dawn_native/vulkan/ResourceMemoryAllocatorVk.cpp - dawn - Git at Google

 // Copyright 2019 The Dawn Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #include "dawn_native/vulkan/ResourceMemoryAllocatorVk.h"

 #include "common/Math.h"
 #include "dawn_native/BuddyMemoryAllocator.h"
 #include "dawn_native/ResourceHeapAllocator.h"
 #include "dawn_native/vulkan/DeviceVk.h"
 #include "dawn_native/vulkan/FencedDeleter.h"
 #include "dawn_native/vulkan/ResourceHeapVk.h"
 #include "dawn_native/vulkan/VulkanError.h"

 namespace dawn_native { namespace vulkan {

     namespace {

         // TODO(crbug.com/dawn/849): This is a hardcoded heurstic to choose when to
         // suballocate but it should ideally depend on the size of the memory heaps and other
         // factors.
         constexpr uint64_t kMaxSizeForSubAllocation = 4ull * 1024ull * 1024ull;  // 4MiB

         // Have each bucket of the buddy system allocate at least some resource of the maximum
         // size
         constexpr uint64_t kBuddyHeapsSize = 2 * kMaxSizeForSubAllocation;

     }  // anonymous namespace

     // SingleTypeAllocator is a combination of a BuddyMemoryAllocator and its client and can
     // service suballocation requests, but for a single Vulkan memory type.

     class ResourceMemoryAllocator::SingleTypeAllocator : public ResourceHeapAllocator {
       public:
         SingleTypeAllocator(Device* device, size_t memoryTypeIndex, VkDeviceSize memoryHeapSize)
             : mDevice(device),
               mMemoryTypeIndex(memoryTypeIndex),
               mMemoryHeapSize(memoryHeapSize),
               mPooledMemoryAllocator(this),
               mBuddySystem(
                   // Round down to a power of 2 that's <= mMemoryHeapSize. This will always
                   // be a multiple of kBuddyHeapsSize because kBuddyHeapsSize is a power of 2.
                   uint64_t(1) << Log2(mMemoryHeapSize),
                   // Take the min in the very unlikely case the memory heap is tiny.
                   std::min(uint64_t(1) << Log2(mMemoryHeapSize), kBuddyHeapsSize),
                   &mPooledMemoryAllocator) {
             ASSERT(IsPowerOfTwo(kBuddyHeapsSize));
         }
         ~SingleTypeAllocator() override = default;

         void DestroyPool() {
             mPooledMemoryAllocator.DestroyPool();
         }

         ResultOrError<ResourceMemoryAllocation> AllocateMemory(uint64_t size, uint64_t alignment) {
             return mBuddySystem.Allocate(size, alignment);
         }

         void DeallocateMemory(const ResourceMemoryAllocation& allocation) {
             mBuddySystem.Deallocate(allocation);
         }

         // Implementation of the MemoryAllocator interface to be a client of BuddyMemoryAllocator

         ResultOrError<std::unique_ptr<ResourceHeapBase>> AllocateResourceHeap(
             uint64_t size) override {
             if (size > mMemoryHeapSize) {
                 return DAWN_OUT_OF_MEMORY_ERROR("Allocation size too large");
             }

             VkMemoryAllocateInfo allocateInfo;
             allocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
             allocateInfo.pNext = nullptr;
             allocateInfo.allocationSize = size;
             allocateInfo.memoryTypeIndex = mMemoryTypeIndex;

             VkDeviceMemory allocatedMemory = VK_NULL_HANDLE;

             // First check OOM that we want to surface to the application.
             DAWN_TRY(CheckVkOOMThenSuccess(
                 mDevice->fn.AllocateMemory(mDevice->GetVkDevice(), &allocateInfo, nullptr,
                                            &*allocatedMemory),
                 "vkAllocateMemory"));

             ASSERT(allocatedMemory != VK_NULL_HANDLE);
             return {std::make_unique<ResourceHeap>(allocatedMemory, mMemoryTypeIndex)};
         }

         void DeallocateResourceHeap(std::unique_ptr<ResourceHeapBase> allocation) override {
             mDevice->GetFencedDeleter()->DeleteWhenUnused(ToBackend(allocation.get())->GetMemory());
         }

       private:
         Device* mDevice;
         size_t mMemoryTypeIndex;
         VkDeviceSize mMemoryHeapSize;
         PooledResourceMemoryAllocator mPooledMemoryAllocator;
         BuddyMemoryAllocator mBuddySystem;
     };

     // Implementation of ResourceMemoryAllocator

     ResourceMemoryAllocator::ResourceMemoryAllocator(Device* device) : mDevice(device) {
         const VulkanDeviceInfo& info = mDevice->GetDeviceInfo();
         mAllocatorsPerType.reserve(info.memoryTypes.size());

         for (size_t i = 0; i < info.memoryTypes.size(); i++) {
             mAllocatorsPerType.emplace_back(std::make_unique<SingleTypeAllocator>(
                 mDevice, i, info.memoryHeaps[info.memoryTypes[i].heapIndex].size));
         }
     }

     ResourceMemoryAllocator::~ResourceMemoryAllocator() = default;

     ResultOrError<ResourceMemoryAllocation> ResourceMemoryAllocator::Allocate(
         const VkMemoryRequirements& requirements,
         MemoryKind kind) {
         // The Vulkan spec guarantees at least on memory type is valid.
         int memoryType = FindBestTypeIndex(requirements, kind);
         ASSERT(memoryType >= 0);

         VkDeviceSize size = requirements.size;

         // Sub-allocate non-mappable resources because at the moment the mapped pointer
         // is part of the resource and not the heap, which doesn't match the Vulkan model.
         // TODO(crbug.com/dawn/849): allow sub-allocating mappable resources, maybe.
         if (requirements.size < kMaxSizeForSubAllocation && kind != MemoryKind::LinearMappable) {
             // When sub-allocating, Vulkan requires that we respect bufferImageGranularity. Some
             // hardware puts information on the memory's page table entry and allocating a linear
             // resource in the same page as a non-linear (aka opaque) resource can cause issues.
             // Probably because some texture compression flags are stored on the page table entry,
             // and allocating a linear resource removes these flags.
             //
             // Anyway, just to be safe we ask that all sub-allocated resources are allocated with at
             // least this alignment. TODO(crbug.com/dawn/849): this is suboptimal because multiple
             // linear (resp. opaque) resources can coexist in the same page. In particular Nvidia
             // GPUs often use a granularity of 64k which will lead to a lot of wasted spec. Revisit
             // with a more efficient algorithm later.
             uint64_t alignment =
                 std::max(requirements.alignment,
                          mDevice->GetDeviceInfo().properties.limits.bufferImageGranularity);

             ResourceMemoryAllocation subAllocation;
             DAWN_TRY_ASSIGN(subAllocation, mAllocatorsPerType[memoryType]->AllocateMemory(
                                                requirements.size, alignment));
             if (subAllocation.GetInfo().mMethod != AllocationMethod::kInvalid) {
                 return std::move(subAllocation);
             }
         }

         // If sub-allocation failed, allocate memory just for it.
         std::unique_ptr<ResourceHeapBase> resourceHeap;
         DAWN_TRY_ASSIGN(resourceHeap, mAllocatorsPerType[memoryType]->AllocateResourceHeap(size));

         void* mappedPointer = nullptr;
         if (kind == MemoryKind::LinearMappable) {
             DAWN_TRY_WITH_CLEANUP(
                 CheckVkSuccess(mDevice->fn.MapMemory(mDevice->GetVkDevice(),
                                                      ToBackend(resourceHeap.get())->GetMemory(), 0,
                                                      size, 0, &mappedPointer),
                                "vkMapMemory"),
                 {
                     mAllocatorsPerType[memoryType]->DeallocateResourceHeap(std::move(resourceHeap));
                 });
         }

         AllocationInfo info;
         info.mMethod = AllocationMethod::kDirect;
         return ResourceMemoryAllocation(info, /*offset*/ 0, resourceHeap.release(),
                                         static_cast<uint8_t*>(mappedPointer));
     }

     void ResourceMemoryAllocator::Deallocate(ResourceMemoryAllocation* allocation) {
         switch (allocation->GetInfo().mMethod) {
             // Some memory allocation can never be initialized, for example when wrapping
             // swapchain VkImages with a Texture.
             case AllocationMethod::kInvalid:
                 break;

             // For direct allocation we can put the memory for deletion immediately and the fence
             // deleter will make sure the resources are freed before the memory.
             case AllocationMethod::kDirect: {
                 ResourceHeap* heap = ToBackend(allocation->GetResourceHeap());
                 allocation->Invalidate();
                 mDevice->GetFencedDeleter()->DeleteWhenUnused(heap->GetMemory());
                 delete heap;
                 break;
             }

             // Suballocations aren't freed immediately, otherwise another resource allocation could
             // happen just after that aliases the old one and would require a barrier.
             // TODO(crbug.com/dawn/851): Maybe we can produce the correct barriers to reduce the
             // latency to reclaim memory.
             case AllocationMethod::kSubAllocated:
                 mSubAllocationsToDelete.Enqueue(*allocation, mDevice->GetPendingCommandSerial());
                 break;

             default:
                 UNREACHABLE();
                 break;
         }

         // Invalidate the underlying resource heap in case the client accidentally
         // calls DeallocateMemory again using the same allocation.
         allocation->Invalidate();
     }

     void ResourceMemoryAllocator::Tick(ExecutionSerial completedSerial) {
         for (const ResourceMemoryAllocation& allocation :
              mSubAllocationsToDelete.IterateUpTo(completedSerial)) {
             ASSERT(allocation.GetInfo().mMethod == AllocationMethod::kSubAllocated);
             size_t memoryType = ToBackend(allocation.GetResourceHeap())->GetMemoryType();

             mAllocatorsPerType[memoryType]->DeallocateMemory(allocation);
         }

         mSubAllocationsToDelete.ClearUpTo(completedSerial);
     }

     int ResourceMemoryAllocator::FindBestTypeIndex(VkMemoryRequirements requirements,
                                                    MemoryKind kind) {
         const VulkanDeviceInfo& info = mDevice->GetDeviceInfo();
         bool mappable = kind == MemoryKind::LinearMappable;

         // Find a suitable memory type for this allocation
         int bestType = -1;
         for (size_t i = 0; i < info.memoryTypes.size(); ++i) {
             // Resource must support this memory type
             if ((requirements.memoryTypeBits & (1 << i)) == 0) {
                 continue;
             }

             // Mappable resource must be host visible
             if (mappable &&
                 (info.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0) {
                 continue;
             }

             // Mappable must also be host coherent.
             if (mappable &&
                 (info.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) == 0) {
                 continue;
             }

             // Found the first candidate memory type
             if (bestType == -1) {
                 bestType = static_cast<int>(i);
                 continue;
             }

             // For non-mappable resources, favor device local memory.
             bool currentDeviceLocal =
                 info.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
             bool bestDeviceLocal =
                 info.memoryTypes[bestType].propertyFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
             if (!mappable && (currentDeviceLocal != bestDeviceLocal)) {
                 if (currentDeviceLocal) {
                     bestType = static_cast<int>(i);
                 }
                 continue;
             }

             // All things equal favor the memory in the biggest heap
             VkDeviceSize bestTypeHeapSize =
                 info.memoryHeaps[info.memoryTypes[bestType].heapIndex].size;
             VkDeviceSize candidateHeapSize = info.memoryHeaps[info.memoryTypes[i].heapIndex].size;
             if (candidateHeapSize > bestTypeHeapSize) {
                 bestType = static_cast<int>(i);
                 continue;
             }
         }

         return bestType;
     }

     void ResourceMemoryAllocator::DestroyPool() {
         for (auto& alloc : mAllocatorsPerType) {
             alloc->DestroyPool();
         }
     }

 }}  // namespace dawn_native::vulkan
	// Copyright 2019 The Dawn Authors
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include "dawn_native/vulkan/ResourceMemoryAllocatorVk.h"

	#include "common/Math.h"
	#include "dawn_native/BuddyMemoryAllocator.h"
	#include "dawn_native/ResourceHeapAllocator.h"
	#include "dawn_native/vulkan/DeviceVk.h"
	#include "dawn_native/vulkan/FencedDeleter.h"
	#include "dawn_native/vulkan/ResourceHeapVk.h"
	#include "dawn_native/vulkan/VulkanError.h"

	namespace dawn_native { namespace vulkan {

	namespace {

	// TODO(crbug.com/dawn/849): This is a hardcoded heurstic to choose when to
	// suballocate but it should ideally depend on the size of the memory heaps and other
	// factors.
	constexpr uint64_t kMaxSizeForSubAllocation = 4ull * 1024ull * 1024ull; // 4MiB

	// Have each bucket of the buddy system allocate at least some resource of the maximum
	// size
	constexpr uint64_t kBuddyHeapsSize = 2 * kMaxSizeForSubAllocation;

	} // anonymous namespace

	// SingleTypeAllocator is a combination of a BuddyMemoryAllocator and its client and can
	// service suballocation requests, but for a single Vulkan memory type.

	class ResourceMemoryAllocator::SingleTypeAllocator : public ResourceHeapAllocator {
	public:
	SingleTypeAllocator(Device* device, size_t memoryTypeIndex, VkDeviceSize memoryHeapSize)
	: mDevice(device),
	mMemoryTypeIndex(memoryTypeIndex),
	mMemoryHeapSize(memoryHeapSize),
	mPooledMemoryAllocator(this),
	mBuddySystem(
	// Round down to a power of 2 that's <= mMemoryHeapSize. This will always
	// be a multiple of kBuddyHeapsSize because kBuddyHeapsSize is a power of 2.
	uint64_t(1) << Log2(mMemoryHeapSize),
	// Take the min in the very unlikely case the memory heap is tiny.
	std::min(uint64_t(1) << Log2(mMemoryHeapSize), kBuddyHeapsSize),
	&mPooledMemoryAllocator) {
	ASSERT(IsPowerOfTwo(kBuddyHeapsSize));
	}
	~SingleTypeAllocator() override = default;

	void DestroyPool() {
	mPooledMemoryAllocator.DestroyPool();
	}

	ResultOrError<ResourceMemoryAllocation> AllocateMemory(uint64_t size, uint64_t alignment) {
	return mBuddySystem.Allocate(size, alignment);
	}

	void DeallocateMemory(const ResourceMemoryAllocation& allocation) {
	mBuddySystem.Deallocate(allocation);
	}

	// Implementation of the MemoryAllocator interface to be a client of BuddyMemoryAllocator

	ResultOrError<std::unique_ptr<ResourceHeapBase>> AllocateResourceHeap(
	uint64_t size) override {
	if (size > mMemoryHeapSize) {
	return DAWN_OUT_OF_MEMORY_ERROR("Allocation size too large");
	}

	VkMemoryAllocateInfo allocateInfo;
	allocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
	allocateInfo.pNext = nullptr;
	allocateInfo.allocationSize = size;
	allocateInfo.memoryTypeIndex = mMemoryTypeIndex;

	VkDeviceMemory allocatedMemory = VK_NULL_HANDLE;

	// First check OOM that we want to surface to the application.
	DAWN_TRY(CheckVkOOMThenSuccess(
	mDevice->fn.AllocateMemory(mDevice->GetVkDevice(), &allocateInfo, nullptr,
	&*allocatedMemory),
	"vkAllocateMemory"));

	ASSERT(allocatedMemory != VK_NULL_HANDLE);
	return {std::make_unique<ResourceHeap>(allocatedMemory, mMemoryTypeIndex)};
	}

	void DeallocateResourceHeap(std::unique_ptr<ResourceHeapBase> allocation) override {
	mDevice->GetFencedDeleter()->DeleteWhenUnused(ToBackend(allocation.get())->GetMemory());
	}

	private:
	Device* mDevice;
	size_t mMemoryTypeIndex;
	VkDeviceSize mMemoryHeapSize;
	PooledResourceMemoryAllocator mPooledMemoryAllocator;
	BuddyMemoryAllocator mBuddySystem;
	};

	// Implementation of ResourceMemoryAllocator

	ResourceMemoryAllocator::ResourceMemoryAllocator(Device* device) : mDevice(device) {
	const VulkanDeviceInfo& info = mDevice->GetDeviceInfo();
	mAllocatorsPerType.reserve(info.memoryTypes.size());

	for (size_t i = 0; i < info.memoryTypes.size(); i++) {
	mAllocatorsPerType.emplace_back(std::make_unique<SingleTypeAllocator>(
	mDevice, i, info.memoryHeaps[info.memoryTypes[i].heapIndex].size));
	}
	}

	ResourceMemoryAllocator::~ResourceMemoryAllocator() = default;

	ResultOrError<ResourceMemoryAllocation> ResourceMemoryAllocator::Allocate(
	const VkMemoryRequirements& requirements,
	MemoryKind kind) {
	// The Vulkan spec guarantees at least on memory type is valid.
	int memoryType = FindBestTypeIndex(requirements, kind);
	ASSERT(memoryType >= 0);

	VkDeviceSize size = requirements.size;

	// Sub-allocate non-mappable resources because at the moment the mapped pointer
	// is part of the resource and not the heap, which doesn't match the Vulkan model.
	// TODO(crbug.com/dawn/849): allow sub-allocating mappable resources, maybe.
	if (requirements.size < kMaxSizeForSubAllocation && kind != MemoryKind::LinearMappable) {
	// When sub-allocating, Vulkan requires that we respect bufferImageGranularity. Some
	// hardware puts information on the memory's page table entry and allocating a linear
	// resource in the same page as a non-linear (aka opaque) resource can cause issues.
	// Probably because some texture compression flags are stored on the page table entry,
	// and allocating a linear resource removes these flags.
	//
	// Anyway, just to be safe we ask that all sub-allocated resources are allocated with at
	// least this alignment. TODO(crbug.com/dawn/849): this is suboptimal because multiple
	// linear (resp. opaque) resources can coexist in the same page. In particular Nvidia
	// GPUs often use a granularity of 64k which will lead to a lot of wasted spec. Revisit
	// with a more efficient algorithm later.
	uint64_t alignment =
	std::max(requirements.alignment,
	mDevice->GetDeviceInfo().properties.limits.bufferImageGranularity);

	ResourceMemoryAllocation subAllocation;
	DAWN_TRY_ASSIGN(subAllocation, mAllocatorsPerType[memoryType]->AllocateMemory(
	requirements.size, alignment));
	if (subAllocation.GetInfo().mMethod != AllocationMethod::kInvalid) {
	return std::move(subAllocation);
	}
	}

	// If sub-allocation failed, allocate memory just for it.
	std::unique_ptr<ResourceHeapBase> resourceHeap;
	DAWN_TRY_ASSIGN(resourceHeap, mAllocatorsPerType[memoryType]->AllocateResourceHeap(size));

	void* mappedPointer = nullptr;
	if (kind == MemoryKind::LinearMappable) {
	DAWN_TRY_WITH_CLEANUP(
	CheckVkSuccess(mDevice->fn.MapMemory(mDevice->GetVkDevice(),
	ToBackend(resourceHeap.get())->GetMemory(), 0,
	size, 0, &mappedPointer),
	"vkMapMemory"),
	{
	mAllocatorsPerType[memoryType]->DeallocateResourceHeap(std::move(resourceHeap));
	});
	}

	AllocationInfo info;
	info.mMethod = AllocationMethod::kDirect;
	return ResourceMemoryAllocation(info, /offset/ 0, resourceHeap.release(),
	static_cast<uint8_t*>(mappedPointer));
	}

	void ResourceMemoryAllocator::Deallocate(ResourceMemoryAllocation* allocation) {
	switch (allocation->GetInfo().mMethod) {
	// Some memory allocation can never be initialized, for example when wrapping
	// swapchain VkImages with a Texture.
	case AllocationMethod::kInvalid:
	break;

	// For direct allocation we can put the memory for deletion immediately and the fence
	// deleter will make sure the resources are freed before the memory.
	case AllocationMethod::kDirect: {
	ResourceHeap* heap = ToBackend(allocation->GetResourceHeap());
	allocation->Invalidate();
	mDevice->GetFencedDeleter()->DeleteWhenUnused(heap->GetMemory());
	delete heap;
	break;
	}

	// Suballocations aren't freed immediately, otherwise another resource allocation could
	// happen just after that aliases the old one and would require a barrier.
	// TODO(crbug.com/dawn/851): Maybe we can produce the correct barriers to reduce the
	// latency to reclaim memory.
	case AllocationMethod::kSubAllocated:
	mSubAllocationsToDelete.Enqueue(*allocation, mDevice->GetPendingCommandSerial());
	break;

	default:
	UNREACHABLE();
	break;
	}

	// Invalidate the underlying resource heap in case the client accidentally
	// calls DeallocateMemory again using the same allocation.
	allocation->Invalidate();
	}

	void ResourceMemoryAllocator::Tick(ExecutionSerial completedSerial) {
	for (const ResourceMemoryAllocation& allocation :
	mSubAllocationsToDelete.IterateUpTo(completedSerial)) {
	ASSERT(allocation.GetInfo().mMethod == AllocationMethod::kSubAllocated);
	size_t memoryType = ToBackend(allocation.GetResourceHeap())->GetMemoryType();

	mAllocatorsPerType[memoryType]->DeallocateMemory(allocation);
	}

	mSubAllocationsToDelete.ClearUpTo(completedSerial);
	}

	int ResourceMemoryAllocator::FindBestTypeIndex(VkMemoryRequirements requirements,
	MemoryKind kind) {
	const VulkanDeviceInfo& info = mDevice->GetDeviceInfo();
	bool mappable = kind == MemoryKind::LinearMappable;

	// Find a suitable memory type for this allocation
	int bestType = -1;
	for (size_t i = 0; i < info.memoryTypes.size(); ++i) {
	// Resource must support this memory type
	if ((requirements.memoryTypeBits & (1 << i)) == 0) {
	continue;
	}

	// Mappable resource must be host visible
	if (mappable &&
	(info.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0) {
	continue;
	}

	// Mappable must also be host coherent.
	if (mappable &&
	(info.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) == 0) {
	continue;
	}

	// Found the first candidate memory type
	if (bestType == -1) {
	bestType = static_cast<int>(i);
	continue;
	}

	// For non-mappable resources, favor device local memory.
	bool currentDeviceLocal =
	info.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
	bool bestDeviceLocal =
	info.memoryTypes[bestType].propertyFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
	if (!mappable && (currentDeviceLocal != bestDeviceLocal)) {
	if (currentDeviceLocal) {
	bestType = static_cast<int>(i);
	}
	continue;
	}

	// All things equal favor the memory in the biggest heap
	VkDeviceSize bestTypeHeapSize =
	info.memoryHeaps[info.memoryTypes[bestType].heapIndex].size;
	VkDeviceSize candidateHeapSize = info.memoryHeaps[info.memoryTypes[i].heapIndex].size;
	if (candidateHeapSize > bestTypeHeapSize) {
	bestType = static_cast<int>(i);
	continue;
	}
	}

	return bestType;
	}

	void ResourceMemoryAllocator::DestroyPool() {
	for (auto& alloc : mAllocatorsPerType) {
	alloc->DestroyPool();
	}
	}

	}} // namespace dawn_native::vulkan