bug-14258: Make descriptor pools and command pools more consistent

20 files changed, 252 insertions, 248 deletions

diff --git a/demos/cube.c b/demos/cube.c
index 1abf525f..91fcd8eb 100644
--- a/demos/cube.c
+++ b/demos/cube.c
@@ -451,7 +451,7 @@ static void demo_flush_init_cmd(struct demo *demo)
     err = vkQueueWaitIdle(demo->queue);
     assert(!err);
 
-    vkDestroyCommandBuffer(demo->device, demo->cmd);
+    vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, cmd_bufs);
     demo->cmd = VK_NULL_HANDLE;
 }
 
@@ -465,15 +465,15 @@ static void demo_set_image_layout(
     VkResult U_ASSERT_ONLY err;
 
     if (demo->cmd == VK_NULL_HANDLE) {
-        const VkCmdBufferCreateInfo cmd = {
-            .sType = VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO,
+        const VkCmdBufferAllocInfo cmd = {
+            .sType = VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO,
             .pNext = NULL,
             .cmdPool = demo->cmd_pool,
             .level = VK_CMD_BUFFER_LEVEL_PRIMARY,
-            .flags = 0,
+            .count = 1,
         };
 
-        err = vkCreateCommandBuffer(demo->device, &cmd, &demo->cmd);
+        err = vkAllocCommandBuffers(demo->device, &cmd, &demo->cmd);
         assert(!err);
 
         VkCmdBufferBeginInfo cmd_buf_info = {
@@ -1630,7 +1630,6 @@ static void demo_prepare_descriptor_pool(struct demo *demo)
     const VkDescriptorPoolCreateInfo descriptor_pool = {
         .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
         .pNext = NULL,
-        .poolUsage = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT,
         .maxSets = 1,
         .count = 2,
         .pTypeCount = type_counts,
@@ -1649,10 +1648,14 @@ static void demo_prepare_descriptor_set(struct demo *demo)
     VkResult U_ASSERT_ONLY err;
     uint32_t i;
 
-    err = vkAllocDescriptorSets(demo->device, demo->desc_pool,
-            VK_DESCRIPTOR_SET_USAGE_STATIC,
-            1, &demo->desc_layout,
-            &demo->desc_set);
+    VkDescriptorSetAllocInfo alloc_info = {
+        .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO,
+        .pNext = NULL,
+        .descriptorPool = demo->desc_pool,
+        .count = 1,
+        .pSetLayouts = &demo->desc_layout
+    };
+    err = vkAllocDescriptorSets(demo->device, &alloc_info, &demo->desc_set);
     assert(!err);
 
     memset(&tex_descs, 0, sizeof(tex_descs));
@@ -1721,12 +1724,12 @@ static void demo_prepare(struct demo *demo)
     err = vkCreateCommandPool(demo->device, &cmd_pool_info, &demo->cmd_pool);
     assert(!err);
 
-    const VkCmdBufferCreateInfo cmd = {
-        .sType = VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO,
+    const VkCmdBufferAllocInfo cmd = {
+        .sType = VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO,
         .pNext = NULL,
         .cmdPool = demo->cmd_pool,
         .level = VK_CMD_BUFFER_LEVEL_PRIMARY,
-        .flags = 0,
+        .count = 1,
     };
 
     demo_prepare_buffers(demo);
@@ -1739,7 +1742,7 @@ static void demo_prepare(struct demo *demo)
     demo_prepare_pipeline(demo);
 
     for (uint32_t i = 0; i < demo->swapchainImageCount; i++) {
-        err = vkCreateCommandBuffer(demo->device, &cmd, &demo->buffers[i].cmd);
+        err = vkAllocCommandBuffers(demo->device, &cmd, &demo->buffers[i].cmd);
         assert(!err);
     }
 
@@ -1798,7 +1801,7 @@ static void demo_cleanup(struct demo *demo)
 
     for (i = 0; i < demo->swapchainImageCount; i++) {
         vkDestroyImageView(demo->device, demo->buffers[i].view);
-        vkDestroyCommandBuffer(demo->device, demo->buffers[i].cmd);
+        vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, &demo->buffers[i].cmd);
     }
     free(demo->buffers);
 
diff --git a/demos/tri.c b/demos/tri.c
index 66dccf6a..cf5f9684 100644
--- a/demos/tri.c
+++ b/demos/tri.c
@@ -291,7 +291,7 @@ static void demo_flush_init_cmd(struct demo *demo)
     err = vkQueueWaitIdle(demo->queue);
     assert(!err);
 
-    vkDestroyCommandBuffer(demo->device, demo->setup_cmd);
+    vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, cmd_bufs);
     demo->setup_cmd = VK_NULL_HANDLE;
 }
 
@@ -305,15 +305,15 @@ static void demo_set_image_layout(
     VkResult U_ASSERT_ONLY err;
 
     if (demo->setup_cmd == VK_NULL_HANDLE) {
-        const VkCmdBufferCreateInfo cmd = {
-            .sType = VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO,
+        const VkCmdBufferAllocInfo cmd = {
+            .sType = VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO,
             .pNext = NULL,
             .cmdPool = demo->cmd_pool,
             .level = VK_CMD_BUFFER_LEVEL_PRIMARY,
-            .flags = 0,
+            .count = 1,
         };
 
-        err = vkCreateCommandBuffer(demo->device, &cmd, &demo->setup_cmd);
+        err = vkAllocCommandBuffers(demo->device, &cmd, &demo->setup_cmd);
         assert(!err);
 
         VkCmdBufferBeginInfo cmd_buf_info = {
@@ -1386,7 +1386,6 @@ static void demo_prepare_descriptor_pool(struct demo *demo)
     const VkDescriptorPoolCreateInfo descriptor_pool = {
         .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
         .pNext = NULL,
-        .poolUsage = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT,
         .maxSets = 1,
         .count = 1,
         .pTypeCount = &type_count,
@@ -1405,10 +1404,14 @@ static void demo_prepare_descriptor_set(struct demo *demo)
     VkResult U_ASSERT_ONLY err;
     uint32_t i;
 
-    err = vkAllocDescriptorSets(demo->device, demo->desc_pool,
-            VK_DESCRIPTOR_SET_USAGE_STATIC,
-            1, &demo->desc_layout,
-            &demo->desc_set);
+    VkDescriptorSetAllocInfo alloc_info = {
+        .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO,
+        .pNext = NULL,
+        .descriptorPool = demo->desc_pool,
+        .count = 1,
+        .pSetLayouts = &demo->desc_layout
+    };
+    err = vkAllocDescriptorSets(demo->device, &alloc_info, &demo->desc_set);
     assert(!err);
 
     memset(&tex_descs, 0, sizeof(tex_descs));
@@ -1469,14 +1472,14 @@ static void demo_prepare(struct demo *demo)
     err = vkCreateCommandPool(demo->device, &cmd_pool_info, &demo->cmd_pool);
     assert(!err);
 
-    const VkCmdBufferCreateInfo cmd = {
-        .sType = VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO,
+    const VkCmdBufferAllocInfo cmd = {
+        .sType = VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO,
         .pNext = NULL,
         .cmdPool = demo->cmd_pool,
         .level = VK_CMD_BUFFER_LEVEL_PRIMARY,
-        .flags = 0,
+        .count = 1,
     };
-    err = vkCreateCommandBuffer(demo->device, &cmd, &demo->draw_cmd);
+    err = vkAllocCommandBuffers(demo->device, &cmd, &demo->draw_cmd);
     assert(!err);
 
     demo_prepare_buffers(demo);
@@ -2162,9 +2165,9 @@ static void demo_cleanup(struct demo *demo)
     vkDestroyDescriptorPool(demo->device, demo->desc_pool);
 
     if (demo->setup_cmd) {
-        vkDestroyCommandBuffer(demo->device, demo->setup_cmd);
+        vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, &demo->setup_cmd);
     }
-    vkDestroyCommandBuffer(demo->device, demo->draw_cmd);
+    vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, &demo->draw_cmd);
     vkDestroyCommandPool(demo->device, demo->cmd_pool);
 
     vkDestroyPipeline(demo->device, demo->pipeline);
diff --git a/icd/nulldrv/nulldrv.c b/icd/nulldrv/nulldrv.c
index e0991b1e..56b677b9 100644
--- a/icd/nulldrv/nulldrv.c
+++ b/icd/nulldrv/nulldrv.c
@@ -481,17 +481,24 @@ static VkResult graphics_pipeline_create(struct nulldrv_dev *dev,
 }
 
 static VkResult nulldrv_cmd_create(struct nulldrv_dev *dev,
-                            const VkCmdBufferCreateInfo *info,
+                            const VkCmdBufferAllocInfo *info,
                             struct nulldrv_cmd **cmd_ret)
 {
     struct nulldrv_cmd *cmd;
-
-    cmd = (struct nulldrv_cmd *) nulldrv_base_create(dev, sizeof(*cmd),
-            VK_OBJECT_TYPE_COMMAND_BUFFER);
-    if (!cmd)
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-
-    *cmd_ret = cmd;
+    uint32_t num_allocated = 0;
+
+    for (uint32_t i = 0; i < info->count; i++) {
+        cmd = (struct nulldrv_cmd *) nulldrv_base_create(dev, sizeof(*cmd),
+                VK_OBJECT_TYPE_COMMAND_BUFFER);
+        if (!cmd) {
+            for (uint32_t j = 0; j < num_allocated; j++) {
+                free(cmd_ret[j]);
+            }
+            return VK_ERROR_OUT_OF_HOST_MEMORY;
+        }
+        num_allocated++;
+        cmd_ret[i] = cmd;
+    }
 
     return VK_SUCCESS;
 }
@@ -517,7 +524,6 @@ static VkResult nulldrv_desc_pool_create(struct nulldrv_dev *dev,
 
 static VkResult nulldrv_desc_set_create(struct nulldrv_dev *dev,
                                  struct nulldrv_desc_pool *pool,
-                                 VkDescriptorSetUsage usage,
                                  const struct nulldrv_desc_layout *layout,
                                  struct nulldrv_desc_set **set_ret)
 {
@@ -645,23 +651,28 @@ ICD_EXPORT VkResult VKAPI vkResetCommandPool(
     return VK_SUCCESS;
 }
 
-ICD_EXPORT VkResult VKAPI vkCreateCommandBuffer(
+ICD_EXPORT VkResult VKAPI vkAllocCommandBuffers(
     VkDevice                                  device,
-    const VkCmdBufferCreateInfo*           pCreateInfo,
-    VkCmdBuffer*                             pCmdBuffer)
+    const VkCmdBufferAllocInfo*               pAllocInfo,
+    VkCmdBuffer*                              pCmdBuffers)
 {
     NULLDRV_LOG_FUNC;
     struct nulldrv_dev *dev = nulldrv_dev(device);
 
-    return nulldrv_cmd_create(dev, pCreateInfo,
-            (struct nulldrv_cmd **) pCmdBuffer);
+    return nulldrv_cmd_create(dev, pAllocInfo,
+            (struct nulldrv_cmd **) pCmdBuffers);
 }
 
-ICD_EXPORT void VKAPI vkDestroyCommandBuffer(
+ICD_EXPORT void VKAPI vkFreeCommandBuffers(
     VkDevice                                  device,
-    VkCmdBuffer                               cmdBuffer)
+    VkCmdPool                                 cmdPool,
+    uint32_t                                  count,
+    const VkCmdBuffer*                        pCmdBuffers)
 {
     NULLDRV_LOG_FUNC;
+    for (uint32_t i = 0; i < count; i++) {
+        free(pCmdBuffers[i]);
+    }
 }
 
 ICD_EXPORT VkResult VKAPI vkBeginCommandBuffer(
@@ -2011,7 +2022,8 @@ ICD_EXPORT void VKAPI vkDestroyDescriptorPool(
 
 ICD_EXPORT VkResult VKAPI vkResetDescriptorPool(
     VkDevice                                device,
-    VkDescriptorPool                        descriptorPool)
+    VkDescriptorPool                        descriptorPool,
+    VkDescriptorPoolResetFlags              flags)
 {
     NULLDRV_LOG_FUNC;
     return VK_SUCCESS;
@@ -2019,23 +2031,20 @@ ICD_EXPORT VkResult VKAPI vkResetDescriptorPool(
 
 ICD_EXPORT VkResult VKAPI vkAllocDescriptorSets(
     VkDevice                                device,
-    VkDescriptorPool                        descriptorPool,
-    VkDescriptorSetUsage                     setUsage,
-    uint32_t                                     count,
-    const VkDescriptorSetLayout*             pSetLayouts,
-    VkDescriptorSet*                          pDescriptorSets)
+    const VkDescriptorSetAllocInfo*         pAllocInfo,
+    VkDescriptorSet*                        pDescriptorSets)
 {
     NULLDRV_LOG_FUNC;
-    struct nulldrv_desc_pool *pool = nulldrv_desc_pool(descriptorPool);
+    struct nulldrv_desc_pool *pool = nulldrv_desc_pool(pAllocInfo->descriptorPool);
     struct nulldrv_dev *dev = pool->dev;
     VkResult ret = VK_SUCCESS;
     uint32_t i;
 
-    for (i = 0; i < count; i++) {
+    for (i = 0; i < pAllocInfo->count; i++) {
         const struct nulldrv_desc_layout *layout =
-            nulldrv_desc_layout(pSetLayouts[i]);
+            nulldrv_desc_layout(pAllocInfo->pSetLayouts[i]);
 
-        ret = nulldrv_desc_set_create(dev, pool, setUsage, layout,
+        ret = nulldrv_desc_set_create(dev, pool, layout,
                 (struct nulldrv_desc_set **) &pDescriptorSets[i]);
         if (ret != VK_SUCCESS)
             break;
diff --git a/include/vk_layer.h b/include/vk_layer.h
index 9c6bcca9..692a2c0f 100644
--- a/include/vk_layer.h
+++ b/include/vk_layer.h
@@ -108,8 +108,8 @@ typedef struct VkLayerDispatchTable_
     PFN_vkCreateCommandPool CreateCommandPool;
     PFN_vkDestroyCommandPool DestroyCommandPool;
     PFN_vkResetCommandPool ResetCommandPool;
-    PFN_vkCreateCommandBuffer CreateCommandBuffer;
-    PFN_vkDestroyCommandBuffer DestroyCommandBuffer;
+    PFN_vkAllocCommandBuffers AllocCommandBuffers;
+    PFN_vkFreeCommandBuffers FreeCommandBuffers;
     PFN_vkBeginCommandBuffer BeginCommandBuffer;
     PFN_vkEndCommandBuffer EndCommandBuffer;
     PFN_vkResetCommandBuffer ResetCommandBuffer;
diff --git a/include/vulkan.h b/include/vulkan.h
index fda86fdd..206daed4 100644
--- a/include/vulkan.h
+++ b/include/vulkan.h
@@ -169,7 +169,7 @@ typedef enum {
     VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 6,
     VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 7,
     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 8,
-    VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 9,
+    VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO = 9,
     VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10,
     VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 11,
     VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 12,
@@ -207,9 +207,10 @@ typedef enum {
     VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO = 44,
     VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 45,
     VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 46,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO = 47,
     VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
-    VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
-    VK_STRUCTURE_TYPE_NUM = (VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
+    VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO,
+    VK_STRUCTURE_TYPE_NUM = (VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
     VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
 } VkStructureType;
 
@@ -725,24 +726,6 @@ typedef enum {
 } VkDescriptorType;
 
 typedef enum {
-    VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT = 0,
-    VK_DESCRIPTOR_POOL_USAGE_DYNAMIC = 1,
-    VK_DESCRIPTOR_POOL_USAGE_BEGIN_RANGE = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT,
-    VK_DESCRIPTOR_POOL_USAGE_END_RANGE = VK_DESCRIPTOR_POOL_USAGE_DYNAMIC,
-    VK_DESCRIPTOR_POOL_USAGE_NUM = (VK_DESCRIPTOR_POOL_USAGE_DYNAMIC - VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT + 1),
-    VK_DESCRIPTOR_POOL_USAGE_MAX_ENUM = 0x7FFFFFFF
-} VkDescriptorPoolUsage;
-
-typedef enum {
-    VK_DESCRIPTOR_SET_USAGE_ONE_SHOT = 0,
-    VK_DESCRIPTOR_SET_USAGE_STATIC = 1,
-    VK_DESCRIPTOR_SET_USAGE_BEGIN_RANGE = VK_DESCRIPTOR_SET_USAGE_ONE_SHOT,
-    VK_DESCRIPTOR_SET_USAGE_END_RANGE = VK_DESCRIPTOR_SET_USAGE_STATIC,
-    VK_DESCRIPTOR_SET_USAGE_NUM = (VK_DESCRIPTOR_SET_USAGE_STATIC - VK_DESCRIPTOR_SET_USAGE_ONE_SHOT + 1),
-    VK_DESCRIPTOR_SET_USAGE_MAX_ENUM = 0x7FFFFFFF
-} VkDescriptorSetUsage;
-
-typedef enum {
     VK_ATTACHMENT_LOAD_OP_LOAD = 0,
     VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
     VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
@@ -985,6 +968,12 @@ typedef VkFlags VkPipelineCreateFlags;
 typedef VkFlags VkShaderStageFlags;
 
 typedef enum {
+    VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001,
+} VkDescriptorPoolCreateFlagBits;
+typedef VkFlags VkDescriptorPoolCreateFlags;
+typedef VkFlags VkDescriptorPoolResetFlags;
+
+typedef enum {
     VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001,
 } VkAttachmentDescriptionFlagBits;
 typedef VkFlags VkAttachmentDescriptionFlags;
@@ -1043,7 +1032,6 @@ typedef enum {
     VK_CMD_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
 } VkCmdPoolResetFlagBits;
 typedef VkFlags VkCmdPoolResetFlags;
-typedef VkFlags VkCmdBufferCreateFlags;
 
 typedef enum {
     VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
@@ -1809,13 +1797,21 @@ typedef struct {
 typedef struct {
     VkStructureType                             sType;
     const void*                                 pNext;
-    VkDescriptorPoolUsage                       poolUsage;
+    VkDescriptorPoolCreateFlags                 flags;
     uint32_t                                    maxSets;
     uint32_t                                    count;
     const VkDescriptorTypeCount*                pTypeCount;
 } VkDescriptorPoolCreateInfo;
 
 typedef struct {
+    VkStructureType                             sType;
+    const void*                                 pNext;
+    VkDescriptorPool                            descriptorPool;
+    uint32_t                                    count;
+    const VkDescriptorSetLayout*                pSetLayouts;
+} VkDescriptorSetAllocInfo;
+
+typedef struct {
     VkSampler                                   sampler;
     VkImageView                                 imageView;
     VkImageLayout                               imageLayout;
@@ -1931,6 +1927,7 @@ typedef struct {
 typedef struct {
     VkStructureType                             sType;
     const void*                                 pNext;
+    uint32_t                                    maxCommandBuffers;
     uint32_t                                    queueFamilyIndex;
     VkCmdPoolCreateFlags                        flags;
 } VkCmdPoolCreateInfo;
@@ -1940,8 +1937,8 @@ typedef struct {
     const void*                                 pNext;
     VkCmdPool                                   cmdPool;
     VkCmdBufferLevel                            level;
-    VkCmdBufferCreateFlags                      flags;
-} VkCmdBufferCreateInfo;
+    uint32_t                                    count;
+} VkCmdBufferAllocInfo;
 
 typedef struct {
     VkStructureType                             sType;
@@ -2174,8 +2171,8 @@ typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const
 typedef void (VKAPI *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout);
 typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool);
 typedef void (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool);
-typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool);
-typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets);
+typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
+typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, const VkDescriptorSetAllocInfo* pAllocInfo, VkDescriptorSet* pDescriptorSets);
 typedef VkResult (VKAPI *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets);
 typedef void (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies);
 typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer);
@@ -2186,8 +2183,8 @@ typedef void (VKAPI *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPa
 typedef VkResult (VKAPI *PFN_vkCreateCommandPool)(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool);
 typedef void (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCmdPool cmdPool);
 typedef VkResult (VKAPI *PFN_vkResetCommandPool)(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags);
-typedef VkResult (VKAPI *PFN_vkCreateCommandBuffer)(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer);
-typedef void (VKAPI *PFN_vkDestroyCommandBuffer)(VkDevice device, VkCmdBuffer commandBuffer);
+typedef VkResult (VKAPI *PFN_vkAllocCommandBuffers)(VkDevice device, const VkCmdBufferAllocInfo* pAllocInfo, VkCmdBuffer* pCmdBuffers);
+typedef void (VKAPI *PFN_vkFreeCommandBuffers)(VkDevice device, VkCmdPool cmdPool, uint32_t count, const VkCmdBuffer* pCommandBuffers);
 typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo);
 typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCmdBuffer cmdBuffer);
 typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags);
@@ -2648,14 +2645,12 @@ void VKAPI vkDestroyDescriptorPool(
 
 VkResult VKAPI vkResetDescriptorPool(
     VkDevice                                    device,
-    VkDescriptorPool                            descriptorPool);
+    VkDescriptorPool                            descriptorPool,
+    VkDescriptorPoolResetFlags                  flags);
 
 VkResult VKAPI vkAllocDescriptorSets(
     VkDevice                                    device,
-    VkDescriptorPool                            descriptorPool,
-    VkDescriptorSetUsage                        setUsage,
-    uint32_t                                    count,
-    const VkDescriptorSetLayout*                pSetLayouts,
+    const VkDescriptorSetAllocInfo*             pAllocInfo,
     VkDescriptorSet*                            pDescriptorSets);
 
 VkResult VKAPI vkFreeDescriptorSets(
@@ -2708,14 +2703,16 @@ VkResult VKAPI vkResetCommandPool(
     VkCmdPool                                   cmdPool,
     VkCmdPoolResetFlags                         flags);
 
-VkResult VKAPI vkCreateCommandBuffer(
+VkResult VKAPI vkAllocCommandBuffers(
     VkDevice                                    device,
-    const VkCmdBufferCreateInfo*                pCreateInfo,
-    VkCmdBuffer*                                pCmdBuffer);
+    const VkCmdBufferAllocInfo*                 pAllocInfo,
+    VkCmdBuffer*                                pCmdBuffers);
 
-void VKAPI vkDestroyCommandBuffer(
+void VKAPI vkFreeCommandBuffers(
     VkDevice                                    device,
-    VkCmdBuffer                                 commandBuffer);
+    VkCmdPool                                   cmdPool,
+    uint32_t                                    count,
+    const VkCmdBuffer*                          pCommandBuffers);
 
 VkResult VKAPI vkBeginCommandBuffer(
     VkCmdBuffer                                 cmdBuffer,
diff --git a/layers/device_limits.cpp b/layers/device_limits.cpp
index 1217a75c..c311f5d6 100644
--- a/layers/device_limits.cpp
+++ b/layers/device_limits.cpp
@@ -458,15 +458,15 @@ VK_LAYER_EXPORT VkResult VKAPI vkResetCommandPool(VkDevice device, VkCmdPool cmd
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandBuffer(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer)
+VK_LAYER_EXPORT VkResult VKAPI vkAllocCommandBuffers(VkDevice device, const VkCmdBufferAllocInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer)
 {
-    VkResult result = get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
+    VkResult result = get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->AllocCommandBuffers(device, pCreateInfo, pCmdBuffer);
     return result;
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyCommandBuffer(VkDevice device, VkCmdBuffer commandBuffer)
+VK_LAYER_EXPORT void VKAPI vkFreeCommandBuffers(VkDevice device, VkCmdPool cmdPool, uint32_t count, const VkCmdBuffer* pCommandBuffers)
 {
-    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyCommandBuffer(device, commandBuffer);
+    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->FreeCommandBuffers(device, cmdPool, count, pCommandBuffers);
 }
 
 VK_LAYER_EXPORT void VKAPI vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
@@ -655,10 +655,10 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice dev, const
         return (PFN_vkVoidFunction) vkDestroyCommandPool;
     if (!strcmp(funcName, "ResetCommandPool"))
         return (PFN_vkVoidFunction) vkResetCommandPool;
-    if (!strcmp(funcName, "vkCreateCommandBuffer"))
-        return (PFN_vkVoidFunction) vkCreateCommandBuffer;
-    if (!strcmp(funcName, "vkDestroyCommandBuffer"))
-        return (PFN_vkVoidFunction) vkDestroyCommandBuffer;
+    if (!strcmp(funcName, "vkAllocCommandBuffers"))
+        return (PFN_vkVoidFunction) vkAllocCommandBuffers;
+    if (!strcmp(funcName, "vkFreeCommandBuffers"))
+        return (PFN_vkVoidFunction) vkFreeCommandBuffers;
     if (!strcmp(funcName, "vkCmdUpdateBuffer"))
         return (PFN_vkVoidFunction) vkCmdUpdateBuffer;
     if (!strcmp(funcName, "vkCmdFillBuffer"))
diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index 7f51083f..f0d0d937 100755
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -1088,13 +1088,14 @@ static void clearDescriptorSet(layer_data* my_data, VkDescriptorSet set)
     }
 }
 
-static void clearDescriptorPool(layer_data* my_data, const VkDevice device, const VkDescriptorPool pool)
+static void clearDescriptorPool(layer_data* my_data, const VkDevice device, const VkDescriptorPool pool, VkDescriptorPoolResetFlags flags)
 {
     POOL_NODE* pPool = getPoolNode(my_data, pool);
     if (!pPool) {
         log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, pool.handle, 0, DRAWSTATE_INVALID_POOL, "DS",
                 "Unable to find pool node for pool %#" PRIxLEAST64 " specified in vkResetDescriptorPool() call", pool.handle);
     } else {
+        // TODO: validate flags
         // For every set off of this pool, clear it
         SET_NODE* pSet = pPool->pSets;
         while (pSet) {
@@ -1171,7 +1172,7 @@ static void resetCB(layer_data* my_data, const VkCmdBuffer cb)
         }
         pCB->pCmds.clear();
         // Reset CB state (need to save createInfo)
-        VkCmdBufferCreateInfo saveCBCI = pCB->createInfo;
+        VkCmdBufferAllocInfo saveCBCI = pCB->createInfo;
         memset(pCB, 0, sizeof(GLOBAL_CB_NODE));
         pCB->cmdBuffer = cb;
         pCB->createInfo = saveCBCI;
@@ -1668,9 +1669,9 @@ VK_LAYER_EXPORT void VKAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptor
     // TODO : Clean up any internal data structures using this obj.
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyCommandBuffer(VkDevice device, VkCmdBuffer commandBuffer)
+VK_LAYER_EXPORT void VKAPI vkFreeCommandBuffers(VkDevice device, VkCmdPool cmdPool, uint32_t count, const VkCmdBuffer *pCommandBuffers)
 {
-    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyCommandBuffer(device, commandBuffer);
+    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->FreeCommandBuffers(device, cmdPool, count, pCommandBuffers);
     // TODO : Clean up any internal data structures using this obj.
 }
 
@@ -1905,39 +1906,39 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, const VkD
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool)
+VK_LAYER_EXPORT VkResult VKAPI vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    VkResult result = dev_data->device_dispatch_table->ResetDescriptorPool(device, descriptorPool);
+    VkResult result = dev_data->device_dispatch_table->ResetDescriptorPool(device, descriptorPool, flags);
     if (VK_SUCCESS == result) {
-        clearDescriptorPool(dev_data, device, descriptorPool);
+        clearDescriptorPool(dev_data, device, descriptorPool, flags);
     }
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets)
+VK_LAYER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDevice device, const VkDescriptorSetAllocInfo* pAllocInfo, VkDescriptorSet* pDescriptorSets)
 {
     VkBool32 skipCall = VK_FALSE;
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     // Verify that requested descriptorSets are available in pool
-    POOL_NODE *pPoolNode = getPoolNode(dev_data, descriptorPool);
+    POOL_NODE *pPoolNode = getPoolNode(dev_data, pAllocInfo->descriptorPool);
     if (!pPoolNode) {
-        skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, descriptorPool.handle, 0, DRAWSTATE_INVALID_POOL, "DS",
-                "Unable to find pool node for pool %#" PRIxLEAST64 " specified in vkAllocDescriptorSets() call", descriptorPool.handle);
+        skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, pAllocInfo->descriptorPool.handle, 0, DRAWSTATE_INVALID_POOL, "DS",
+                "Unable to find pool node for pool %#" PRIxLEAST64 " specified in vkAllocDescriptorSets() call", pAllocInfo->descriptorPool.handle);
     } else { // Make sure pool has all the available descriptors before calling down chain
-        skipCall |= validate_descriptor_availability_in_pool(dev_data, pPoolNode, count, pSetLayouts);
+        skipCall |= validate_descriptor_availability_in_pool(dev_data, pPoolNode, pAllocInfo->count, pAllocInfo->pSetLayouts);
     }
     if (skipCall)
         return VK_ERROR_VALIDATION_FAILED;
-    VkResult result = dev_data->device_dispatch_table->AllocDescriptorSets(device, descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets);
+    VkResult result = dev_data->device_dispatch_table->AllocDescriptorSets(device, pAllocInfo, pDescriptorSets);
     if (VK_SUCCESS == result) {
-        POOL_NODE *pPoolNode = getPoolNode(dev_data, descriptorPool);
+        POOL_NODE *pPoolNode = getPoolNode(dev_data, pAllocInfo->descriptorPool);
         if (pPoolNode) {
-            if (count == 0) {
-                log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, count, 0, DRAWSTATE_NONE, "DS",
+            if (pAllocInfo->count == 0) {
+                log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pAllocInfo->count, 0, DRAWSTATE_NONE, "DS",
                         "AllocDescriptorSets called with 0 count");
             }
-            for (uint32_t i = 0; i < count; i++) {
+            for (uint32_t i = 0; i < pAllocInfo->count; i++) {
                 log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pDescriptorSets[i].handle, 0, DRAWSTATE_NONE, "DS",
                         "Created Descriptor Set %#" PRIxLEAST64, pDescriptorSets[i].handle);
                 // Create new set node and add to head of pool nodes
@@ -1954,16 +1955,15 @@ VK_LAYER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDevice device, VkDescript
                     // Insert set at head of Set LL for this pool
                     pNewNode->pNext = pPoolNode->pSets;
                     pPoolNode->pSets = pNewNode;
-                    LAYOUT_NODE* pLayout = getLayoutNode(dev_data, pSetLayouts[i]);
+                    LAYOUT_NODE* pLayout = getLayoutNode(dev_data, pAllocInfo->pSetLayouts[i]);
                     if (NULL == pLayout) {
-                        if (log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, pSetLayouts[i].handle, 0, DRAWSTATE_INVALID_LAYOUT, "DS",
-                                "Unable to find set layout node for layout %#" PRIxLEAST64 " specified in vkAllocDescriptorSets() call", pSetLayouts[i].handle))
+                        if (log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, pAllocInfo->pSetLayouts[i].handle, 0, DRAWSTATE_INVALID_LAYOUT, "DS",
+                                "Unable to find set layout node for layout %#" PRIxLEAST64 " specified in vkAllocDescriptorSets() call", pAllocInfo->pSetLayouts[i].handle))
                             return VK_ERROR_VALIDATION_FAILED;
                     }
                     pNewNode->pLayout = pLayout;
-                    pNewNode->pool = descriptorPool;
+                    pNewNode->pool = pAllocInfo->descriptorPool;
                     pNewNode->set = pDescriptorSets[i];
-                    pNewNode->setUsage = setUsage;
                     pNewNode->descriptorCount = pLayout->endIndex + 1;
                     if (pNewNode->descriptorCount) {
                         size_t descriptorArraySize = sizeof(GENERIC_HEADER*)*pNewNode->descriptorCount;
@@ -1983,10 +1983,10 @@ VK_LAYER_EXPORT VkResult VKAPI vkFreeDescriptorSets(VkDevice device, VkDescripto
     VkBool32 skipCall = VK_FALSE;
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     POOL_NODE *pPoolNode = getPoolNode(dev_data, descriptorPool);
-    if (pPoolNode && (VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT == pPoolNode->createInfo.poolUsage)) {
-        // Can't Free from a ONE_SHOT pool
-        skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE, (uint64_t)device, 0, DRAWSTATE_CANT_FREE_FROM_ONE_SHOT_POOL, "DS",
-                    "It is invalid to call vkFreeDescriptorSets() with a pool created with usage type VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT.");
+    if (pPoolNode && !(VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT & pPoolNode->createInfo.flags)) {
+        // Can't Free from a NON_FREE pool
+        skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE, (uint64_t)device, 0, DRAWSTATE_CANT_FREE_FROM_NON_FREE_POOL, "DS",
+                    "It is invalid to call vkFreeDescriptorSets() with a pool created without setting VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT.");
     }
     if (skipCall)
         return VK_ERROR_VALIDATION_FAILED;
@@ -2018,10 +2018,10 @@ VK_LAYER_EXPORT void VKAPI vkUpdateDescriptorSets(VkDevice device, uint32_t writ
     }
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandBuffer(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer)
+VK_LAYER_EXPORT VkResult VKAPI vkAllocCommandBuffers(VkDevice device, const VkCmdBufferAllocInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    VkResult result = dev_data->device_dispatch_table->CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
+    VkResult result = dev_data->device_dispatch_table->AllocCommandBuffers(device, pCreateInfo, pCmdBuffer);
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
         GLOBAL_CB_NODE* pCB = new GLOBAL_CB_NODE;
@@ -2048,13 +2048,13 @@ VK_LAYER_EXPORT VkResult VKAPI vkBeginCommandBuffer(VkCmdBuffer cmdBuffer, const
             if (pBeginInfo->renderPass.handle || pBeginInfo->framebuffer.handle) {
                 // These should be NULL for a Primary CB
                 skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_BEGIN_CB_INVALID_STATE, "DS",
-                    "vkCreateCommandBuffer():  Primary Command Buffer (%p) may not specify framebuffer or renderpass parameters", (void*)cmdBuffer);
+                    "vkAllocCommandBuffers():  Primary Command Buffer (%p) may not specify framebuffer or renderpass parameters", (void*)cmdBuffer);
             }
         } else {
             if (!pBeginInfo->renderPass.handle || !pBeginInfo->framebuffer.handle) {
                 // These should NOT be null for an Secondary CB
                 skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_BEGIN_CB_INVALID_STATE, "DS",
-                    "vkCreateCommandBuffer():  Secondary Command Buffers (%p) must specify framebuffer and renderpass parameters", (void*)cmdBuffer);
+                    "vkAllocCommandBuffers():  Secondary Command Buffers (%p) must specify framebuffer and renderpass parameters", (void*)cmdBuffer);
             }
         }
         pCB->beginInfo = *pBeginInfo;
@@ -3508,8 +3508,8 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice dev, const
         return (PFN_vkVoidFunction) vkDestroyDescriptorSetLayout;
     if (!strcmp(funcName, "vkDestroyDescriptorPool"))
         return (PFN_vkVoidFunction) vkDestroyDescriptorPool;
-    if (!strcmp(funcName, "vkDestroyCommandBuffer"))
-        return (PFN_vkVoidFunction) vkDestroyCommandBuffer;
+    if (!strcmp(funcName, "vkFreeCommandBuffers"))
+        return (PFN_vkVoidFunction) vkFreeCommandBuffers;
     if (!strcmp(funcName, "vkDestroyFramebuffer"))
         return (PFN_vkVoidFunction) vkDestroyFramebuffer;
     if (!strcmp(funcName, "vkDestroyRenderPass"))
@@ -3546,8 +3546,8 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice dev, const
         return (PFN_vkVoidFunction) vkFreeDescriptorSets;
     if (!strcmp(funcName, "vkUpdateDescriptorSets"))
         return (PFN_vkVoidFunction) vkUpdateDescriptorSets;
-    if (!strcmp(funcName, "vkCreateCommandBuffer"))
-        return (PFN_vkVoidFunction) vkCreateCommandBuffer;
+    if (!strcmp(funcName, "vkAllocCommandBuffers"))
+        return (PFN_vkVoidFunction) vkAllocCommandBuffers;
     if (!strcmp(funcName, "vkBeginCommandBuffer"))
         return (PFN_vkVoidFunction) vkBeginCommandBuffer;
     if (!strcmp(funcName, "vkEndCommandBuffer"))
diff --git a/layers/draw_state.h b/layers/draw_state.h
index c8a6883d..4e6692d1 100755
--- a/layers/draw_state.h
+++ b/layers/draw_state.h
@@ -47,7 +47,7 @@ typedef enum _DRAW_STATE_ERROR
     DRAWSTATE_DESCRIPTOR_TYPE_MISMATCH,         // Type in layout vs. update are not the same
     DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS,  // Descriptors set for update out of bounds for corresponding layout section
     DRAWSTATE_DESCRIPTOR_POOL_EMPTY,            // Attempt to allocate descriptor from a pool with no more descriptors of that type available
-    DRAWSTATE_CANT_FREE_FROM_ONE_SHOT_POOL,     // Invalid to call vkFreeDescriptorSets on Sets allocated from a ONE_SHOT Pool
+    DRAWSTATE_CANT_FREE_FROM_NON_FREE_POOL,     // Invalid to call vkFreeDescriptorSets on Sets allocated from a NON_FREE Pool
     DRAWSTATE_INVALID_UPDATE_INDEX,             // Index of requested update is invalid for specified descriptors set
     DRAWSTATE_INVALID_UPDATE_STRUCT,            // Struct in DS Update tree is of invalid type
     DRAWSTATE_NUM_SAMPLES_MISMATCH,             // Number of samples in bound PSO does not match number in FB of current RenderPass
@@ -159,7 +159,6 @@ struct PIPELINE_LAYOUT_NODE {
 typedef struct _SET_NODE {
     VkDescriptorSet      set;
     VkDescriptorPool     pool;
-    VkDescriptorSetUsage setUsage;
     // Head of LL of all Update structs for this set
     GENERIC_HEADER*      pUpdateStructs;
     // Total num of descriptors in this set (count of its layout plus all prior layouts)
@@ -171,13 +170,14 @@ typedef struct _SET_NODE {
 
 typedef struct _POOL_NODE {
     VkDescriptorPool           pool;
+    uint32_t                   maxSets;
     VkDescriptorPoolCreateInfo createInfo;
     SET_NODE*                  pSets; // Head of LL of sets for this Pool
     vector<uint32_t>           maxDescriptorTypeCount; // max # of descriptors of each type in this pool
     vector<uint32_t>           availableDescriptorTypeCount; // available # of descriptors of each type in this pool
 
     _POOL_NODE(const VkDescriptorPool pool, const VkDescriptorPoolCreateInfo* pCreateInfo) :
-    pool(pool), createInfo(*pCreateInfo), pSets(NULL),
+    pool(pool), createInfo(*pCreateInfo), maxSets(pCreateInfo->maxSets), pSets(NULL),
     maxDescriptorTypeCount(VK_DESCRIPTOR_TYPE_END_RANGE), availableDescriptorTypeCount(VK_DESCRIPTOR_TYPE_END_RANGE)
     {
         if (createInfo.count) { // Shadow type struct from ptr into local struct
@@ -305,7 +305,7 @@ typedef struct stencil_data {
 // Cmd Buffer Wrapper Struct
 typedef struct _GLOBAL_CB_NODE {
     VkCmdBuffer                  cmdBuffer;
-    VkCmdBufferCreateInfo        createInfo;
+    VkCmdBufferAllocInfo        createInfo;
     VkCmdBufferBeginInfo         beginInfo;
     VkFence                      fence;    // fence tracking this cmd buffer
     uint64_t                     numCmds;  // number of cmds in this CB
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index 704e007e..c19819d9 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -1571,12 +1571,12 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandBuffer(
+VK_LAYER_EXPORT VkResult VKAPI vkAllocCommandBuffers(
     VkDevice                     device,
-    const VkCmdBufferCreateInfo *pCreateInfo,
+    const VkCmdBufferAllocInfo *pCreateInfo,
     VkCmdBuffer                 *pCmdBuffer)
 {
-    VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
+    VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->AllocCommandBuffers(device, pCreateInfo, pCmdBuffer);
     // At time of cmd buffer creation, create global cmd buffer info for the returned cmd buffer
     loader_platform_thread_lock_mutex(&globalLock);
     if (*pCmdBuffer)
@@ -2461,8 +2461,8 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(
         return (PFN_vkVoidFunction) vkCreateImage;
     if (!strcmp(funcName, "vkCreateImageView"))
         return (PFN_vkVoidFunction) vkCreateImageView;
-    if (!strcmp(funcName, "vkCreateCommandBuffer"))
-        return (PFN_vkVoidFunction) vkCreateCommandBuffer;
+    if (!strcmp(funcName, "vkAllocCommandBuffers"))
+        return (PFN_vkVoidFunction) vkAllocCommandBuffers;
     if (!strcmp(funcName, "vkBeginCommandBuffer"))
         return (PFN_vkVoidFunction) vkBeginCommandBuffer;
     if (!strcmp(funcName, "vkEndCommandBuffer"))
diff --git a/layers/mem_tracker.h b/layers/mem_tracker.h
index 4e23b821..0d15baaa 100644
--- a/layers/mem_tracker.h
+++ b/layers/mem_tracker.h
@@ -115,7 +115,7 @@ struct MT_OBJ_BINDING_INFO {
 
 // Track all command buffers
 struct MT_CB_INFO {
-    VkCmdBufferCreateInfo       createInfo;
+    VkCmdBufferAllocInfo       createInfo;
     VkPipeline                  pipelines[VK_PIPELINE_BIND_POINT_NUM];
     uint32_t                    attachmentCount;
     VkCmdBuffer                 cmdBuffer;
diff --git a/layers/object_track.h b/layers/object_track.h
index 99ad2ea2..c2f0e674 100644
--- a/layers/object_track.h
+++ b/layers/object_track.h
@@ -819,28 +819,25 @@ explicit_QueueBindSparseImageOpaqueMemory(
 VkResult
 explicit_AllocDescriptorSets(
     VkDevice                     device,
-    VkDescriptorPool             descriptorPool,
-    VkDescriptorSetUsage         setUsage,
-    uint32_t                     count,
-    const VkDescriptorSetLayout *pSetLayouts,
+    const VkDescriptorSetAllocInfo *pAllocInfo,
     VkDescriptorSet             *pDescriptorSets)
 {
     VkBool32 skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&objLock);
     skipCall |= validate_object(device, device);
-    skipCall |= validate_object(device, descriptorPool);
-    for (uint32_t i = 0; i < count; i++) {
-        skipCall |= validate_object(device, pSetLayouts[i]);
+    skipCall |= validate_object(device, pAllocInfo->descriptorPool);
+    for (uint32_t i = 0; i < pAllocInfo->count; i++) {
+        skipCall |= validate_object(device, pAllocInfo->pSetLayouts[i]);
     }
     loader_platform_thread_unlock_mutex(&objLock);
     if (skipCall)
         return VK_ERROR_VALIDATION_FAILED;
 
     VkResult result = get_dispatch_table(ObjectTracker_device_table_map, device)->AllocDescriptorSets(
-        device, descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets);
+        device, pAllocInfo, pDescriptorSets);
 
     loader_platform_thread_lock_mutex(&objLock);
-    for (uint32_t i = 0; i < count; i++) {
+    for (uint32_t i = 0; i < pAllocInfo->count; i++) {
         create_obj(device, pDescriptorSets[i], VK_OBJECT_TYPE_DESCRIPTOR_SET);
     }
     loader_platform_thread_unlock_mutex(&objLock);
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index 618e0fc4..dc9f8da4 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -4606,20 +4606,11 @@ bool PreCreateDescriptorPool(
 
 bool PostCreateDescriptorPool(
     VkDevice device,
-    VkDescriptorPoolUsage poolUsage,
     uint32_t maxSets,
     VkDescriptorPool* pDescriptorPool,
     VkResult result)
 {
 
-    if(poolUsage < VK_DESCRIPTOR_POOL_USAGE_BEGIN_RANGE ||
-        poolUsage > VK_DESCRIPTOR_POOL_USAGE_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCreateDescriptorPool parameter, VkDescriptorPoolUsage poolUsage, is an unrecognized enumerator");
-        return false;
-    }
-
     /* TODOVV: How do we validate maxSets? Probably belongs in the limits layer? */
 
     if(pDescriptorPool != nullptr)
@@ -4645,7 +4636,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorPool(
 
     VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDescriptorPool(device, pCreateInfo, pDescriptorPool);
 
-    PostCreateDescriptorPool(device, pCreateInfo->poolUsage, pCreateInfo->maxSets, pDescriptorPool, result);
+    PostCreateDescriptorPool(device, pCreateInfo->maxSets, pDescriptorPool, result);
 
     return result;
 }
@@ -4669,9 +4660,10 @@ bool PostResetDescriptorPool(
 
 VK_LAYER_EXPORT VkResult VKAPI vkResetDescriptorPool(
     VkDevice device,
-    VkDescriptorPool descriptorPool)
+    VkDescriptorPool descriptorPool,
+    VkDescriptorPoolResetFlags flags)
 {
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->ResetDescriptorPool(device, descriptorPool);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->ResetDescriptorPool(device, descriptorPool, flags);
 
     PostResetDescriptorPool(device, descriptorPool, result);
 
@@ -4692,22 +4684,12 @@ bool PreAllocDescriptorSets(
 bool PostAllocDescriptorSets(
     VkDevice device,
     VkDescriptorPool descriptorPool,
-    VkDescriptorSetUsage setUsage,
     uint32_t count,
     VkDescriptorSet* pDescriptorSets,
     VkResult result)
 {
 
 
-    if(setUsage < VK_DESCRIPTOR_SET_USAGE_BEGIN_RANGE ||
-        setUsage > VK_DESCRIPTOR_SET_USAGE_END_RANGE)
-    {
-        log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkAllocDescriptorSets parameter, VkDescriptorSetUsage setUsage, is an unrecognized enumerator");
-        return false;
-    }
-
-
     if(pDescriptorSets != nullptr)
     {
     }
@@ -4724,17 +4706,14 @@ bool PostAllocDescriptorSets(
 
 VK_LAYER_EXPORT VkResult VKAPI vkAllocDescriptorSets(
     VkDevice device,
-    VkDescriptorPool descriptorPool,
-    VkDescriptorSetUsage setUsage,
-    uint32_t count,
-    const VkDescriptorSetLayout* pSetLayouts,
+    const VkDescriptorSetAllocInfo* pAllocInfo,
     VkDescriptorSet* pDescriptorSets)
 {
-    PreAllocDescriptorSets(device, pSetLayouts);
+    PreAllocDescriptorSets(device, pAllocInfo->pSetLayouts);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->AllocDescriptorSets(device, descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->AllocDescriptorSets(device, pAllocInfo, pDescriptorSets);
 
-    PostAllocDescriptorSets(device, descriptorPool, setUsage, count, pDescriptorSets, result);
+    PostAllocDescriptorSets(device, pAllocInfo->descriptorPool, pAllocInfo->count, pDescriptorSets, result);
 
     return result;
 }
@@ -5184,21 +5163,21 @@ VK_LAYER_EXPORT VkResult VKAPI vkResetCommandPool(
 
 bool PreCreateCommandBuffer(
     VkDevice device,
-    const VkCmdBufferCreateInfo* pCreateInfo)
+    const VkCmdBufferAllocInfo* pCreateInfo)
 {
     if(pCreateInfo != nullptr)
     {
-    if(pCreateInfo->sType != VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO)
+    if(pCreateInfo->sType != VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCreateCommandBuffer parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
+        "vkAllocCommandBuffers parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
         return false;
     }
     if(pCreateInfo->level < VK_CMD_BUFFER_LEVEL_BEGIN_RANGE ||
         pCreateInfo->level > VK_CMD_BUFFER_LEVEL_END_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCreateCommandBuffer parameter, VkCmdBufferLevel pCreateInfo->level, is an unrecognized enumerator");
+        "vkAllocCommandBuffers parameter, VkCmdBufferLevel pCreateInfo->level, is an unrecognized enumerator");
         return false;
     }
     }
@@ -5218,7 +5197,7 @@ bool PostCreateCommandBuffer(
 
     if(result < VK_SUCCESS)
     {
-        std::string reason = "vkCreateCommandBuffer parameter, VkResult result, is " + EnumeratorString(result);
+        std::string reason = "vkAllocCommandBuffers parameter, VkResult result, is " + EnumeratorString(result);
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK", reason.c_str());
         return false;
     }
@@ -5226,14 +5205,14 @@ bool PostCreateCommandBuffer(
     return true;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandBuffer(
+VK_LAYER_EXPORT VkResult VKAPI vkAllocCommandBuffers(
     VkDevice device,
-    const VkCmdBufferCreateInfo* pCreateInfo,
+    const VkCmdBufferAllocInfo* pCreateInfo,
     VkCmdBuffer* pCmdBuffer)
 {
     PreCreateCommandBuffer(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->AllocCommandBuffers(device, pCreateInfo, pCmdBuffer);
 
     PostCreateCommandBuffer(device, pCmdBuffer, result);
 
@@ -6804,8 +6783,8 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice device, co
         return (PFN_vkVoidFunction) vkCmdSetStencilWriteMask;
     if (!strcmp(funcName, "vkCmdSetStencilReference"))
         return (PFN_vkVoidFunction) vkCmdSetStencilReference;
-    if (!strcmp(funcName, "vkCreateCommandBuffer"))
-        return (PFN_vkVoidFunction) vkCreateCommandBuffer;
+    if (!strcmp(funcName, "vkAllocCommandBuffers"))
+        return (PFN_vkVoidFunction) vkAllocCommandBuffers;
     if (!strcmp(funcName, "vkBeginCommandBuffer"))
         return (PFN_vkVoidFunction) vkBeginCommandBuffer;
     if (!strcmp(funcName, "vkEndCommandBuffer"))
diff --git a/layers/screenshot.cpp b/layers/screenshot.cpp
index c7eb4cad..ec1ac0c5 100644
--- a/layers/screenshot.cpp
+++ b/layers/screenshot.cpp
@@ -168,12 +168,12 @@ static void writePPM( const char *filename, VkImage image1)
         0,     // allocationSize, queried later
         0      // memoryTypeIndex, queried later
     };
-    const VkCmdBufferCreateInfo createCommandBufferInfo = {
-        VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO,
+    const VkCmdBufferAllocInfo allocCommandBufferInfo = {
+        VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO,
         NULL,
         deviceMap[device]->cmdPool,
         VK_CMD_BUFFER_LEVEL_PRIMARY,
-        0
+        1
     };
     const VkCmdBufferBeginInfo cmdBufferBeginInfo = {
         VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO,
@@ -228,7 +228,7 @@ static void writePPM( const char *filename, VkImage image1)
     err = pTableQueue->BindImageMemory(device, image2, mem2, 0);
     assert(!err);
 
-    err = pTableDevice->CreateCommandBuffer(device, &createCommandBufferInfo,  &cmdBuffer);
+    err = pTableDevice->AllocCommandBuffers(device, &allocCommandBufferInfo,  &cmdBuffer);
     assert(!err);
 
     screenshot_device_table_map.emplace(cmdBuffer, pTableDevice);
@@ -308,7 +308,7 @@ static void writePPM( const char *filename, VkImage image1)
     // Clean up
     pTableDevice->UnmapMemory(device, mem2);
     pTableDevice->FreeMemory(device, mem2);
-    pTableDevice->DestroyCommandBuffer(device, cmdBuffer);
+    pTableDevice->FreeCommandBuffers(device, deviceMap[device]->cmdPool, 1, &cmdBuffer);
 }
 
 
diff --git a/layers/vk_validation_layer_details.md b/layers/vk_validation_layer_details.md
index 6fcbcd9d..c97268cd 100644
--- a/layers/vk_validation_layer_details.md
+++ b/layers/vk_validation_layer_details.md
@@ -21,7 +21,7 @@ The DrawState layer tracks state leading into Draw cmds. This includes the Pipel
 | Valid DescriptorSetLayout | Flag DescriptorSetLayout object that was not properly created | INVALID_LAYOUT | vkAllocDescriptorSets | None | Anywhere else to check this? |
 | Valid Pipeline | Flag VkPipeline object that was not properly created | INVALID_PIPELINE | vkCmdBindPipeline | InvalidPipeline | NA |
 | Valid Pipeline Create Info | Tests for the following: That compute shaders are not specified for the graphics pipeline, tess evaluation and tess control shaders are included or excluded as a pair, that VK_PRIMITIVE_TOPOLOGY_PATCH is set as IA topology for tessellation pipelines, that VK_PRIMITIVE_TOPOLOGY_PATCH primitive topology is only set for tessellation pipelines, and that Vtx Shader specified | INVALID_PIPELINE_CREATE_STATE | vkCreateGraphicsPipelines | InvalidPipelineCreateState | NA |
-| Valid CmdBuffer | Validates that the command buffer object was properly created and is currently valid | INVALID_CMD_BUFFER | vkQueueSubmit vkBeginCommandBuffer vkEndCommandBuffer vkCmdBindPipeline vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearAttachments vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdBeginRenderPass vkCmdNextSubpass vkCmdEndRenderPass vkCmdExecuteCommands vkCmdDbgMarkerBegin vkCmdDbgMarkerEnd vkCreateCommandBuffer | None | NA |
+| Valid CmdBuffer | Validates that the command buffer object was properly created and is currently valid | INVALID_CMD_BUFFER | vkQueueSubmit vkBeginCommandBuffer vkEndCommandBuffer vkCmdBindPipeline vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearAttachments vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdBeginRenderPass vkCmdNextSubpass vkCmdEndRenderPass vkCmdExecuteCommands vkCmdDbgMarkerBegin vkCmdDbgMarkerEnd vkAllocCommandBuffers | None | NA |
 | Vtx Buffer Bounds | Check if VBO index too large for PSO Vtx binding count, and that at least one vertex buffer is attached to pipeline object | VTX_INDEX_OUT_OF_BOUNDS | vkCmdBindDescriptorSets vkCmdBindVertexBuffers | VtxBufferBadIndex | NA |
 | Idx Buffer Alignment | Verify that offset of Index buffer falls on an alignment boundary as defined by IdxBufferAlignmentError param | VTX_INDEX_ALIGNMENT_ERROR | vkCmdBindIndexBuffer | IdxBufferAlignmentError | NA |
 | Cmd Buffer End | Verifies that EndCommandBuffer was called for this cmdBuffer at QueueSubmit time | NO_END_CMD_BUFFER | vkQueueSubmit | NoEndCmdBuffer | NA |
@@ -31,7 +31,7 @@ The DrawState layer tracks state leading into Draw cmds. This includes the Pipel
 | Descriptor Type | Verify Descriptor type in bound descriptor set layout matches descriptor type specified in update | DESCRIPTOR_TYPE_MISMATCH | vkUpdateDescriptorSets | DSTypeMismatch | With various DS API updates, need to revisit this code |
 | DS Update Size | DS update out of bounds for given layout section | DESCRIPTOR_UPDATE_OUT_OF_BOUNDS | vkUpdateDescriptorSets | DSUpdateOutOfBounds | NA |
 | Descriptor Pool empty | Attempt to allocate descriptor type from descriptor pool when no more of that type are available to be allocated. | DESCRIPTOR_POOL_EMPTY | vkAllocDescriptorSets | AllocDescriptorFromEmptyPool | NA |
-| Free from ONE_SHOT Pool | It's invalid to call vkFreeDescriptorSets() on Sets that were allocated from a Pool created with ONE_SHOT usage. | CANT_FREE_FROM_ONE_SHOT_POOL | vkFreeDescriptorSets | None | NA |
+| Free from NON_FREE Pool | It's invalid to call vkFreeDescriptorSets() on Sets that were allocated from a Pool created with NON_FREE usage. | CANT_FREE_FROM_NON_FREE_POOL | vkFreeDescriptorSets | None | NA |
 | DS Update Index | DS update binding too large for layout count | INVALID_UPDATE_INDEX | vkUpdateDescriptorSets | InvalidDSUpdateIndex | NA |
 | DS Update Type | Verifies that structs in DS Update tree are properly created, currenly valid, and of the right type | INVALID_UPDATE_STRUCT | vkUpdateDescriptorSets | InvalidDSUpdateStruct | NA |
 | MSAA Sample Count | Verifies that Pipeline, RenderPass, and Subpass sample counts are consistent | NUM_SAMPLES_MISMATCH | vkCmdBindPipeline vkCmdBeginRenderPass vkCmdNextSubpass | NumSamplesMismatch | NA |
@@ -63,7 +63,7 @@ Additional checks to be added to DrawState
  7. Lifetime validation (See [bug 13383](https://cvs.khronos.org/bugzilla/show_bug.cgi?id=13383))
 	 8. XGL_DESCRIPTOR_SET
 		 9. Cannot be deleted until no longer in use on GPU, or referenced in any pending command.
-		 10. Sets in XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT regions can never be deleted. Instead the xglClearDescriptorRegion() deletes all sets.
+                 10. Sets in XGL_DESCRIPTOR_REGION_USAGE_NON_FREE regions can never be deleted. Instead the xglClearDescriptorRegion() deletes all sets.
 		 11. Sets in XGL_DESCRIPTOR_REGION_USAGE_DYNAMIC regions can be deleted. 
 	 12. XGL_DESCRIPTOR_SET_LAYOUT
 		 13. What do IHVs want here?
@@ -93,8 +93,8 @@ The ParamChecker layer validates parameter values and flags errors for any value
 
 | Check | Overview | ENUM | Relevant API | Testname | Notes/TODO |
 | ----- | -------- | ---------------- | ------------ | -------- | ---------- |
-| Input Parameters | Pointers in structures are recursively validated to be non-null. Enumerated types are validated against min and max enum values. Structure Types are verified to be correct. | NA | vkQueueSubmit vkAllocMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkQueueBindSparseBufferMemory vkQueueBindSparseImageOpaqueMemory vkQueueBindSparseImageMemory vkCreateFence vkResetFences vkWaitForFences vkCreateSemaphore vkCreateEvent vkCreateQueryPool vkCreateBuffer vkCreateBufferView vkCreateImage vkGetImageSubresourceLayout vkCreateImageView vkCreateShader vkCreatePipelineCache vkMergePipelineCaches vkCreateGraphicsPipelines vkCreateComputePipelines vkCreatePipelineLayout vkCreateSampler vkCreateDescriptorSetLayout( vkCreateDescriptorPool vkAllocDescriptorSets vkFreeDescriptorSets vkUpdateDescriptorSets vkCreateFramebuffer vkCreateRenderPass vkCreateCommandPool vkCreateCommandBuffer vkBeginCommandBuffer vkCmdBindDescriptorSets vkCmdBindVertexBuffers vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearAttachments vkCmdResolveImage vkCmdWaitEvents vkCmdPipelineBarrier vkCmdPushConstants vkCmdBeginRenderPass vkCmdExecuteCommands | TBD | NA |
-| Call results, Output Parameters | Return values are checked for VK_SUCCESS, returned pointers are checked to be NON-NULL, enumerated types of return values are checked to be within the defined range. | NA | vkEnumeratePhysicalDevices vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceLimits vkGetPhysicalDeviceProperties vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceMemoryProperties vkGetDeviceQueue vkQueueSubmit vkQueueWaitIdle vkDeviceWaitIdle vkAllocMemory vkFreeMemory vkMapMemory vkUnmapMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkGetDeviceMemoryCommitment vkBindBufferMemory vkBindImageMemory vkGetBufferMemoryRequirements vkGetImageMemoryRequirements vkGetImageSparseMemoryRequirements vkGetPhysicalDeviceSparseImageFormatProperties vkQueueBindSparseBufferMemory vkQueueBindSparseImageOpaqueMemory vkQueueBindSparseImageMemory vkCreateFence vkDestroyFence vkResetFences vkGetFenceStatus vkWaitForFences vkCreateSemaphore vkDestroySemaphore vkQueueSignalSemaphore vkQueueWaitSemaphore vkCreateEvent vkDestroyEvent vkGetEventStatus vkSetEvent vkResetEvent vkCreateQueryPool vkDestroyQueryPool vkGetQueryPoolResults vkCreateBuffer vkDestroyBuffer vkCreateBufferView vkDestroyBufferView vkCreateImage vkDestroyImage vkGetImageSubresourceLayout vkCreateImageView vkDestroyImageView vkDestroyShaderModule vkCreateShader vkDestroyShader vkCreatePipelineCache vkDestroyPipelineCache vkGetPipelineCacheSize vkGetPipelineCacheData vkMergePipelineCaches vkCreateGraphicsPipelines vkCreateComputePipelines vkDestroyPipeline vkCreatePipelineLayout vkDestroyPipelineLayout vkCreateSampler vkDestroySampler vkCreateDescriptorSetLayout vkDestroyDescriptorSetLayout vkCreateDescriptorPool vkDestroyDescriptorPool vkResetDescriptorPool vkAllocDescriptorSets vkFreeDescriptorSets vkUpdateDescriptorSets vkCreateFramebuffer vkDestroyFramebuffer vkCreateRenderPass vkDestroyRenderPass vkGetRenderAreaGranularity vkCreateCommandPool vkDestroyCommandPool vkResetCommandPool vkCreateCommandBuffer vkDestroyCommandBuffer vkBeginCommandBuffer vkEndCommandBuffer vkResetCommandBuffer vkCmdBindPipeline vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearAttachments vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdCopyQueryPoolResults vkCmdPushConstants vkCmdBeginRenderPass vkCmdNextSubpass vkCmdEndRenderPass vkCmdExecuteCommands | TBD | NA |
+| Input Parameters | Pointers in structures are recursively validated to be non-null. Enumerated types are validated against min and max enum values. Structure Types are verified to be correct. | NA | vkQueueSubmit vkAllocMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkQueueBindSparseBufferMemory vkQueueBindSparseImageOpaqueMemory vkQueueBindSparseImageMemory vkCreateFence vkResetFences vkWaitForFences vkCreateSemaphore vkCreateEvent vkCreateQueryPool vkCreateBuffer vkCreateBufferView vkCreateImage vkGetImageSubresourceLayout vkCreateImageView vkCreateShader vkCreatePipelineCache vkMergePipelineCaches vkCreateGraphicsPipelines vkCreateComputePipelines vkCreatePipelineLayout vkCreateSampler vkCreateDescriptorSetLayout( vkCreateDescriptorPool vkAllocDescriptorSets vkFreeDescriptorSets vkUpdateDescriptorSets vkCreateFramebuffer vkCreateRenderPass vkCreateCommandPool vkAllocCommandBuffers vkBeginCommandBuffer vkCmdBindDescriptorSets vkCmdBindVertexBuffers vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearAttachments vkCmdResolveImage vkCmdWaitEvents vkCmdPipelineBarrier vkCmdPushConstants vkCmdBeginRenderPass vkCmdExecuteCommands | TBD | NA |
+| Call results, Output Parameters | Return values are checked for VK_SUCCESS, returned pointers are checked to be NON-NULL, enumerated types of return values are checked to be within the defined range. | NA | vkEnumeratePhysicalDevices vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceLimits vkGetPhysicalDeviceProperties vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceMemoryProperties vkGetDeviceQueue vkQueueSubmit vkQueueWaitIdle vkDeviceWaitIdle vkAllocMemory vkFreeMemory vkMapMemory vkUnmapMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkGetDeviceMemoryCommitment vkBindBufferMemory vkBindImageMemory vkGetBufferMemoryRequirements vkGetImageMemoryRequirements vkGetImageSparseMemoryRequirements vkGetPhysicalDeviceSparseImageFormatProperties vkQueueBindSparseBufferMemory vkQueueBindSparseImageOpaqueMemory vkQueueBindSparseImageMemory vkCreateFence vkDestroyFence vkResetFences vkGetFenceStatus vkWaitForFences vkCreateSemaphore vkDestroySemaphore vkQueueSignalSemaphore vkQueueWaitSemaphore vkCreateEvent vkDestroyEvent vkGetEventStatus vkSetEvent vkResetEvent vkCreateQueryPool vkDestroyQueryPool vkGetQueryPoolResults vkCreateBuffer vkDestroyBuffer vkCreateBufferView vkDestroyBufferView vkCreateImage vkDestroyImage vkGetImageSubresourceLayout vkCreateImageView vkDestroyImageView vkDestroyShaderModule vkCreateShader vkDestroyShader vkCreatePipelineCache vkDestroyPipelineCache vkGetPipelineCacheSize vkGetPipelineCacheData vkMergePipelineCaches vkCreateGraphicsPipelines vkCreateComputePipelines vkDestroyPipeline vkCreatePipelineLayout vkDestroyPipelineLayout vkCreateSampler vkDestroySampler vkCreateDescriptorSetLayout vkDestroyDescriptorSetLayout vkCreateDescriptorPool vkDestroyDescriptorPool vkResetDescriptorPool vkAllocDescriptorSets vkFreeDescriptorSets vkUpdateDescriptorSets vkCreateFramebuffer vkDestroyFramebuffer vkCreateRenderPass vkDestroyRenderPass vkGetRenderAreaGranularity vkCreateCommandPool vkDestroyCommandPool vkResetCommandPool vkAllocCommandBuffers vkFreeCommandBuffers vkBeginCommandBuffer vkEndCommandBuffer vkResetCommandBuffer vkCmdBindPipeline vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearAttachments vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdCopyQueryPoolResults vkCmdPushConstants vkCmdBeginRenderPass vkCmdNextSubpass vkCmdEndRenderPass vkCmdExecuteCommands | TBD | NA |
 | NA | Enum used for informational messages | NONE | | NA | None |
 
 ### ParamChecker Pending Work
@@ -220,11 +220,11 @@ The ObjectTracker layer maintains a record of all Vulkan objects. It flags error
 
 | Check | Overview | ENUM OBJTRACK_* | Relevant API | Testname | Notes/TODO |
 | ----- | -------- | ---------------- | ------------ | -------- | ---------- |
-| Valid Object | Validates that referenced object was properly created and is currently valid. | INVALID_OBJECT | vkAcquireNextImageKHR vkAllocDescriptorSets vkAllocMemory vkBeginCommandBuffer vkBindBufferMemory vkBindImageMemory vkCmdBeginQuery vkCmdBeginRenderPass vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindPipeline vkCmdBindVertexBuffers vkCmdBlitImage vkCmdClearAttachments vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdCopyBuffer vkCmdCopyBufferToImage vkCmdCopyImage vkCmdCopyImageToBuffer vkCmdCopyQueryPoolResults vkCmdDispatch vkCmdDispatchIndirect vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndexedIndirect vkCmdDrawIndirect vkCmdEndQuery vkCmdEndRenderPass vkCmdExecuteCommands vkCmdFillBuffer vkCmdNextSubpass vkCmdPipelineBarrier vkCmdPushConstants vkCmdResetEvent vkCmdResetQueryPool vkCmdResolveImage vkCmdSetEvent vkCmdUpdateBuffer vkCmdWaitEvents vkCmdWriteTimestamp vkCreateBuffer vkCreateBufferView vkCreateCommandBuffer vkCreateCommandPool vkCreateComputePipelines vkCreateDescriptorPool vkCreateDescriptorSetLayout vkCreateEvent vkCreateFence vkCreateFramebuffer vkCreateGraphicsPipelines vkCreateImage vkCreateImageView vkCreatePipelineCache vkCreatePipelineLayout vkCreateQueryPool vkCreateRenderPass vkCreateSampler vkCreateSemaphore vkCreateShader vkCreateShaderModule vkCreateSwapchainKHR vkDestroyBuffer vkDestroyBufferView vkDestroyCommandBuffer vkDestroyCommandPool vkDestroyDescriptorPool vkDestroyDescriptorSetLayout vkDestroyEvent vkDestroyFence vkDestroyFramebuffer vkDestroyImage vkDestroyImageView vkDestroyPipeline vkDestroyPipelineCache vkDestroyPipelineLayout vkDestroyQueryPool vkDestroyRenderPass vkDestroySampler vkDestroySemaphore vkDestroyShader vkDestroyShaderModule vkDestroySwapchainKHR vkDeviceWaitIdle vkEndCommandBuffer vkEnumeratePhysicalDevices vkFreeDescriptorSets vkFreeMemory vkFreeMemory vkGetBufferMemoryRequirements vkGetDeviceMemoryCommitment vkGetDeviceQueue vkGetEventStatus vkGetFenceStatus vkGetImageMemoryRequirements vkGetImageSparseMemoryRequirements vkGetImageSubresourceLayout vkGetPhysicalDeviceSurfaceSupportKHR vkGetPipelineCacheData vkGetPipelineCacheSize vkGetQueryPoolResults vkGetRenderAreaGranularity vkInvalidateMappedMemoryRanges vkMapMemory vkMergePipelineCaches vkQueueBindSparseBufferMemory vkQueueSignalSemaphore vkQueueWaitSemaphore vkResetCommandBuffer vkResetCommandPool vkResetDescriptorPool vkResetEvent vkResetFences vkSetEvent vkUnmapMemory vkUpdateDescriptorSets vkWaitForFences | BindInvalidMemory BindMemoryToDestroyedObject | Every VkObject class of parameter will be run through this check. This check may ultimately supersede UNKNOWN_OBJECT |
+| Valid Object | Validates that referenced object was properly created and is currently valid. | INVALID_OBJECT | vkAcquireNextImageKHR vkAllocDescriptorSets vkAllocMemory vkBeginCommandBuffer vkBindBufferMemory vkBindImageMemory vkCmdBeginQuery vkCmdBeginRenderPass vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindPipeline vkCmdBindVertexBuffers vkCmdBlitImage vkCmdClearAttachments vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdCopyBuffer vkCmdCopyBufferToImage vkCmdCopyImage vkCmdCopyImageToBuffer vkCmdCopyQueryPoolResults vkCmdDispatch vkCmdDispatchIndirect vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndexedIndirect vkCmdDrawIndirect vkCmdEndQuery vkCmdEndRenderPass vkCmdExecuteCommands vkCmdFillBuffer vkCmdNextSubpass vkCmdPipelineBarrier vkCmdPushConstants vkCmdResetEvent vkCmdResetQueryPool vkCmdResolveImage vkCmdSetEvent vkCmdUpdateBuffer vkCmdWaitEvents vkCmdWriteTimestamp vkCreateBuffer vkCreateBufferView vkAllocCommandBuffers vkCreateCommandPool vkCreateComputePipelines vkCreateDescriptorPool vkCreateDescriptorSetLayout vkCreateEvent vkCreateFence vkCreateFramebuffer vkCreateGraphicsPipelines vkCreateImage vkCreateImageView vkCreatePipelineCache vkCreatePipelineLayout vkCreateQueryPool vkCreateRenderPass vkCreateSampler vkCreateSemaphore vkCreateShader vkCreateShaderModule vkCreateSwapchainKHR vkDestroyBuffer vkDestroyBufferView vkFreeCommandBuffers vkDestroyCommandPool vkDestroyDescriptorPool vkDestroyDescriptorSetLayout vkDestroyEvent vkDestroyFence vkDestroyFramebuffer vkDestroyImage vkDestroyImageView vkDestroyPipeline vkDestroyPipelineCache vkDestroyPipelineLayout vkDestroyQueryPool vkDestroyRenderPass vkDestroySampler vkDestroySemaphore vkDestroyShader vkDestroyShaderModule vkDestroySwapchainKHR vkDeviceWaitIdle vkEndCommandBuffer vkEnumeratePhysicalDevices vkFreeDescriptorSets vkFreeMemory vkFreeMemory vkGetBufferMemoryRequirements vkGetDeviceMemoryCommitment vkGetDeviceQueue vkGetEventStatus vkGetFenceStatus vkGetImageMemoryRequirements vkGetImageSparseMemoryRequirements vkGetImageSubresourceLayout vkGetPhysicalDeviceSurfaceSupportKHR vkGetPipelineCacheData vkGetPipelineCacheSize vkGetQueryPoolResults vkGetRenderAreaGranularity vkInvalidateMappedMemoryRanges vkMapMemory vkMergePipelineCaches vkQueueBindSparseBufferMemory vkQueueSignalSemaphore vkQueueWaitSemaphore vkResetCommandBuffer vkResetCommandPool vkResetDescriptorPool vkResetEvent vkResetFences vkSetEvent vkUnmapMemory vkUpdateDescriptorSets vkWaitForFences | BindInvalidMemory BindMemoryToDestroyedObject | Every VkObject class of parameter will be run through this check. This check may ultimately supersede UNKNOWN_OBJECT |
 | Object Cleanup | Verify that object properly destroyed | DESTROY_OBJECT_FAILED | vkDestroyInstance, vkDestroyDevice, vkFreeMemory | ? | NA |
 | Objects Leak | When an Instance or Device object is destroyed, validates that all objects belonging to that device/instance have previously been destroyed | OBJECT_LEAK | vkDestroyDevice vkDestroyInstance | ? | NA |
 | Object Count | Flag error if number of objects requested from extenstion functions exceeds max number of actual objects | OBJCOUNT_MAX_EXCEEDED | objTrackGetObjects objTrackGetObjectsOfType | ? | NA |
-| Valid Destroy Object | Validates that an object pass into a destroy function was properly created and is currently valid | NONE | vkDestroyInstance vkDestroyDevice vkDestroyFence vkDestroySemaphore vkDestroyEvent vkDestroyQueryPool vkDestroyBuffer vkDestroyBufferView vkDestroyImage vkDestroyImageView vkDestroyShaderModule vkDestroyShader vkDestroyPipelineCache vkDestroyPipeline vkDestroyPipelineLayout vkDestroySampler vkDestroyDescriptorSetLayout vkDestroyDescriptorPool vkDestroyCommandPool vkDestroyCommandBuffer vkDestroyFramebuffer vkDestroyRenderPass vkDestroySwapchainKHR | TBD | These cases need to be moved to a more appropriate error enum |
+| Valid Destroy Object | Validates that an object pass into a destroy function was properly created and is currently valid | NONE | vkDestroyInstance vkDestroyDevice vkDestroyFence vkDestroySemaphore vkDestroyEvent vkDestroyQueryPool vkDestroyBuffer vkDestroyBufferView vkDestroyImage vkDestroyImageView vkDestroyShaderModule vkDestroyShader vkDestroyPipelineCache vkDestroyPipeline vkDestroyPipelineLayout vkDestroySampler vkDestroyDescriptorSetLayout vkDestroyDescriptorPool vkDestroyCommandPool vkFreeCommandBuffers vkDestroyFramebuffer vkDestroyRenderPass vkDestroySwapchainKHR | TBD | These cases need to be moved to a more appropriate error enum |
 | Unknown object  | Internal layer errors when it attempts to update use count for an object that's not in its internal tracking datastructures. | UNKNOWN_OBJECT | | NA | This may be irrelevant due to INVALID_OBJECT error, need to look closely and merge this with that error as appropriate. |
 | NA | Enum used for informational messages | NONE | | NA | None |
 | NA | Enum used for errors in the layer itself. This does not indicate an app issue, but instead a bug in the layer. | INTERNAL_ERROR | | NA | None |
@@ -267,8 +267,8 @@ It cannot insure that there is no latent race condition.
 
 | Check | Overview | ENUM THREADING_CHECKER_* | Relevant API | Testname | Notes/TODO |
 | ----- | -------- | ---------------- | ---------------- | -------- | ---------- |
-| Thread Collision | Detects and notifies user if multiple threads are modifying thes same object | MULTIPLE_THREADS | vkQueueSubmit vkFreeMemory vkMapMemory vkUnmapMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkBindBufferMemory vkBindImageMemory vkQueueBindSparseBufferMemory vkQueueBindSparseImageOpaqueMemory vkQueueBindSparseImageMemory vkDestroySemaphore vkQueueSignalSemaphore vkDestroyBuffer vkDestroyImage vkDestroyDescriptorPool vkResetDescriptorPool vkAllocDescriptorSets vkFreeDescriptorSets vkDestroyCommandBuffer vkBeginCommandBuffer vkEndCommandBuffer vkResetCommandBuffer vkCmdBindPipeline vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearAttachments vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdCopyQueryPoolResults vkCmdBeginRenderPass vkCmdNextSubpass vkCmdPushConstants vkCmdEndRenderPass vkCmdExecuteCommands | ??? | NA |
-| Thread Reentrancy | Detects cases of a single thread calling Vulkan reentrantly | SINGLE_THREAD_REUSE | vkQueueSubmit vkFreeMemory vkMapMemory vkUnmapMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkBindBufferMemory vkBindImageMemory vkQueueBindSparseBufferMemory vkQueueBindSparseImageOpaqueMemory vkQueueBindSparseImageMemory vkDestroySemaphore vkQueueSignalSemaphore vkDestroyBuffer vkDestroyImage vkDestroyDescriptorPool vkResetDescriptorPool vkAllocDescriptorSets vkFreeDescriptorSets vkDestroyCommandBuffer vkBeginCommandBuffer vkEndCommandBuffer vkResetCommandBuffer vkCmdBindPipeline vkCmdSetViewport vkCmdSetBlendConstants vkCmdSetLineWidth vkCmdSetDepthBias vkCmdSetDepthBounds vkCmdSetStencilCompareMask vkCmdSetStencilWriteMask vkCmdSetStencilReference vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearAttachments vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdCopyQueryPoolResults vkCmdBeginRenderPass vkCmdNextSubpass vkCmdPushConstants vkCmdEndRenderPass vkCmdExecuteCommands | ??? | NA |
+| Thread Collision | Detects and notifies user if multiple threads are modifying thes same object | MULTIPLE_THREADS | vkQueueSubmit vkFreeMemory vkMapMemory vkUnmapMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkBindBufferMemory vkBindImageMemory vkQueueBindSparseBufferMemory vkQueueBindSparseImageOpaqueMemory vkQueueBindSparseImageMemory vkDestroySemaphore vkQueueSignalSemaphore vkDestroyBuffer vkDestroyImage vkDestroyDescriptorPool vkResetDescriptorPool vkAllocDescriptorSets vkFreeDescriptorSets vkFreeCommandBuffers vkBeginCommandBuffer vkEndCommandBuffer vkResetCommandBuffer vkCmdBindPipeline vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearAttachments vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdCopyQueryPoolResults vkCmdBeginRenderPass vkCmdNextSubpass vkCmdPushConstants vkCmdEndRenderPass vkCmdExecuteCommands | ??? | NA |
+| Thread Reentrancy | Detects cases of a single thread calling Vulkan reentrantly | SINGLE_THREAD_REUSE | vkQueueSubmit vkFreeMemory vkMapMemory vkUnmapMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkBindBufferMemory vkBindImageMemory vkQueueBindSparseBufferMemory vkQueueBindSparseImageOpaqueMemory vkQueueBindSparseImageMemory vkDestroySemaphore vkQueueSignalSemaphore vkDestroyBuffer vkDestroyImage vkDestroyDescriptorPool vkResetDescriptorPool vkAllocDescriptorSets vkFreeDescriptorSets vkFreeCommandBuffers vkBeginCommandBuffer vkEndCommandBuffer vkResetCommandBuffer vkCmdBindPipeline vkCmdSetViewport vkCmdSetBlendConstants vkCmdSetLineWidth vkCmdSetDepthBias vkCmdSetDepthBounds vkCmdSetStencilCompareMask vkCmdSetStencilWriteMask vkCmdSetStencilReference vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearAttachments vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdCopyQueryPoolResults vkCmdBeginRenderPass vkCmdNextSubpass vkCmdPushConstants vkCmdEndRenderPass vkCmdExecuteCommands | ??? | NA |
 | NA | Enum used for informational messages | NONE | | NA | None |
 
 ### Threading Pending Work
diff --git a/loader/gpa_helper.h b/loader/gpa_helper.h
index d462694a..11de1aa4 100644
--- a/loader/gpa_helper.h
+++ b/loader/gpa_helper.h
@@ -221,10 +221,10 @@ static inline void* globalGetProcAddr(const char *name)
         return (void*) vkDestroyCommandPool;
     if (!strcmp(name, "ResetCommandPool"))
         return (void*) vkResetCommandPool;
-    if (!strcmp(name, "CreateCommandBuffer"))
-        return (void*) vkCreateCommandBuffer;
-    if (!strcmp(name, "DestroyCommandBuffer"))
-        return (void*) vkDestroyCommandBuffer;
+    if (!strcmp(name, "AllocCommandBuffers"))
+        return (void*) vkAllocCommandBuffers;
+    if (!strcmp(name, "FreeCommandBuffers"))
+        return (void*) vkFreeCommandBuffers;
     if (!strcmp(name, "BeginCommandBuffer"))
         return (void*) vkBeginCommandBuffer;
     if (!strcmp(name, "EndCommandBuffer"))
@@ -366,8 +366,8 @@ static inline void *loader_non_passthrough_gdpa(const char *name)
         return (void*) vkDestroyDevice;
     if (!strcmp(name, "GetDeviceQueue"))
         return (void*) vkGetDeviceQueue;
-    if (!strcmp(name, "CreateCommandBuffer"))
-        return (void*) vkCreateCommandBuffer;
+    if (!strcmp(name, "AllocCommandBuffers"))
+        return (void*) vkAllocCommandBuffers;
 
     return NULL;
 }
diff --git a/loader/table_ops.h b/loader/table_ops.h
index a10fe8a1..6edb7496 100644
--- a/loader/table_ops.h
+++ b/loader/table_ops.h
@@ -116,8 +116,8 @@ static inline void loader_init_device_dispatch_table(VkLayerDispatchTable *table
     table->CreateCommandPool = (PFN_vkCreateCommandPool) gpa(dev, "vkCreateCommandPool");
     table->DestroyCommandPool = (PFN_vkDestroyCommandPool) gpa(dev, "vkDestroyCommandPool");
     table->ResetCommandPool = (PFN_vkResetCommandPool) gpa(dev, "vkResetCommandPool");
-    table->CreateCommandBuffer = (PFN_vkCreateCommandBuffer) gpa(dev, "vkCreateCommandBuffer");
-    table->DestroyCommandBuffer = (PFN_vkDestroyCommandBuffer) gpa(dev, "vkDestroyCommandBuffer");
+    table->AllocCommandBuffers = (PFN_vkAllocCommandBuffers) gpa(dev, "vkAllocCommandBuffers");
+    table->FreeCommandBuffers = (PFN_vkFreeCommandBuffers) gpa(dev, "vkFreeCommandBuffers");
     table->BeginCommandBuffer = (PFN_vkBeginCommandBuffer) gpa(dev, "vkBeginCommandBuffer");
     table->EndCommandBuffer = (PFN_vkEndCommandBuffer) gpa(dev, "vkEndCommandBuffer");
     table->ResetCommandBuffer = (PFN_vkResetCommandBuffer) gpa(dev, "vkResetCommandBuffer");
@@ -346,10 +346,10 @@ static inline void *loader_lookup_device_dispatch_table(
         return (void *) table->DestroyCommandPool;
     if (!strcmp(name, "ResetCommandPool"))
         return (void *) table->ResetCommandPool;
-    if (!strcmp(name, "CreateCommandBuffer"))
-        return (void *) table->CreateCommandBuffer;
-    if (!strcmp(name, "DestroyCommandBuffer"))
-        return (void *) table->DestroyCommandBuffer;
+    if (!strcmp(name, "AllocCommandBuffers"))
+        return (void *) table->AllocCommandBuffers;
+    if (!strcmp(name, "FreeCommandBuffers"))
+        return (void *) table->FreeCommandBuffers;
     if (!strcmp(name, "BeginCommandBuffer"))
         return (void *) table->BeginCommandBuffer;
     if (!strcmp(name, "EndCommandBuffer"))
diff --git a/loader/trampoline.c b/loader/trampoline.c
index a2f5d1a5..012473d1 100644
--- a/loader/trampoline.c
+++ b/loader/trampoline.c
@@ -929,22 +929,22 @@ LOADER_EXPORT void VKAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPo
 }
 
 
-LOADER_EXPORT VkResult VKAPI vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool)
+LOADER_EXPORT VkResult VKAPI vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->ResetDescriptorPool(device, descriptorPool);
+    return disp->ResetDescriptorPool(device, descriptorPool, flags);
 }
 
-LOADER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets)
+LOADER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDevice device, const VkDescriptorSetAllocInfo* pAllocInfo, VkDescriptorSet* pDescriptorSets)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->AllocDescriptorSets(device, descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets);
+    return disp->AllocDescriptorSets(device, pAllocInfo, pDescriptorSets);
 }
 
 LOADER_EXPORT VkResult VKAPI vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets)
@@ -1037,28 +1037,39 @@ LOADER_EXPORT VkResult VKAPI vkResetCommandPool(VkDevice device, VkCmdPool cmdPo
     return disp->ResetCommandPool(device, cmdPool, flags);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateCommandBuffer(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer)
+LOADER_EXPORT VkResult VKAPI vkAllocCommandBuffers(
+        VkDevice device,
+        const VkCmdBufferAllocInfo* pAllocInfo,
+        VkCmdBuffer* pCmdBuffers)
 {
     const VkLayerDispatchTable *disp;
     VkResult res;
 
     disp = loader_get_dispatch(device);
 
-    res = disp->CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
+    res = disp->AllocCommandBuffers(device, pAllocInfo, pCmdBuffers);
     if (res == VK_SUCCESS) {
-        loader_init_dispatch(*pCmdBuffer, disp);
+        for (uint32_t i =0; i < pAllocInfo->count; i++) {
+            if (pCmdBuffers[i]) {
+                loader_init_dispatch(pCmdBuffers[i], disp);
+            }
+        }
     }
 
     return res;
 }
 
-LOADER_EXPORT void VKAPI vkDestroyCommandBuffer(VkDevice device, VkCmdBuffer cmdBuffer)
+LOADER_EXPORT void VKAPI vkFreeCommandBuffers(
+        VkDevice                                device,
+        VkCmdPool                               cmdPool,
+        uint32_t                                count,
+        const VkCmdBuffer*                      pCommandBuffers)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    disp->DestroyCommandBuffer(device, cmdBuffer);
+    disp->FreeCommandBuffers(device, cmdPool, count, pCommandBuffers);
 }
 
 LOADER_EXPORT VkResult VKAPI vkBeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo)
diff --git a/loader/vk-loader-generate.py b/loader/vk-loader-generate.py
index b51c6e4a..6439703e 100755
--- a/loader/vk-loader-generate.py
+++ b/loader/vk-loader-generate.py
@@ -49,7 +49,7 @@ class Subcommand(object):
         # Dont be cute trying to use a general rule to programmatically populate this list
         # it just obsfucates what is going on!
         wsi_creates_dispatchable_object = ["CreateSwapchainKHR"]
-        creates_dispatchable_object = ["CreateDevice", "GetDeviceQueue", "CreateCommandBuffer"] + wsi_creates_dispatchable_object
+        creates_dispatchable_object = ["CreateDevice", "GetDeviceQueue", "AllocCommandBuffers"] + wsi_creates_dispatchable_object
         if name in creates_dispatchable_object:
             return True
         else:
diff --git a/vk-layer-generate.py b/vk-layer-generate.py
index a846892e..f02b7acf 100755
--- a/vk-layer-generate.py
+++ b/vk-layer-generate.py
@@ -1625,13 +1625,18 @@ class ObjectTrackerSubcommand(Subcommand):
                 create_line += '        create_obj(%s, *%s, %s);\n' % (param0_name, proto.params[-1].name, obj_type_mapping[proto.params[-1].ty.strip('*').replace('const ', '')])
                 create_line += '    }\n'
                 create_line += '    loader_platform_thread_unlock_mutex(&objLock);\n'
+            if 'FreeCommandBuffers' in proto.name:
+                funcs.append('%s\n' % self.lineinfo.get())
+                destroy_line =  '    loader_platform_thread_lock_mutex(&objLock);\n'
+                destroy_line += '    for (uint32_t i = 0; i < count; i++) {\n'
+                destroy_line += '        destroy_obj(%s[i], %s[i]);\n' % (proto.params[-1].name, proto.params[-1].name)
+                destroy_line += '    }\n'
+                destroy_line += '    loader_platform_thread_unlock_mutex(&objLock);\n'
             if 'Destroy' in proto.name:
+                funcs.append('%s\n' % self.lineinfo.get())
                 destroy_line =  '    loader_platform_thread_lock_mutex(&objLock);\n'
 #                destroy_line += '    if (result == VK_SUCCESS) {\n'
-                if 'DestroyCommandBuffer' in proto.name:
-                    destroy_line += '    destroy_obj(%s, %s);\n' % (proto.params[-1].name, proto.params[-1].name)
-                else:
-                    destroy_line += '    destroy_obj(%s, %s);\n' % (param0_name, proto.params[-1].name)
+                destroy_line += '    destroy_obj(%s, %s);\n' % (param0_name, proto.params[-1].name)
 #                destroy_line += '    }\n'
                 destroy_line += '    loader_platform_thread_unlock_mutex(&objLock);\n'
             if len(loop_params) > 0:
diff --git a/vulkan.py b/vulkan.py
index 3a690a48..3581d30e 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -622,14 +622,12 @@ core = Extension(
 
         Proto("VkResult", "ResetDescriptorPool",
             [Param("VkDevice", "device"),
-             Param("VkDescriptorPool", "descriptorPool")]),
+             Param("VkDescriptorPool", "descriptorPool"),
+             Param("VkDescriptorPoolResetFlags", "flags")]),
 
         Proto("VkResult", "AllocDescriptorSets",
             [Param("VkDevice", "device"),
-             Param("VkDescriptorPool", "descriptorPool"),
-             Param("VkDescriptorSetUsage", "setUsage"),
-             Param("uint32_t", "count"),
-             Param("const VkDescriptorSetLayout*", "pSetLayouts"),
+             Param("const VkDescriptorSetAllocInfo*", "pAllocInfo"),
              Param("VkDescriptorSet*", "pDescriptorSets")]),
 
         Proto("VkResult", "FreeDescriptorSets",
@@ -659,14 +657,16 @@ core = Extension(
              Param("VkCmdPool", "cmdPool"),
              Param("VkCmdPoolResetFlags", "flags")]),
 
-        Proto("VkResult", "CreateCommandBuffer",
+        Proto("VkResult", "AllocCommandBuffers",
             [Param("VkDevice", "device"),
-             Param("const VkCmdBufferCreateInfo*", "pCreateInfo"),
-             Param("VkCmdBuffer*", "pCmdBuffer")]),
+             Param("const VkCmdBufferAllocInfo*", "pAllocInfo"),
+             Param("VkCmdBuffer*", "pCmdBuffers")]),
 
-        Proto("void", "DestroyCommandBuffer",
+        Proto("void", "FreeCommandBuffers",
             [Param("VkDevice", "device"),
-             Param("VkCmdBuffer", "commandBuffer")]),
+             Param("VkCmdPool", "cmdPool"),
+             Param("uint32_t", "count"),
+             Param("const VkCmdBuffer*", "pCommandBuffers")]),
 
         Proto("VkResult", "BeginCommandBuffer",
             [Param("VkCmdBuffer", "cmdBuffer"),