1 files changed, 96 insertions, 0 deletions
diff --git a/layers/gpu_validation.h b/layers/gpu_validation.h
new file mode 100644
index 000000000..ea17c3af9
--- /dev/null
+++ b/layers/gpu_validation.h
@@ -0,0 +1,96 @@
+/* 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