/* Copyright (c) 2018-2019 The Khronos Group Inc.
|
* Copyright (c) 2018-2019 Valve Corporation
|
* Copyright (c) 2018-2019 LunarG, Inc.
|
* Copyright (C) 2018-2019 Google Inc.
|
*
|
* 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.
|
*
|
*/
|
|
#ifndef VULKAN_GPU_VALIDATION_H
|
#define VULKAN_GPU_VALIDATION_H
|
|
// Class to encapsulate Vulkan Device Memory allocations.
|
// It allocates device memory in large chunks for efficiency and to avoid
|
// hitting the device limit of the number of allocations.
|
// This manager handles only fixed-sized blocks of "data_size" bytes.
|
// The interface allows the caller to "get" and "put back" blocks.
|
// The manager allocates and frees chunks as needed.
|
|
class CoreChecks;
|
typedef CoreChecks layer_data;
|
|
class GpuDeviceMemoryManager {
|
public:
|
GpuDeviceMemoryManager(layer_data *dev_data, uint32_t data_size);
|
~GpuDeviceMemoryManager();
|
|
uint32_t GetBlockSize() { return block_size_; }
|
|
VkResult GetBlock(GpuDeviceMemoryBlock *block);
|
void PutBackBlock(VkBuffer buffer, VkDeviceMemory memory, uint32_t offset);
|
void PutBackBlock(GpuDeviceMemoryBlock &block);
|
void FreeAllBlocks();
|
|
private:
|
// Define allocation granularity of Vulkan resources.
|
// Things like device memory and descriptors are allocated in "chunks".
|
// This number should be chosen to try to avoid too many chunk allocations
|
// and chunk allocations that are too large.
|
static const uint32_t kItemsPerChunk = 512;
|
|
struct MemoryChunk {
|
VkBuffer buffer;
|
VkDeviceMemory memory;
|
std::vector<uint32_t> available_offsets;
|
};
|
|
layer_data *dev_data_;
|
uint32_t record_size_;
|
uint32_t block_size_;
|
uint32_t blocks_per_chunk_;
|
uint32_t chunk_size_;
|
std::list<MemoryChunk> chunk_list_;
|
|
bool MemoryTypeFromProperties(uint32_t typeBits, VkFlags requirements_mask, uint32_t *typeIndex);
|
VkResult AllocMemoryChunk(MemoryChunk &chunk);
|
void FreeMemoryChunk(MemoryChunk &chunk);
|
};
|
|
// Class to encapsulate Descriptor Set allocation. This manager creates and destroys Descriptor Pools
|
// as needed to satisfy requests for descriptor sets.
|
class GpuDescriptorSetManager {
|
public:
|
GpuDescriptorSetManager(layer_data *dev_data);
|
~GpuDescriptorSetManager();
|
|
VkResult GetDescriptorSets(uint32_t count, VkDescriptorPool *pool, std::vector<VkDescriptorSet> *desc_sets);
|
void PutBackDescriptorSet(VkDescriptorPool desc_pool, VkDescriptorSet desc_set);
|
void DestroyDescriptorPools();
|
|
private:
|
static const uint32_t kItemsPerChunk = 512;
|
struct PoolTracker {
|
uint32_t size;
|
uint32_t used;
|
};
|
|
layer_data *dev_data_;
|
std::unordered_map<VkDescriptorPool, struct PoolTracker> desc_pool_map_;
|
};
|
|
using mutex_t = std::mutex;
|
using lock_guard_t = std::lock_guard<mutex_t>;
|
using unique_lock_t = std::unique_lock<mutex_t>;
|
|
#endif // VULKAN_GPU_VALIDATION_H
|
