diff --git a/demos/cube.c b/demos/cube.c
index 77a9410..2880cf9 100644
--- a/demos/cube.c
+++ b/demos/cube.c
@@ -637,6 +637,7 @@
 
     err = vkCreateSemaphore(demo->device,
                             &presentCompleteSemaphoreCreateInfo,
+                            NULL,
                             &presentCompleteSemaphore);
     assert(!err);
 
@@ -650,7 +651,7 @@
         // must be recreated:
         demo_resize(demo);
         demo_draw(demo);
-        vkDestroySemaphore(demo->device, presentCompleteSemaphore);
+        vkDestroySemaphore(demo->device, presentCompleteSemaphore, NULL);
         return;
     } else if (err == VK_SUBOPTIMAL_KHR) {
         // demo->swapchain is not as optimal as it could be, but the platform's
@@ -711,7 +712,7 @@
     err = vkQueueWaitIdle(demo->queue);
     assert(err == VK_SUCCESS);
 
-    vkDestroySemaphore(demo->device, presentCompleteSemaphore);
+    vkDestroySemaphore(demo->device, presentCompleteSemaphore, NULL);
 }
 
 static void demo_prepare_buffers(struct demo *demo)
@@ -873,7 +874,7 @@
         color_image_view.image = demo->buffers[i].image;
 
         err = vkCreateImageView(demo->device,
-                &color_image_view, &demo->buffers[i].view);
+                &color_image_view, NULL, &demo->buffers[i].view);
         assert(!err);
     }
 }
@@ -918,7 +919,7 @@
     demo->depth.format = depth_format;
 
     /* create image */
-    err = vkCreateImage(demo->device, &image,
+    err = vkCreateImage(demo->device, &image, NULL,
             &demo->depth.image);
     assert(!err);
 
@@ -938,7 +939,8 @@
     assert(pass);
 
     /* allocate memory */
-    err = vkAllocMemory(demo->device, &demo->depth.mem_alloc, &demo->depth.mem);
+    err = vkAllocMemory(demo->device, &demo->depth.mem_alloc,
+            NULL, &demo->depth.mem);
     assert(!err);
 
     /* bind memory */
@@ -953,7 +955,7 @@
 
     /* create image view */
     view.image = demo->depth.image;
-    err = vkCreateImageView(demo->device, &view, &demo->depth.view);
+    err = vkCreateImageView(demo->device, &view, NULL, &demo->depth.view);
     assert(!err);
 }
 
@@ -1047,7 +1049,7 @@
 
     VkMemoryRequirements mem_reqs;
 
-    err = vkCreateImage(demo->device, &image_create_info,
+    err = vkCreateImage(demo->device, &image_create_info, NULL,
             &tex_obj->image);
     assert(!err);
 
@@ -1062,7 +1064,7 @@
     assert(pass);
 
     /* allocate memory */
-    err = vkAllocMemory(demo->device, &tex_obj->mem_alloc,
+    err = vkAllocMemory(demo->device, &tex_obj->mem_alloc, NULL,
                 &(tex_obj->mem));
     assert(!err);
 
@@ -1103,8 +1105,8 @@
 static void demo_destroy_texture_image(struct demo *demo, struct texture_object *tex_objs)
 {
     /* clean up staging resources */
-    vkFreeMemory(demo->device, tex_objs->mem);
-    vkDestroyImage(demo->device, tex_objs->image);
+    vkFreeMemory(demo->device, tex_objs->mem, NULL);
+    vkDestroyImage(demo->device, tex_objs->image, NULL);
 }
 
 static void demo_prepare_textures(struct demo *demo)
@@ -1203,13 +1205,13 @@
         };
 
         /* create sampler */
-        err = vkCreateSampler(demo->device, &sampler,
+        err = vkCreateSampler(demo->device, &sampler, NULL,
                 &demo->textures[i].sampler);
         assert(!err);
 
         /* create image view */
         view.image = demo->textures[i].image;
-        err = vkCreateImageView(demo->device, &view,
+        err = vkCreateImageView(demo->device, &view, NULL,
                 &demo->textures[i].view);
         assert(!err);
     }
@@ -1246,7 +1248,8 @@
     buf_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
     buf_info.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
     buf_info.size = sizeof(data);
-    err = vkCreateBuffer(demo->device, &buf_info, &demo->uniform_data.buf);
+    err = vkCreateBuffer(demo->device, &buf_info, NULL,
+            &demo->uniform_data.buf);
     assert(!err);
 
     vkGetBufferMemoryRequirements(demo->device, demo->uniform_data.buf, &mem_reqs);
@@ -1262,7 +1265,8 @@
                                       &demo->uniform_data.mem_alloc.memoryTypeIndex);
     assert(pass);
 
-    err = vkAllocMemory(demo->device, &demo->uniform_data.mem_alloc, &(demo->uniform_data.mem));
+    err = vkAllocMemory(demo->device, &demo->uniform_data.mem_alloc,
+            NULL, &(demo->uniform_data.mem));
     assert(!err);
 
     err = vkMapMemory(demo->device, demo->uniform_data.mem, 0, demo->uniform_data.mem_alloc.allocationSize, 0, (void **) &pData);
@@ -1307,7 +1311,7 @@
     VkResult U_ASSERT_ONLY err;
 
     err = vkCreateDescriptorSetLayout(demo->device,
-            &descriptor_layout, &demo->desc_layout);
+            &descriptor_layout, NULL, &demo->desc_layout);
     assert(!err);
 
     const VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo = {
@@ -1319,6 +1323,7 @@
 
     err = vkCreatePipelineLayout(demo->device,
                                  &pPipelineLayoutCreateInfo,
+                                 NULL,
                                  &demo->pipeline_layout);
     assert(!err);
 }
@@ -1384,7 +1389,7 @@
     };
     VkResult U_ASSERT_ONLY err;
 
-    err = vkCreateRenderPass(demo->device, &rp_info, &demo->render_pass);
+    err = vkCreateRenderPass(demo->device, &rp_info, NULL, &demo->render_pass);
     assert(!err);
 }
 
@@ -1411,14 +1416,14 @@
         moduleCreateInfo.codeSize = size;
         moduleCreateInfo.pCode = code;
         moduleCreateInfo.flags = 0;
-        err = vkCreateShaderModule(demo->device, &moduleCreateInfo, pShaderModule);
+        err = vkCreateShaderModule(demo->device, &moduleCreateInfo, NULL, pShaderModule);
         assert(!err);
 
         shaderCreateInfo.flags = 0;
         shaderCreateInfo.module = *pShaderModule;
         shaderCreateInfo.pName = "main";
         shaderCreateInfo.stage = stage;
-        err = vkCreateShader(demo->device, &shaderCreateInfo, &shader);
+        err = vkCreateShader(demo->device, &shaderCreateInfo, NULL, &shader);
         assert(!err);
     } else {
         // Create fake SPV structure to feed GLSL
@@ -1433,7 +1438,7 @@
         ((uint32_t *) moduleCreateInfo.pCode)[2] = stage;
         memcpy(((uint32_t *) moduleCreateInfo.pCode + 3), code, size + 1);
 
-        err = vkCreateShaderModule(demo->device, &moduleCreateInfo, pShaderModule);
+        err = vkCreateShaderModule(demo->device, &moduleCreateInfo, NULL, pShaderModule);
         if (err) {
             free((void *) moduleCreateInfo.pCode);
         }
@@ -1442,7 +1447,7 @@
         shaderCreateInfo.module = *pShaderModule;
         shaderCreateInfo.pName = "main";
         shaderCreateInfo.stage = stage;
-        err = vkCreateShader(demo->device, &shaderCreateInfo, &shader);
+        err = vkCreateShader(demo->device, &shaderCreateInfo, NULL, &shader);
         assert(!err);
         free((void *) moduleCreateInfo.pCode);
     }
@@ -1635,7 +1640,7 @@
     memset(&pipelineCache, 0, sizeof(pipelineCache));
     pipelineCache.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
 
-    err = vkCreatePipelineCache(demo->device, &pipelineCache, &demo->pipelineCache);
+    err = vkCreatePipelineCache(demo->device, &pipelineCache, NULL, &demo->pipelineCache);
     assert(!err);
 
     pipeline.pVertexInputState   = &vi;
@@ -1651,14 +1656,15 @@
 
     pipeline.renderPass = demo->render_pass;
 
-    err = vkCreateGraphicsPipelines(demo->device, demo->pipelineCache, 1, &pipeline, &demo->pipeline);
+    err = vkCreateGraphicsPipelines(demo->device, demo->pipelineCache,
+            1, &pipeline, NULL, &demo->pipeline);
     assert(!err);
 
     for (uint32_t i = 0; i < pipeline.stageCount; i++) {
-        vkDestroyShader(demo->device, shaderStages[i].shader);
+        vkDestroyShader(demo->device, shaderStages[i].shader, NULL);
     }
-    vkDestroyShaderModule(demo->device, demo->frag_shader_module);
-    vkDestroyShaderModule(demo->device, demo->vert_shader_module);
+    vkDestroyShaderModule(demo->device, demo->frag_shader_module, NULL);
+    vkDestroyShaderModule(demo->device, demo->vert_shader_module, NULL);
 }
 
 static void demo_prepare_descriptor_pool(struct demo *demo)
@@ -1683,7 +1689,7 @@
     VkResult U_ASSERT_ONLY err;
 
     err = vkCreateDescriptorPool(demo->device,
-            &descriptor_pool, &demo->desc_pool);
+            &descriptor_pool, NULL, &demo->desc_pool);
     assert(!err);
 }
 
@@ -1752,7 +1758,7 @@
 
     for (i = 0; i < demo->swapchainImageCount; i++) {
         attachments[0] = demo->buffers[i].view;
-        err = vkCreateFramebuffer(demo->device, &fb_info, &demo->framebuffers[i]);
+        err = vkCreateFramebuffer(demo->device, &fb_info, NULL, &demo->framebuffers[i]);
         assert(!err);
     }
 }
@@ -1767,7 +1773,7 @@
         .queueFamilyIndex = demo->graphics_queue_node_index,
         .flags = 0,
     };
-    err = vkCreateCommandPool(demo->device, &cmd_pool_info, &demo->cmd_pool);
+    err = vkCreateCommandPool(demo->device, &cmd_pool_info, NULL, &demo->cmd_pool);
     assert(!err);
 
     const VkCmdBufferAllocInfo cmd = {
@@ -1819,46 +1825,46 @@
     demo->prepared = false;
 
     for (i = 0; i < demo->swapchainImageCount; i++) {
-        vkDestroyFramebuffer(demo->device, demo->framebuffers[i]);
+        vkDestroyFramebuffer(demo->device, demo->framebuffers[i], NULL);
     }
     free(demo->framebuffers);
-    vkDestroyDescriptorPool(demo->device, demo->desc_pool);
+    vkDestroyDescriptorPool(demo->device, demo->desc_pool, NULL);
 
-    vkDestroyPipeline(demo->device, demo->pipeline);
-    vkDestroyPipelineCache(demo->device, demo->pipelineCache);
-    vkDestroyRenderPass(demo->device, demo->render_pass);
-    vkDestroyPipelineLayout(demo->device, demo->pipeline_layout);
-    vkDestroyDescriptorSetLayout(demo->device, demo->desc_layout);
+    vkDestroyPipeline(demo->device, demo->pipeline, NULL);
+    vkDestroyPipelineCache(demo->device, demo->pipelineCache, NULL);
+    vkDestroyRenderPass(demo->device, demo->render_pass, NULL);
+    vkDestroyPipelineLayout(demo->device, demo->pipeline_layout, NULL);
+    vkDestroyDescriptorSetLayout(demo->device, demo->desc_layout, NULL);
 
     for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
-        vkDestroyImageView(demo->device, demo->textures[i].view);
-        vkDestroyImage(demo->device, demo->textures[i].image);
-        vkFreeMemory(demo->device, demo->textures[i].mem);
-        vkDestroySampler(demo->device, demo->textures[i].sampler);
+        vkDestroyImageView(demo->device, demo->textures[i].view, NULL);
+        vkDestroyImage(demo->device, demo->textures[i].image, NULL);
+        vkFreeMemory(demo->device, demo->textures[i].mem, NULL);
+        vkDestroySampler(demo->device, demo->textures[i].sampler, NULL);
     }
     demo->fpDestroySwapchainKHR(demo->device, demo->swapchain);
 
-    vkDestroyImageView(demo->device, demo->depth.view);
-    vkDestroyImage(demo->device, demo->depth.image);
-    vkFreeMemory(demo->device, demo->depth.mem);
+    vkDestroyImageView(demo->device, demo->depth.view, NULL);
+    vkDestroyImage(demo->device, demo->depth.image, NULL);
+    vkFreeMemory(demo->device, demo->depth.mem, NULL);
 
-    vkDestroyBuffer(demo->device, demo->uniform_data.buf);
-    vkFreeMemory(demo->device, demo->uniform_data.mem);
+    vkDestroyBuffer(demo->device, demo->uniform_data.buf, NULL);
+    vkFreeMemory(demo->device, demo->uniform_data.mem, NULL);
 
     for (i = 0; i < demo->swapchainImageCount; i++) {
-        vkDestroyImageView(demo->device, demo->buffers[i].view);
+        vkDestroyImageView(demo->device, demo->buffers[i].view, NULL);
         vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, &demo->buffers[i].cmd);
     }
     free(demo->buffers);
 
     free(demo->queue_props);
 
-    vkDestroyCommandPool(demo->device, demo->cmd_pool);
-    vkDestroyDevice(demo->device);
+    vkDestroyCommandPool(demo->device, demo->cmd_pool, NULL);
+    vkDestroyDevice(demo->device, NULL);
     if (demo->validate) {
         demo->dbgDestroyMsgCallback(demo->inst, demo->msg_callback);
     }
-    vkDestroyInstance(demo->inst);
+    vkDestroyInstance(demo->inst, NULL);
 
 #ifndef _WIN32
     xcb_destroy_window(demo->connection, demo->window);
@@ -1882,39 +1888,39 @@
     demo->prepared = false;
 
     for (i = 0; i < demo->swapchainImageCount; i++) {
-        vkDestroyFramebuffer(demo->device, demo->framebuffers[i]);
+        vkDestroyFramebuffer(demo->device, demo->framebuffers[i], NULL);
     }
     free(demo->framebuffers);
-    vkDestroyDescriptorPool(demo->device, demo->desc_pool);
+    vkDestroyDescriptorPool(demo->device, demo->desc_pool, NULL);
 
-    vkDestroyPipeline(demo->device, demo->pipeline);
-    vkDestroyPipelineCache(demo->device, demo->pipelineCache);
-    vkDestroyRenderPass(demo->device, demo->render_pass);
-    vkDestroyPipelineLayout(demo->device, demo->pipeline_layout);
-    vkDestroyDescriptorSetLayout(demo->device, demo->desc_layout);
+    vkDestroyPipeline(demo->device, demo->pipeline, NULL);
+    vkDestroyPipelineCache(demo->device, demo->pipelineCache, NULL);
+    vkDestroyRenderPass(demo->device, demo->render_pass, NULL);
+    vkDestroyPipelineLayout(demo->device, demo->pipeline_layout, NULL);
+    vkDestroyDescriptorSetLayout(demo->device, demo->desc_layout, NULL);
 
     for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
-        vkDestroyImageView(demo->device, demo->textures[i].view);
-        vkDestroyImage(demo->device, demo->textures[i].image);
-        vkFreeMemory(demo->device, demo->textures[i].mem);
-        vkDestroySampler(demo->device, demo->textures[i].sampler);
+        vkDestroyImageView(demo->device, demo->textures[i].view, NULL);
+        vkDestroyImage(demo->device, demo->textures[i].image, NULL);
+        vkFreeMemory(demo->device, demo->textures[i].mem, NULL);
+        vkDestroySampler(demo->device, demo->textures[i].sampler, NULL);
     }
 
-    vkDestroyImageView(demo->device, demo->depth.view);
-    vkDestroyImage(demo->device, demo->depth.image);
-    vkFreeMemory(demo->device, demo->depth.mem);
+    vkDestroyImageView(demo->device, demo->depth.view, NULL);
+    vkDestroyImage(demo->device, demo->depth.image, NULL);
+    vkFreeMemory(demo->device, demo->depth.mem, NULL);
 
-    vkDestroyBuffer(demo->device, demo->uniform_data.buf);
-    vkFreeMemory(demo->device, demo->uniform_data.mem);
+    vkDestroyBuffer(demo->device, demo->uniform_data.buf, NULL);
+    vkFreeMemory(demo->device, demo->uniform_data.mem, NULL);
 
     for (i = 0; i < demo->swapchainImageCount; i++) {
-        vkDestroyImageView(demo->device, demo->buffers[i].view);
+        vkDestroyImageView(demo->device, demo->buffers[i].view, NULL);
         vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, &demo->buffers[i].cmd);
     }
-    vkDestroyCommandPool(demo->device, demo->cmd_pool);
+    vkDestroyCommandPool(demo->device, demo->cmd_pool, NULL);
     free(demo->buffers);
 
-    vkDestroyCommandPool(demo->device, demo->cmd_pool);
+    vkDestroyCommandPool(demo->device, demo->cmd_pool, NULL);
 
 
     // Second, re-perform the demo_prepare() function, which will re-create the
@@ -2268,7 +2274,6 @@
         .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
         .pNext = NULL,
         .pAppInfo = &app,
-        .pAllocCb = NULL,
         .enabledLayerNameCount = enabled_layer_count,
         .ppEnabledLayerNames = (const char *const*) ((demo->validate) ? instance_validation_layers : NULL),
         .enabledExtensionNameCount = enabled_extension_count,
@@ -2277,7 +2282,7 @@
 
     uint32_t gpu_count;
 
-    err = vkCreateInstance(&inst_info, &demo->inst);
+    err = vkCreateInstance(&inst_info, NULL, &demo->inst);
     if (err == VK_ERROR_INCOMPATIBLE_DRIVER) {
         ERR_EXIT("Cannot find a compatible Vulkan installable client driver "
                  "(ICD).\n\nPlease look at the Getting Started guide for "
@@ -2444,7 +2449,7 @@
         .pEnabledFeatures = NULL, // If specific features are required, pass them in here
     };
 
-    err = vkCreateDevice(demo->gpu, &device, &demo->device);
+    err = vkCreateDevice(demo->gpu, &device, NULL, &demo->device);
     assert(!err);
 
     free(device_layers);
diff --git a/demos/tri.c b/demos/tri.c
index 83f99b7..bd4f8eb 100644
--- a/demos/tri.c
+++ b/demos/tri.c
@@ -169,6 +169,8 @@
     bool use_staging_buffer;
     bool use_glsl;
 
+    VkAllocCallbacks allocator;
+
     VkInstance inst;
     VkPhysicalDevice gpu;
     VkDevice device;
@@ -454,6 +456,7 @@
 
     err = vkCreateSemaphore(demo->device,
                             &presentCompleteSemaphoreCreateInfo,
+                            NULL,
                             &presentCompleteSemaphore);
     assert(!err);
 
@@ -467,7 +470,7 @@
         // must be recreated:
         demo_resize(demo);
         demo_draw(demo);
-        vkDestroySemaphore(demo->device, presentCompleteSemaphore);
+        vkDestroySemaphore(demo->device, presentCompleteSemaphore, NULL);
         return;
     } else if (err == VK_SUBOPTIMAL_KHR) {
         // demo->swapchain is not as optimal as it could be, but the platform's
@@ -531,7 +534,7 @@
     err = vkQueueWaitIdle(demo->queue);
     assert(err == VK_SUCCESS);
 
-    vkDestroySemaphore(demo->device, presentCompleteSemaphore);
+    vkDestroySemaphore(demo->device, presentCompleteSemaphore, NULL);
 }
 
 static void demo_prepare_buffers(struct demo *demo)
@@ -679,7 +682,7 @@
         color_attachment_view.image = demo->buffers[i].image;
 
         err = vkCreateImageView(demo->device,
-                &color_attachment_view, &demo->buffers[i].view);
+                &color_attachment_view, NULL, &demo->buffers[i].view);
         assert(!err);
     }
 
@@ -731,7 +734,7 @@
     demo->depth.format = depth_format;
 
     /* create image */
-    err = vkCreateImage(demo->device, &image,
+    err = vkCreateImage(demo->device, &image, NULL,
             &demo->depth.image);
     assert(!err);
 
@@ -748,7 +751,7 @@
     assert(pass);
 
     /* allocate memory */
-    err = vkAllocMemory(demo->device, &mem_alloc, &demo->depth.mem);
+    err = vkAllocMemory(demo->device, &mem_alloc, NULL, &demo->depth.mem);
     assert(!err);
 
     /* bind memory */
@@ -763,7 +766,7 @@
 
     /* create image view */
     view.image = demo->depth.image;
-    err = vkCreateImageView(demo->device, &view, &demo->depth.view);
+    err = vkCreateImageView(demo->device, &view, NULL, &demo->depth.view);
     assert(!err);
 }
 
@@ -805,7 +808,7 @@
 
     VkMemoryRequirements mem_reqs;
 
-    err = vkCreateImage(demo->device, &image_create_info,
+    err = vkCreateImage(demo->device, &image_create_info, NULL,
             &tex_obj->image);
     assert(!err);
 
@@ -816,7 +819,7 @@
     assert(pass);
 
     /* allocate memory */
-    err = vkAllocMemory(demo->device, &mem_alloc, &tex_obj->mem);
+    err = vkAllocMemory(demo->device, &mem_alloc, NULL, &tex_obj->mem);
     assert(!err);
 
     /* bind memory */
@@ -859,8 +862,8 @@
 static void demo_destroy_texture_image(struct demo *demo, struct texture_object *tex_obj)
 {
     /* clean up staging resources */
-    vkDestroyImage(demo->device, tex_obj->image);
-    vkFreeMemory(demo->device, tex_obj->mem);
+    vkDestroyImage(demo->device, tex_obj->image, NULL);
+    vkFreeMemory(demo->device, tex_obj->mem, NULL);
 }
 
 static void demo_prepare_textures(struct demo *demo)
@@ -960,13 +963,13 @@
         };
 
         /* create sampler */
-        err = vkCreateSampler(demo->device, &sampler,
+        err = vkCreateSampler(demo->device, &sampler, NULL,
                 &demo->textures[i].sampler);
         assert(!err);
 
         /* create image view */
         view.image = demo->textures[i].image;
-        err = vkCreateImageView(demo->device, &view,
+        err = vkCreateImageView(demo->device, &view, NULL,
                                  &demo->textures[i].view);
         assert(!err);
     }
@@ -1000,7 +1003,7 @@
 
     memset(&demo->vertices, 0, sizeof(demo->vertices));
 
-    err = vkCreateBuffer(demo->device, &buf_info, &demo->vertices.buf);
+    err = vkCreateBuffer(demo->device, &buf_info, NULL, &demo->vertices.buf);
     assert(!err);
 
     vkGetBufferMemoryRequirements(demo->device,
@@ -1014,7 +1017,7 @@
                                       &mem_alloc.memoryTypeIndex);
     assert(pass);
 
-    err = vkAllocMemory(demo->device, &mem_alloc, &demo->vertices.mem);
+    err = vkAllocMemory(demo->device, &mem_alloc, NULL, &demo->vertices.mem);
     assert(!err);
 
     err = vkMapMemory(demo->device, demo->vertices.mem, 0, mem_alloc.allocationSize, 0, &data);
@@ -1067,7 +1070,7 @@
     VkResult U_ASSERT_ONLY err;
 
     err = vkCreateDescriptorSetLayout(demo->device,
-            &descriptor_layout, &demo->desc_layout);
+            &descriptor_layout, NULL, &demo->desc_layout);
     assert(!err);
 
     const VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo = {
@@ -1079,6 +1082,7 @@
 
     err = vkCreatePipelineLayout(demo->device,
                                  &pPipelineLayoutCreateInfo,
+                                 NULL,
                                  &demo->pipeline_layout);
     assert(!err);
 }
@@ -1144,7 +1148,7 @@
     };
     VkResult U_ASSERT_ONLY err;
 
-    err = vkCreateRenderPass(demo->device, &rp_info, &demo->render_pass);
+    err = vkCreateRenderPass(demo->device, &rp_info, NULL, &demo->render_pass);
     assert(!err);
 }
 
@@ -1170,14 +1174,14 @@
         moduleCreateInfo.codeSize = size;
         moduleCreateInfo.pCode = code;
         moduleCreateInfo.flags = 0;
-        err = vkCreateShaderModule(demo->device, &moduleCreateInfo, pShaderModule);
+        err = vkCreateShaderModule(demo->device, &moduleCreateInfo, NULL, pShaderModule);
         assert(!err);
 
         shaderCreateInfo.flags = 0;
         shaderCreateInfo.module = *pShaderModule;
         shaderCreateInfo.pName = "main";
         shaderCreateInfo.stage = stage;
-        err = vkCreateShader(demo->device, &shaderCreateInfo, &shader);
+        err = vkCreateShader(demo->device, &shaderCreateInfo, NULL, &shader);
         assert(!err);
     } else {
         // Create fake SPV structure to feed GLSL
@@ -1192,14 +1196,14 @@
         ((uint32_t *) moduleCreateInfo.pCode)[2] = stage;
         memcpy(((uint32_t *) moduleCreateInfo.pCode + 3), code, size + 1);
 
-        err = vkCreateShaderModule(demo->device, &moduleCreateInfo, pShaderModule);
+        err = vkCreateShaderModule(demo->device, &moduleCreateInfo, NULL, pShaderModule);
         assert(!err);
 
         shaderCreateInfo.flags = 0;
         shaderCreateInfo.module = *pShaderModule;
         shaderCreateInfo.pName = "main";
         shaderCreateInfo.stage = stage;
-        err = vkCreateShader(demo->device, &shaderCreateInfo, &shader);
+        err = vkCreateShader(demo->device, &shaderCreateInfo, NULL, &shader);
         assert(!err);
         free((void *) moduleCreateInfo.pCode);
     }
@@ -1397,18 +1401,19 @@
     memset(&pipelineCache, 0, sizeof(pipelineCache));
     pipelineCache.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
 
-    err = vkCreatePipelineCache(demo->device, &pipelineCache, &demo->pipelineCache);
+    err = vkCreatePipelineCache(demo->device, &pipelineCache, NULL, &demo->pipelineCache);
     assert(!err);
-    err = vkCreateGraphicsPipelines(demo->device, demo->pipelineCache, 1, &pipeline, &demo->pipeline);
+    err = vkCreateGraphicsPipelines(demo->device, demo->pipelineCache,
+            1, &pipeline, NULL, &demo->pipeline);
     assert(!err);
 
-    vkDestroyPipelineCache(demo->device, demo->pipelineCache);
+    vkDestroyPipelineCache(demo->device, demo->pipelineCache, NULL);
 
     for (uint32_t i = 0; i < pipeline.stageCount; i++) {
-        vkDestroyShader(demo->device, shaderStages[i].shader);
+        vkDestroyShader(demo->device, shaderStages[i].shader, NULL);
     }
-    vkDestroyShaderModule(demo->device, demo->frag_shader_module);
-    vkDestroyShaderModule(demo->device, demo->vert_shader_module);
+    vkDestroyShaderModule(demo->device, demo->frag_shader_module, NULL);
+    vkDestroyShaderModule(demo->device, demo->vert_shader_module, NULL);
 }
 
 static void demo_prepare_descriptor_pool(struct demo *demo)
@@ -1427,7 +1432,7 @@
     VkResult U_ASSERT_ONLY err;
 
     err = vkCreateDescriptorPool(demo->device,
-            &descriptor_pool, &demo->desc_pool);
+            &descriptor_pool, NULL, &demo->desc_pool);
     assert(!err);
 }
 
@@ -1488,7 +1493,7 @@
 
     for (i = 0; i < demo->swapchainImageCount; i++) {
         attachments[0]= demo->buffers[i].view;
-        err = vkCreateFramebuffer(demo->device, &fb_info, &demo->framebuffers[i]);
+        err = vkCreateFramebuffer(demo->device, &fb_info, NULL, &demo->framebuffers[i]);
         assert(!err);
     }
 }
@@ -1503,7 +1508,7 @@
         .queueFamilyIndex = demo->graphics_queue_node_index,
         .flags = 0,
     };
-    err = vkCreateCommandPool(demo->device, &cmd_pool_info, &demo->cmd_pool);
+    err = vkCreateCommandPool(demo->device, &cmd_pool_info, NULL, &demo->cmd_pool);
     assert(!err);
 
     const VkCmdBufferAllocInfo cmd = {
@@ -1759,7 +1764,7 @@
     void*                           pUserData,
     size_t                          size,
     size_t                          alignment,
-    VkSystemAllocType               allocType)
+    VkSystemAllocScope              allocScope)
 {
     return malloc(size);
 }
@@ -1850,16 +1855,10 @@
         .engineVersion = 0,
         .apiVersion = VK_API_VERSION,
     };
-    VkAllocCallbacks cb = {
-        .pUserData = NULL,
-        .pfnAlloc = myalloc,
-        .pfnFree = myfree,
-    };
     VkInstanceCreateInfo inst_info = {
         .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
         .pNext = NULL,
         .pAppInfo = &app,
-        .pAllocCb = &cb,
         .enabledLayerNameCount = enabled_layer_count,
         .ppEnabledLayerNames = (const char *const*) layer_names,
         .enabledExtensionNameCount = enabled_extension_count,
@@ -1875,7 +1874,10 @@
     };
     uint32_t gpu_count;
 
-    err = vkCreateInstance(&inst_info, &demo->inst);
+    demo->allocator.pfnAlloc = myalloc;
+    demo->allocator.pfnFree = myfree;
+
+    err = vkCreateInstance(&inst_info, &demo->allocator, &demo->inst);
     if (err == VK_ERROR_INCOMPATIBLE_DRIVER) {
         ERR_EXIT("Cannot find a compatible Vulkan installable client driver "
                  "(ICD).\n\nPlease look at the Getting Started guide for "
@@ -1996,7 +1998,7 @@
     }
 
 
-    err = vkCreateDevice(demo->gpu, &device, &demo->device);
+    err = vkCreateDevice(demo->gpu, &device, NULL, &demo->device);
     assert(!err);
 
     GET_INSTANCE_PROC_ADDR(demo->inst, GetPhysicalDeviceSurfaceSupportKHR);
@@ -2207,45 +2209,45 @@
     demo->prepared = false;
 
     for (i = 0; i < demo->swapchainImageCount; i++) {
-        vkDestroyFramebuffer(demo->device, demo->framebuffers[i]);
+        vkDestroyFramebuffer(demo->device, demo->framebuffers[i], NULL);
     }
     free(demo->framebuffers);
-    vkDestroyDescriptorPool(demo->device, demo->desc_pool);
+    vkDestroyDescriptorPool(demo->device, demo->desc_pool, NULL);
 
     if (demo->setup_cmd) {
         vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, &demo->setup_cmd);
     }
     vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, &demo->draw_cmd);
-    vkDestroyCommandPool(demo->device, demo->cmd_pool);
+    vkDestroyCommandPool(demo->device, demo->cmd_pool, NULL);
 
-    vkDestroyPipeline(demo->device, demo->pipeline);
-    vkDestroyRenderPass(demo->device, demo->render_pass);
-    vkDestroyPipelineLayout(demo->device, demo->pipeline_layout);
-    vkDestroyDescriptorSetLayout(demo->device, demo->desc_layout);
+    vkDestroyPipeline(demo->device, demo->pipeline, NULL);
+    vkDestroyRenderPass(demo->device, demo->render_pass, NULL);
+    vkDestroyPipelineLayout(demo->device, demo->pipeline_layout, NULL);
+    vkDestroyDescriptorSetLayout(demo->device, demo->desc_layout, NULL);
 
-    vkDestroyBuffer(demo->device, demo->vertices.buf);
-    vkFreeMemory(demo->device, demo->vertices.mem);
+    vkDestroyBuffer(demo->device, demo->vertices.buf, NULL);
+    vkFreeMemory(demo->device, demo->vertices.mem, NULL);
 
     for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
-        vkDestroyImageView(demo->device, demo->textures[i].view);
-        vkDestroyImage(demo->device, demo->textures[i].image);
-        vkFreeMemory(demo->device, demo->textures[i].mem);
-        vkDestroySampler(demo->device, demo->textures[i].sampler);
+        vkDestroyImageView(demo->device, demo->textures[i].view, NULL);
+        vkDestroyImage(demo->device, demo->textures[i].image, NULL);
+        vkFreeMemory(demo->device, demo->textures[i].mem, NULL);
+        vkDestroySampler(demo->device, demo->textures[i].sampler, NULL);
     }
 
     for (i = 0; i < demo->swapchainImageCount; i++) {
-        vkDestroyImageView(demo->device, demo->buffers[i].view);
+        vkDestroyImageView(demo->device, demo->buffers[i].view, NULL);
     }
 
-    vkDestroyImageView(demo->device, demo->depth.view);
-    vkDestroyImage(demo->device, demo->depth.image);
-    vkFreeMemory(demo->device, demo->depth.mem);
+    vkDestroyImageView(demo->device, demo->depth.view, NULL);
+    vkDestroyImage(demo->device, demo->depth.image, NULL);
+    vkFreeMemory(demo->device, demo->depth.mem, NULL);
 
     demo->fpDestroySwapchainKHR(demo->device, demo->swapchain);
     free(demo->buffers);
 
-    vkDestroyDevice(demo->device);
-    vkDestroyInstance(demo->inst);
+    vkDestroyDevice(demo->device, NULL);
+    vkDestroyInstance(demo->inst, &demo->allocator);
 
     free(demo->queue_props);
 
@@ -2271,39 +2273,39 @@
     demo->prepared = false;
 
     for (i = 0; i < demo->swapchainImageCount; i++) {
-        vkDestroyFramebuffer(demo->device, demo->framebuffers[i]);
+        vkDestroyFramebuffer(demo->device, demo->framebuffers[i], NULL);
     }
     free(demo->framebuffers);
-    vkDestroyDescriptorPool(demo->device, demo->desc_pool);
+    vkDestroyDescriptorPool(demo->device, demo->desc_pool, NULL);
 
     if (demo->setup_cmd) {
         vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, &demo->setup_cmd);
     }
     vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, &demo->draw_cmd);
-    vkDestroyCommandPool(demo->device, demo->cmd_pool);
+    vkDestroyCommandPool(demo->device, demo->cmd_pool, NULL);
 
-    vkDestroyPipeline(demo->device, demo->pipeline);
-    vkDestroyRenderPass(demo->device, demo->render_pass);
-    vkDestroyPipelineLayout(demo->device, demo->pipeline_layout);
-    vkDestroyDescriptorSetLayout(demo->device, demo->desc_layout);
+    vkDestroyPipeline(demo->device, demo->pipeline, NULL);
+    vkDestroyRenderPass(demo->device, demo->render_pass, NULL);
+    vkDestroyPipelineLayout(demo->device, demo->pipeline_layout, NULL);
+    vkDestroyDescriptorSetLayout(demo->device, demo->desc_layout, NULL);
 
-    vkDestroyBuffer(demo->device, demo->vertices.buf);
-    vkFreeMemory(demo->device, demo->vertices.mem);
+    vkDestroyBuffer(demo->device, demo->vertices.buf, NULL);
+    vkFreeMemory(demo->device, demo->vertices.mem, NULL);
 
     for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
-        vkDestroyImageView(demo->device, demo->textures[i].view);
-        vkDestroyImage(demo->device, demo->textures[i].image);
-        vkFreeMemory(demo->device, demo->textures[i].mem);
-        vkDestroySampler(demo->device, demo->textures[i].sampler);
+        vkDestroyImageView(demo->device, demo->textures[i].view, NULL);
+        vkDestroyImage(demo->device, demo->textures[i].image, NULL);
+        vkFreeMemory(demo->device, demo->textures[i].mem, NULL);
+        vkDestroySampler(demo->device, demo->textures[i].sampler, NULL);
     }
 
     for (i = 0; i < demo->swapchainImageCount; i++) {
-        vkDestroyImageView(demo->device, demo->buffers[i].view);
+        vkDestroyImageView(demo->device, demo->buffers[i].view, NULL);
     }
 
-    vkDestroyImageView(demo->device, demo->depth.view);
-    vkDestroyImage(demo->device, demo->depth.image);
-    vkFreeMemory(demo->device, demo->depth.mem);
+    vkDestroyImageView(demo->device, demo->depth.view, NULL);
+    vkDestroyImage(demo->device, demo->depth.image, NULL);
+    vkFreeMemory(demo->device, demo->depth.mem, NULL);
 
     free(demo->buffers);
 
diff --git a/demos/vulkaninfo.c b/demos/vulkaninfo.c
index 91ded08..69b2896 100644
--- a/demos/vulkaninfo.c
+++ b/demos/vulkaninfo.c
@@ -480,7 +480,7 @@
     info.enabledExtensionNameCount = enabled_extension_count;
     info.ppEnabledExtensionNames = (const char*const*) known_extensions;
     dev->gpu = gpu;
-    err = vkCreateDevice(gpu->obj, &info, &dev->obj);
+    err = vkCreateDevice(gpu->obj, &info, NULL, &dev->obj);
     if (err)
         ERR_EXIT(err);
 
@@ -488,7 +488,7 @@
 
 static void app_dev_destroy(struct app_dev *dev)
 {
-    vkDestroyDevice(dev->obj);
+    vkDestroyDevice(dev->obj, NULL);
 }
 
 static void app_get_global_layer_extensions(
@@ -532,7 +532,6 @@
         .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
         .pNext = NULL,
         .pAppInfo = &app_info,
-        .pAllocCb = NULL,
         .enabledLayerNameCount = 0,
         .ppEnabledLayerNames = NULL,
         .enabledExtensionNameCount = 0,
@@ -613,7 +612,7 @@
     inst_info.enabledExtensionNameCount = global_extension_count;
     inst_info.ppEnabledExtensionNames = (const char * const *) known_extensions;
 
-    err = vkCreateInstance(&inst_info, &inst->instance);
+    err = vkCreateInstance(&inst_info, NULL, &inst->instance);
     if (err == VK_ERROR_INCOMPATIBLE_DRIVER) {
         printf("Cannot create Vulkan instance.\n");
         ERR_EXIT(err);
@@ -625,7 +624,7 @@
 static void app_destroy_instance(struct app_instance *inst)
 {
     free(inst->global_extensions);
-    vkDestroyInstance(inst->instance);
+    vkDestroyInstance(inst->instance, NULL);
 }
 
 
diff --git a/icd/common/icd-enumerate-drm.c b/icd/common/icd-enumerate-drm.c
index 9941b65..050eac3 100644
--- a/icd/common/icd-enumerate-drm.c
+++ b/icd/common/icd-enumerate-drm.c
@@ -125,7 +125,7 @@
         return devices;
     } else {
         dev = icd_instance_alloc(instance, sizeof(*dev), 0,
-                VK_SYSTEM_ALLOC_TYPE_INTERNAL_TEMP);
+                VK_SYSTEM_ALLOC_SCOPE_FUNCTION);
         if (!dev)
             return devices;
 
diff --git a/icd/common/icd-instance.c b/icd/common/icd-instance.c
index b792048..20febda 100644
--- a/icd/common/icd-instance.c
+++ b/icd/common/icd-instance.c
@@ -33,7 +33,7 @@
 
 static void * VKAPI default_alloc(void *user_data, size_t size,
                                    size_t alignment,
-                                   VkSystemAllocType allocType)
+                                   VkSystemAllocScope allocScope)
 {
     if (alignment <= 1) {
         return malloc(size);
@@ -80,7 +80,7 @@
         alloc_cb = &default_alloc_cb;
 
     instance = alloc_cb->pfnAlloc(alloc_cb->pUserData, sizeof(*instance), 0,
-            VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
+            VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
     if (!instance)
         return NULL;
 
@@ -89,7 +89,7 @@
     name = (app_info->pAppName) ? app_info->pAppName : "unnamed";
     len = strlen(name);
     instance->name = alloc_cb->pfnAlloc(alloc_cb->pUserData, len + 1, 0,
-            VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+            VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
     if (!instance->name) {
         alloc_cb->pfnFree(alloc_cb->pUserData, instance);
         return NULL;
@@ -133,7 +133,7 @@
 //    }
 
     logger = icd_instance_alloc(instance, sizeof(*logger), 0,
-            VK_SYSTEM_ALLOC_TYPE_DEBUG);
+            VK_SYSTEM_ALLOC_SCOPE_OBJECT);
     if (!logger)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
 
diff --git a/icd/common/icd-instance.h b/icd/common/icd-instance.h
index 400c642..d54af4e 100644
--- a/icd/common/icd-instance.h
+++ b/icd/common/icd-instance.h
@@ -57,10 +57,10 @@
 
 static inline void *icd_instance_alloc(const struct icd_instance *instance,
                                        size_t size, size_t alignment,
-                                       VkSystemAllocType type)
+                                       VkSystemAllocScope scope)
 {
     return instance->alloc_cb.pfnAlloc(instance->alloc_cb.pUserData,
-            size, alignment, type);
+            size, alignment, scope);
 }
 
 static inline void icd_instance_free(const struct icd_instance *instance,
diff --git a/icd/intel/buf.c b/icd/intel/buf.c
index a776828..2e2c176 100644
--- a/icd/intel/buf.c
+++ b/icd/intel/buf.c
@@ -91,6 +91,7 @@
 ICD_EXPORT VkResult VKAPI vkCreateBuffer(
     VkDevice                                  device,
     const VkBufferCreateInfo*               pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkBuffer*                                 pBuffer)
 {
     struct intel_dev *dev = intel_dev(device);
@@ -100,10 +101,10 @@
 
 ICD_EXPORT void VKAPI vkDestroyBuffer(
     VkDevice                                device,
-    VkBuffer                                buffer)
-
- {
+    VkBuffer                                buffer,
+    const VkAllocCallbacks*                     pAllocator)
+{
     struct intel_obj *obj = intel_obj(buffer);
 
     obj->destroy(obj);
- }
+}
diff --git a/icd/intel/cmd.c b/icd/intel/cmd.c
index 6d71433..4ee3c15 100644
--- a/icd/intel/cmd.c
+++ b/icd/intel/cmd.c
@@ -194,7 +194,7 @@
         struct intel_cmd_item *items;
 
         items = intel_alloc(cmd, sizeof(writer->items[0]) * new_alloc,
-                0, VK_SYSTEM_ALLOC_TYPE_DEBUG);
+                0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
         if (!items) {
             writer->item_used = 0;
             cmd_fail(cmd, VK_ERROR_OUT_OF_HOST_MEMORY);
@@ -296,7 +296,7 @@
      */
     cmd->reloc_count = dev->gpu->batch_buffer_reloc_count;
     cmd->relocs = intel_alloc(cmd, sizeof(cmd->relocs[0]) * cmd->reloc_count,
-            4096, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+            4096, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
     if (!cmd->relocs) {
         intel_cmd_destroy(cmd);
         return VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -472,6 +472,7 @@
 ICD_EXPORT VkResult VKAPI vkCreateCommandPool(
     VkDevice                                    device,
     const VkCmdPoolCreateInfo*                  pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkCmdPool*                                  pCmdPool)
 {
     struct intel_dev *dev = intel_dev(device);
@@ -482,7 +483,8 @@
 
 ICD_EXPORT void VKAPI vkDestroyCommandPool(
     VkDevice                                    device,
-    VkCmdPool                                   cmdPool)
+    VkCmdPool                                   cmdPool,
+    const VkAllocCallbacks*                     pAllocator)
 {
 }
 
diff --git a/icd/intel/cmd_pipeline.c b/icd/intel/cmd_pipeline.c
index 28c92b2..e654369 100644
--- a/icd/intel/cmd_pipeline.c
+++ b/icd/intel/cmd_pipeline.c
@@ -2099,7 +2099,7 @@
         void *entries;
 
         entries = intel_alloc(cmd, sizeof(cache->entries[0]) * count, 0,
-                VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+                VK_SYSTEM_ALLOC_SCOPE_OBJECT);
         if (entries) {
             if (cache->entries) {
                 memcpy(entries, cache->entries,
@@ -3300,7 +3300,7 @@
 
         data->set_offsets = intel_alloc(cmd,
                 sizeof(data->set_offsets[0]) * pipeline_layout->layout_count,
-                sizeof(data->set_offsets[0]), VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+                sizeof(data->set_offsets[0]), VK_SYSTEM_ALLOC_SCOPE_OBJECT);
         if (!data->set_offsets) {
             cmd_fail(cmd, VK_ERROR_OUT_OF_HOST_MEMORY);
             data->set_offset_count = 0;
@@ -3316,7 +3316,7 @@
 
         data->dynamic_offsets = intel_alloc(cmd,
                 sizeof(data->dynamic_offsets[0]) * pipeline_layout->total_dynamic_desc_count,
-                sizeof(data->dynamic_offsets[0]), VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+                sizeof(data->dynamic_offsets[0]), VK_SYSTEM_ALLOC_SCOPE_OBJECT);
         if (!data->dynamic_offsets) {
             cmd_fail(cmd, VK_ERROR_OUT_OF_HOST_MEMORY);
             data->dynamic_offset_count = 0;
diff --git a/icd/intel/compiler/pipeline/pipeline_compiler_interface.cpp b/icd/intel/compiler/pipeline/pipeline_compiler_interface.cpp
index 23d7144..75e34e6 100644
--- a/icd/intel/compiler/pipeline/pipeline_compiler_interface.cpp
+++ b/icd/intel/compiler/pipeline/pipeline_compiler_interface.cpp
@@ -345,12 +345,12 @@
 
 static inline void *pipe_interface_alloc(const void *handle,
                                                     size_t size, size_t alignment,
-                                                    VkSystemAllocType type)
+                                                    VkSystemAllocScope scope)
 {
     if (standaloneCompiler)
         return calloc(size, sizeof(char));
     else
-        return intel_alloc(handle, size, alignment, type);
+        return intel_alloc(handle, size, alignment, scope);
 }
 
 static void rmap_destroy(const struct intel_gpu *gpu,
@@ -369,7 +369,7 @@
     uint32_t surface_count, i;
 
     rmap = (struct intel_pipeline_rmap *)
-        pipe_interface_alloc(gpu, sizeof(*rmap), 0, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+        pipe_interface_alloc(gpu, sizeof(*rmap), 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
     if (!rmap)
         return NULL;
 
@@ -390,7 +390,7 @@
 
     rmap->slots = (struct intel_pipeline_rmap_slot *)
         pipe_interface_alloc(gpu, sizeof(rmap->slots[0]) * rmap->slot_count,
-            0, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+            0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
     if (!rmap->slots) {
         pipe_interface_free(gpu, rmap);
         return NULL;
@@ -638,7 +638,7 @@
         {
             pipe_shader->codeSize = get_vs_program_size(brw->shader_prog);
 
-            pipe_shader->pCode = pipe_interface_alloc(gpu, pipe_shader->codeSize, 0, VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER);
+            pipe_shader->pCode = pipe_interface_alloc(gpu, pipe_shader->codeSize, 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
 
             if (!pipe_shader->pCode) {
                 status = VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -709,7 +709,7 @@
         {
             pipe_shader->codeSize = get_gs_program_size(brw->shader_prog);
 
-            pipe_shader->pCode = pipe_interface_alloc(gpu, pipe_shader->codeSize, 0, VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER);
+            pipe_shader->pCode = pipe_interface_alloc(gpu, pipe_shader->codeSize, 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
 
             if (!pipe_shader->pCode) {
                 status = VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -786,7 +786,7 @@
 
             pipe_shader->codeSize = get_wm_program_size(brw->shader_prog);
 
-            pipe_shader->pCode = pipe_interface_alloc(gpu, pipe_shader->codeSize, 0, VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER);
+            pipe_shader->pCode = pipe_interface_alloc(gpu, pipe_shader->codeSize, 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
 
             if (!pipe_shader->pCode) {
                 status = VK_ERROR_OUT_OF_HOST_MEMORY;
diff --git a/icd/intel/compiler/pipeline/pipeline_compiler_interface_meta.cpp b/icd/intel/compiler/pipeline/pipeline_compiler_interface_meta.cpp
index bc1bf47..40053e8 100644
--- a/icd/intel/compiler/pipeline/pipeline_compiler_interface_meta.cpp
+++ b/icd/intel/compiler/pipeline/pipeline_compiler_interface_meta.cpp
@@ -621,7 +621,7 @@
 
     prog = get_program(&prog_size, stderr);
 
-    code = intel_alloc(gpu, prog_size, 0, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+    code = intel_alloc(gpu, prog_size, 0, VK_SYSTEM_ALLOC_SCOPE_DEVICE);
     if (!code)
         return NULL;
 
diff --git a/icd/intel/compiler/shader/standalone_utils.c b/icd/intel/compiler/shader/standalone_utils.c
index bb70706..4c96fd2 100644
--- a/icd/intel/compiler/shader/standalone_utils.c
+++ b/icd/intel/compiler/shader/standalone_utils.c
@@ -38,11 +38,11 @@
 
 void *intel_alloc(const void *handle,
                                 size_t size, size_t alignment,
-                                VkSystemAllocType type)
+                                VkSystemAllocScope scope)
 {
     assert(intel_handle_validate(handle));
     return icd_instance_alloc(((const struct intel_handle *) handle)->instance->icd,
-            size, alignment, type);
+            size, alignment, scope);
 }
 
 void intel_free(const void *handle, void *ptr)
diff --git a/icd/intel/desc.c b/icd/intel/desc.c
index ab50390..7fa9653 100644
--- a/icd/intel/desc.c
+++ b/icd/intel/desc.c
@@ -121,7 +121,7 @@
     const uint32_t sampler_count = 1024*1024;
     struct intel_desc_region *region;
 
-    region = intel_alloc(dev, sizeof(*region), 0, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+    region = intel_alloc(dev, sizeof(*region), 0, VK_SYSTEM_ALLOC_SCOPE_DEVICE);
     if (!region)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
 
@@ -134,14 +134,14 @@
             region->sampler_desc_size * sampler_count);
 
     region->surfaces = intel_alloc(dev, region->size.surface,
-            64, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+            64, VK_SYSTEM_ALLOC_SCOPE_DEVICE);
     if (!region->surfaces) {
         intel_free(dev, region);
         return VK_ERROR_OUT_OF_HOST_MEMORY;
     }
 
     region->samplers = intel_alloc(dev, region->size.sampler,
-            64, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+            64, VK_SYSTEM_ALLOC_SCOPE_DEVICE);
     if (!region->samplers) {
         intel_free(dev, region->surfaces);
         intel_free(dev, region);
@@ -562,7 +562,7 @@
 
     /* allocate bindings */
     layout->bindings = intel_alloc(layout, sizeof(layout->bindings[0]) *
-            info->bindingCount, 0, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+            info->bindingCount, 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
     if (!layout->bindings)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
 
@@ -618,7 +618,7 @@
             } else {
                 binding->immutable_samplers = intel_alloc(layout,
                         sizeof(binding->immutable_samplers[0]) * lb->arraySize,
-                        0, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+                        0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
                 if (!binding->immutable_samplers)
                     return VK_ERROR_OUT_OF_HOST_MEMORY;
 
@@ -705,7 +705,7 @@
 
     pipeline_layout->layouts = intel_alloc(pipeline_layout,
                                            sizeof(pipeline_layout->layouts[0]) * count,
-                                           0, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+                                           0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
     if (!pipeline_layout->layouts) {
         intel_pipeline_layout_destroy(pipeline_layout);
         return VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -713,7 +713,7 @@
 
     pipeline_layout->dynamic_desc_indices = intel_alloc(pipeline_layout,
             sizeof(pipeline_layout->dynamic_desc_indices[0]) * count,
-            0, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+            0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
     if (!pipeline_layout->dynamic_desc_indices) {
         intel_pipeline_layout_destroy(pipeline_layout);
         return VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -748,6 +748,7 @@
 ICD_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(
     VkDevice                                   device,
     const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkDescriptorSetLayout*                   pSetLayout)
 {
     struct intel_dev *dev = intel_dev(device);
@@ -758,7 +759,8 @@
 
 ICD_EXPORT void VKAPI vkDestroyDescriptorSetLayout(
     VkDevice                                device,
-    VkDescriptorSetLayout                   descriptorSetLayout)
+    VkDescriptorSetLayout                   descriptorSetLayout,
+    const VkAllocCallbacks*                     pAllocator)
 
 {
     struct intel_obj *obj = intel_obj(descriptorSetLayout);
@@ -769,6 +771,7 @@
 ICD_EXPORT VkResult VKAPI vkCreatePipelineLayout(
     VkDevice                                device,
     const VkPipelineLayoutCreateInfo*       pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkPipelineLayout*                       pPipelineLayout)
 {
     struct intel_dev *dev = intel_dev(device);
@@ -780,7 +783,8 @@
 
 ICD_EXPORT void VKAPI vkDestroyPipelineLayout(
     VkDevice                                device,
-    VkPipelineLayout                        pipelineLayout)
+    VkPipelineLayout                        pipelineLayout,
+    const VkAllocCallbacks*                     pAllocator)
 
 {
     struct intel_obj *obj = intel_obj(pipelineLayout);
@@ -791,6 +795,7 @@
 ICD_EXPORT VkResult VKAPI vkCreateDescriptorPool(
     VkDevice                                    device,
     const VkDescriptorPoolCreateInfo*           pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkDescriptorPool*                           pDescriptorPool)
 {
     struct intel_dev *dev = intel_dev(device);
@@ -801,7 +806,8 @@
 
 ICD_EXPORT void VKAPI vkDestroyDescriptorPool(
     VkDevice                                device,
-    VkDescriptorPool                        descriptorPool)
+    VkDescriptorPool                        descriptorPool,
+    const VkAllocCallbacks*                     pAllocator)
 
 {
     struct intel_obj *obj = intel_obj(descriptorPool);
diff --git a/icd/intel/dev.c b/icd/intel/dev.c
index 4e41752..3ebcaf3 100644
--- a/icd/intel/dev.c
+++ b/icd/intel/dev.c
@@ -212,6 +212,7 @@
 ICD_EXPORT VkResult VKAPI vkCreateDevice(
     VkPhysicalDevice                    gpu_,
     const VkDeviceCreateInfo*           pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkDevice*                           pDevice)
 {
     struct intel_gpu *gpu = intel_gpu(gpu_);
@@ -220,7 +221,8 @@
 }
 
 ICD_EXPORT void VKAPI vkDestroyDevice(
-    VkDevice                                  device)
+    VkDevice                                  device,
+    const VkAllocCallbacks*                     pAllocator)
 {
     struct intel_dev *dev = intel_dev(device);
 
diff --git a/icd/intel/event.c b/icd/intel/event.c
index f2ac3d6..e254c60 100644
--- a/icd/intel/event.c
+++ b/icd/intel/event.c
@@ -142,6 +142,7 @@
 ICD_EXPORT VkResult VKAPI vkCreateEvent(
     VkDevice                                  device,
     const VkEventCreateInfo*                pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkEvent*                                  pEvent)
 {
     struct intel_dev *dev = intel_dev(device);
@@ -152,7 +153,8 @@
 
 ICD_EXPORT void VKAPI vkDestroyEvent(
     VkDevice                                device,
-    VkEvent                                 event)
+    VkEvent                                 event,
+    const VkAllocCallbacks*                     pAllocator)
 
  {
     struct intel_obj *obj = intel_obj(event);
diff --git a/icd/intel/fb.c b/icd/intel/fb.c
index 2950c47..5a21546 100644
--- a/icd/intel/fb.c
+++ b/icd/intel/fb.c
@@ -38,6 +38,7 @@
 
 VkResult intel_fb_create(struct intel_dev *dev,
                          const VkFramebufferCreateInfo *info,
+                         const VkAllocCallbacks *allocator,
                          struct intel_fb **fb_ret)
 {
     struct intel_fb *fb;
@@ -50,7 +51,7 @@
 
     fb->view_count = info->attachmentCount;
     fb->views = intel_alloc(fb, sizeof(fb->views[0]) * fb->view_count, 0,
-            VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+            VK_SYSTEM_ALLOC_SCOPE_OBJECT);
     if (!fb->views) {
         intel_fb_destroy(fb);
         return VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -97,6 +98,7 @@
 
 VkResult intel_render_pass_create(struct intel_dev *dev,
                                   const VkRenderPassCreateInfo *info,
+                                  const VkAllocCallbacks *allocator,
                                   struct intel_render_pass **rp_ret)
 {
     struct intel_render_pass *rp;
@@ -116,7 +118,7 @@
     rp->attachments = intel_alloc(rp,
             sizeof(rp->attachments[0]) * rp->attachment_count +
             sizeof(rp->subpasses[0]) * rp->subpass_count, 0,
-            VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+            VK_SYSTEM_ALLOC_SCOPE_OBJECT);
     if (!rp->attachments) {
         intel_render_pass_destroy(rp);
         return VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -199,17 +201,19 @@
 ICD_EXPORT VkResult VKAPI vkCreateFramebuffer(
     VkDevice                                  device,
     const VkFramebufferCreateInfo*          pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkFramebuffer*                            pFramebuffer)
 {
     struct intel_dev *dev = intel_dev(device);
 
-    return intel_fb_create(dev, pCreateInfo,
+    return intel_fb_create(dev, pCreateInfo, pAllocator,
             (struct intel_fb **) pFramebuffer);
 }
 
 ICD_EXPORT void VKAPI vkDestroyFramebuffer(
     VkDevice                                device,
-    VkFramebuffer                           framebuffer)
+    VkFramebuffer                           framebuffer,
+    const VkAllocCallbacks*                     pAllocator)
 
 {
     struct intel_obj *obj = intel_obj(framebuffer);
@@ -220,18 +224,19 @@
 ICD_EXPORT VkResult VKAPI vkCreateRenderPass(
     VkDevice                                  device,
     const VkRenderPassCreateInfo*          pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkRenderPass*                            pRenderPass)
 {
     struct intel_dev *dev = intel_dev(device);
 
-    return intel_render_pass_create(dev, pCreateInfo,
+    return intel_render_pass_create(dev, pCreateInfo, pAllocator,
             (struct intel_render_pass **) pRenderPass);
 }
 
 ICD_EXPORT void VKAPI vkDestroyRenderPass(
     VkDevice                                device,
-    VkRenderPass                           renderPass)
-
+    VkRenderPass                           renderPass,
+    const VkAllocCallbacks*                     pAllocator)
 {
     struct intel_obj *obj = intel_obj(renderPass);
 
diff --git a/icd/intel/fb.h b/icd/intel/fb.h
index eca65d2..fade414 100644
--- a/icd/intel/fb.h
+++ b/icd/intel/fb.h
@@ -96,13 +96,15 @@
 }
 
 VkResult intel_fb_create(struct intel_dev *dev,
-                           const VkFramebufferCreateInfo *pInfo,
-                           struct intel_fb **fb_ret);
+                         const VkFramebufferCreateInfo *pInfo,
+                         const VkAllocCallbacks *allocator,
+                         struct intel_fb **fb_ret);
 void intel_fb_destroy(struct intel_fb *fb);
 
 VkResult intel_render_pass_create(struct intel_dev *dev,
-                                    const VkRenderPassCreateInfo *pInfo,
-                                    struct intel_render_pass **rp_ret);
+                                  const VkRenderPassCreateInfo *pInfo,
+                                  const VkAllocCallbacks *allocator,
+                                  struct intel_render_pass **rp_ret);
 void intel_render_pass_destroy(struct intel_render_pass *rp);
 
 #endif /* FB_H */
diff --git a/icd/intel/fence.c b/icd/intel/fence.c
index 91eaaf1..5669650 100644
--- a/icd/intel/fence.c
+++ b/icd/intel/fence.c
@@ -120,6 +120,7 @@
 ICD_EXPORT VkResult VKAPI vkCreateFence(
     VkDevice                                  device,
     const VkFenceCreateInfo*                pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkFence*                                  pFence)
 {
     struct intel_dev *dev = intel_dev(device);
@@ -130,7 +131,8 @@
 
 ICD_EXPORT void VKAPI vkDestroyFence(
     VkDevice                                device,
-    VkFence                                 fence)
+    VkFence                                 fence,
+    const VkAllocCallbacks*                     pAllocator)
 
  {
     struct intel_obj *obj = intel_obj(fence);
diff --git a/icd/intel/gpu.c b/icd/intel/gpu.c
index 223baf1..3a192e2 100644
--- a/icd/intel/gpu.c
+++ b/icd/intel/gpu.c
@@ -157,7 +157,7 @@
         return VK_ERROR_INITIALIZATION_FAILED;
     }
 
-    gpu = intel_alloc(instance, sizeof(*gpu), 0, VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
+    gpu = intel_alloc(instance, sizeof(*gpu), 0, VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
     if (!gpu)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
 
@@ -171,7 +171,7 @@
     render_len = (render_node) ? strlen(render_node) : 0;
 
     gpu->primary_node = intel_alloc(gpu, primary_len + 1 +
-            ((render_len) ? (render_len + 1) : 0), 0, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+            ((render_len) ? (render_len + 1) : 0), 0, VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
     if (!gpu->primary_node) {
         intel_free(instance, gpu);
         return VK_ERROR_OUT_OF_HOST_MEMORY;
diff --git a/icd/intel/img.c b/icd/intel/img.c
index 9322973..1a72a5d 100644
--- a/icd/intel/img.c
+++ b/icd/intel/img.c
@@ -60,6 +60,7 @@
 
 VkResult intel_img_create(struct intel_dev *dev,
                           const VkImageCreateInfo *info,
+                          const VkAllocCallbacks *allocator,
                           bool scanout,
                           struct intel_img **img_ret)
 {
@@ -93,7 +94,7 @@
         VkImageCreateInfo s8_info;
 
         img->s8_layout = intel_alloc(img, sizeof(*img->s8_layout), 0,
-                VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+                VK_SYSTEM_ALLOC_SCOPE_OBJECT);
         if (!img->s8_layout) {
             intel_img_destroy(img);
             return VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -142,17 +143,19 @@
 ICD_EXPORT VkResult VKAPI vkCreateImage(
     VkDevice                                  device,
     const VkImageCreateInfo*                pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkImage*                                  pImage)
 {
     struct intel_dev *dev = intel_dev(device);
 
-    return intel_img_create(dev, pCreateInfo, false,
+    return intel_img_create(dev, pCreateInfo, pAllocator, false,
             (struct intel_img **) pImage);
 }
 
 ICD_EXPORT void VKAPI vkDestroyImage(
     VkDevice                                device,
-    VkImage                                 image)
+    VkImage                                 image,
+    const VkAllocCallbacks*                     pAllocator)
 
  {
     struct intel_obj *obj = intel_obj(image);
diff --git a/icd/intel/img.h b/icd/intel/img.h
index 9a79e47..b583dfe 100644
--- a/icd/intel/img.h
+++ b/icd/intel/img.h
@@ -70,9 +70,10 @@
 }
 
 VkResult intel_img_create(struct intel_dev *dev,
-                            const VkImageCreateInfo *info,
-                            bool scanout,
-                            struct intel_img **img_ret);
+                          const VkImageCreateInfo *info,
+                          const VkAllocCallbacks *allocator,
+                          bool scanout,
+                          struct intel_img **img_ret);
 
 void intel_img_destroy(struct intel_img *img);
 
diff --git a/icd/intel/instance.c b/icd/intel/instance.c
index 890a513..bff0551 100644
--- a/icd/intel/instance.c
+++ b/icd/intel/instance.c
@@ -35,11 +35,11 @@
 
 void *intel_alloc(const void *handle,
                                 size_t size, size_t alignment,
-                                VkSystemAllocType type)
+                                VkSystemAllocScope scope)
 {
     assert(intel_handle_validate(handle));
     return icd_instance_alloc(((const struct intel_handle *) handle)->instance->icd,
-            size, alignment, type);
+            size, alignment, scope);
 }
 
 void intel_free(const void *handle, void *ptr)
@@ -146,6 +146,7 @@
 
 static VkResult intel_instance_create(
         const VkInstanceCreateInfo* info,
+        const VkAllocCallbacks* allocator,
         struct intel_instance **pInstance)
 {
     struct intel_instance *instance;
@@ -154,12 +155,12 @@
 
     intel_debug_init();
 
-    icd = icd_instance_create(info->pAppInfo, info->pAllocCb);
+    icd = icd_instance_create(info->pAppInfo, allocator);
     if (!icd)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
 
     instance = icd_instance_alloc(icd, sizeof(*instance), 0,
-            VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
+            VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
     if (!instance) {
         icd_instance_destroy(icd);
         return VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -219,13 +220,16 @@
 
 ICD_EXPORT VkResult VKAPI vkCreateInstance(
     const VkInstanceCreateInfo*             pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkInstance*                             pInstance)
 {
-    return intel_instance_create(pCreateInfo, (struct intel_instance **) pInstance);
+    return intel_instance_create(pCreateInfo, pAllocator,
+            (struct intel_instance **) pInstance);
 }
 
 ICD_EXPORT void VKAPI vkDestroyInstance(
-    VkInstance                                pInstance)
+    VkInstance                                pInstance,
+    const VkAllocCallbacks*                     pAllocator)
 {
     struct intel_instance *instance = intel_instance(pInstance);
 
diff --git a/icd/intel/intel.h b/icd/intel/intel.h
index e324f24..9628bb1 100644
--- a/icd/intel/intel.h
+++ b/icd/intel/intel.h
@@ -126,7 +126,7 @@
 
 void *intel_alloc(const void *handle,
                   size_t size, size_t alignment,
-                  VkSystemAllocType type);
+                  VkSystemAllocScope scope);
 
 void intel_free(const void *handle, void *ptr);
 
diff --git a/icd/intel/kmd/winsys_drm.c b/icd/intel/kmd/winsys_drm.c
index 2c8a2b8..edc6e70 100644
--- a/icd/intel/kmd/winsys_drm.c
+++ b/icd/intel/kmd/winsys_drm.c
@@ -168,7 +168,7 @@
    struct intel_winsys *winsys;
 
    winsys = icd_instance_alloc(instance, sizeof(*winsys), 0,
-           VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+           VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
    if (!winsys)
       return NULL;
 
diff --git a/icd/intel/mem.c b/icd/intel/mem.c
index 21936a5..b5e70a0 100644
--- a/icd/intel/mem.c
+++ b/icd/intel/mem.c
@@ -65,6 +65,7 @@
 ICD_EXPORT VkResult VKAPI vkAllocMemory(
     VkDevice                                device,
     const VkMemoryAllocInfo*                pAllocInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkDeviceMemory*                         pMem)
 {
     struct intel_dev *dev = intel_dev(device);
@@ -74,7 +75,8 @@
 
 ICD_EXPORT void VKAPI vkFreeMemory(
     VkDevice                                  device,
-    VkDeviceMemory                            mem_)
+    VkDeviceMemory                            mem_,
+    const VkAllocCallbacks*                     pAllocator)
 {
     struct intel_mem *mem = intel_mem(mem_);
 
diff --git a/icd/intel/obj.c b/icd/intel/obj.c
index 27135b9..a1c61a3 100644
--- a/icd/intel/obj.c
+++ b/icd/intel/obj.c
@@ -137,7 +137,7 @@
 
     if (shallow_copy) {
         dbg->create_info = intel_alloc(handle, shallow_copy, 0,
-                VK_SYSTEM_ALLOC_TYPE_DEBUG);
+                VK_SYSTEM_ALLOC_SCOPE_OBJECT);
         if (!dbg->create_info)
             return false;
 
@@ -152,7 +152,7 @@
         size = sizeof(*src);
 
         dbg->create_info_size = size;
-        dst = intel_alloc(handle, size, 0, VK_SYSTEM_ALLOC_TYPE_DEBUG);
+        dst = intel_alloc(handle, size, 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
         if (!dst)
             return false;
         memcpy(dst, src, sizeof(*src));
@@ -182,7 +182,7 @@
             size += strlen(src->ppEnabledExtensionNames[i]) + 1;
         }
 
-        dst = intel_alloc(handle, size, 0, VK_SYSTEM_ALLOC_TYPE_DEBUG);
+        dst = intel_alloc(handle, size, 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
         if (!dst)
             return false;
 
@@ -239,7 +239,7 @@
 
     assert(dbg_size >= sizeof(*dbg));
 
-    dbg = intel_alloc(handle, dbg_size, 0, VK_SYSTEM_ALLOC_TYPE_DEBUG);
+    dbg = intel_alloc(handle, dbg_size, 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
     if (!dbg)
         return NULL;
 
@@ -284,7 +284,7 @@
 
     assert(obj_size >= sizeof(*base));
 
-    base = intel_alloc(handle, obj_size, 0, VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
+    base = intel_alloc(handle, obj_size, 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
     if (!base)
         return NULL;
 
diff --git a/icd/intel/pipeline.c b/icd/intel/pipeline.c
index 503e771..62f4860 100644
--- a/icd/intel/pipeline.c
+++ b/icd/intel/pipeline.c
@@ -207,7 +207,7 @@
     struct intel_pipeline_shader *sh;
     VkResult ret;
 
-    sh = intel_alloc(dev, sizeof(*sh), 0, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+    sh = intel_alloc(dev, sizeof(*sh), 0, VK_SYSTEM_ALLOC_SCOPE_DEVICE);
     if (!sh)
         return NULL;
     memset(sh, 0, sizeof(*sh));
@@ -1350,6 +1350,7 @@
 ICD_EXPORT VkResult VKAPI vkCreatePipelineCache(
     VkDevice                                    device,
     const VkPipelineCacheCreateInfo*            pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkPipelineCache*                            pPipelineCache)
 {
 
@@ -1360,7 +1361,8 @@
 
 void VKAPI vkDestroyPipelineCache(
     VkDevice                                    device,
-    VkPipelineCache                             pipelineCache)
+    VkPipelineCache                             pipelineCache,
+    const VkAllocCallbacks*                     pAllocator)
 {
 }
 
@@ -1387,6 +1389,7 @@
     VkPipelineCache                           pipelineCache,
     uint32_t                                  createInfoCount,
     const VkGraphicsPipelineCreateInfo*       pCreateInfos,
+    const VkAllocCallbacks*                     pAllocator,
     VkPipeline*                               pPipelines)
 {
     struct intel_dev *dev = intel_dev(device);
@@ -1415,6 +1418,7 @@
     VkPipelineCache                           pipelineCache,
     uint32_t                                  createInfoCount,
     const VkComputePipelineCreateInfo*        pCreateInfos,
+    const VkAllocCallbacks*                     pAllocator,
     VkPipeline*                               pPipelines)
 {
     return VK_ERROR_VALIDATION_FAILED;
@@ -1422,7 +1426,8 @@
 
 ICD_EXPORT void VKAPI vkDestroyPipeline(
     VkDevice                                device,
-    VkPipeline                              pipeline)
+    VkPipeline                              pipeline,
+    const VkAllocCallbacks*                     pAllocator)
 
  {
     struct intel_obj *obj = intel_obj(pipeline);
diff --git a/icd/intel/query.c b/icd/intel/query.c
index 9cb6af2..88c647b 100644
--- a/icd/intel/query.c
+++ b/icd/intel/query.c
@@ -219,6 +219,7 @@
 ICD_EXPORT VkResult VKAPI vkCreateQueryPool(
     VkDevice                                    device,
     const VkQueryPoolCreateInfo*                pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkQueryPool*                                pQueryPool)
 {
     struct intel_dev *dev = intel_dev(device);
@@ -229,7 +230,8 @@
 
 ICD_EXPORT void VKAPI vkDestroyQueryPool(
     VkDevice                                    device,
-    VkQueryPool                                 queryPool)
+    VkQueryPool                                 queryPool,
+    const VkAllocCallbacks*                     pAllocator)
 
  {
     struct intel_obj *obj = intel_obj(queryPool);
diff --git a/icd/intel/queue.c b/icd/intel/queue.c
index 5565a5f..7a47e28 100644
--- a/icd/intel/queue.c
+++ b/icd/intel/queue.c
@@ -439,6 +439,7 @@
 ICD_EXPORT VkResult VKAPI vkCreateSemaphore(
     VkDevice                                device,
     const VkSemaphoreCreateInfo            *pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkSemaphore                            *pSemaphore)
 {
     /*
@@ -459,7 +460,8 @@
 
 ICD_EXPORT void VKAPI vkDestroySemaphore(
     VkDevice                                    device,
-    VkSemaphore                                 semaphore)
+    VkSemaphore                                 semaphore,
+    const VkAllocCallbacks*                     pAllocator)
 {
     struct intel_obj *obj = intel_obj(semaphore);
     obj->destroy(obj);
diff --git a/icd/intel/sampler.c b/icd/intel/sampler.c
index 493d097..e5b946b 100644
--- a/icd/intel/sampler.c
+++ b/icd/intel/sampler.c
@@ -398,6 +398,7 @@
 ICD_EXPORT VkResult VKAPI vkCreateSampler(
     VkDevice                                  device,
     const VkSamplerCreateInfo*              pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkSampler*                                pSampler)
 {
     struct intel_dev *dev = intel_dev(device);
@@ -408,7 +409,8 @@
 
 ICD_EXPORT void VKAPI vkDestroySampler(
     VkDevice                                device,
-    VkSampler                                 sampler)
+    VkSampler                                 sampler,
+    const VkAllocCallbacks*                     pAllocator)
 
  {
     struct intel_obj *obj = intel_obj(sampler);
diff --git a/icd/intel/shader.c b/icd/intel/shader.c
index 9965d7e..d8a3146 100644
--- a/icd/intel/shader.c
+++ b/icd/intel/shader.c
@@ -68,6 +68,7 @@
 ICD_EXPORT VkResult VKAPI vkCreateShaderModule(
     VkDevice                                    device,
     const VkShaderModuleCreateInfo*             pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkShaderModule*                             pShaderModule)
 {
     struct intel_dev *dev = intel_dev(device);
@@ -77,7 +78,8 @@
 
 ICD_EXPORT void VKAPI vkDestroyShaderModule(
     VkDevice                                device,
-    VkShaderModule                          shaderModule)
+    VkShaderModule                          shaderModule,
+    const VkAllocCallbacks*                     pAllocator)
 
  {
     struct intel_obj *obj = intel_obj(shaderModule);
@@ -127,6 +129,7 @@
 ICD_EXPORT VkResult VKAPI vkCreateShader(
         VkDevice                                  device,
         const VkShaderCreateInfo*               pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
         VkShader*                                 pShader)
 {
     struct intel_dev *dev = intel_dev(device);
@@ -136,7 +139,8 @@
 
 ICD_EXPORT void VKAPI vkDestroyShader(
     VkDevice                                device,
-    VkShader                                shader)
+    VkShader                                shader,
+    const VkAllocCallbacks*                     pAllocator)
 
  {
     struct intel_obj *obj = intel_obj(shader);
diff --git a/icd/intel/view.c b/icd/intel/view.c
index 8593f53..b246927 100644
--- a/icd/intel/view.c
+++ b/icd/intel/view.c
@@ -1356,6 +1356,7 @@
 ICD_EXPORT VkResult VKAPI vkCreateBufferView(
     VkDevice                            device,
     const VkBufferViewCreateInfo*       pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkBufferView*                       pView)
 {
     struct intel_dev *dev = intel_dev(device);
@@ -1366,7 +1367,8 @@
 
 ICD_EXPORT void VKAPI vkDestroyBufferView(
     VkDevice                            device,
-    VkBufferView                        bufferView)
+    VkBufferView                        bufferView,
+    const VkAllocCallbacks*                     pAllocator)
 
  {
     struct intel_obj *obj = intel_obj(bufferView);
@@ -1377,6 +1379,7 @@
 ICD_EXPORT VkResult VKAPI vkCreateImageView(
     VkDevice                            device,
     const VkImageViewCreateInfo*        pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkImageView*                        pView)
 {
     struct intel_dev *dev = intel_dev(device);
@@ -1387,7 +1390,8 @@
 
 ICD_EXPORT void VKAPI vkDestroyImageView(
     VkDevice                            device,
-    VkImageView                         imageView)
+    VkImageView                         imageView,
+    const VkAllocCallbacks*                     pAllocator)
 
 {
     struct intel_obj *obj = intel_obj(imageView);
diff --git a/icd/intel/wsi_x11.c b/icd/intel/wsi_x11.c
index dbcd2d6..77fe2f4 100644
--- a/icd/intel/wsi_x11.c
+++ b/icd/intel/wsi_x11.c
@@ -409,7 +409,7 @@
     xcb_pixmap_t pixmap;
     VkResult ret;
 
-    ret = intel_img_create(dev, img_info, true, &img);
+    ret = intel_img_create(dev, img_info, NULL, true, &img);
     if (ret != VK_SUCCESS)
         return NULL;
 
@@ -456,12 +456,12 @@
     uint32_t i;
 
     images = intel_alloc(sc, sizeof(*images) * info->minImageCount,
-            0, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+            0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
     if (!images)
         return false;
     image_state = intel_alloc(
             sc, sizeof(intel_x11_swap_chain_image_state) * info->minImageCount,
-            0, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+            0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
     if (!image_state) {
         for (i = 0; i < info->minImageCount; i++) {
             intel_img_destroy(images[i]);
@@ -471,7 +471,7 @@
     }
     present_queue = intel_alloc(
             sc, sizeof(uint32_t) * info->minImageCount,
-            0, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+            0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
     if (!present_queue) {
         for (i = 0; i < info->minImageCount; i++) {
             intel_img_destroy(images[i]);
@@ -786,7 +786,7 @@
 
     close(fd);
 
-    sc = intel_alloc(dev, sizeof(*sc), 0, VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
+    sc = intel_alloc(dev, sizeof(*sc), 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
     if (!sc)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
 
@@ -843,7 +843,7 @@
 {
     struct intel_x11_img_data *data;
 
-    data = intel_alloc(img, sizeof(*data), 0, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+    data = intel_alloc(img, sizeof(*data), 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
     if (!data)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
 
@@ -872,7 +872,7 @@
 {
     struct intel_x11_fence_data *data;
 
-    data = intel_alloc(fence, sizeof(*data), 0, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+    data = intel_alloc(fence, sizeof(*data), 0, VK_SYSTEM_ALLOC_SCOPE_OBJECT);
     if (!data)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
 
diff --git a/icd/nulldrv/nulldrv.c b/icd/nulldrv/nulldrv.c
index b217e22..a0e175a 100644
--- a/icd/nulldrv/nulldrv.c
+++ b/icd/nulldrv/nulldrv.c
@@ -611,6 +611,7 @@
 ICD_EXPORT VkResult VKAPI vkCreateBuffer(
     VkDevice                                  device,
     const VkBufferCreateInfo*               pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkBuffer*                                 pBuffer)
 {
     NULLDRV_LOG_FUNC;
@@ -621,7 +622,8 @@
 
 ICD_EXPORT void VKAPI vkDestroyBuffer(
     VkDevice                                  device,
-    VkBuffer                                  buffer)
+    VkBuffer                                  buffer,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -629,6 +631,7 @@
 ICD_EXPORT VkResult VKAPI vkCreateCommandPool(
     VkDevice                                    device,
     const VkCmdPoolCreateInfo*                  pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkCmdPool*                                  pCmdPool)
 {
     NULLDRV_LOG_FUNC;
@@ -637,7 +640,8 @@
 
 ICD_EXPORT void VKAPI vkDestroyCommandPool(
     VkDevice                                    device,
-    VkCmdPool                                   cmdPool)
+    VkCmdPool                                   cmdPool,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -1237,6 +1241,7 @@
 ICD_EXPORT VkResult VKAPI vkCreateDevice(
     VkPhysicalDevice                            gpu_,
     const VkDeviceCreateInfo*               pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkDevice*                                 pDevice)
 {
     NULLDRV_LOG_FUNC;
@@ -1245,7 +1250,8 @@
 }
 
 ICD_EXPORT void VKAPI vkDestroyDevice(
-    VkDevice                                  device)
+    VkDevice                                  device,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -1271,6 +1277,7 @@
 ICD_EXPORT VkResult VKAPI vkCreateEvent(
     VkDevice                                  device,
     const VkEventCreateInfo*                pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkEvent*                                  pEvent)
 {
     NULLDRV_LOG_FUNC;
@@ -1279,7 +1286,8 @@
 
 ICD_EXPORT void VKAPI vkDestroyEvent(
     VkDevice                                  device,
-    VkEvent                                   event)
+    VkEvent                                   event,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -1311,6 +1319,7 @@
 ICD_EXPORT VkResult VKAPI vkCreateFence(
     VkDevice                                  device,
     const VkFenceCreateInfo*                pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkFence*                                  pFence)
 {
     NULLDRV_LOG_FUNC;
@@ -1322,7 +1331,8 @@
 
 ICD_EXPORT void VKAPI vkDestroyFence(
     VkDevice                                  device,
-    VkFence                                  fence)
+    VkFence                                  fence,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -1468,6 +1478,7 @@
 ICD_EXPORT VkResult VKAPI vkCreateImage(
     VkDevice                                  device,
     const VkImageCreateInfo*                pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkImage*                                  pImage)
 {
     NULLDRV_LOG_FUNC;
@@ -1479,7 +1490,8 @@
 
 ICD_EXPORT void VKAPI vkDestroyImage(
     VkDevice                                  device,
-    VkImage                                   image)
+    VkImage                                   image,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -1501,6 +1513,7 @@
 ICD_EXPORT VkResult VKAPI vkAllocMemory(
     VkDevice                                  device,
     const VkMemoryAllocInfo*                pAllocInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkDeviceMemory*                             pMem)
 {
     NULLDRV_LOG_FUNC;
@@ -1511,7 +1524,8 @@
 
 ICD_EXPORT void VKAPI vkFreeMemory(
     VkDevice                                    device,
-    VkDeviceMemory                              mem_)
+    VkDeviceMemory                              mem_,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -1567,6 +1581,7 @@
 
 ICD_EXPORT VkResult VKAPI vkCreateInstance(
     const VkInstanceCreateInfo*             pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkInstance*                               pInstance)
 {
     NULLDRV_LOG_FUNC;
@@ -1585,7 +1600,8 @@
 }
 
 ICD_EXPORT void VKAPI vkDestroyInstance(
-    VkInstance                                pInstance)
+    VkInstance                                pInstance,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -1712,6 +1728,7 @@
 ICD_EXPORT VkResult VKAPI vkCreatePipelineCache(
     VkDevice                                    device,
     const VkPipelineCacheCreateInfo*            pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkPipelineCache*                            pPipelineCache)
 {
 
@@ -1721,14 +1738,16 @@
 
 ICD_EXPORT void VKAPI vkDestroyPipeline(
     VkDevice                                  device,
-    VkPipeline                                pipeline)
+    VkPipeline                                pipeline,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
 
 void VKAPI vkDestroyPipelineCache(
     VkDevice                                    device,
-    VkPipelineCache                             pipelineCache)
+    VkPipelineCache                             pipelineCache,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -1757,6 +1776,7 @@
     VkPipelineCache                           pipelineCache,
     uint32_t                                  createInfoCount,
     const VkGraphicsPipelineCreateInfo*    pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkPipeline*                               pPipeline)
 {
     NULLDRV_LOG_FUNC;
@@ -1773,6 +1793,7 @@
     VkPipelineCache                           pipelineCache,
     uint32_t                                  createInfoCount,
     const VkComputePipelineCreateInfo*     pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkPipeline*                               pPipeline)
 {
     NULLDRV_LOG_FUNC;
@@ -1786,6 +1807,7 @@
 ICD_EXPORT VkResult VKAPI vkCreateQueryPool(
     VkDevice                                  device,
     const VkQueryPoolCreateInfo*           pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkQueryPool*                             pQueryPool)
 {
     NULLDRV_LOG_FUNC;
@@ -1794,7 +1816,8 @@
 
 ICD_EXPORT void VKAPI vkDestroyQueryPool(
     VkDevice                                  device,
-    VkQueryPool                               queryPoool)
+    VkQueryPool                               queryPoool,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -1833,6 +1856,7 @@
 ICD_EXPORT VkResult VKAPI vkCreateSemaphore(
     VkDevice                                  device,
     const VkSemaphoreCreateInfo*            pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkSemaphore*                              pSemaphore)
 {
     NULLDRV_LOG_FUNC;
@@ -1841,7 +1865,8 @@
 
 ICD_EXPORT void VKAPI vkDestroySemaphore(
     VkDevice                                  device,
-    VkSemaphore                               semaphore)
+    VkSemaphore                               semaphore,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -1849,6 +1874,7 @@
 ICD_EXPORT VkResult VKAPI vkCreateSampler(
     VkDevice                                  device,
     const VkSamplerCreateInfo*              pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkSampler*                                pSampler)
 {
     NULLDRV_LOG_FUNC;
@@ -1860,7 +1886,8 @@
 
 ICD_EXPORT void VKAPI vkDestroySampler(
     VkDevice                                  device,
-    VkSampler                                 sampler)
+    VkSampler                                 sampler,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -1868,6 +1895,7 @@
 ICD_EXPORT VkResult VKAPI vkCreateShaderModule(
     VkDevice                                    device,
     const VkShaderModuleCreateInfo*             pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkShaderModule*                             pShaderModule)
 {
     // TODO: Fill in with real data
@@ -1877,7 +1905,8 @@
 
 ICD_EXPORT void VKAPI vkDestroyShaderModule(
     VkDevice                                    device,
-    VkShaderModule                              shaderModule)
+    VkShaderModule                              shaderModule,
+    const VkAllocCallbacks*                     pAllocator)
 {
     // TODO: Fill in with real data
     NULLDRV_LOG_FUNC;
@@ -1886,6 +1915,7 @@
 ICD_EXPORT VkResult VKAPI vkCreateShader(
         VkDevice                                  device,
         const VkShaderCreateInfo*               pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
         VkShader*                                 pShader)
 {
     NULLDRV_LOG_FUNC;
@@ -1896,7 +1926,8 @@
 
 ICD_EXPORT void VKAPI vkDestroyShader(
     VkDevice                                  device,
-    VkShader                                  shader)
+    VkShader                                  shader,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -1904,6 +1935,7 @@
 ICD_EXPORT VkResult VKAPI vkCreateBufferView(
     VkDevice                                  device,
     const VkBufferViewCreateInfo*          pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkBufferView*                            pView)
 {
     NULLDRV_LOG_FUNC;
@@ -1915,7 +1947,8 @@
 
 ICD_EXPORT void VKAPI vkDestroyBufferView(
     VkDevice                                  device,
-    VkBufferView                              bufferView)
+    VkBufferView                              bufferView,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -1923,6 +1956,7 @@
 ICD_EXPORT VkResult VKAPI vkCreateImageView(
     VkDevice                                  device,
     const VkImageViewCreateInfo*           pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkImageView*                             pView)
 {
     NULLDRV_LOG_FUNC;
@@ -1934,7 +1968,8 @@
 
 ICD_EXPORT void VKAPI vkDestroyImageView(
     VkDevice                                  device,
-    VkImageView                               imageView)
+    VkImageView                               imageView,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -1942,6 +1977,7 @@
 ICD_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(
     VkDevice                                   device,
     const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkDescriptorSetLayout*                   pSetLayout)
 {
     NULLDRV_LOG_FUNC;
@@ -1953,7 +1989,8 @@
 
 ICD_EXPORT void VKAPI vkDestroyDescriptorSetLayout(
     VkDevice                                  device,
-    VkDescriptorSetLayout                     descriptorSetLayout)
+    VkDescriptorSetLayout                     descriptorSetLayout,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -1961,6 +1998,7 @@
 ICD_EXPORT VkResult VKAPI  vkCreatePipelineLayout(
     VkDevice                                device,
     const VkPipelineLayoutCreateInfo*       pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkPipelineLayout*                       pPipelineLayout)
 {
     NULLDRV_LOG_FUNC;
@@ -1973,7 +2011,8 @@
 
 ICD_EXPORT void VKAPI vkDestroyPipelineLayout(
     VkDevice                                  device,
-    VkPipelineLayout                          pipelineLayout)
+    VkPipelineLayout                          pipelineLayout,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -1981,6 +2020,7 @@
 ICD_EXPORT VkResult VKAPI vkCreateDescriptorPool(
     VkDevice                                    device,
     const VkDescriptorPoolCreateInfo*           pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkDescriptorPool*                           pDescriptorPool)
 {
     NULLDRV_LOG_FUNC;
@@ -1992,7 +2032,8 @@
 
 ICD_EXPORT void VKAPI vkDestroyDescriptorPool(
     VkDevice                                  device,
-    VkDescriptorPool                          descriptorPool)
+    VkDescriptorPool                          descriptorPool,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -2053,6 +2094,7 @@
 ICD_EXPORT VkResult VKAPI vkCreateFramebuffer(
     VkDevice                                  device,
     const VkFramebufferCreateInfo*          info,
+    const VkAllocCallbacks*                     pAllocator,
     VkFramebuffer*                            fb_ret)
 {
     NULLDRV_LOG_FUNC;
@@ -2063,7 +2105,8 @@
 
 ICD_EXPORT void VKAPI vkDestroyFramebuffer(
     VkDevice                                  device,
-    VkFramebuffer                             framebuffer)
+    VkFramebuffer                             framebuffer,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -2071,6 +2114,7 @@
 ICD_EXPORT VkResult VKAPI vkCreateRenderPass(
     VkDevice                                  device,
     const VkRenderPassCreateInfo*          info,
+    const VkAllocCallbacks*                     pAllocator,
     VkRenderPass*                            rp_ret)
 {
     NULLDRV_LOG_FUNC;
@@ -2081,7 +2125,8 @@
 
 ICD_EXPORT void VKAPI vkDestroyRenderPass(
     VkDevice                                  device,
-    VkRenderPass                              renderPass)
+    VkRenderPass                              renderPass,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
diff --git a/include/vulkan.h b/include/vulkan.h
index 6624b8e..f7e6cc3 100644
--- a/include/vulkan.h
+++ b/include/vulkan.h
@@ -189,16 +189,24 @@
 } VkStructureType;
 
 typedef enum {
-    VK_SYSTEM_ALLOC_TYPE_API_OBJECT = 0,
-    VK_SYSTEM_ALLOC_TYPE_INTERNAL = 1,
-    VK_SYSTEM_ALLOC_TYPE_INTERNAL_TEMP = 2,
-    VK_SYSTEM_ALLOC_TYPE_INTERNAL_SHADER = 3,
-    VK_SYSTEM_ALLOC_TYPE_DEBUG = 4,
-    VK_SYSTEM_ALLOC_TYPE_BEGIN_RANGE = VK_SYSTEM_ALLOC_TYPE_API_OBJECT,
-    VK_SYSTEM_ALLOC_TYPE_END_RANGE = VK_SYSTEM_ALLOC_TYPE_DEBUG,
-    VK_SYSTEM_ALLOC_TYPE_NUM = (VK_SYSTEM_ALLOC_TYPE_DEBUG - VK_SYSTEM_ALLOC_TYPE_API_OBJECT + 1),
-    VK_SYSTEM_ALLOC_TYPE_MAX_ENUM = 0x7FFFFFFF
-} VkSystemAllocType;
+    VK_SYSTEM_ALLOC_SCOPE_FUNCTION = 0,
+    VK_SYSTEM_ALLOC_SCOPE_OBJECT = 1,
+    VK_SYSTEM_ALLOC_SCOPE_CACHE = 2,
+    VK_SYSTEM_ALLOC_SCOPE_DEVICE = 3,
+    VK_SYSTEM_ALLOC_SCOPE_INSTANCE = 4,
+    VK_SYSTEM_ALLOC_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOC_SCOPE_FUNCTION,
+    VK_SYSTEM_ALLOC_SCOPE_END_RANGE = VK_SYSTEM_ALLOC_SCOPE_INSTANCE,
+    VK_SYSTEM_ALLOC_SCOPE_NUM = (VK_SYSTEM_ALLOC_SCOPE_INSTANCE - VK_SYSTEM_ALLOC_SCOPE_FUNCTION + 1),
+    VK_SYSTEM_ALLOC_SCOPE_MAX_ENUM = 0x7FFFFFFF
+} VkSystemAllocScope;
+
+typedef enum {
+    VK_INTERNAL_ALLOC_TYPE_EXECUTABLE = 0,
+    VK_INTERNAL_ALLOC_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOC_TYPE_EXECUTABLE,
+    VK_INTERNAL_ALLOC_TYPE_END_RANGE = VK_INTERNAL_ALLOC_TYPE_EXECUTABLE,
+    VK_INTERNAL_ALLOC_TYPE_NUM = (VK_INTERNAL_ALLOC_TYPE_EXECUTABLE - VK_INTERNAL_ALLOC_TYPE_EXECUTABLE + 1),
+    VK_INTERNAL_ALLOC_TYPE_MAX_ENUM = 0x7FFFFFFF
+} VkInternalAllocType;
 
 typedef enum {
     VK_FORMAT_UNDEFINED = 0,
@@ -1023,15 +1031,34 @@
 typedef VkFlags VkQueryControlFlags;
 
 typedef void* (VKAPI *PFN_vkAllocFunction)(
-    void*                           pUserData,
-    size_t                          size,
-    size_t                          alignment,
-    VkSystemAllocType               allocType);
+    void*              pUserData,
+    size_t             size,
+    size_t             alignment,
+    VkSystemAllocScope allocScope);
+
+typedef void* (VKAPI *PFN_vkReallocFunction)(
+    void*              pUserData,
+    void*              pOriginal,
+    size_t             size,
+    size_t             alignment,
+    VkSystemAllocScope allocScope);
 
 typedef void (VKAPI *PFN_vkFreeFunction)(
     void*                           pUserData,
     void*                           pMem);
 
+typedef void (VKAPI *PFN_vkInternalAllocNotification)(
+    void*              pUserData,
+    size_t                           size,
+    VkInternalAllocType              allocType,
+    VkSystemAllocScope               allocScope);
+
+typedef void (VKAPI *PFN_vkInternalFreeNotification)(
+    void*              pUserData,
+    size_t                           size,
+    VkInternalAllocType              allocType,
+    VkSystemAllocScope               allocScope);
+
 typedef void (VKAPI *PFN_vkVoidFunction)(void);
 
 typedef struct {
@@ -1045,16 +1072,9 @@
 } VkApplicationInfo;
 
 typedef struct {
-    void*                                       pUserData;
-    PFN_vkAllocFunction                         pfnAlloc;
-    PFN_vkFreeFunction                          pfnFree;
-} VkAllocCallbacks;
-
-typedef struct {
     VkStructureType                             sType;
     const void*                                 pNext;
     const VkApplicationInfo*                    pAppInfo;
-    const VkAllocCallbacks*                     pAllocCb;
     uint32_t                                    enabledLayerNameCount;
     const char*const*                           ppEnabledLayerNames;
     uint32_t                                    enabledExtensionNameCount;
@@ -1062,6 +1082,15 @@
 } VkInstanceCreateInfo;
 
 typedef struct {
+    void*                                       pUserData;
+    PFN_vkAllocFunction                         pfnAlloc;
+    PFN_vkReallocFunction                       pfnRealloc;
+    PFN_vkFreeFunction                          pfnFree;
+    PFN_vkInternalAllocNotification             pfnInternalAlloc;
+    PFN_vkInternalFreeNotification              pfnInternalFree;
+} VkAllocCallbacks;
+
+typedef struct {
     VkBool32                                    robustBufferAccess;
     VkBool32                                    fullDrawIndexUint32;
     VkBool32                                    imageCubeArray;
@@ -2047,8 +2076,8 @@
 } VkMemoryBarrier;
 
 
-typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance);
-typedef void (VKAPI *PFN_vkDestroyInstance)(VkInstance instance);
+typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkInstance* pInstance);
+typedef void (VKAPI *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocCallbacks* pAllocator);
 typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
 typedef void (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
 typedef void (VKAPI *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
@@ -2058,8 +2087,8 @@
 typedef void (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
 typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName);
 typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName);
-typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice);
-typedef void (VKAPI *PFN_vkDestroyDevice)(VkDevice device);
+typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice);
+typedef void (VKAPI *PFN_vkDestroyDevice)(VkDevice device, const VkAllocCallbacks* pAllocator);
 typedef VkResult (VKAPI *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
 typedef VkResult (VKAPI *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
 typedef VkResult (VKAPI *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
@@ -2068,8 +2097,8 @@
 typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmitInfo, VkFence fence);
 typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue);
 typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device);
-typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem);
-typedef void (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory mem);
+typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, const VkAllocCallbacks* pAllocator, VkDeviceMemory* pMem);
+typedef void (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory mem, const VkAllocCallbacks* pAllocator);
 typedef VkResult (VKAPI *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
 typedef void (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory mem);
 typedef VkResult (VKAPI *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
@@ -2084,60 +2113,60 @@
 typedef VkResult (VKAPI *PFN_vkQueueBindSparseBufferMemory)(VkQueue queue, VkBuffer buffer, uint32_t bindInfoCount, const VkSparseMemoryBindInfo* pBindInfo);
 typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageOpaqueMemory)(VkQueue queue, VkImage image, uint32_t bindInfoCount, const VkSparseMemoryBindInfo* pBindInfo);
 typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageMemory)(VkQueue queue, VkImage image, uint32_t bindInfoCount, const VkSparseImageMemoryBindInfo* pBindInfo);
-typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence);
-typedef void (VKAPI *PFN_vkDestroyFence)(VkDevice device, VkFence fence);
+typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFence* pFence);
+typedef void (VKAPI *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocCallbacks* pAllocator);
 typedef VkResult (VKAPI *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
 typedef VkResult (VKAPI *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
 typedef VkResult (VKAPI *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
-typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore);
-typedef void (VKAPI *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore);
-typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent);
-typedef void (VKAPI *PFN_vkDestroyEvent)(VkDevice device, VkEvent event);
+typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSemaphore* pSemaphore);
+typedef void (VKAPI *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkEvent* pEvent);
+typedef void (VKAPI *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocCallbacks* pAllocator);
 typedef VkResult (VKAPI *PFN_vkGetEventStatus)(VkDevice device, VkEvent event);
 typedef VkResult (VKAPI *PFN_vkSetEvent)(VkDevice device, VkEvent event);
 typedef VkResult (VKAPI *PFN_vkResetEvent)(VkDevice device, VkEvent event);
-typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool);
-typedef void (VKAPI *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool);
+typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkQueryPool* pQueryPool);
+typedef void (VKAPI *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocCallbacks* pAllocator);
 typedef VkResult (VKAPI *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
-typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer);
-typedef void (VKAPI *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer);
-typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView);
-typedef void (VKAPI *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView);
-typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage);
-typedef void (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image);
+typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBuffer* pBuffer);
+typedef void (VKAPI *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBufferView* pView);
+typedef void (VKAPI *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImage* pImage);
+typedef void (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocCallbacks* pAllocator);
 typedef void (VKAPI *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
-typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView);
-typedef void (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView);
-typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule);
-typedef void (VKAPI *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule);
-typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader);
-typedef void (VKAPI *PFN_vkDestroyShader)(VkDevice device, VkShader shader);
-typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache);
-typedef void (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache);
+typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImageView* pView);
+typedef void (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkShaderModule* pShaderModule);
+typedef void (VKAPI *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkShader* pShader);
+typedef void (VKAPI *PFN_vkDestroyShader)(VkDevice device, VkShader shader, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
+typedef void (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocCallbacks* pAllocator);
 typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
 typedef VkResult (VKAPI *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
-typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
-typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
-typedef void (VKAPI *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline);
-typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout);
-typedef void (VKAPI *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout);
-typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler);
-typedef void (VKAPI *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler);
-typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout);
-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_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines);
+typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines);
+typedef void (VKAPI *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
+typedef void (VKAPI *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSampler* pSampler);
+typedef void (VKAPI *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
+typedef void (VKAPI *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
+typedef void (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocCallbacks* pAllocator);
 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 descriptorSetCount, 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);
-typedef void (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer);
-typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass);
-typedef void (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass);
+typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
+typedef void (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkRenderPass* pRenderPass);
+typedef void (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocCallbacks* pAllocator);
 typedef void (VKAPI *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
-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_vkCreateCommandPool)(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkCmdPool* pCmdPool);
+typedef void (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCmdPool cmdPool, const VkAllocCallbacks* pAllocator);
 typedef VkResult (VKAPI *PFN_vkResetCommandPool)(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags);
 typedef VkResult (VKAPI *PFN_vkAllocCommandBuffers)(VkDevice device, const VkCmdBufferAllocInfo* pAllocInfo, VkCmdBuffer* pCmdBuffers);
 typedef void (VKAPI *PFN_vkFreeCommandBuffers)(VkDevice device, VkCmdPool cmdPool, uint32_t commandBufferCount, const VkCmdBuffer* pCommandBuffers);
@@ -2192,10 +2221,12 @@
 #ifdef VK_PROTOTYPES
 VkResult VKAPI vkCreateInstance(
     const VkInstanceCreateInfo*                 pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkInstance*                                 pInstance);
 
 void VKAPI vkDestroyInstance(
-    VkInstance                                  instance);
+    VkInstance                                  instance,
+    const VkAllocCallbacks*                     pAllocator);
 
 VkResult VKAPI vkEnumeratePhysicalDevices(
     VkInstance                                  instance,
@@ -2244,10 +2275,12 @@
 VkResult VKAPI vkCreateDevice(
     VkPhysicalDevice                            physicalDevice,
     const VkDeviceCreateInfo*                   pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkDevice*                                   pDevice);
 
 void VKAPI vkDestroyDevice(
-    VkDevice                                    device);
+    VkDevice                                    device,
+    const VkAllocCallbacks*                     pAllocator);
 
 VkResult VKAPI vkEnumerateInstanceExtensionProperties(
     const char*                                 pLayerName,
@@ -2290,11 +2323,13 @@
 VkResult VKAPI vkAllocMemory(
     VkDevice                                    device,
     const VkMemoryAllocInfo*                    pAllocInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkDeviceMemory*                             pMem);
 
 void VKAPI vkFreeMemory(
     VkDevice                                    device,
-    VkDeviceMemory                              mem);
+    VkDeviceMemory                              mem,
+    const VkAllocCallbacks*                     pAllocator);
 
 VkResult VKAPI vkMapMemory(
     VkDevice                                    device,
@@ -2382,11 +2417,13 @@
 VkResult VKAPI vkCreateFence(
     VkDevice                                    device,
     const VkFenceCreateInfo*                    pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkFence*                                    pFence);
 
 void VKAPI vkDestroyFence(
     VkDevice                                    device,
-    VkFence                                     fence);
+    VkFence                                     fence,
+    const VkAllocCallbacks*                     pAllocator);
 
 VkResult VKAPI vkResetFences(
     VkDevice                                    device,
@@ -2407,20 +2444,24 @@
 VkResult VKAPI vkCreateSemaphore(
     VkDevice                                    device,
     const VkSemaphoreCreateInfo*                pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkSemaphore*                                pSemaphore);
 
 void VKAPI vkDestroySemaphore(
     VkDevice                                    device,
-    VkSemaphore                                 semaphore);
+    VkSemaphore                                 semaphore,
+    const VkAllocCallbacks*                     pAllocator);
 
 VkResult VKAPI vkCreateEvent(
     VkDevice                                    device,
     const VkEventCreateInfo*                    pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkEvent*                                    pEvent);
 
 void VKAPI vkDestroyEvent(
     VkDevice                                    device,
-    VkEvent                                     event);
+    VkEvent                                     event,
+    const VkAllocCallbacks*                     pAllocator);
 
 VkResult VKAPI vkGetEventStatus(
     VkDevice                                    device,
@@ -2437,11 +2478,13 @@
 VkResult VKAPI vkCreateQueryPool(
     VkDevice                                    device,
     const VkQueryPoolCreateInfo*                pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkQueryPool*                                pQueryPool);
 
 void VKAPI vkDestroyQueryPool(
     VkDevice                                    device,
-    VkQueryPool                                 queryPool);
+    VkQueryPool                                 queryPool,
+    const VkAllocCallbacks*                     pAllocator);
 
 VkResult VKAPI vkGetQueryPoolResults(
     VkDevice                                    device,
@@ -2456,29 +2499,35 @@
 VkResult VKAPI vkCreateBuffer(
     VkDevice                                    device,
     const VkBufferCreateInfo*                   pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkBuffer*                                   pBuffer);
 
 void VKAPI vkDestroyBuffer(
     VkDevice                                    device,
-    VkBuffer                                    buffer);
+    VkBuffer                                    buffer,
+    const VkAllocCallbacks*                     pAllocator);
 
 VkResult VKAPI vkCreateBufferView(
     VkDevice                                    device,
     const VkBufferViewCreateInfo*               pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkBufferView*                               pView);
 
 void VKAPI vkDestroyBufferView(
     VkDevice                                    device,
-    VkBufferView                                bufferView);
+    VkBufferView                                bufferView,
+    const VkAllocCallbacks*                     pAllocator);
 
 VkResult VKAPI vkCreateImage(
     VkDevice                                    device,
     const VkImageCreateInfo*                    pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkImage*                                    pImage);
 
 void VKAPI vkDestroyImage(
     VkDevice                                    device,
-    VkImage                                     image);
+    VkImage                                     image,
+    const VkAllocCallbacks*                     pAllocator);
 
 void VKAPI vkGetImageSubresourceLayout(
     VkDevice                                    device,
@@ -2489,38 +2538,46 @@
 VkResult VKAPI vkCreateImageView(
     VkDevice                                    device,
     const VkImageViewCreateInfo*                pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkImageView*                                pView);
 
 void VKAPI vkDestroyImageView(
     VkDevice                                    device,
-    VkImageView                                 imageView);
+    VkImageView                                 imageView,
+    const VkAllocCallbacks*                     pAllocator);
 
 VkResult VKAPI vkCreateShaderModule(
     VkDevice                                    device,
     const VkShaderModuleCreateInfo*             pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkShaderModule*                             pShaderModule);
 
 void VKAPI vkDestroyShaderModule(
     VkDevice                                    device,
-    VkShaderModule                              shaderModule);
+    VkShaderModule                              shaderModule,
+    const VkAllocCallbacks*                     pAllocator);
 
 VkResult VKAPI vkCreateShader(
     VkDevice                                    device,
     const VkShaderCreateInfo*                   pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkShader*                                   pShader);
 
 void VKAPI vkDestroyShader(
     VkDevice                                    device,
-    VkShader                                    shader);
+    VkShader                                    shader,
+    const VkAllocCallbacks*                     pAllocator);
 
 VkResult VKAPI vkCreatePipelineCache(
     VkDevice                                    device,
     const VkPipelineCacheCreateInfo*            pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkPipelineCache*                            pPipelineCache);
 
 void VKAPI vkDestroyPipelineCache(
     VkDevice                                    device,
-    VkPipelineCache                             pipelineCache);
+    VkPipelineCache                             pipelineCache,
+    const VkAllocCallbacks*                     pAllocator);
 
 VkResult VKAPI vkGetPipelineCacheData(
     VkDevice                                    device,
@@ -2539,6 +2596,7 @@
     VkPipelineCache                             pipelineCache,
     uint32_t                                    createInfoCount,
     const VkGraphicsPipelineCreateInfo*         pCreateInfos,
+    const VkAllocCallbacks*                     pAllocator,
     VkPipeline*                                 pPipelines);
 
 VkResult VKAPI vkCreateComputePipelines(
@@ -2546,47 +2604,57 @@
     VkPipelineCache                             pipelineCache,
     uint32_t                                    createInfoCount,
     const VkComputePipelineCreateInfo*          pCreateInfos,
+    const VkAllocCallbacks*                     pAllocator,
     VkPipeline*                                 pPipelines);
 
 void VKAPI vkDestroyPipeline(
     VkDevice                                    device,
-    VkPipeline                                  pipeline);
+    VkPipeline                                  pipeline,
+    const VkAllocCallbacks*                     pAllocator);
 
 VkResult VKAPI vkCreatePipelineLayout(
     VkDevice                                    device,
     const VkPipelineLayoutCreateInfo*           pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkPipelineLayout*                           pPipelineLayout);
 
 void VKAPI vkDestroyPipelineLayout(
     VkDevice                                    device,
-    VkPipelineLayout                            pipelineLayout);
+    VkPipelineLayout                            pipelineLayout,
+    const VkAllocCallbacks*                     pAllocator);
 
 VkResult VKAPI vkCreateSampler(
     VkDevice                                    device,
     const VkSamplerCreateInfo*                  pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkSampler*                                  pSampler);
 
 void VKAPI vkDestroySampler(
     VkDevice                                    device,
-    VkSampler                                   sampler);
+    VkSampler                                   sampler,
+    const VkAllocCallbacks*                     pAllocator);
 
 VkResult VKAPI vkCreateDescriptorSetLayout(
     VkDevice                                    device,
     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkDescriptorSetLayout*                      pSetLayout);
 
 void VKAPI vkDestroyDescriptorSetLayout(
     VkDevice                                    device,
-    VkDescriptorSetLayout                       descriptorSetLayout);
+    VkDescriptorSetLayout                       descriptorSetLayout,
+    const VkAllocCallbacks*                     pAllocator);
 
 VkResult VKAPI vkCreateDescriptorPool(
     VkDevice                                    device,
     const VkDescriptorPoolCreateInfo*           pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkDescriptorPool*                           pDescriptorPool);
 
 void VKAPI vkDestroyDescriptorPool(
     VkDevice                                    device,
-    VkDescriptorPool                            descriptorPool);
+    VkDescriptorPool                            descriptorPool,
+    const VkAllocCallbacks*                     pAllocator);
 
 VkResult VKAPI vkResetDescriptorPool(
     VkDevice                                    device,
@@ -2614,20 +2682,24 @@
 VkResult VKAPI vkCreateFramebuffer(
     VkDevice                                    device,
     const VkFramebufferCreateInfo*              pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkFramebuffer*                              pFramebuffer);
 
 void VKAPI vkDestroyFramebuffer(
     VkDevice                                    device,
-    VkFramebuffer                               framebuffer);
+    VkFramebuffer                               framebuffer,
+    const VkAllocCallbacks*                     pAllocator);
 
 VkResult VKAPI vkCreateRenderPass(
     VkDevice                                    device,
     const VkRenderPassCreateInfo*               pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkRenderPass*                               pRenderPass);
 
 void VKAPI vkDestroyRenderPass(
     VkDevice                                    device,
-    VkRenderPass                                renderPass);
+    VkRenderPass                                renderPass,
+    const VkAllocCallbacks*                     pAllocator);
 
 void VKAPI vkGetRenderAreaGranularity(
     VkDevice                                    device,
@@ -2637,11 +2709,13 @@
 VkResult VKAPI vkCreateCommandPool(
     VkDevice                                    device,
     const VkCmdPoolCreateInfo*                  pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkCmdPool*                                  pCmdPool);
 
 void VKAPI vkDestroyCommandPool(
     VkDevice                                    device,
-    VkCmdPool                                   cmdPool);
+    VkCmdPool                                   cmdPool,
+    const VkAllocCallbacks*                     pAllocator);
 
 VkResult VKAPI vkResetCommandPool(
     VkDevice                                    device,
diff --git a/layers/basic.cpp b/layers/basic.cpp
index 778a362..f416d5a 100644
--- a/layers/basic.cpp
+++ b/layers/basic.cpp
@@ -95,27 +95,27 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI basic_CreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice)
+VK_LAYER_EXPORT VkResult VKAPI basic_CreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice)
 {
     printf("At start of wrapped vkCreateDevice() call w/ gpu: %p\n", (void*)gpu);
-    VkResult result = device_dispatch_table(*pDevice)->CreateDevice(gpu, pCreateInfo, pDevice);
+    VkResult result = device_dispatch_table(*pDevice)->CreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
     printf("Completed wrapped vkCreateDevice() call w/ pDevice, Device %p: %p\n", (void*)pDevice, (void *) *pDevice);
     return result;
 }
 
 /* hook DestroyDevice to remove tableMap entry */
-VK_LAYER_EXPORT void VKAPI basic_DestroyDevice(VkDevice device)
+VK_LAYER_EXPORT void VKAPI basic_DestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator)
 {
     dispatch_key key = get_dispatch_key(device);
-    device_dispatch_table(device)->DestroyDevice(device);
+    device_dispatch_table(device)->DestroyDevice(device, pAllocator);
     destroy_device_dispatch_table(key);
 }
 
 /* hook DestroyInstance to remove tableInstanceMap entry */
-VK_LAYER_EXPORT void VKAPI basic_DestroyInstance(VkInstance instance)
+VK_LAYER_EXPORT void VKAPI basic_DestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
 {
     dispatch_key key = get_dispatch_key(instance);
-    instance_dispatch_table(instance)->DestroyInstance(instance);
+    instance_dispatch_table(instance)->DestroyInstance(instance, pAllocator);
     destroy_instance_dispatch_table(key);
 }
 
diff --git a/layers/device_limits.cpp b/layers/device_limits.cpp
index 1d686dd..eb21585 100644
--- a/layers/device_limits.cpp
+++ b/layers/device_limits.cpp
@@ -158,11 +158,11 @@
                                    pCount, pProperties);
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkInstance* pInstance)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
     VkLayerInstanceDispatchTable* pTable = my_data->instance_dispatch_table;
-    VkResult result = pTable->CreateInstance(pCreateInfo, pInstance);
+    VkResult result = pTable->CreateInstance(pCreateInfo, pAllocator, pInstance);
 
     if (result == VK_SUCCESS) {
         my_data->report_data = debug_report_create_instance(
@@ -178,12 +178,12 @@
 }
 
 /* hook DestroyInstance to remove tableInstanceMap entry */
-VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance)
+VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
 {
     dispatch_key key = get_dispatch_key(instance);
     layer_data *my_data = get_my_data_ptr(key, layer_data_map);
     VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
-    pTable->DestroyInstance(instance);
+    pTable->DestroyInstance(instance, pAllocator);
 
     // Clean up logging callback, if any
     while (my_data->logging_callback.size() > 0) {
@@ -387,7 +387,7 @@
     return skipCall;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice)
 {
     VkBool32 skipCall = VK_FALSE;
     layer_data *phy_dev_data = get_my_data_ptr(get_dispatch_key(gpu), layer_data_map);
@@ -420,7 +420,7 @@
         return VK_ERROR_VALIDATION_FAILED;
 
     layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
-    VkResult result = my_device_data->device_dispatch_table->CreateDevice(gpu, pCreateInfo, pDevice);
+    VkResult result = my_device_data->device_dispatch_table->CreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
     if (result == VK_SUCCESS) {
         my_device_data->report_data = layer_debug_report_create_device(phy_dev_data->report_data, *pDevice);
         createDeviceRegisterExtensions(pCreateInfo, *pDevice);
@@ -429,27 +429,27 @@
     return result;
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device)
+VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator)
 {
     // Free device lifetime allocations
     dispatch_key key = get_dispatch_key(device);
     layer_data *my_device_data = get_my_data_ptr(key, layer_data_map);
-    my_device_data->device_dispatch_table->DestroyDevice(device);
+    my_device_data->device_dispatch_table->DestroyDevice(device, pAllocator);
     tableDebugMarkerMap.erase(key);
     delete my_device_data->device_dispatch_table;
     layer_data_map.erase(key);
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkCmdPool* pCmdPool)
 {
     // TODO : Verify that requested QueueFamilyIndex for this pool exists
-    VkResult result = get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->CreateCommandPool(device, pCreateInfo, pCmdPool);
+    VkResult result = get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->CreateCommandPool(device, pCreateInfo, pAllocator, pCmdPool);
     return result;
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyCommandPool(VkDevice device, VkCmdPool cmdPool)
+VK_LAYER_EXPORT void VKAPI vkDestroyCommandPool(VkDevice device, VkCmdPool cmdPool, const VkAllocCallbacks* pAllocator)
 {
-    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyCommandPool(device, cmdPool);
+    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyCommandPool(device, cmdPool, pAllocator);
 }
 
 VK_LAYER_EXPORT VkResult VKAPI vkResetCommandPool(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags)
@@ -490,6 +490,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(
     VkDevice                 device,
     const VkImageCreateInfo *pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkImage                 *pImage)
 {
     VkBool32                skipCall       = VK_FALSE;
@@ -536,7 +537,7 @@
                         totalSize, ImageFormatProperties.maxResourceSize);
     }
     if (VK_FALSE == skipCall) {
-        result = dev_data->device_dispatch_table->CreateImage(device, pCreateInfo, pImage);
+        result = dev_data->device_dispatch_table->CreateImage(device, pCreateInfo, pAllocator, pImage);
     }
     return result;
 }
diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index bbcc4b0..c823e98 100755
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -1565,11 +1565,11 @@
     }
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkInstance* pInstance)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
     VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
-    VkResult result = pTable->CreateInstance(pCreateInfo, pInstance);
+    VkResult result = pTable->CreateInstance(pCreateInfo, pAllocator, pInstance);
 
     if (result == VK_SUCCESS) {
         layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
@@ -1585,12 +1585,12 @@
 }
 
 /* hook DestroyInstance to remove tableInstanceMap entry */
-VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance)
+VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
 {
     dispatch_key key = get_dispatch_key(instance);
     layer_data *my_data = get_my_data_ptr(key, layer_data_map);
     VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
-    pTable->DestroyInstance(instance);
+    pTable->DestroyInstance(instance, pAllocator);
 
     // Clean up logging callback, if any
     while (my_data->logging_callback.size() > 0) {
@@ -1625,10 +1625,10 @@
     }
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
-    VkResult result = dev_data->device_dispatch_table->CreateDevice(gpu, pCreateInfo, pDevice);
+    VkResult result = dev_data->device_dispatch_table->CreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
     if (result == VK_SUCCESS) {
         layer_data *my_instance_data = get_my_data_ptr(get_dispatch_key(gpu), layer_data_map);
         dev_data->report_data = layer_debug_report_create_device(my_instance_data->report_data, *pDevice);
@@ -1638,7 +1638,7 @@
 }
 // prototype
 static void deleteRenderPasses(layer_data*);
-VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device)
+VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator)
 {
     dispatch_key key = get_dispatch_key(device);
     layer_data* dev_data = get_my_data_ptr(key, layer_data_map);
@@ -1655,7 +1655,7 @@
     dev_data->bufferMap.clear();
     loader_platform_thread_unlock_mutex(&globalLock);
 
-    dev_data->device_dispatch_table->DestroyDevice(device);
+    dev_data->device_dispatch_table->DestroyDevice(device, pAllocator);
     tableDebugMarkerMap.erase(key);
     delete dev_data->device_dispatch_table;
     layer_data_map.erase(key);
@@ -1757,97 +1757,97 @@
     return VK_ERROR_VALIDATION_FAILED;
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyFence(VkDevice device, VkFence fence)
+VK_LAYER_EXPORT void VKAPI vkDestroyFence(VkDevice device, VkFence fence, const VkAllocCallbacks* pAllocator)
 {
-    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyFence(device, fence);
+    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyFence(device, fence, pAllocator);
     // TODO : Clean up any internal data structures using this obj.
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroySemaphore(VkDevice device, VkSemaphore semaphore)
+VK_LAYER_EXPORT void VKAPI vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocCallbacks* pAllocator)
 {
-    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroySemaphore(device, semaphore);
+    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroySemaphore(device, semaphore, pAllocator);
     // TODO : Clean up any internal data structures using this obj.
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyEvent(VkDevice device, VkEvent event)
+VK_LAYER_EXPORT void VKAPI vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocCallbacks* pAllocator)
 {
-    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyEvent(device, event);
+    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyEvent(device, event, pAllocator);
     // TODO : Clean up any internal data structures using this obj.
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool)
+VK_LAYER_EXPORT void VKAPI vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocCallbacks* pAllocator)
 {
-    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyQueryPool(device, queryPool);
+    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyQueryPool(device, queryPool, pAllocator);
     // TODO : Clean up any internal data structures using this obj.
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer)
+VK_LAYER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocCallbacks* pAllocator)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    dev_data->device_dispatch_table->DestroyBuffer(device, buffer);
+    dev_data->device_dispatch_table->DestroyBuffer(device, buffer, pAllocator);
     dev_data->bufferMap.erase(buffer);
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView)
+VK_LAYER_EXPORT void VKAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocCallbacks* pAllocator)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    dev_data->device_dispatch_table->DestroyBufferView(device, bufferView);
+    dev_data->device_dispatch_table->DestroyBufferView(device, bufferView, pAllocator);
     dev_data->bufferViewMap.erase(bufferView);
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image)
+VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image, const VkAllocCallbacks* pAllocator)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    dev_data->device_dispatch_table->DestroyImage(device, image);
+    dev_data->device_dispatch_table->DestroyImage(device, image, pAllocator);
     dev_data->imageMap.erase(image);
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyImageView(VkDevice device, VkImageView imageView)
+VK_LAYER_EXPORT void VKAPI vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocCallbacks* pAllocator)
 {
-    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyImageView(device, imageView);
+    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyImageView(device, imageView, pAllocator);
     // TODO : Clean up any internal data structures using this obj.
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule)
+VK_LAYER_EXPORT void VKAPI vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocCallbacks* pAllocator)
 {
-    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyShaderModule(device, shaderModule);
+    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyShaderModule(device, shaderModule, pAllocator);
     // TODO : Clean up any internal data structures using this obj.
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyShader(VkDevice device, VkShader shader)
+VK_LAYER_EXPORT void VKAPI vkDestroyShader(VkDevice device, VkShader shader, const VkAllocCallbacks* pAllocator)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    dev_data->device_dispatch_table->DestroyShader(device, shader);
+    dev_data->device_dispatch_table->DestroyShader(device, shader, pAllocator);
     dev_data->shaderStageMap.erase(shader);
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline)
+VK_LAYER_EXPORT void VKAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocCallbacks* pAllocator)
 {
-    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyPipeline(device, pipeline);
+    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyPipeline(device, pipeline, pAllocator);
     // TODO : Clean up any internal data structures using this obj.
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout)
+VK_LAYER_EXPORT void VKAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocCallbacks* pAllocator)
 {
-    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyPipelineLayout(device, pipelineLayout);
+    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyPipelineLayout(device, pipelineLayout, pAllocator);
     // TODO : Clean up any internal data structures using this obj.
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroySampler(VkDevice device, VkSampler sampler)
+VK_LAYER_EXPORT void VKAPI vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocCallbacks* pAllocator)
 {
-    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroySampler(device, sampler);
+    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroySampler(device, sampler, pAllocator);
     // TODO : Clean up any internal data structures using this obj.
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout)
+VK_LAYER_EXPORT void VKAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocCallbacks* pAllocator)
 {
-    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyDescriptorSetLayout(device, descriptorSetLayout);
+    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
     // TODO : Clean up any internal data structures using this obj.
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool)
+VK_LAYER_EXPORT void VKAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocCallbacks* pAllocator)
 {
-    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyDescriptorPool(device, descriptorPool);
+    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyDescriptorPool(device, descriptorPool, pAllocator);
     // TODO : Clean up any internal data structures using this obj.
 }
 
@@ -1857,22 +1857,22 @@
     // TODO : Clean up any internal data structures using this obj.
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer)
+VK_LAYER_EXPORT void VKAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocCallbacks* pAllocator)
 {
-    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyFramebuffer(device, framebuffer);
+    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyFramebuffer(device, framebuffer, pAllocator);
     // TODO : Clean up any internal data structures using this obj.
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass)
+VK_LAYER_EXPORT void VKAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocCallbacks* pAllocator)
 {
-    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyRenderPass(device, renderPass);
+    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyRenderPass(device, renderPass, pAllocator);
     // TODO : Clean up any internal data structures using this obj.
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBuffer* pBuffer)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    VkResult result = dev_data->device_dispatch_table->CreateBuffer(device, pCreateInfo, pBuffer);
+    VkResult result = dev_data->device_dispatch_table->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
         // TODO : This doesn't create deep copy of pQueueFamilyIndices so need to fix that if/when we want that data to be valid
@@ -1882,10 +1882,10 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBufferView* pView)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    VkResult result = dev_data->device_dispatch_table->CreateBufferView(device, pCreateInfo, pView);
+    VkResult result = dev_data->device_dispatch_table->CreateBufferView(device, pCreateInfo, pAllocator, pView);
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
         dev_data->bufferViewMap[*pView] = unique_ptr<VkBufferViewCreateInfo>(new VkBufferViewCreateInfo(*pCreateInfo));
@@ -1894,10 +1894,10 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImage* pImage)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    VkResult result = dev_data->device_dispatch_table->CreateImage(device, pCreateInfo, pImage);
+    VkResult result = dev_data->device_dispatch_table->CreateImage(device, pCreateInfo, pAllocator, pImage);
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
         dev_data->imageMap[*pImage] = unique_ptr<VkImageCreateInfo>(new VkImageCreateInfo(*pCreateInfo));
@@ -1906,10 +1906,10 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImageView* pView)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    VkResult result = dev_data->device_dispatch_table->CreateImageView(device, pCreateInfo, pView);
+    VkResult result = dev_data->device_dispatch_table->CreateImageView(device, pCreateInfo, pAllocator, pView);
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
         dev_data->imageViewMap[*pView] = unique_ptr<VkImageViewCreateInfo>(new VkImageViewCreateInfo(*pCreateInfo));
@@ -1921,10 +1921,11 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateShader(
         VkDevice device,
         const VkShaderCreateInfo *pCreateInfo,
+        const VkAllocCallbacks* pAllocator,
         VkShader *pShader)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    VkResult result = dev_data->device_dispatch_table->CreateShader(device, pCreateInfo, pShader);
+    VkResult result = dev_data->device_dispatch_table->CreateShader(device, pCreateInfo, pAllocator, pShader);
 
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
@@ -1939,19 +1940,21 @@
 VkResult VKAPI vkCreatePipelineCache(
     VkDevice                                    device,
     const VkPipelineCacheCreateInfo*            pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkPipelineCache*                            pPipelineCache)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    VkResult result = dev_data->device_dispatch_table->CreatePipelineCache(device, pCreateInfo, pPipelineCache);
+    VkResult result = dev_data->device_dispatch_table->CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
     return result;
 }
 
 void VKAPI vkDestroyPipelineCache(
     VkDevice                                    device,
-    VkPipelineCache                             pipelineCache)
+    VkPipelineCache                             pipelineCache,
+    const VkAllocCallbacks* pAllocator)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    dev_data->device_dispatch_table->DestroyPipelineCache(device, pipelineCache);
+    dev_data->device_dispatch_table->DestroyPipelineCache(device, pipelineCache, pAllocator);
 }
 
 VkResult VKAPI vkGetPipelineCacheData(
@@ -1976,7 +1979,7 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines)
 {
     VkResult result = VK_SUCCESS;
     //TODO What to do with pipelineCache?
@@ -1996,7 +1999,7 @@
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
-        result = dev_data->device_dispatch_table->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pPipelines);
+        result = dev_data->device_dispatch_table->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pAllocator, pPipelines);
         loader_platform_thread_lock_mutex(&globalLock);
         for (i=0; i<count; i++) {
             pPipeNode[i]->pipeline = pPipelines[i];
@@ -2018,10 +2021,10 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSampler* pSampler)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    VkResult result = dev_data->device_dispatch_table->CreateSampler(device, pCreateInfo, pSampler);
+    VkResult result = dev_data->device_dispatch_table->CreateSampler(device, pCreateInfo, pAllocator, pSampler);
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
         dev_data->sampleMap[*pSampler] = unique_ptr<SAMPLER_NODE>(new SAMPLER_NODE(pSampler, pCreateInfo));
@@ -2030,10 +2033,10 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    VkResult result = dev_data->device_dispatch_table->CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
+    VkResult result = dev_data->device_dispatch_table->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
     if (VK_SUCCESS == result) {
         LAYOUT_NODE* pNewNode = new LAYOUT_NODE;
         if (NULL == pNewNode) {
@@ -2079,10 +2082,10 @@
     return result;
 }
 
-VkResult VKAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout)
+VkResult VKAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    VkResult result = dev_data->device_dispatch_table->CreatePipelineLayout(device, pCreateInfo, pPipelineLayout);
+    VkResult result = dev_data->device_dispatch_table->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
     if (VK_SUCCESS == result) {
         PIPELINE_LAYOUT_NODE plNode = dev_data->pipelineLayoutMap[*pPipelineLayout];
         plNode.descriptorSetLayouts.resize(pCreateInfo->setLayoutCount);
@@ -2098,10 +2101,10 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    VkResult result = dev_data->device_dispatch_table->CreateDescriptorPool(device, pCreateInfo, pDescriptorPool);
+    VkResult result = dev_data->device_dispatch_table->CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
     if (VK_SUCCESS == result) {
         // Insert this pool into Global Pool LL at head
         if (log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (uint64_t) *pDescriptorPool, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
@@ -3270,10 +3273,10 @@
         dev_data->device_dispatch_table->CmdWriteTimestamp(cmdBuffer, pipelineStage, queryPool, slot);
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    VkResult result = dev_data->device_dispatch_table->CreateFramebuffer(device, pCreateInfo, pFramebuffer);
+    VkResult result = dev_data->device_dispatch_table->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
     if (VK_SUCCESS == result) {
         // Shadow create info and store in map
         VkFramebufferCreateInfo* localFBCI = new VkFramebufferCreateInfo(*pCreateInfo);
@@ -3437,13 +3440,13 @@
     return skip_call;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkRenderPass* pRenderPass)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     if (validateDependencies(dev_data, device, pCreateInfo)) {
         return VK_ERROR_VALIDATION_FAILED;
     }
-    VkResult result = dev_data->device_dispatch_table->CreateRenderPass(device, pCreateInfo, pRenderPass);
+    VkResult result = dev_data->device_dispatch_table->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
     if (VK_SUCCESS == result) {
         // Shadow create info and store in map
         VkRenderPassCreateInfo* localRPCI = new VkRenderPassCreateInfo(*pCreateInfo);
diff --git a/layers/image.cpp b/layers/image.cpp
index 8ae7a12..c615109 100644
--- a/layers/image.cpp
+++ b/layers/image.cpp
@@ -112,11 +112,11 @@
     return res;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkInstance* pInstance)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
     VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
-    VkResult result = pTable->CreateInstance(pCreateInfo, pInstance);
+    VkResult result = pTable->CreateInstance(pCreateInfo, pAllocator, pInstance);
 
     if (result == VK_SUCCESS) {
         my_data->report_data = debug_report_create_instance(pTable, *pInstance, pCreateInfo->enabledExtensionNameCount,
@@ -127,13 +127,13 @@
     return result;
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance)
+VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
 {
     // Grab the key before the instance is destroyed.
     dispatch_key key = get_dispatch_key(instance);
     layer_data *my_data = get_my_data_ptr(key, layer_data_map);
     VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
-    pTable->DestroyInstance(instance);
+    pTable->DestroyInstance(instance, pAllocator);
 
     // Clean up logging callback, if any
     while (my_data->logging_callback.size() > 0) {
@@ -148,11 +148,11 @@
 
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice)
 {
     layer_data *instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
     layer_data *device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
-    VkResult result = device_data->device_dispatch_table->CreateDevice(physicalDevice, pCreateInfo, pDevice);
+    VkResult result = device_data->device_dispatch_table->CreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
     if(result == VK_SUCCESS)
     {
         device_data->report_data = layer_debug_report_create_device(instance_data->report_data, *pDevice);
@@ -162,11 +162,11 @@
     return result;
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device)
+VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator)
 {
     dispatch_key key = get_dispatch_key(device);
     layer_data *my_data = get_my_data_ptr(key, layer_data_map);
-    my_data->device_dispatch_table->DestroyDevice(device);
+    my_data->device_dispatch_table->DestroyDevice(device, pAllocator);
     delete my_data->device_dispatch_table;
     layer_data_map.erase(key);
 }
@@ -240,7 +240,7 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImage* pImage)
 {
     VkBool32 skipCall = VK_FALSE;
     layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -259,7 +259,7 @@
     if (skipCall)
         return VK_ERROR_VALIDATION_FAILED;
 
-    VkResult result = device_data->device_dispatch_table->CreateImage(device, pCreateInfo, pImage);
+    VkResult result = device_data->device_dispatch_table->CreateImage(device, pCreateInfo, pAllocator, pImage);
 
     if(result == VK_SUCCESS) {
         device_data->imageMap[*pImage] = IMAGE_STATE(pCreateInfo);
@@ -267,14 +267,14 @@
     return result;
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image)
+VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image, const VkAllocCallbacks* pAllocator)
 {
     layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     device_data->imageMap.erase(image);
-    device_data->device_dispatch_table->DestroyImage(device, image);
+    device_data->device_dispatch_table->DestroyImage(device, image, pAllocator);
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkRenderPass* pRenderPass)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkBool32 skipCall = VK_FALSE;
@@ -346,12 +346,12 @@
     if (skipCall)
         return VK_ERROR_VALIDATION_FAILED;
 
-    VkResult result = my_data->device_dispatch_table->CreateRenderPass(device, pCreateInfo, pRenderPass);
+    VkResult result = my_data->device_dispatch_table->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
 
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImageView* pView)
 {
     VkBool32 skipCall = VK_FALSE;
     layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -454,7 +454,7 @@
     if (skipCall)
         return VK_ERROR_VALIDATION_FAILED;
 
-    VkResult result = device_data->device_dispatch_table->CreateImageView(device, pCreateInfo, pView);
+    VkResult result = device_data->device_dispatch_table->CreateImageView(device, pCreateInfo, pAllocator, pView);
     return result;
 }
 
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index cd60627..c9ea469 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -925,13 +925,13 @@
 }
 
 // hook DestroyInstance to remove tableInstanceMap entry
-VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance)
+VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
 {
     // Grab the key before the instance is destroyed.
     dispatch_key key = get_dispatch_key(instance);
     layer_data *my_data = get_my_data_ptr(key, layer_data_map);
     VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
-    pTable->DestroyInstance(instance);
+    pTable->DestroyInstance(instance, pAllocator);
 
     // Clean up logging callback, if any
     while (my_data->logging_callback.size() > 0) {
@@ -952,11 +952,12 @@
 
 VkResult VKAPI vkCreateInstance(
     const VkInstanceCreateInfo*                 pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkInstance*                                 pInstance)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
     VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
-    VkResult result = pTable->CreateInstance(pCreateInfo, pInstance);
+    VkResult result = pTable->CreateInstance(pCreateInfo, pAllocator, pInstance);
 
     if (result == VK_SUCCESS) {
         my_data->report_data = debug_report_create_instance(
@@ -993,11 +994,12 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(
     VkPhysicalDevice          gpu,
     const VkDeviceCreateInfo *pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkDevice                 *pDevice)
 {
     layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
     VkLayerDispatchTable *pDeviceTable = my_device_data->device_dispatch_table;
-    VkResult result = pDeviceTable->CreateDevice(gpu, pCreateInfo, pDevice);
+    VkResult result = pDeviceTable->CreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
     if (result == VK_SUCCESS) {
         layer_data *my_instance_data = get_my_data_ptr(get_dispatch_key(gpu), layer_data_map);
         my_device_data->report_data = layer_debug_report_create_device(my_instance_data->report_data, *pDevice);
@@ -1007,7 +1009,8 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkDestroyDevice(
-    VkDevice device)
+    VkDevice device,
+    const VkAllocCallbacks* pAllocator)
 {
     dispatch_key key = get_dispatch_key(device);
     layer_data *my_device_data = get_my_data_ptr(key, layer_data_map);
@@ -1042,7 +1045,7 @@
 #endif
     VkLayerDispatchTable *pDisp  = my_device_data->device_dispatch_table;
     if (VK_FALSE == skipCall) {
-        pDisp->DestroyDevice(device);
+        pDisp->DestroyDevice(device, pAllocator);
     }
     delete my_device_data->device_dispatch_table;
     layer_data_map.erase(key);
@@ -1195,10 +1198,11 @@
 VK_LAYER_EXPORT VkResult VKAPI vkAllocMemory(
     VkDevice                 device,
     const VkMemoryAllocInfo *pAllocInfo,
+    const VkAllocCallbacks* pAllocator,
     VkDeviceMemory          *pMem)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    VkResult result = my_data->device_dispatch_table->AllocMemory(device, pAllocInfo, pMem);
+    VkResult result = my_data->device_dispatch_table->AllocMemory(device, pAllocInfo, pAllocator, pMem);
     // TODO : Track allocations and overall size here
     loader_platform_thread_lock_mutex(&globalLock);
     add_mem_obj_info(my_data, device, *pMem, pAllocInfo);
@@ -1209,7 +1213,8 @@
 
 VK_LAYER_EXPORT void VKAPI vkFreeMemory(
     VkDevice       device,
-    VkDeviceMemory mem)
+    VkDeviceMemory mem,
+    const VkAllocCallbacks* pAllocator)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     /* From spec : A memory object is freed by calling vkFreeMemory() when it is no longer needed. Before
@@ -1221,7 +1226,7 @@
     print_mem_list(my_data, device);
     printCBList(my_data, device);
     loader_platform_thread_unlock_mutex(&globalLock);
-    my_data->device_dispatch_table->FreeMemory(device, mem);
+    my_data->device_dispatch_table->FreeMemory(device, mem, pAllocator);
 }
 
 VK_LAYER_EXPORT VkResult VKAPI vkMapMemory(
@@ -1260,7 +1265,7 @@
     my_data->device_dispatch_table->UnmapMemory(device, mem);
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyFence(VkDevice device, VkFence fence)
+VK_LAYER_EXPORT void VKAPI vkDestroyFence(VkDevice device, VkFence fence, const VkAllocCallbacks* pAllocator)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     loader_platform_thread_lock_mutex(&globalLock);
@@ -1270,10 +1275,10 @@
         my_data->fenceMap.erase(item);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    my_data->device_dispatch_table->DestroyFence(device, fence);
+    my_data->device_dispatch_table->DestroyFence(device, fence, pAllocator);
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer)
+VK_LAYER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocCallbacks* pAllocator)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkBool32 skipCall = VK_FALSE;
@@ -1285,11 +1290,11 @@
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
-        my_data->device_dispatch_table->DestroyBuffer(device, buffer);
+        my_data->device_dispatch_table->DestroyBuffer(device, buffer, pAllocator);
     }
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image)
+VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image, const VkAllocCallbacks* pAllocator)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkBool32 skipCall = VK_FALSE;
@@ -1301,7 +1306,7 @@
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
-        my_data->device_dispatch_table->DestroyImage(device, image);
+        my_data->device_dispatch_table->DestroyImage(device, image, pAllocator);
     }
 }
 
@@ -1429,10 +1434,11 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateFence(
     VkDevice                 device,
     const VkFenceCreateInfo *pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkFence                 *pFence)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    VkResult result = my_data->device_dispatch_table->CreateFence(device, pCreateInfo, pFence);
+    VkResult result = my_data->device_dispatch_table->CreateFence(device, pCreateInfo, pAllocator, pFence);
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
         MT_FENCE_INFO* pFI = &my_data->fenceMap[*pFence];
@@ -1568,10 +1574,11 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateBuffer(
     VkDevice                  device,
     const VkBufferCreateInfo *pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkBuffer                 *pBuffer)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    VkResult result = my_data->device_dispatch_table->CreateBuffer(device, pCreateInfo, pBuffer);
+    VkResult result = my_data->device_dispatch_table->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
         add_object_create_info(my_data, (uint64_t)*pBuffer, VK_OBJECT_TYPE_BUFFER, pCreateInfo);
@@ -1583,10 +1590,11 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(
     VkDevice                 device,
     const VkImageCreateInfo *pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkImage                 *pImage)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    VkResult result = my_data->device_dispatch_table->CreateImage(device, pCreateInfo, pImage);
+    VkResult result = my_data->device_dispatch_table->CreateImage(device, pCreateInfo, pAllocator, pImage);
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
         add_object_create_info(my_data, (uint64_t)*pImage, VK_OBJECT_TYPE_IMAGE, pCreateInfo);
@@ -1598,10 +1606,11 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(
     VkDevice                     device,
     const VkImageViewCreateInfo *pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkImageView                 *pView)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    VkResult result = my_data->device_dispatch_table->CreateImageView(device, pCreateInfo, pView);
+    VkResult result = my_data->device_dispatch_table->CreateImageView(device, pCreateInfo, pAllocator, pView);
     if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
         // Validate that img has correct usage flags set
@@ -1616,10 +1625,11 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(
     VkDevice                      device,
     const VkBufferViewCreateInfo *pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkBufferView                 *pView)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    VkResult result = my_data->device_dispatch_table->CreateBufferView(device, pCreateInfo, pView);
+    VkResult result = my_data->device_dispatch_table->CreateBufferView(device, pCreateInfo, pAllocator, pView);
     if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
         // In order to create a valid buffer view, the buffer must have been created with at least one of the
@@ -2431,10 +2441,11 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateSemaphore(
     VkDevice                     device,
     const VkSemaphoreCreateInfo *pCreateInfo,
+    const VkAllocCallbacks*      pAllocator,
     VkSemaphore                 *pSemaphore)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    VkResult result = my_data->device_dispatch_table->CreateSemaphore(device, pCreateInfo, pSemaphore);
+    VkResult result = my_data->device_dispatch_table->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
     loader_platform_thread_lock_mutex(&globalLock);
     if (*pSemaphore != VK_NULL_HANDLE) {
         my_data->semaphoreMap[*pSemaphore] = MEMTRACK_SEMAPHORE_STATE_UNSET;
@@ -2445,7 +2456,8 @@
 
 VK_LAYER_EXPORT void VKAPI vkDestroySemaphore(
     VkDevice    device,
-    VkSemaphore semaphore)
+    VkSemaphore semaphore,
+    const VkAllocCallbacks* pAllocator)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     loader_platform_thread_lock_mutex(&globalLock);
@@ -2454,7 +2466,7 @@
         my_data->semaphoreMap.erase(item);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    my_data->device_dispatch_table->DestroySemaphore(device, semaphore);
+    my_data->device_dispatch_table->DestroySemaphore(device, semaphore, pAllocator);
 }
 
 VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(
diff --git a/layers/multi.cpp b/layers/multi.cpp
index 1db6b6f..5234462 100644
--- a/layers/multi.cpp
+++ b/layers/multi.cpp
@@ -40,23 +40,23 @@
 /******************************** Layer multi1 functions **************************/
 
 /* hook DestroyDevice to remove tableMap entry */
-VK_LAYER_EXPORT void VKAPI multi1DestroyDevice(VkDevice device)
+VK_LAYER_EXPORT void VKAPI multi1DestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator)
 {
     VkLayerDispatchTable *pDisp = get_dispatch_table(multi1_device_table_map, device);
     dispatch_key key = get_dispatch_key(device);
 
     printf("At start of multi1 layer vkDestroyDevice()\n");
-    pDisp->DestroyDevice(device);
+    pDisp->DestroyDevice(device, pAllocator);
     multi1_device_table_map.erase(key);
     printf("Completed multi1 layer vkDestroyDevice()\n");
 }
 
-VK_LAYER_EXPORT VkResult VKAPI multi1CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler)
+VK_LAYER_EXPORT VkResult VKAPI multi1CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSampler* pSampler)
 {
     VkLayerDispatchTable *pDisp = get_dispatch_table(multi1_device_table_map, device);
 
     printf("At start of multi1 layer vkCreateSampler()\n");
-    VkResult result = pDisp->CreateSampler(device, pCreateInfo, pSampler);
+    VkResult result = pDisp->CreateSampler(device, pCreateInfo, pAllocator, pSampler);
     printf("Completed multi1 layer vkCreateSampler()\n");
     return result;
 }
@@ -66,12 +66,13 @@
                                 VkPipelineCache pipelineCache,
                                 uint32_t count,
                                 const VkGraphicsPipelineCreateInfo* pCreateInfos,
+                                const VkAllocCallbacks* pAllocator,
                                 VkPipeline* pPipelines)
 {
     VkLayerDispatchTable *pDisp = get_dispatch_table(multi1_device_table_map, device);
 
     printf("At start of multi1 layer vkCreateGraphicsPipeline()\n");
-    VkResult result = pDisp->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pPipelines);
+    VkResult result = pDisp->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pAllocator, pPipelines);
     printf("Completed multi1 layer vkCreateGraphicsPipeline()\n");
     return result;
 }
@@ -139,13 +140,13 @@
 }
 
 /* hook DestroyInstance to remove tableInstanceMap entry */
-VK_LAYER_EXPORT void VKAPI multi2DestroyInstance(VkInstance instance)
+VK_LAYER_EXPORT void VKAPI multi2DestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
 {
     VkLayerInstanceDispatchTable *pDisp = get_dispatch_table(multi2_instance_table_map, instance);
     dispatch_key key = get_dispatch_key(instance);
 
     printf("At start of wrapped multi2 vkDestroyInstance()\n");
-    pDisp->DestroyInstance(instance);
+    pDisp->DestroyInstance(instance, pAllocator);
     multi2_instance_table_map.erase(key);
     printf("Completed multi2 layer vkDestroyInstance()\n");
 }
diff --git a/layers/object_track.h b/layers/object_track.h
index 6969b6f..ed611e9 100644
--- a/layers/object_track.h
+++ b/layers/object_track.h
@@ -634,11 +634,12 @@
 VkResult
 explicit_CreateInstance(
     const VkInstanceCreateInfo *pCreateInfo,
+    const VkAllocCallbacks     * pAllocator,
     VkInstance                 * pInstance)
 {
 
     VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(ObjectTracker_instance_table_map, *pInstance);
-    VkResult result = pInstanceTable->CreateInstance(pCreateInfo, pInstance);
+    VkResult result = pInstanceTable->CreateInstance(pCreateInfo, pAllocator, pInstance);
 
     if (result == VK_SUCCESS) {
         layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
@@ -673,12 +674,13 @@
 explicit_CreateDevice(
     VkPhysicalDevice         gpu,
     const VkDeviceCreateInfo *pCreateInfo,
+    const VkAllocCallbacks   *pAllocator,
     VkDevice                 *pDevice)
 {
     loader_platform_thread_lock_mutex(&objLock);
 //    VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(ObjectTracker_instance_table_map, gpu);
     VkLayerDispatchTable *pDeviceTable = get_dispatch_table(ObjectTracker_device_table_map, *pDevice);
-    VkResult result = pDeviceTable->CreateDevice(gpu, pCreateInfo, pDevice);
+    VkResult result = pDeviceTable->CreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
     if (result == VK_SUCCESS) {
         layer_data *my_instance_data = get_my_data_ptr(get_dispatch_key(gpu), layer_data_map);
         //// VkLayerDispatchTable *pTable = get_dispatch_table(ObjectTracker_device_table_map, *pDevice);
@@ -872,13 +874,14 @@
 void
 explicit_FreeMemory(
     VkDevice       device,
-    VkDeviceMemory mem)
+    VkDeviceMemory mem,
+    const VkAllocCallbacks* pAllocator)
 {
     loader_platform_thread_lock_mutex(&objLock);
     validate_object(device, device);
     loader_platform_thread_unlock_mutex(&objLock);
 
-    get_dispatch_table(ObjectTracker_device_table_map, device)->FreeMemory(device, mem);
+    get_dispatch_table(ObjectTracker_device_table_map, device)->FreeMemory(device, mem, pAllocator);
 
     loader_platform_thread_lock_mutex(&objLock);
     destroy_obj(device, mem);
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index 359a8c2..638bce5 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -1822,10 +1822,11 @@
 
 VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(
     const VkInstanceCreateInfo* pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkInstance* pInstance)
 {
     VkLayerInstanceDispatchTable *pTable = get_dispatch_table(pc_instance_table_map, *pInstance);
-    VkResult result = pTable->CreateInstance(pCreateInfo, pInstance);
+    VkResult result = pTable->CreateInstance(pCreateInfo, pAllocator, pInstance);
 
     if (result == VK_SUCCESS) {
         layer_data *data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
@@ -1839,12 +1840,13 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkDestroyInstance(
-    VkInstance instance)
+    VkInstance instance,
+    const VkAllocCallbacks* pAllocator)
 {
     // Grab the key before the instance is destroyed.
     dispatch_key key = get_dispatch_key(instance);
     VkLayerInstanceDispatchTable *pTable = get_dispatch_table(pc_instance_table_map, instance);
-    pTable->DestroyInstance(instance);
+    pTable->DestroyInstance(instance, pAllocator);
 
     // Clean up logging callback, if any
     layer_data *my_data = get_my_data_ptr(key, layer_data_map);
@@ -2085,6 +2087,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(
     VkPhysicalDevice physicalDevice,
     const VkDeviceCreateInfo* pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkDevice* pDevice)
 {
     /*
@@ -2095,7 +2098,7 @@
      * object as the first parameter. We couldn't get here if it was wrong!
      */
     VkLayerDispatchTable *pTable = get_dispatch_table(pc_device_table_map, *pDevice);
-    VkResult result = pTable->CreateDevice(physicalDevice, pCreateInfo, pDevice);
+    VkResult result = pTable->CreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
     if(result == VK_SUCCESS)
     {
         layer_data *instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
@@ -2107,7 +2110,8 @@
 }
 
 VK_LAYER_EXPORT void VKAPI vkDestroyDevice(
-    VkDevice device)
+    VkDevice device,
+    const VkAllocCallbacks* pAllocator)
 {
     layer_debug_report_destroy_device(device);
 
@@ -2116,7 +2120,7 @@
     fprintf(stderr, "Device: %p, key: %p\n", device, key);
 #endif
 
-    get_dispatch_table(pc_device_table_map, device)->DestroyDevice(device);
+    get_dispatch_table(pc_device_table_map, device)->DestroyDevice(device, pAllocator);
     pc_device_table_map.erase(key);
     assert(pc_device_table_map.size() == 0 && "Should not have any instance mappings hanging around");
 }
@@ -2291,11 +2295,12 @@
 VK_LAYER_EXPORT VkResult VKAPI vkAllocMemory(
     VkDevice device,
     const VkMemoryAllocInfo* pAllocInfo,
+    const VkAllocCallbacks* pAllocator,
     VkDeviceMemory* pMem)
 {
     PreAllocMemory(device, pAllocInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->AllocMemory(device, pAllocInfo, pMem);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->AllocMemory(device, pAllocInfo, pAllocator, pMem);
 
     PostAllocMemory(device, pMem, result);
 
@@ -2870,11 +2875,12 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateFence(
     VkDevice device,
     const VkFenceCreateInfo* pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkFence* pFence)
 {
     PreCreateFence(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateFence(device, pCreateInfo, pFence);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateFence(device, pCreateInfo, pAllocator, pFence);
 
     PostCreateFence(device, pFence, result);
 
@@ -3039,11 +3045,12 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateSemaphore(
     VkDevice device,
     const VkSemaphoreCreateInfo* pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkSemaphore* pSemaphore)
 {
     PreCreateSemaphore(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateSemaphore(device, pCreateInfo, pSemaphore);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
 
     PostCreateSemaphore(device, pSemaphore, result);
 
@@ -3090,11 +3097,12 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateEvent(
     VkDevice device,
     const VkEventCreateInfo* pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkEvent* pEvent)
 {
     PreCreateEvent(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateEvent(device, pCreateInfo, pEvent);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateEvent(device, pCreateInfo, pAllocator, pEvent);
 
     PostCreateEvent(device, pEvent, result);
 
@@ -3232,11 +3240,12 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateQueryPool(
     VkDevice device,
     const VkQueryPoolCreateInfo* pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkQueryPool* pQueryPool)
 {
     PreCreateQueryPool(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateQueryPool(device, pCreateInfo, pQueryPool);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
 
     PostCreateQueryPool(device, pQueryPool, result);
 
@@ -3340,11 +3349,12 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateBuffer(
     VkDevice device,
     const VkBufferCreateInfo* pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkBuffer* pBuffer)
 {
     PreCreateBuffer(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateBuffer(device, pCreateInfo, pBuffer);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
 
     PostCreateBuffer(device, pBuffer, result);
 
@@ -3398,11 +3408,12 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(
     VkDevice device,
     const VkBufferViewCreateInfo* pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkBufferView* pView)
 {
     PreCreateBufferView(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateBufferView(device, pCreateInfo, pView);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateBufferView(device, pCreateInfo, pAllocator, pView);
 
     PostCreateBufferView(device, pView, result);
 
@@ -3480,11 +3491,12 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(
     VkDevice device,
     const VkImageCreateInfo* pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkImage* pImage)
 {
     PreCreateImage(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateImage(device, pCreateInfo, pImage);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateImage(device, pCreateInfo, pAllocator, pImage);
 
     PostCreateImage(device, pImage, result);
 
@@ -3618,11 +3630,12 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(
     VkDevice device,
     const VkImageViewCreateInfo* pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkImageView* pView)
 {
     PreCreateImageView(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateImageView(device, pCreateInfo, pView);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateImageView(device, pCreateInfo, pAllocator, pView);
 
     PostCreateImageView(device, pView, result);
 
@@ -3670,10 +3683,11 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateShaderModule(
     VkDevice device,
     const VkShaderModuleCreateInfo* pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkShaderModule* pShaderModule)
 {
     PreCreateShaderModule(device, pCreateInfo);
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateShaderModule(device, pCreateInfo, pShaderModule);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
     PostCreateShaderModule(device, pShaderModule, result);
     return result;
 }
@@ -3721,11 +3735,12 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateShader(
     VkDevice device,
     const VkShaderCreateInfo* pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkShader* pShader)
 {
     PreCreateShader(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateShader(device, pCreateInfo, pShader);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateShader(device, pCreateInfo, pAllocator, pShader);
 
     PostCreateShader(device, pShader, result);
 
@@ -3775,11 +3790,12 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreatePipelineCache(
     VkDevice device,
     const VkPipelineCacheCreateInfo* pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkPipelineCache* pPipelineCache)
 {
     PreCreatePipelineCache(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreatePipelineCache(device, pCreateInfo, pPipelineCache);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
 
     PostCreatePipelineCache(device, pPipelineCache, result);
 
@@ -4176,11 +4192,12 @@
     VkPipelineCache pipelineCache,
     uint32_t count,
     const VkGraphicsPipelineCreateInfo* pCreateInfos,
+    const VkAllocCallbacks* pAllocator,
     VkPipeline* pPipelines)
 {
     PreCreateGraphicsPipelines(device, pCreateInfos);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pPipelines);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pAllocator, pPipelines);
 
     PostCreateGraphicsPipelines(device, pipelineCache, count, pPipelines, result);
 
@@ -4248,11 +4265,12 @@
     VkPipelineCache pipelineCache,
     uint32_t count,
     const VkComputePipelineCreateInfo* pCreateInfos,
+    const VkAllocCallbacks* pAllocator,
     VkPipeline* pPipelines)
 {
     PreCreateComputePipelines(device, pCreateInfos);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateComputePipelines(device, pipelineCache, count, pCreateInfos, pPipelines);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateComputePipelines(device, pipelineCache, count, pCreateInfos, pAllocator, pPipelines);
 
     PostCreateComputePipelines(device, pipelineCache, count, pPipelines, result);
 
@@ -4305,11 +4323,12 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreatePipelineLayout(
     VkDevice device,
     const VkPipelineLayoutCreateInfo* pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkPipelineLayout* pPipelineLayout)
 {
     PreCreatePipelineLayout(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreatePipelineLayout(device, pCreateInfo, pPipelineLayout);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
 
     PostCreatePipelineLayout(device, pPipelineLayout, result);
 
@@ -4412,11 +4431,12 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateSampler(
     VkDevice device,
     const VkSamplerCreateInfo* pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkSampler* pSampler)
 {
     PreCreateSampler(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateSampler(device, pCreateInfo, pSampler);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateSampler(device, pCreateInfo, pAllocator, pSampler);
 
     PostCreateSampler(device, pSampler, result);
 
@@ -4476,11 +4496,12 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(
     VkDevice device,
     const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkDescriptorSetLayout* pSetLayout)
 {
     PreCreateDescriptorSetLayout(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
 
     PostCreateDescriptorSetLayout(device, pSetLayout, result);
 
@@ -4540,11 +4561,12 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorPool(
     VkDevice device,
     const VkDescriptorPoolCreateInfo* pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkDescriptorPool* pDescriptorPool)
 {
     PreCreateDescriptorPool(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDescriptorPool(device, pCreateInfo, pDescriptorPool);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
 
     PostCreateDescriptorPool(device, pCreateInfo->maxSets, pDescriptorPool, result);
 
@@ -4775,11 +4797,12 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateFramebuffer(
     VkDevice device,
     const VkFramebufferCreateInfo* pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkFramebuffer* pFramebuffer)
 {
     PreCreateFramebuffer(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateFramebuffer(device, pCreateInfo, pFramebuffer);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
 
     PostCreateFramebuffer(device, pFramebuffer, result);
 
@@ -4956,11 +4979,12 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(
     VkDevice device,
     const VkRenderPassCreateInfo* pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkRenderPass* pRenderPass)
 {
     PreCreateRenderPass(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateRenderPass(device, pCreateInfo, pRenderPass);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
 
     PostCreateRenderPass(device, pRenderPass, result);
 
@@ -5031,11 +5055,12 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandPool(
     VkDevice device,
     const VkCmdPoolCreateInfo* pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkCmdPool* pCmdPool)
 {
     PreCreateCommandPool(device, pCreateInfo);
 
-    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateCommandPool(device, pCreateInfo, pCmdPool);
+    VkResult result = get_dispatch_table(pc_device_table_map, device)->CreateCommandPool(device, pCreateInfo, pAllocator, pCmdPool);
 
     PostCreateCommandPool(device, pCmdPool, result);
 
diff --git a/layers/screenshot.cpp b/layers/screenshot.cpp
index eae5867..c53d776 100644
--- a/layers/screenshot.cpp
+++ b/layers/screenshot.cpp
@@ -207,7 +207,7 @@
     //     map image2
     //     read from image2's mapped memeory.
 
-    err = pTableDevice->CreateImage(device, &imgCreateInfo, &image2);
+    err = pTableDevice->CreateImage(device, &imgCreateInfo, NULL, &image2);
     assert(!err);
 
     pTableDevice->GetImageMemoryRequirements(device, image2, &memRequirements);
@@ -222,7 +222,7 @@
                                 &memAllocInfo.memoryTypeIndex);
     assert(pass);
 
-    err = pTableDevice->AllocMemory(device, &memAllocInfo, &mem2);
+    err = pTableDevice->AllocMemory(device, &memAllocInfo, NULL, &mem2);
     assert(!err);
 
     err = pTableQueue->BindImageMemory(device, image2, mem2, 0);
@@ -308,7 +308,7 @@
 
     // Clean up
     pTableDevice->UnmapMemory(device, mem2);
-    pTableDevice->FreeMemory(device, mem2);
+    pTableDevice->FreeMemory(device, mem2, NULL);
     pTableDevice->FreeCommandBuffers(device, deviceMap[device]->cmdPool, 1, &cmdBuffer);
 }
 
@@ -336,10 +336,11 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(
     VkPhysicalDevice          gpu,
     const VkDeviceCreateInfo *pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkDevice                 *pDevice)
 {
     VkLayerDispatchTable *pDisp  = get_dispatch_table(screenshot_device_table_map, *pDevice);
-    VkResult result = pDisp->CreateDevice(gpu, pCreateInfo, pDevice);
+    VkResult result = pDisp->CreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
 
     if (result == VK_SUCCESS) {
         init_screenshot();
@@ -461,10 +462,11 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateCommandPool(
     VkDevice  device,
     const VkCmdPoolCreateInfo *pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkCmdPool *pCmdPool)
 {
     VkLayerDispatchTable* pTable = screenshot_device_table_map[device];
-    VkResult result = get_dispatch_table(screenshot_device_table_map, device)->CreateCommandPool(device, pCreateInfo, pCmdPool);
+    VkResult result = get_dispatch_table(screenshot_device_table_map, device)->CreateCommandPool(device, pCreateInfo, pAllocator, pCmdPool);
 
     loader_platform_thread_lock_mutex(&globalLock);
     if (screenshotEnvQueried && screenshotFrames.empty()) {
diff --git a/layers/shader_checker.cpp b/layers/shader_checker.cpp
index 53efcad..9e417f6 100644
--- a/layers/shader_checker.cpp
+++ b/layers/shader_checker.cpp
@@ -138,11 +138,12 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(
     VkDevice device,
     const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkDescriptorSetLayout* pSetLayout)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     /* stash a copy of the layout bindings */
-    VkResult result = my_data->device_dispatch_table->CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
+    VkResult result = my_data->device_dispatch_table->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
 
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
@@ -158,10 +159,11 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreatePipelineLayout(
     VkDevice                                    device,
     const VkPipelineLayoutCreateInfo*           pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkPipelineLayout*                           pPipelineLayout)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    VkResult result = my_data->device_dispatch_table->CreatePipelineLayout(device, pCreateInfo, pPipelineLayout);
+    VkResult result = my_data->device_dispatch_table->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
 
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
@@ -602,6 +604,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateShaderModule(
         VkDevice device,
         const VkShaderModuleCreateInfo *pCreateInfo,
+        const VkAllocCallbacks* pAllocator,
         VkShaderModule *pShaderModule)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -613,7 +616,7 @@
         return VK_ERROR_VALIDATION_FAILED;
     }
 
-    VkResult res = my_data->device_dispatch_table->CreateShaderModule(device, pCreateInfo, pShaderModule);
+    VkResult res = my_data->device_dispatch_table->CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
 
     if (res == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
@@ -626,10 +629,11 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateShader(
         VkDevice device,
         const VkShaderCreateInfo *pCreateInfo,
+        const VkAllocCallbacks* pAllocator,
         VkShader *pShader)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    VkResult res = my_data->device_dispatch_table->CreateShader(device, pCreateInfo, pShader);
+    VkResult res = my_data->device_dispatch_table->CreateShader(device, pCreateInfo, pAllocator, pShader);
 
     loader_platform_thread_lock_mutex(&globalLock);
     my_data->shader_object_map[*pShader] = new shader_object(my_data, pCreateInfo);
@@ -640,10 +644,11 @@
 VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(
         VkDevice device,
         const VkRenderPassCreateInfo *pCreateInfo,
+        const VkAllocCallbacks* pAllocator,
         VkRenderPass *pRenderPass)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    VkResult res = my_data->device_dispatch_table->CreateRenderPass(device, pCreateInfo, pRenderPass);
+    VkResult res = my_data->device_dispatch_table->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
 
     loader_platform_thread_lock_mutex(&globalLock);
     my_data->render_pass_map[*pRenderPass] = new render_pass(pCreateInfo);
@@ -1130,6 +1135,7 @@
                          VkPipelineCache pipelineCache,
                          uint32_t count,
                          const VkGraphicsPipelineCreateInfo *pCreateInfos,
+                         const VkAllocCallbacks* pAllocator,
                          VkPipeline *pPipelines)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
@@ -1142,7 +1148,7 @@
         /* The driver is allowed to crash if passed junk. Only actually create the
          * pipeline if we didn't run into any showstoppers above.
          */
-        return my_data->device_dispatch_table->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pPipelines);
+        return my_data->device_dispatch_table->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pAllocator, pPipelines);
     }
     else {
         return VK_ERROR_VALIDATION_FAILED;
@@ -1150,10 +1156,10 @@
 }
 
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice)
 {
     layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
-    VkResult result = my_device_data->device_dispatch_table->CreateDevice(gpu, pCreateInfo, pDevice);
+    VkResult result = my_device_data->device_dispatch_table->CreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
     if (result == VK_SUCCESS) {
         layer_data *my_instance_data = get_my_data_ptr(get_dispatch_key(gpu), layer_data_map);
         my_device_data->report_data = layer_debug_report_create_device(my_instance_data->report_data, *pDevice);
@@ -1162,22 +1168,23 @@
 }
 
 /* hook DextroyDevice to remove tableMap entry */
-VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device)
+VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator)
 {
     dispatch_key key = get_dispatch_key(device);
     layer_data *my_device_data = get_my_data_ptr(key, layer_data_map);
-    my_device_data->device_dispatch_table->DestroyDevice(device);
+    my_device_data->device_dispatch_table->DestroyDevice(device, pAllocator);
     delete my_device_data->device_dispatch_table;
     layer_data_map.erase(key);
 }
 
 VkResult VKAPI vkCreateInstance(
     const VkInstanceCreateInfo*                 pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkInstance*                                 pInstance)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
     VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
-    VkResult result = pTable->CreateInstance(pCreateInfo, pInstance);
+    VkResult result = pTable->CreateInstance(pCreateInfo, pAllocator, pInstance);
 
     if (result == VK_SUCCESS) {
         layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
@@ -1193,11 +1200,11 @@
 }
 
 /* hook DestroyInstance to remove tableInstanceMap entry */
-VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance)
+VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
 {
     dispatch_key key = get_dispatch_key(instance);
     layer_data *my_data = get_my_data_ptr(key, layer_data_map);
-    my_data->instance_dispatch_table->DestroyInstance(instance);
+    my_data->instance_dispatch_table->DestroyInstance(instance, pAllocator);
 
     // Clean up logging callback, if any
     while (my_data->logging_callback.size() > 0) {
diff --git a/layers/swapchain.cpp b/layers/swapchain.cpp
index 42cf7a8..0075b6f 100644
--- a/layers/swapchain.cpp
+++ b/layers/swapchain.cpp
@@ -197,12 +197,12 @@
 }
 
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkInstance* pInstance)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
     // Call down the call chain:
     VkLayerInstanceDispatchTable* pTable = my_data->instance_dispatch_table;
-    VkResult result = pTable->CreateInstance(pCreateInfo, pInstance);
+    VkResult result = pTable->CreateInstance(pCreateInfo, pAllocator, pInstance);
     if (result == VK_SUCCESS) {
         // Since it succeeded, do layer-specific work:
         layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
@@ -218,7 +218,7 @@
     return result;
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance)
+VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator)
 {
     VkBool32 skipCall = VK_FALSE;
     dispatch_key key = get_dispatch_key(instance);
@@ -233,7 +233,7 @@
 
     if (VK_FALSE == skipCall) {
         // Call down the call chain:
-        my_data->instance_dispatch_table->DestroyInstance(instance);
+        my_data->instance_dispatch_table->DestroyInstance(instance, pAllocator);
 
         // Clean up logging callback, if any
         while (my_data->logging_callback.size() > 0) {
@@ -299,7 +299,7 @@
     return VK_ERROR_VALIDATION_FAILED;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice)
+VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice)
 {
     VkResult result = VK_SUCCESS;
     VkBool32 skipCall = VK_FALSE;
@@ -319,7 +319,7 @@
     layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
     // Call down the call chain:
     result = my_device_data->device_dispatch_table->CreateDevice(
-            physicalDevice, pCreateInfo, pDevice);
+            physicalDevice, pCreateInfo, pAllocator, pDevice);
     if (result == VK_SUCCESS) {
         // Since it succeeded, do layer-specific work:
         my_data->report_data = layer_debug_report_create_device(my_data->report_data, *pDevice);
@@ -329,7 +329,7 @@
     return result;
 }
 
-VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device)
+VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator)
 {
     VkBool32 skipCall = VK_FALSE;
     dispatch_key key = get_dispatch_key(device);
@@ -344,7 +344,7 @@
 
     if (VK_FALSE == skipCall) {
         // Call down the call chain:
-        my_data->device_dispatch_table->DestroyDevice(device);
+        my_data->device_dispatch_table->DestroyDevice(device, pAllocator);
     }
 
     // Regardless of skipCall value, do some internal cleanup:
diff --git a/loader/debug_report.c b/loader/debug_report.c
index d8d3450..c1cca4f 100644
--- a/loader/debug_report.c
+++ b/loader/debug_report.c
@@ -74,7 +74,7 @@
         void* pUserData,
         VkDbgMsgCallback* pMsgCallback)
 {
-    VkLayerDbgFunctionNode *pNewDbgFuncNode = (VkLayerDbgFunctionNode *) loader_heap_alloc((struct loader_instance *)instance, sizeof(VkLayerDbgFunctionNode), VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+    VkLayerDbgFunctionNode *pNewDbgFuncNode = (VkLayerDbgFunctionNode *) loader_heap_alloc((struct loader_instance *)instance, sizeof(VkLayerDbgFunctionNode), VK_SYSTEM_ALLOC_SCOPE_OBJECT);
     if (!pNewDbgFuncNode)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
 
diff --git a/loader/loader.c b/loader/loader.c
index 6b06b31..53fdbf3 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -111,11 +111,11 @@
 void* loader_heap_alloc(
     const struct loader_instance     *instance,
     size_t                            size,
-    VkSystemAllocType                 alloc_type)
+    VkSystemAllocScope                alloc_scope)
 {
     if (instance && instance->alloc_callbacks.pfnAlloc) {
         /* TODO: What should default alignment be? 1, 4, 8, other? */
-        return instance->alloc_callbacks.pfnAlloc(instance->alloc_callbacks.pUserData, size, 4, alloc_type);
+        return instance->alloc_callbacks.pfnAlloc(instance->alloc_callbacks.pUserData, size, 4, alloc_scope);
     }
     return malloc(size);
 }
@@ -137,10 +137,10 @@
     void                       *pMem,
     size_t                      orig_size,
     size_t                      size,
-    VkSystemAllocType           alloc_type)
+    VkSystemAllocScope          alloc_scope)
 {
     if (pMem == NULL  || orig_size == 0)
-        return loader_heap_alloc(instance, size, alloc_type);
+        return loader_heap_alloc(instance, size, alloc_scope);
     if (size == 0) {
         loader_heap_free(instance, pMem);
         return NULL;
@@ -150,7 +150,7 @@
             memset(((uint8_t *)pMem) + size,  0, orig_size - size);
             return pMem;
         }
-        void *new_ptr = instance->alloc_callbacks.pfnAlloc(instance->alloc_callbacks.pUserData, size, 4, alloc_type);
+        void *new_ptr = instance->alloc_callbacks.pfnAlloc(instance->alloc_callbacks.pUserData, size, 4, alloc_scope);
         if (!new_ptr)
             return NULL;
         memcpy(new_ptr, pMem, orig_size);
@@ -162,7 +162,7 @@
 
 void *loader_tls_heap_alloc(size_t size)
 {
-    return loader_heap_alloc(tls_instance, size, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+    return loader_heap_alloc(tls_instance, size, VK_SYSTEM_ALLOC_SCOPE_FUNCTION);
 }
 
 void loader_tls_heap_free(void *pMem)
@@ -429,7 +429,7 @@
     if (layer_list->capacity == 0) {
         layer_list->list = loader_heap_alloc(inst,
                                   sizeof(struct loader_layer_properties) * 64,
-                                  VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+                                  VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
         if (layer_list->list == NULL) {
             loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Out of memory can't add any layer properties to list");
             return NULL;
@@ -444,7 +444,7 @@
         layer_list->list = loader_heap_realloc(inst, layer_list->list,
                                             layer_list->capacity,
                                             layer_list->capacity * 2,
-                                            VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+                                            VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
         if (layer_list->list == NULL) {
             loader_log(VK_DBG_REPORT_ERROR_BIT, 0,
                             "realloc failed for layer list");
@@ -575,7 +575,7 @@
                                  struct loader_extension_list *ext_info)
 {
     ext_info->capacity = 32 * sizeof(VkExtensionProperties);
-    ext_info->list = loader_heap_alloc(inst, ext_info->capacity, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+    ext_info->list = loader_heap_alloc(inst, ext_info->capacity, VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
     if (ext_info->list == NULL) {
         return false;
     }
@@ -629,7 +629,7 @@
                                                  ext_list->list,
                                                  ext_list->capacity,
                                                  ext_list->capacity * 2,
-                                                 VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+                                                 VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
             // double capacity
             ext_list->capacity *= 2;
         }
@@ -676,7 +676,7 @@
                                    struct loader_layer_list *list)
 {
     list->capacity = 32 * sizeof(struct loader_layer_properties);
-    list->list = loader_heap_alloc(inst, list->capacity, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+    list->list = loader_heap_alloc(inst, list->capacity, VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
     if (list->list == NULL) {
         return false;
     }
@@ -700,7 +700,7 @@
                                            struct loader_layer_library_list *list)
 {
     list->capacity = 32 * sizeof(struct loader_lib_info);
-    list->list = loader_heap_alloc(inst, list->capacity, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+    list->list = loader_heap_alloc(inst, list->capacity, VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
     if (list->list == NULL) {
         return false;
     }
@@ -755,7 +755,7 @@
                                              list->list,
                                              list->capacity,
                                              list->capacity * 2,
-                                             VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+                                             VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
             // double capacity
             list->capacity *= 2;
         }
@@ -833,7 +833,7 @@
                                              list->list,
                                              list->capacity,
                                              list->capacity * 2,
-                                             VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+                                             VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
             // double capacity
             list->capacity *= 2;
         }
@@ -958,7 +958,7 @@
 {
     struct loader_device *new_dev;
 
-    new_dev = loader_heap_alloc(inst, sizeof(struct loader_device), VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+    new_dev = loader_heap_alloc(inst, sizeof(struct loader_device), VK_SYSTEM_ALLOC_SCOPE_DEVICE);
     if (!new_dev) {
         loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Failed to alloc struct laoder-device");
         return NULL;
@@ -1017,7 +1017,7 @@
 {
     struct loader_icd *icd;
 
-    icd = loader_heap_alloc(inst, sizeof(*icd), VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+    icd = loader_heap_alloc(inst, sizeof(*icd), VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
     if (!icd)
         return NULL;
 
@@ -1068,7 +1068,7 @@
 {
     loader_scanned_icd_clear(inst, icd_libs);
     icd_libs->capacity = 8 * sizeof(struct loader_scanned_icds);
-    icd_libs->list = loader_heap_alloc(inst, icd_libs->capacity, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+    icd_libs->list = loader_heap_alloc(inst, icd_libs->capacity, VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
 
 }
 
@@ -1113,7 +1113,7 @@
                                                  icd_libs->list,
                                                  icd_libs->capacity,
                                                  icd_libs->capacity * 2,
-                                                 VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+                                                 VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
             // double capacity
             icd_libs->capacity *= 2;
     }
@@ -1126,7 +1126,7 @@
 
     new_node->lib_name = (char *) loader_heap_alloc(inst,
                                             strlen(filename) + 1,
-                                            VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+                                            VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
     if (!new_node->lib_name) {
         loader_log(VK_DBG_REPORT_WARN_BIT, 0, "Out of memory can't add icd");
         return;
@@ -1376,7 +1376,7 @@
                                         inst,
                                         sizeof(VkExtensionProperties) *
                                         src->instance_extension_list.count,
-                                        VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+                                        VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
     dst->instance_extension_list.capacity = sizeof(VkExtensionProperties) *
                                         src->instance_extension_list.count;
     memcpy(dst->instance_extension_list.list, src->instance_extension_list.list,
@@ -1385,7 +1385,7 @@
                                         inst,
                                         sizeof(VkExtensionProperties) *
                                         src->device_extension_list.count,
-                                        VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+                                        VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
     dst->device_extension_list.capacity = sizeof(VkExtensionProperties) *
                                         src->device_extension_list.count;
     memcpy(dst->device_extension_list.list, src->device_extension_list.list,
@@ -1759,14 +1759,14 @@
                     if (out_files->count == 0) {
                         out_files->filename_list = loader_heap_alloc(inst,
                                               alloced_count * sizeof(char *),
-                                              VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+                                              VK_SYSTEM_ALLOC_SCOPE_FUNCTION);
                     }
                     else if (out_files->count == alloced_count) {
                         out_files->filename_list = loader_heap_realloc(inst,
                                         out_files->filename_list,
                                         alloced_count * sizeof(char *),
                                         alloced_count * sizeof(char *) * 2,
-                                        VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+                                        VK_SYSTEM_ALLOC_SCOPE_FUNCTION);
                         alloced_count *= 2;
                     }
                     if (out_files->filename_list == NULL) {
@@ -1776,7 +1776,7 @@
                     out_files->filename_list[out_files->count] = loader_heap_alloc(
                                                 inst,
                                                 strlen(name) + 1,
-                                                VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+                                                VK_SYSTEM_ALLOC_SCOPE_FUNCTION);
                     if (out_files->filename_list[out_files->count] == NULL) {
                         loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Out of memory can't get manifest files");
                         return;
@@ -2073,7 +2073,7 @@
                                             inst, loader.loaded_layer_lib_list,
                                             loader.loaded_layer_lib_capacity,
                                             new_alloc_size,
-                                            VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+                                            VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
         if (!new_layer_lib_list) {
             loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "loader: realloc failed in loader_add_layer_lib");
             return NULL;
@@ -2135,7 +2135,7 @@
     /* Need to remove unused library from list */
     new_layer_lib_list = loader_heap_alloc(inst,
                                            loader.loaded_layer_lib_capacity,
-                                           VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+                                           VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
     if (!new_layer_lib_list) {
         loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "loader: heap alloc failed loader_remove_layer_library");
         return;
@@ -2415,6 +2415,7 @@
 static VkResult VKAPI scratch_vkCreateDevice(
     VkPhysicalDevice          gpu,
     const VkDeviceCreateInfo *pCreateInfo,
+    const VkAllocCallbacks*   pAllocator,
     VkDevice                 *pDevice)
 {
     return VK_SUCCESS;
@@ -2456,7 +2457,7 @@
 
     wrappedGpus = loader_heap_alloc(inst,
                     sizeof (VkBaseLayerObject) * dev->activated_layer_list.count,
-                    VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+                    VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
     if (!wrappedGpus) {
         loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Failed to alloc Gpu objects for layer");
         return 0;
@@ -2612,6 +2613,7 @@
 
 VkResult VKAPI loader_CreateInstance(
         const VkInstanceCreateInfo*     pCreateInfo,
+        const VkAllocCallbacks*         pAllocator,
         VkInstance*                     pInstance)
 {
     struct loader_instance *ptr_instance = *(struct loader_instance **) pInstance;
@@ -2625,7 +2627,6 @@
     icd_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
     icd_create_info.enabledLayerNameCount = 0;
     icd_create_info.ppEnabledLayerNames = NULL;
-    icd_create_info.pAllocCb = pCreateInfo->pAllocCb;
     icd_create_info.pAppInfo = pCreateInfo->pAppInfo;
     icd_create_info.pNext = pCreateInfo->pNext;
 
@@ -2656,6 +2657,7 @@
             }
 
             res = ptr_instance->icd_libs.list[i].CreateInstance(&icd_create_info,
+                                           pAllocator,
                                            &(icd->instance));
             success = loader_icd_init_entrys(
                                 icd,
@@ -2690,7 +2692,8 @@
 }
 
 void VKAPI loader_DestroyInstance(
-        VkInstance                                instance)
+        VkInstance                                instance,
+        const VkAllocCallbacks*                   pAllocator)
 {
     struct loader_instance *ptr_instance = loader_instance(instance);
     struct loader_icd *icds = ptr_instance->icds;
@@ -2714,7 +2717,7 @@
 
     while (icds) {
         if (icds->instance) {
-            icds->DestroyInstance(icds->instance);
+            icds->DestroyInstance(icds->instance, pAllocator);
         }
         next_icd = icds->next;
         icds->instance = VK_NULL_HANDLE;
@@ -2754,7 +2757,7 @@
         icd->gpus = (VkPhysicalDevice *) loader_heap_alloc(
                                                 ptr_instance,
                                                 n * sizeof(VkPhysicalDevice),
-                                                VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+                                                VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
         if (!icd->gpus) {
             /* TODO: Add cleanup code here */
             return VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -2927,6 +2930,7 @@
 VkResult VKAPI loader_CreateDevice(
         VkPhysicalDevice                        gpu,
         const VkDeviceCreateInfo*               pCreateInfo,
+        const VkAllocCallbacks*                 pAllocator,
         VkDevice*                               pDevice)
 {
     uint32_t gpu_index;
@@ -2997,7 +3001,7 @@
 
     // since gpu object maybe wrapped by a layer need to get unwrapped version
     // we haven't yet called down the chain for the layer to unwrap the object
-    res = icd->CreateDevice(icd->gpus[gpu_index], pCreateInfo, pDevice);
+    res = icd->CreateDevice(icd->gpus[gpu_index], pCreateInfo, pAllocator, pDevice);
     if (res != VK_SUCCESS) {
         return res;
     }
@@ -3021,7 +3025,7 @@
     }
     loader_activate_device_layers(inst, dev, *pDevice);
 
-    res = dev->loader_dispatch.CreateDevice(gpu, pCreateInfo, pDevice);
+    res = dev->loader_dispatch.CreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
 
     dev->loader_dispatch.CreateDevice = icd->CreateDevice;
 
diff --git a/loader/loader.h b/loader/loader.h
index 3e4ce1b..96dd277 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -265,10 +265,12 @@
 /* instance layer chain termination entrypoint definitions */
 VkResult VKAPI loader_CreateInstance(
         const VkInstanceCreateInfo*             pCreateInfo,
+        const VkAllocCallbacks*                 pAllocator,
         VkInstance*                             pInstance);
 
 void VKAPI loader_DestroyInstance(
-        VkInstance                              instance);
+        VkInstance                              instance,
+        const VkAllocCallbacks*                 pAllocator);
 
 VkResult VKAPI loader_EnumeratePhysicalDevices(
         VkInstance                              instance,
@@ -326,6 +328,7 @@
 VkResult VKAPI loader_CreateDevice(
         VkPhysicalDevice                        gpu,
         const VkDeviceCreateInfo*               pCreateInfo,
+        const VkAllocCallbacks*                 pAllocator,
         VkDevice*                               pDevice);
 
 /* helper function definitions */
@@ -390,7 +393,7 @@
 void* loader_heap_alloc(
         const struct loader_instance *instance,
         size_t                       size,
-        VkSystemAllocType            allocType);
+        VkSystemAllocScope           allocScope);
 
 void loader_heap_free(
         const struct loader_instance *instance,
diff --git a/loader/trampoline.c b/loader/trampoline.c
index a73e922..219827c 100644
--- a/loader/trampoline.c
+++ b/loader/trampoline.c
@@ -34,6 +34,7 @@
 /* Trampoline entrypoints */
 LOADER_EXPORT VkResult VKAPI vkCreateInstance(
         const VkInstanceCreateInfo* pCreateInfo,
+        const VkAllocCallbacks* pAllocator,
         VkInstance* pInstance)
 {
     struct loader_instance *ptr_instance = NULL;
@@ -41,14 +42,12 @@
 
     loader_platform_thread_once(&once_init, loader_initialize);
 
-    if (pCreateInfo->pAllocCb
-            && pCreateInfo->pAllocCb->pfnAlloc
-            && pCreateInfo->pAllocCb->pfnFree) {
-        ptr_instance = (struct loader_instance *) pCreateInfo->pAllocCb->pfnAlloc(
-                           pCreateInfo->pAllocCb->pUserData,
+    if (pAllocator) {
+        ptr_instance = (struct loader_instance *) pAllocator->pfnAlloc(
+                           pAllocator->pUserData,
                            sizeof(struct loader_instance),
                            sizeof(VkInstance),
-                           VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
+                           VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
     } else {
         ptr_instance = (struct loader_instance *) malloc(sizeof(struct loader_instance));
     }
@@ -60,12 +59,8 @@
     loader_platform_thread_lock_mutex(&loader_lock);
     memset(ptr_instance, 0, sizeof(struct loader_instance));
 
-    if (pCreateInfo->pAllocCb
-            && pCreateInfo->pAllocCb->pfnAlloc
-            && pCreateInfo->pAllocCb->pfnFree) {
-        ptr_instance->alloc_callbacks.pUserData = pCreateInfo->pAllocCb->pUserData;
-        ptr_instance->alloc_callbacks.pfnAlloc = pCreateInfo->pAllocCb->pfnAlloc;
-        ptr_instance->alloc_callbacks.pfnFree = pCreateInfo->pAllocCb->pfnFree;
+    if (pAllocator) {
+        ptr_instance->alloc_callbacks = *pAllocator;
     }
 
     /* Due to implicit layers need to get layer list even if
@@ -116,7 +111,7 @@
     ptr_instance->disp = loader_heap_alloc(
                              ptr_instance,
                              sizeof(VkLayerInstanceDispatchTable),
-                             VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+                             VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
     if (ptr_instance->disp == NULL) {
         loader_delete_layer_properties(ptr_instance,
                                        &ptr_instance->device_layer_list);
@@ -161,7 +156,7 @@
 
     *pInstance = (VkInstance) ptr_instance;
 
-    res = ptr_instance->disp->CreateInstance(pCreateInfo, pInstance);
+    res = ptr_instance->disp->CreateInstance(pCreateInfo, pAllocator, pInstance);
 
     /*
      * Finally have the layers in place and everyone has seen
@@ -176,7 +171,8 @@
 }
 
 LOADER_EXPORT void VKAPI vkDestroyInstance(
-                                            VkInstance instance)
+                                            VkInstance instance,
+                                            const VkAllocCallbacks* pAllocator)
 {
     const VkLayerInstanceDispatchTable *disp;
     struct loader_instance *ptr_instance = NULL;
@@ -185,7 +181,7 @@
     loader_platform_thread_lock_mutex(&loader_lock);
 
     ptr_instance = loader_get_instance(instance);
-    disp->DestroyInstance(instance);
+    disp->DestroyInstance(instance, pAllocator);
 
     loader_deactivate_instance_layers(ptr_instance);
     loader_heap_free(ptr_instance, ptr_instance->disp);
@@ -277,19 +273,20 @@
 LOADER_EXPORT VkResult VKAPI vkCreateDevice(
         VkPhysicalDevice gpu,
         const VkDeviceCreateInfo* pCreateInfo,
+        const VkAllocCallbacks* pAllocator,
         VkDevice* pDevice)
 {
     VkResult res;
 
     loader_platform_thread_lock_mutex(&loader_lock);
 
-    res = loader_CreateDevice(gpu, pCreateInfo, pDevice);
+    res = loader_CreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
 
     loader_platform_thread_unlock_mutex(&loader_lock);
     return res;
 }
 
-LOADER_EXPORT void VKAPI vkDestroyDevice(VkDevice device)
+LOADER_EXPORT void VKAPI vkDestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
     struct loader_device *dev;
@@ -298,7 +295,7 @@
     disp = loader_get_dispatch(device);
 
     loader_platform_thread_lock_mutex(&loader_lock);
-    disp->DestroyDevice(device);
+    disp->DestroyDevice(device, pAllocator);
     loader_remove_logical_device(inst, device);
     loader_platform_thread_unlock_mutex(&loader_lock);
 }
@@ -369,22 +366,22 @@
     return disp->DeviceWaitIdle(device);
 }
 
-LOADER_EXPORT VkResult VKAPI vkAllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem)
+LOADER_EXPORT VkResult VKAPI vkAllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, const VkAllocCallbacks* pAllocator, VkDeviceMemory* pMem)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->AllocMemory(device, pAllocInfo, pMem);
+    return disp->AllocMemory(device, pAllocInfo, pAllocator, pMem);
 }
 
-LOADER_EXPORT void VKAPI vkFreeMemory(VkDevice device, VkDeviceMemory mem)
+LOADER_EXPORT void VKAPI vkFreeMemory(VkDevice device, VkDeviceMemory mem, const VkAllocCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    disp->FreeMemory(device, mem);
+    disp->FreeMemory(device, mem, pAllocator);
 }
 
 LOADER_EXPORT VkResult VKAPI vkMapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkFlags flags, void** ppData)
@@ -513,22 +510,22 @@
     return disp->QueueBindSparseImageMemory(queue, image, bindInfoCount, pBindInfo);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence)
+LOADER_EXPORT VkResult VKAPI vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFence* pFence)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreateFence(device, pCreateInfo, pFence);
+    return disp->CreateFence(device, pCreateInfo, pAllocator, pFence);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyFence(VkDevice device, VkFence fence)
+LOADER_EXPORT void VKAPI vkDestroyFence(VkDevice device, VkFence fence, const VkAllocCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    disp->DestroyFence(device, fence);
+    disp->DestroyFence(device, fence, pAllocator);
 }
 
 LOADER_EXPORT VkResult VKAPI vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences)
@@ -558,40 +555,40 @@
     return disp->WaitForFences(device, fenceCount, pFences, waitAll, timeout);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore)
+LOADER_EXPORT VkResult VKAPI vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSemaphore* pSemaphore)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreateSemaphore(device, pCreateInfo, pSemaphore);
+    return disp->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
 }
 
-LOADER_EXPORT void VKAPI vkDestroySemaphore(VkDevice device, VkSemaphore semaphore)
+LOADER_EXPORT void VKAPI vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    disp->DestroySemaphore(device, semaphore);
+    disp->DestroySemaphore(device, semaphore, pAllocator);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent)
+LOADER_EXPORT VkResult VKAPI vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkEvent* pEvent)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreateEvent(device, pCreateInfo, pEvent);
+    return disp->CreateEvent(device, pCreateInfo, pAllocator, pEvent);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyEvent(VkDevice device, VkEvent event)
+LOADER_EXPORT void VKAPI vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    disp->DestroyEvent(device, event);
+    disp->DestroyEvent(device, event, pAllocator);
 }
 
 LOADER_EXPORT VkResult VKAPI vkGetEventStatus(VkDevice device, VkEvent event)
@@ -621,22 +618,22 @@
     return disp->ResetEvent(device, event);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool)
+LOADER_EXPORT VkResult VKAPI vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkQueryPool* pQueryPool)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreateQueryPool(device, pCreateInfo, pQueryPool);
+    return disp->CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool)
+LOADER_EXPORT void VKAPI vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    disp->DestroyQueryPool(device, queryPool);
+    disp->DestroyQueryPool(device, queryPool, pAllocator);
 }
 
 LOADER_EXPORT VkResult VKAPI vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
@@ -648,58 +645,58 @@
     return disp->GetQueryPoolResults(device, queryPool, startQuery, queryCount, dataSize, pData, stride, flags);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer)
+LOADER_EXPORT VkResult VKAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBuffer* pBuffer)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreateBuffer(device, pCreateInfo, pBuffer);
+    return disp->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer)
+LOADER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    disp->DestroyBuffer(device, buffer);
+    disp->DestroyBuffer(device, buffer, pAllocator);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView)
+LOADER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBufferView* pView)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreateBufferView(device, pCreateInfo, pView);
+    return disp->CreateBufferView(device, pCreateInfo, pAllocator, pView);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView)
+LOADER_EXPORT void VKAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    disp->DestroyBufferView(device, bufferView);
+    disp->DestroyBufferView(device, bufferView, pAllocator);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage)
+LOADER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImage* pImage)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreateImage(device, pCreateInfo, pImage);
+    return disp->CreateImage(device, pCreateInfo, pAllocator, pImage);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image)
+LOADER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image, const VkAllocCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    disp->DestroyImage(device, image);
+    disp->DestroyImage(device, image, pAllocator);
 }
 
 LOADER_EXPORT void VKAPI vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
@@ -711,76 +708,76 @@
     disp->GetImageSubresourceLayout(device, image, pSubresource, pLayout);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView)
+LOADER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImageView* pView)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreateImageView(device, pCreateInfo, pView);
+    return disp->CreateImageView(device, pCreateInfo, pAllocator, pView);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyImageView(VkDevice device, VkImageView imageView)
+LOADER_EXPORT void VKAPI vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    disp->DestroyImageView(device, imageView);
+    disp->DestroyImageView(device, imageView, pAllocator);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShader)
+LOADER_EXPORT VkResult VKAPI vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkShaderModule* pShader)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreateShaderModule(device, pCreateInfo, pShader);
+    return disp->CreateShaderModule(device, pCreateInfo, pAllocator, pShader);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule)
+LOADER_EXPORT void VKAPI vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    disp->DestroyShaderModule(device, shaderModule);
+    disp->DestroyShaderModule(device, shaderModule, pAllocator);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader)
+LOADER_EXPORT VkResult VKAPI vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkShader* pShader)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreateShader(device, pCreateInfo, pShader);
+    return disp->CreateShader(device, pCreateInfo, pAllocator, pShader);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyShader(VkDevice device, VkShader shader)
+LOADER_EXPORT void VKAPI vkDestroyShader(VkDevice device, VkShader shader, const VkAllocCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    disp->DestroyShader(device, shader);
+    disp->DestroyShader(device, shader, pAllocator);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache)
+LOADER_EXPORT VkResult VKAPI vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreatePipelineCache(device, pCreateInfo, pPipelineCache);
+    return disp->CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache)
+LOADER_EXPORT void VKAPI vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    disp->DestroyPipelineCache(device, pipelineCache);
+    disp->DestroyPipelineCache(device, pipelineCache, pAllocator);
 }
 
 LOADER_EXPORT VkResult VKAPI vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData)
@@ -801,104 +798,104 @@
     return disp->MergePipelineCaches(device, destCache, srcCacheCount, pSrcCaches);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines)
+LOADER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pPipelines);
+    return disp->CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines)
+LOADER_EXPORT VkResult VKAPI vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pPipelines);
+    return disp->CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline)
+LOADER_EXPORT void VKAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    disp->DestroyPipeline(device, pipeline);
+    disp->DestroyPipeline(device, pipeline, pAllocator);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout)
+LOADER_EXPORT VkResult VKAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreatePipelineLayout(device, pCreateInfo, pPipelineLayout);
+    return disp->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout)
+LOADER_EXPORT void VKAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    disp->DestroyPipelineLayout(device, pipelineLayout);
+    disp->DestroyPipelineLayout(device, pipelineLayout, pAllocator);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler)
+LOADER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSampler* pSampler)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreateSampler(device, pCreateInfo, pSampler);
+    return disp->CreateSampler(device, pCreateInfo, pAllocator, pSampler);
 }
 
-LOADER_EXPORT void VKAPI vkDestroySampler(VkDevice device, VkSampler sampler)
+LOADER_EXPORT void VKAPI vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    disp->DestroySampler(device, sampler);
+    disp->DestroySampler(device, sampler, pAllocator);
 }
 
 
-LOADER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout)
+LOADER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
+    return disp->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout)
+LOADER_EXPORT void VKAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    disp->DestroyDescriptorSetLayout(device, descriptorSetLayout);
+    disp->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool)
+LOADER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreateDescriptorPool(device, pCreateInfo, pDescriptorPool);
+    return disp->CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool)
+LOADER_EXPORT void VKAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    disp->DestroyDescriptorPool(device, descriptorPool);
+    disp->DestroyDescriptorPool(device, descriptorPool, pAllocator);
 }
 
 
@@ -938,40 +935,40 @@
     disp->UpdateDescriptorSets(device, writeCount, pDescriptorWrites, copyCount, pDescriptorCopies);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer)
+LOADER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreateFramebuffer(device, pCreateInfo, pFramebuffer);
+    return disp->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer)
+LOADER_EXPORT void VKAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    disp->DestroyFramebuffer(device, framebuffer);
+    disp->DestroyFramebuffer(device, framebuffer, pAllocator);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass)
+LOADER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkRenderPass* pRenderPass)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreateRenderPass(device, pCreateInfo, pRenderPass);
+    return disp->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass)
+LOADER_EXPORT void VKAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    disp->DestroyRenderPass(device, renderPass);
+    disp->DestroyRenderPass(device, renderPass, pAllocator);
 }
 
 LOADER_EXPORT void VKAPI vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
@@ -983,22 +980,22 @@
     disp->GetRenderAreaGranularity(device, renderPass, pGranularity);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool)
+LOADER_EXPORT VkResult VKAPI vkCreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkCmdPool* pCmdPool)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreateCommandPool(device, pCreateInfo, pCmdPool);
+    return disp->CreateCommandPool(device, pCreateInfo, pAllocator, pCmdPool);
 }
 
-LOADER_EXPORT void VKAPI vkDestroyCommandPool(VkDevice device, VkCmdPool cmdPool)
+LOADER_EXPORT void VKAPI vkDestroyCommandPool(VkDevice device, VkCmdPool cmdPool, const VkAllocCallbacks* pAllocator)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    disp->DestroyCommandPool(device, cmdPool);
+    disp->DestroyCommandPool(device, cmdPool, pAllocator);
 }
 
 LOADER_EXPORT VkResult VKAPI vkResetCommandPool(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags)
diff --git a/tests/blit_tests.cpp b/tests/blit_tests.cpp
index a1abc8c..d1e61e7 100644
--- a/tests/blit_tests.cpp
+++ b/tests/blit_tests.cpp
@@ -764,7 +764,7 @@
     memset(&event_info, 0, sizeof(event_info));
     event_info.sType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO;
 
-    err = vkCreateEvent(dev_.handle(), &event_info, &event);
+    err = vkCreateEvent(dev_.handle(), &event_info, NULL, &event);
     ASSERT_VK_SUCCESS(err);
 
     err = vkResetEvent(dev_.handle(), event);
@@ -821,7 +821,7 @@
     EXPECT_EQ(0x11111111, data[0]);
     bufs[2].memory().unmap();
 
-    vkDestroyEvent(dev_.handle(), event);
+    vkDestroyEvent(dev_.handle(), event, NULL);
 
 }
 
diff --git a/tests/image_tests.cpp b/tests/image_tests.cpp
index 37b72e2..34afc93 100644
--- a/tests/image_tests.cpp
+++ b/tests/image_tests.cpp
@@ -97,12 +97,11 @@
         inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
         inst_info.pNext = NULL;
         inst_info.pAppInfo = &app_info;
-        inst_info.pAllocCb = NULL;
         inst_info.enabledLayerNameCount = 0;
         inst_info.ppEnabledLayerNames = NULL;
         inst_info.enabledExtensionNameCount = 0;
         inst_info.ppEnabledExtensionNames = NULL;
-        err = vkCreateInstance(&inst_info, &this->inst);
+        err = vkCreateInstance(&inst_info, NULL, &this->inst);
         ASSERT_VK_SUCCESS(err);
         err = vkEnumeratePhysicalDevices(this->inst, &this->gpu_count, NULL);
         ASSERT_VK_SUCCESS(err);
@@ -117,7 +116,7 @@
 
     virtual void TearDown() {
         delete this->m_device;
-        vkDestroyInstance(this->inst);
+        vkDestroyInstance(this->inst, NULL);
     }
 };
 
@@ -212,7 +211,7 @@
     //        VkDevice                                  device,
     //        const VkImageCreateInfo*                pCreateInfo,
     //        VkImage*                                  pImage);
-    err = vkCreateImage(device(), &imageCreateInfo, &m_image);
+    err = vkCreateImage(device(), &imageCreateInfo, NULL, &m_image);
     ASSERT_VK_SUCCESS(err);
 
     VkMemoryRequirements mem_req;
@@ -231,7 +230,7 @@
     ASSERT_TRUE(pass);
 
     /* allocate memory */
-    err = vkAllocMemory(device(), &mem_info, &m_image_mem);
+    err = vkAllocMemory(device(), &mem_info, NULL, &m_image_mem);
     ASSERT_VK_SUCCESS(err);
 
     /* bind memory */
@@ -242,8 +241,8 @@
 void VkImageTest::DestroyImage()
 {
     // All done with image object and memory, clean up
-    vkDestroyImage(device(), m_image);
-    vkFreeMemory(device(), m_image_mem);
+    vkDestroyImage(device(), m_image, NULL);
+    vkFreeMemory(device(), m_image_mem, NULL);
 }
 
 void VkImageTest::CreateImageView(VkImageViewCreateInfo *pCreateInfo,
@@ -251,13 +250,13 @@
 {
     VkResult err;
     pCreateInfo->image = this->m_image;
-    err = vkCreateImageView(device(), pCreateInfo, pView);
+    err = vkCreateImageView(device(), pCreateInfo, NULL, pView);
     ASSERT_VK_SUCCESS(err);
 }
 
 void VkImageTest::DestroyImageView(VkImageView imageView)
 {
-    vkDestroyImageView(device(), imageView);
+    vkDestroyImageView(device(), imageView, NULL);
 }
 
 TEST_F(VkImageTest, CreateImageViewTest) {
diff --git a/tests/init.cpp b/tests/init.cpp
index 0eb32f1..bbb63cc 100644
--- a/tests/init.cpp
+++ b/tests/init.cpp
@@ -103,12 +103,11 @@
         inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
         inst_info.pNext = NULL;
         inst_info.pAppInfo = &app_info;
-        inst_info.pAllocCb = NULL;
         inst_info.enabledLayerNameCount = 0;
         inst_info.ppEnabledLayerNames = NULL;
         inst_info.enabledExtensionNameCount = 0;
         inst_info.ppEnabledExtensionNames = NULL;
-        err = vkCreateInstance(&inst_info, &inst);
+        err = vkCreateInstance(&inst_info, NULL, &inst);
         ASSERT_VK_SUCCESS(err);
         err = vkEnumeratePhysicalDevices(inst, &this->gpu_count, NULL);
         ASSERT_VK_SUCCESS(err);
@@ -135,7 +134,7 @@
 
     virtual void TearDown() {
         delete m_device;
-        vkDestroyInstance(inst);
+        vkDestroyInstance(inst, NULL);
     }
 };
 
@@ -156,7 +155,7 @@
     pass = m_device->phy().set_memory_type(((1 << mem_props.memoryTypeCount) - 1), &alloc_info, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
     ASSERT_TRUE(pass);
 
-    err = vkAllocMemory(device(), &alloc_info, &gpu_mem);
+    err = vkAllocMemory(device(), &alloc_info, NULL, &gpu_mem);
     ASSERT_VK_SUCCESS(err);
 
     err = vkMapMemory(device(), gpu_mem, 0, 0, 0, (void **) &pData);
@@ -167,7 +166,7 @@
 
     vkUnmapMemory(device(), gpu_mem);
 
-    vkFreeMemory(device(), gpu_mem);
+    vkFreeMemory(device(), gpu_mem, NULL);
 }
 
 TEST_F(VkTest, Event) {
@@ -184,7 +183,7 @@
     memset(&event_info, 0, sizeof(event_info));
     event_info.sType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO;
 
-    err = vkCreateEvent(device(), &event_info, &event);
+    err = vkCreateEvent(device(), &event_info, NULL, &event);
     ASSERT_VK_SUCCESS(err);
 
     err = vkResetEvent(device(), event);
@@ -202,7 +201,7 @@
     // TODO: Test actual synchronization with command buffer event.
 
     // All done with event memory, clean up
-    vkDestroyEvent(device(), event);
+    vkDestroyEvent(device(), event, NULL);
 }
 
 #define MAX_QUERY_SLOTS 10
@@ -243,7 +242,7 @@
     //            const VkQueryPoolCreateInfo*           pCreateInfo,
     //            VkQueryPool*                             pQueryPool);
 
-    err = vkCreateQueryPool(device(), &query_info, &query_pool);
+    err = vkCreateQueryPool(device(), &query_info, NULL, &query_pool);
     ASSERT_VK_SUCCESS(err);
 
     // TODO: Test actual synchronization with command buffer event.
@@ -265,7 +264,7 @@
 
     }
 
-    vkDestroyQueryPool(device(), query_pool);
+    vkDestroyQueryPool(device(), query_pool, NULL);
 }
 
 void getQueue(vk_testing::Device *device, uint32_t queue_node_index, const char *qname)
@@ -357,7 +356,7 @@
 //        VkDevice                                  device,
 //        const VkImageCreateInfo*                pCreateInfo,
 //        VkImage*                                  pImage);
-    err = vkCreateImage(device(), &imageCreateInfo, &image);
+    err = vkCreateImage(device(), &imageCreateInfo, NULL, &image);
     ASSERT_VK_SUCCESS(err);
 
     // Verify image resources
@@ -423,7 +422,7 @@
         pass = m_device->phy().set_memory_type(mem_req.memoryTypeBits, &mem_info, 0);
         ASSERT_TRUE(pass);
 
-        err = vkAllocMemory(device(), &mem_info, &image_mem);
+        err = vkAllocMemory(device(), &mem_info, NULL, &image_mem);
         ASSERT_VK_SUCCESS(err);
 
         err = vkBindImageMemory(device(), image, image_mem, 0);
@@ -464,17 +463,17 @@
 //        const VkImageViewCreateInfo*           pCreateInfo,
 //        VkImageView*                             pView);
 
-    err = vkCreateImageView(device(), &viewInfo, &view);
+    err = vkCreateImageView(device(), &viewInfo, NULL, &view);
     ASSERT_VK_SUCCESS(err) << "vkCreateImageView failed";
 
     // TODO: Test image memory.
 
     // All done with image memory, clean up
-    vkDestroyImageView(device(), view);
-    vkDestroyImage(device(), image);
+    vkDestroyImageView(device(), view, NULL);
+    vkDestroyImage(device(), image, NULL);
 
     if (mem_req.size) {
-        vkFreeMemory(device(), image_mem);
+        vkFreeMemory(device(), image_mem, NULL);
     }
 }
 
@@ -502,7 +501,7 @@
     cmd_pool_info.pNext = NULL,
     cmd_pool_info.queueFamilyIndex = graphics_queue_node_index;
     cmd_pool_info.flags = 0,
-    err = vkCreateCommandPool(device(), &cmd_pool_info, &cmdPool);
+    err = vkCreateCommandPool(device(), &cmd_pool_info, NULL, &cmdPool);
     ASSERT_VK_SUCCESS(err) << "vkCreateCommandPool failed";
 
     info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO;
@@ -513,7 +512,7 @@
     ASSERT_VK_SUCCESS(err) << "vkAllocCommandBuffers failed";
 
     vkFreeCommandBuffers(device(), cmdPool, 1, &cmdBuffer);
-    vkDestroyCommandPool(device(), cmdPool);
+    vkDestroyCommandPool(device(), cmdPool, NULL);
 }
 
 TEST_F(VkTest, TestCommandBuffer) {
@@ -548,7 +547,7 @@
     moduleCreateInfo.pCode = code;
     moduleCreateInfo.codeSize = codeSize;
     moduleCreateInfo.flags = 0;
-    err = vkCreateShaderModule(device(), &moduleCreateInfo, &module);
+    err = vkCreateShaderModule(device(), &moduleCreateInfo, NULL, &module);
     ASSERT_VK_SUCCESS(err);
 
     createInfo.sType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO;
@@ -557,10 +556,10 @@
     createInfo.pName = "main";
     createInfo.flags = 0;
     createInfo.stage = stage;
-    err = vkCreateShader(device(), &createInfo, &shader);
+    err = vkCreateShader(device(), &createInfo, NULL, &shader);
     ASSERT_VK_SUCCESS(err);
 
-    vkDestroyShaderModule(device(), module);
+    vkDestroyShaderModule(device(), module, NULL);
 
     *pshader = shader;
 }
diff --git a/tests/layer_validation_tests.cpp b/tests/layer_validation_tests.cpp
index f6fb2ab..81d77f8 100644
--- a/tests/layer_validation_tests.cpp
+++ b/tests/layer_validation_tests.cpp
@@ -533,7 +533,7 @@
         // Introduce failure, do NOT set memProps to VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
         mem_alloc.memoryTypeIndex = 1;
 
-    err = vkCreateImage(m_device->device(), &image_create_info, &image);
+    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
     ASSERT_VK_SUCCESS(err);
 
     vkGetImageMemoryRequirements(m_device->device(),
@@ -544,12 +544,12 @@
 
     pass = m_device->phy().set_memory_type(mem_reqs.memoryTypeBits, &mem_alloc, 0, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
     if(!pass) { // If we can't find any unmappable memory this test doesn't make sense
-        vkDestroyImage(m_device->device(), image);
+        vkDestroyImage(m_device->device(), image, NULL);
         return;
     }
 
     // allocate memory
-    err = vkAllocMemory(m_device->device(), &mem_alloc, &mem);
+    err = vkAllocMemory(m_device->device(), &mem_alloc, NULL, &mem);
     ASSERT_VK_SUCCESS(err);
 
     // Try to bind free memory that has been freed
@@ -566,7 +566,7 @@
         FAIL() << "Error received did not match expected error message from vkMapMemory in MemTracker";
     }
 
-    vkDestroyImage(m_device->device(), image);
+    vkDestroyImage(m_device->device(), image, NULL);
 }
 
 // TODO : Is this test still valid. Not sure it is with updates to memory binding model
@@ -609,7 +609,7 @@
 //        .memoryTypeIndex = 0,
 //    };
 //
-//    err = vkCreateImage(m_device->device(), &image_create_info, &image);
+//    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
 //    ASSERT_VK_SUCCESS(err);
 //
 //    err = vkGetImageMemoryRequirements(m_device->device(),
@@ -623,7 +623,7 @@
 //    ASSERT_VK_SUCCESS(err);
 //
 //    // allocate memory
-//    err = vkAllocMemory(m_device->device(), &mem_alloc, &mem);
+//    err = vkAllocMemory(m_device->device(), &mem_alloc, NULL, &mem);
 //    ASSERT_VK_SUCCESS(err);
 //
 //    // Bind memory to Image object
@@ -631,7 +631,7 @@
 //    ASSERT_VK_SUCCESS(err);
 //
 //    // Introduce validation failure, free memory while still bound to object
-//    vkFreeMemory(m_device->device(), mem);
+//    vkFreeMemory(m_device->device(), mem, NULL);
 //    msgFlags = m_errorMonitor->GetState(&msgString);
 //
 //    ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive an warning while tring to free bound memory";
@@ -683,7 +683,7 @@
 
     // Introduce failure, do NOT set memProps to VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
     mem_alloc.memoryTypeIndex = 1;
-    err = vkCreateImage(m_device->device(), &image_create_info, &image);
+    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
     ASSERT_VK_SUCCESS(err);
 
     vkGetImageMemoryRequirements(m_device->device(),
@@ -695,9 +695,9 @@
     ASSERT_TRUE(pass);
 
     // allocate 2 memory objects
-    err = vkAllocMemory(m_device->device(), &mem_alloc, &mem1);
+    err = vkAllocMemory(m_device->device(), &mem_alloc, NULL, &mem1);
     ASSERT_VK_SUCCESS(err);
-    err = vkAllocMemory(m_device->device(), &mem_alloc, &mem2);
+    err = vkAllocMemory(m_device->device(), &mem_alloc, NULL, &mem2);
     ASSERT_VK_SUCCESS(err);
 
     // Bind first memory object to Image object
@@ -713,9 +713,9 @@
         FAIL() << "Error received did not match expected message when rebinding memory to an object";
     }
 
-    vkDestroyImage(m_device->device(), image);
-    vkFreeMemory(m_device->device(), mem1);
-    vkFreeMemory(m_device->device(), mem2);
+    vkDestroyImage(m_device->device(), image, NULL);
+    vkFreeMemory(m_device->device(), mem1, NULL);
+    vkFreeMemory(m_device->device(), mem2, NULL);
 }
 
 TEST_F(VkLayerTest, SubmitSignaledFence)
@@ -816,7 +816,7 @@
     };
 
     VkImage dsi;
-    vkCreateImage(m_device->device(), &ici, &dsi);
+    vkCreateImage(m_device->device(), &ici, NULL, &dsi);
     VkDepthStencilView dsv;
     const VkDepthStencilViewCreateInfo dsvci = {
         .sType = VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO,
@@ -827,7 +827,7 @@
         .arraySize = 1,
         .flags = 0,
     };
-    vkCreateDepthStencilView(m_device->device(), &dsvci, &dsv);
+    vkCreateDepthStencilView(m_device->device(), &dsvci, NULL, &dsv);
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after attempting to create DSView w/ image lacking USAGE_DS_BIT flag";
     if (!strstr(msgString.c_str(),"Invalid usage flag for image ")) {
@@ -860,7 +860,7 @@
         ds_pool_ci.pTypeCounts = &ds_type_count;
 
     VkDescriptorPool ds_pool;
-    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -876,7 +876,7 @@
         ds_layout_ci.pBindings = &dsl_binding;
 
     VkDescriptorSetLayout ds_layout;
-    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
@@ -895,7 +895,7 @@
         pipeline_layout_ci.pSetLayouts = &ds_layout;
 
     VkPipelineLayout pipeline_layout;
-    err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, &pipeline_layout);
+    err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkPipeline badPipeline = (VkPipeline)0xbaadb1be;
@@ -909,9 +909,9 @@
         FAIL() << "Error received was not 'Invalid VkPipeline Object 0xbaadb1be' but instead it was '" << msgString.c_str() << "'";
     }
 
-    vkDestroyPipelineLayout(m_device->device(), pipeline_layout);
-    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
-    vkDestroyDescriptorPool(m_device->device(), ds_pool);
+    vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);
+    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+    vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
 }
 
 TEST_F(VkLayerTest, BindInvalidMemory)
@@ -954,7 +954,7 @@
         mem_alloc.allocationSize = 0;
         mem_alloc.memoryTypeIndex = 0;
 
-    err = vkCreateImage(m_device->device(), &image_create_info, &image);
+    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
     ASSERT_VK_SUCCESS(err);
 
     vkGetImageMemoryRequirements(m_device->device(),
@@ -967,11 +967,11 @@
     ASSERT_TRUE(pass);
 
     // allocate memory
-    err = vkAllocMemory(m_device->device(), &mem_alloc, &mem);
+    err = vkAllocMemory(m_device->device(), &mem_alloc, NULL, &mem);
     ASSERT_VK_SUCCESS(err);
 
     // Introduce validation failure, free memory before binding
-    vkFreeMemory(m_device->device(), mem);
+    vkFreeMemory(m_device->device(), mem, NULL);
 
     // Try to bind free memory that has been freed
     err = vkBindImageMemory(m_device->device(), image, mem, 0);
@@ -984,7 +984,7 @@
         FAIL() << "Error received from BindInvalidMemory was not 'Invalid VkDeviceMemory Object 0x<handle>' but instead '" << msgString.c_str() << "'";
     }
 
-    vkDestroyImage(m_device->device(), image);
+    vkDestroyImage(m_device->device(), image, NULL);
 }
 
 TEST_F(VkLayerTest, BindMemoryToDestroyedObject)
@@ -1027,7 +1027,7 @@
         mem_alloc.allocationSize = 0;
         mem_alloc.memoryTypeIndex = 0;
 
-    err = vkCreateImage(m_device->device(), &image_create_info, &image);
+    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
     ASSERT_VK_SUCCESS(err);
 
     vkGetImageMemoryRequirements(m_device->device(),
@@ -1039,11 +1039,11 @@
     ASSERT_TRUE(pass);
 
     // Allocate memory
-    err = vkAllocMemory(m_device->device(), &mem_alloc, &mem);
+    err = vkAllocMemory(m_device->device(), &mem_alloc, NULL, &mem);
     ASSERT_VK_SUCCESS(err);
 
     // Introduce validation failure, destroy Image object before binding
-    vkDestroyImage(m_device->device(), image);
+    vkDestroyImage(m_device->device(), image, NULL);
     ASSERT_VK_SUCCESS(err);
 
     // Now Try to bind memory to this destroyed object
@@ -1057,7 +1057,7 @@
         FAIL() << "Error received from BindMemoryToDestroyedObject was not 'Invalid VkImage Object 0x<handle>' but rather '" << msgString.c_str() << "'";
     }
 
-    vkFreeMemory(m_device->device(), mem);
+    vkFreeMemory(m_device->device(), mem, NULL);
 }
 
 TEST_F(VkLayerTest, InvalidBufferViewObject)
@@ -1081,7 +1081,7 @@
         ds_pool_ci.pTypeCounts = &ds_type_count;
 
     VkDescriptorPool ds_pool;
-    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -1096,7 +1096,7 @@
         ds_layout_ci.bindingCount = 1;
         ds_layout_ci.pBindings = &dsl_binding;
     VkDescriptorSetLayout ds_layout;
-    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
@@ -1127,8 +1127,8 @@
         FAIL() << "Error received was not 'Invalid VkBufferView Object 0xbaadbeef' but instead '" << msgString.c_str() << "'";
     }
 
-    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
-    vkDestroyDescriptorPool(m_device->device(), ds_pool);
+    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+    vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
 }
 #endif // OBJ_TRACKER_TESTS
 
@@ -1354,7 +1354,7 @@
         ds_pool_ci.pTypeCounts = &ds_type_count;
 
     VkDescriptorPool ds_pool;
-    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -1370,7 +1370,7 @@
         ds_layout_ci.pBindings = &dsl_binding;
 
     VkDescriptorSetLayout ds_layout;
-    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
@@ -1396,7 +1396,7 @@
         pipeline_layout_ci.pSetLayouts = &ds_layout;
         VkPipelineLayout pipeline_layout;
 
-    err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, &pipeline_layout);
+    err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
@@ -1424,9 +1424,9 @@
         FAIL() << "Error received was not 'Incorrectly binding graphics pipeline (0x<handle>) without an active RenderPass' but rather '" << msgString.c_str() << "'";
     }
 
-    vkDestroyPipelineLayout(m_device->device(), pipeline_layout);
-    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
-    vkDestroyDescriptorPool(m_device->device(), ds_pool);
+    vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);
+    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+    vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
 }
 
 TEST_F(VkLayerTest, AllocDescriptorFromEmptyPool)
@@ -1454,7 +1454,7 @@
         ds_pool_ci.pTypeCounts = &ds_type_count;
 
     VkDescriptorPool ds_pool;
-    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -1470,7 +1470,7 @@
         ds_layout_ci.pBindings = &dsl_binding;
 
     VkDescriptorSetLayout ds_layout;
-    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
@@ -1487,8 +1487,8 @@
         FAIL() << "Error received was not 'Unable to allocate 1 descriptors of type VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER...' but rather '" << msgString.c_str() << "'";
     }
 
-    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
-    vkDestroyDescriptorPool(m_device->device(), ds_pool);
+    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+    vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
 }
 
 TEST_F(VkLayerTest, FreeDescriptorFromOneShotPool)
@@ -1516,7 +1516,7 @@
         ds_pool_ci.pTypeCounts = &ds_type_count;
 
     VkDescriptorPool ds_pool;
-    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -1532,7 +1532,7 @@
         ds_layout_ci.pBindings = &dsl_binding;
 
     VkDescriptorSetLayout ds_layout;
-    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
@@ -1552,8 +1552,8 @@
         FAIL() << "Error received was not 'It is invalid to call vkFreeDescriptorSets() with a pool created with...' but instead it was '" << msgString.c_str() << "'";
     }
 
-    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
-    vkDestroyDescriptorPool(m_device->device(), ds_pool);
+    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+    vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
 }
 
 TEST_F(VkLayerTest, InvalidDescriptorPool)
@@ -1632,7 +1632,7 @@
         ds_pool_ci.pTypeCounts = &ds_type_count;
 
     VkDescriptorPool ds_pool;
-    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -1647,7 +1647,7 @@
         ds_layout_ci.bindingCount = 1;
         ds_layout_ci.pBindings = &dsl_binding;
     VkDescriptorSetLayout ds_layout;
-    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
@@ -1666,7 +1666,7 @@
         pipeline_layout_ci.pSetLayouts = &ds_layout;
 
     VkPipelineLayout pipeline_layout;
-    err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, &pipeline_layout);
+    err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
@@ -1688,9 +1688,9 @@
         FAIL() << "Error received was not 'DS <blah> bound but it was never updated. You may want to either update it or not bind it.'";
     }
 
-    vkDestroyPipelineLayout(m_device->device(), pipeline_layout);
-    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
-    vkDestroyDescriptorPool(m_device->device(), ds_pool);
+    vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);
+    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+    vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
 }
 
 TEST_F(VkLayerTest, NoBeginCmdBuffer)
@@ -1800,7 +1800,7 @@
         ds_pool_ci.pTypeCounts = &ds_type_count;
 
     VkDescriptorPool ds_pool;
-    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -1816,7 +1816,7 @@
         ds_layout_ci.pBindings = &dsl_binding;
 
     VkDescriptorSetLayout ds_layout;
-    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
@@ -1834,7 +1834,7 @@
         pipeline_layout_ci.pSetLayouts = &ds_layout;
 
     VkPipelineLayout pipeline_layout;
-    err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, &pipeline_layout);
+    err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkViewport vp = {}; // Just need dummy vp to point to
@@ -1863,9 +1863,9 @@
     VkPipeline pipeline;
     VkPipelineCache pipelineCache;
 
-    err = vkCreatePipelineCache(m_device->device(), &pc_ci, &pipelineCache);
+    err = vkCreatePipelineCache(m_device->device(), &pc_ci, NULL, &pipelineCache);
     ASSERT_VK_SUCCESS(err);
-    err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, &pipeline);
+    err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, NULL, &pipeline);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after creating Gfx Pipeline w/o VS.";
@@ -1873,10 +1873,10 @@
         FAIL() << "Error received was not 'Invalid Pipeline CreateInfo State: Vtx Shader required'";
     }
 
-    vkDestroyPipelineCache(m_device->device(), pipelineCache);
-    vkDestroyPipelineLayout(m_device->device(), pipeline_layout);
-    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
-    vkDestroyDescriptorPool(m_device->device(), ds_pool);
+    vkDestroyPipelineCache(m_device->device(), pipelineCache, NULL);
+    vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);
+    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+    vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
 }
 /*// TODO : This test should be good, but needs Tess support in compiler to run
 TEST_F(VkLayerTest, InvalidPatchControlPoints)
@@ -1901,7 +1901,7 @@
         ds_pool_ci.pTypeCounts = &ds_type_count;
 
     VkDescriptorPool ds_pool;
-    err = vkCreateDescriptorPool(m_device->device(), VK_DESCRIPTOR_POOL_USAGE_NON_FREE, 1, &ds_pool_ci, &ds_pool);
+    err = vkCreateDescriptorPool(m_device->device(), VK_DESCRIPTOR_POOL_USAGE_NON_FREE, 1, &ds_pool_ci, NULL, &ds_pool);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -1917,7 +1917,7 @@
         ds_layout_ci.pBindings = &dsl_binding;
 
     VkDescriptorSetLayout ds_layout;
-    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
@@ -1931,7 +1931,7 @@
         pipeline_layout_ci.pSetLayouts = &ds_layout;
 
     VkPipelineLayout pipeline_layout;
-    err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, &pipeline_layout);
+    err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkPipelineShaderStageCreateInfo shaderStages[3];
@@ -1987,9 +1987,9 @@
     VkPipeline pipeline;
     VkPipelineCache pipelineCache;
 
-    err = vkCreatePipelineCache(m_device->device(), &pc_ci, &pipelineCache);
+    err = vkCreatePipelineCache(m_device->device(), &pc_ci, NULL, &pipelineCache);
     ASSERT_VK_SUCCESS(err);
-    err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, &pipeline);
+    err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, NULL, &pipeline);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after creating Tess Gfx Pipeline w/ 0 patchControlPoints.";
@@ -1997,10 +1997,10 @@
         FAIL() << "Error received was not 'Invalid Pipeline CreateInfo State: VK_PRIMITIVE_TOPOLOGY_PATCH primitive...' but instead '" << msgString.c_str() << "'";
     }
 
-    vkDestroyPipelineCache(m_device->device(), pipelineCache);
-    vkDestroyPipelineLayout(m_device->device(), pipeline_layout);
-    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
-    vkDestroyDescriptorPool(m_device->device(), ds_pool);
+    vkDestroyPipelineCache(m_device->device(), pipelineCache, NULL);
+    vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);
+    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+    vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
 }
 */
 // Set scissor and viewport counts to different numbers
@@ -2026,7 +2026,7 @@
         ds_pool_ci.pTypeCounts = &ds_type_count;
 
     VkDescriptorPool ds_pool;
-    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -2040,7 +2040,7 @@
         ds_layout_ci.pBindings = &dsl_binding;
 
     VkDescriptorSetLayout ds_layout;
-    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
@@ -2058,7 +2058,7 @@
         pipeline_layout_ci.pSetLayouts = &ds_layout;
 
     VkPipelineLayout pipeline_layout;
-    err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, &pipeline_layout);
+    err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkViewport vp = {}; // Just need dummy vp to point to
@@ -2096,9 +2096,9 @@
     VkPipeline pipeline;
     VkPipelineCache pipelineCache;
 
-    err = vkCreatePipelineCache(m_device->device(), &pc_ci, &pipelineCache);
+    err = vkCreatePipelineCache(m_device->device(), &pc_ci, NULL, &pipelineCache);
     ASSERT_VK_SUCCESS(err);
-    err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, &pipeline);
+    err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, NULL, &pipeline);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after creating Gfx Pipeline w/ viewport and scissor count mismatch.";
@@ -2106,10 +2106,10 @@
         FAIL() << "Error received was not 'Gfx Pipeline viewport count (1) must match scissor count (0).' but instead it was '" << msgString.c_str() << "'";
     }
 
-    vkDestroyPipelineCache(m_device->device(), pipelineCache);
-    vkDestroyPipelineLayout(m_device->device(), pipeline_layout);
-    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
-    vkDestroyDescriptorPool(m_device->device(), ds_pool);
+    vkDestroyPipelineCache(m_device->device(), pipelineCache, NULL);
+    vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);
+    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+    vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
 }
 // Don't set viewport state in PSO. This is an error b/c we always need this state
 //  for the counts even if the data is going to be set dynamically.
@@ -2135,7 +2135,7 @@
         ds_pool_ci.pTypeCounts = &ds_type_count;
 
     VkDescriptorPool ds_pool;
-    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -2149,7 +2149,7 @@
         ds_layout_ci.pBindings = &dsl_binding;
 
     VkDescriptorSetLayout ds_layout;
-    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
@@ -2167,7 +2167,7 @@
         pipeline_layout_ci.pSetLayouts = &ds_layout;
 
     VkPipelineLayout pipeline_layout;
-    err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, &pipeline_layout);
+    err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkDynamicState sc_state = VK_DYNAMIC_STATE_SCISSOR;
@@ -2205,9 +2205,9 @@
     VkPipeline pipeline;
     VkPipelineCache pipelineCache;
 
-    err = vkCreatePipelineCache(m_device->device(), &pc_ci, &pipelineCache);
+    err = vkCreatePipelineCache(m_device->device(), &pc_ci, NULL, &pipelineCache);
     ASSERT_VK_SUCCESS(err);
-    err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, &pipeline);
+    err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, NULL, &pipeline);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after creating Gfx Pipeline w/o viewport state set.";
@@ -2215,10 +2215,10 @@
         FAIL() << "Error received was not 'Gfx Pipeline pViewportState is null. Even if...' but instead it was '" << msgString.c_str() << "'";
     }
 
-    vkDestroyPipelineCache(m_device->device(), pipelineCache);
-    vkDestroyPipelineLayout(m_device->device(), pipeline_layout);
-    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
-    vkDestroyDescriptorPool(m_device->device(), ds_pool);
+    vkDestroyPipelineCache(m_device->device(), pipelineCache, NULL);
+    vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);
+    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+    vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
 }
 // Create PSO w/o non-zero viewportCount but no viewport data
 // Then run second test where dynamic scissor count doesn't match PSO scissor count
@@ -2243,7 +2243,7 @@
         ds_pool_ci.pTypeCounts = &ds_type_count;
 
     VkDescriptorPool ds_pool;
-    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -2257,7 +2257,7 @@
         ds_layout_ci.pBindings = &dsl_binding;
 
     VkDescriptorSetLayout ds_layout;
-    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
@@ -2275,7 +2275,7 @@
         pipeline_layout_ci.pSetLayouts = &ds_layout;
 
     VkPipelineLayout pipeline_layout;
-    err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, &pipeline_layout);
+    err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkPipelineViewportStateCreateInfo vp_state_ci = {};
@@ -2344,9 +2344,9 @@
     VkPipeline pipeline;
     VkPipelineCache pipelineCache;
 
-    err = vkCreatePipelineCache(m_device->device(), &pc_ci, &pipelineCache);
+    err = vkCreatePipelineCache(m_device->device(), &pc_ci, NULL, &pipelineCache);
     ASSERT_VK_SUCCESS(err);
-    err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, &pipeline);
+    err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, NULL, &pipeline);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after creating Gfx Pipeline w/o scissor set.";
@@ -2358,7 +2358,7 @@
     // First need to successfully create the PSO from above by setting pViewports
     VkViewport vp = {}; // Just need dummy vp to point to
     vp_state_ci.pViewports = &vp;
-    err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, &pipeline);
+    err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, NULL, &pipeline);
     ASSERT_VK_SUCCESS(err);
     BeginCommandBuffer();
     vkCmdBindPipeline(m_cmdBuffer->GetBufferHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
@@ -2373,10 +2373,10 @@
         FAIL() << "Error received was not 'Dynamic scissorCount from vkCmdSetScissor() is 2, but PSO scissorCount is 1...' but instead it was '" << msgString.c_str() << "'";
     }
 
-    vkDestroyPipelineCache(m_device->device(), pipelineCache);
-    vkDestroyPipelineLayout(m_device->device(), pipeline_layout);
-    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
-    vkDestroyDescriptorPool(m_device->device(), ds_pool);
+    vkDestroyPipelineCache(m_device->device(), pipelineCache, NULL);
+    vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);
+    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+    vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
 }
 // Create PSO w/o non-zero scissorCount but no scissor data
 // Then run second test where dynamic viewportCount doesn't match PSO viewportCount
@@ -2401,7 +2401,7 @@
         ds_pool_ci.pTypeCounts = &ds_type_count;
 
     VkDescriptorPool ds_pool;
-    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -2415,7 +2415,7 @@
         ds_layout_ci.pBindings = &dsl_binding;
 
     VkDescriptorSetLayout ds_layout;
-    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
@@ -2433,7 +2433,7 @@
         pipeline_layout_ci.pSetLayouts = &ds_layout;
 
     VkPipelineLayout pipeline_layout;
-    err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, &pipeline_layout);
+    err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkPipelineViewportStateCreateInfo vp_state_ci = {};
@@ -2502,9 +2502,9 @@
     VkPipeline pipeline;
     VkPipelineCache pipelineCache;
 
-    err = vkCreatePipelineCache(m_device->device(), &pc_ci, &pipelineCache);
+    err = vkCreatePipelineCache(m_device->device(), &pc_ci, NULL, &pipelineCache);
     ASSERT_VK_SUCCESS(err);
-    err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, &pipeline);
+    err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, NULL, &pipeline);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after creating Gfx Pipeline w/o scissor set.";
@@ -2516,7 +2516,7 @@
     // First need to successfully create the PSO from above by setting pViewports
     VkRect2D sc = {}; // Just need dummy vp to point to
     vp_state_ci.pScissors = &sc;
-    err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, &pipeline);
+    err = vkCreateGraphicsPipelines(m_device->device(), pipelineCache, 1, &gp_ci, NULL, &pipeline);
     ASSERT_VK_SUCCESS(err);
     BeginCommandBuffer();
     vkCmdBindPipeline(m_cmdBuffer->GetBufferHandle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
@@ -2531,10 +2531,10 @@
         FAIL() << "Error received was not 'Dynamic viewportCount from vkCmdSetViewport() is 2, but PSO viewportCount is 1...' but instead it was '" << msgString.c_str() << "'";
     }
 
-    vkDestroyPipelineCache(m_device->device(), pipelineCache);
-    vkDestroyPipelineLayout(m_device->device(), pipeline_layout);
-    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
-    vkDestroyDescriptorPool(m_device->device(), ds_pool);
+    vkDestroyPipelineCache(m_device->device(), pipelineCache, NULL);
+    vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);
+    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+    vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
 }
 
 TEST_F(VkLayerTest, NullRenderPass)
@@ -2802,7 +2802,7 @@
         buffCI.pQueueFamilyIndices = &qfi;
 
     VkBuffer ib;
-    err = vkCreateBuffer(m_device->device(), &buffCI, &ib);
+    err = vkCreateBuffer(m_device->device(), &buffCI, NULL, &ib);
     ASSERT_VK_SUCCESS(err);
 
     BeginCommandBuffer();
@@ -2817,7 +2817,7 @@
         FAIL() << "Error received was not 'vkCmdBindIndexBuffer() offset (0x7) does not fall on ...' but instead '" << msgString.c_str() << "'";
     }
 
-    vkDestroyBuffer(m_device->device(), ib);
+    vkDestroyBuffer(m_device->device(), ib, NULL);
 }
 
 TEST_F(VkLayerTest, ExecuteCommandsPrimaryCB)
@@ -2864,7 +2864,7 @@
         ds_pool_ci.pTypeCounts = &ds_type_count;
 
     VkDescriptorPool ds_pool;
-    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
     ASSERT_VK_SUCCESS(err);
     VkDescriptorSetLayoutBinding dsl_binding = {};
         dsl_binding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
@@ -2879,7 +2879,7 @@
         ds_layout_ci.pBindings = &dsl_binding;
 
     VkDescriptorSetLayout ds_layout;
-    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
@@ -2910,7 +2910,7 @@
         sampler_ci.unnormalizedCoordinates = VK_FALSE;
 
     VkSampler sampler;
-    err = vkCreateSampler(m_device->device(), &sampler_ci, &sampler);
+    err = vkCreateSampler(m_device->device(), &sampler_ci, NULL, &sampler);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorImageInfo info = {};
@@ -2933,9 +2933,9 @@
         FAIL() << "Error received was not 'Write descriptor update has descriptor type VK_DESCRIPTOR_TYPE_SAMPLER that does not match...' but instead '" << msgString.c_str() << "'";
     }
 
-    vkDestroySampler(m_device->device(), sampler);
-    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
-    vkDestroyDescriptorPool(m_device->device(), ds_pool);
+    vkDestroySampler(m_device->device(), sampler, NULL);
+    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+    vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
 }
 
 TEST_F(VkLayerTest, DSUpdateOutOfBounds)
@@ -2960,7 +2960,7 @@
         ds_pool_ci.pTypeCounts = &ds_type_count;
 
     VkDescriptorPool ds_pool;
-    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -2976,7 +2976,7 @@
         ds_layout_ci.pBindings = &dsl_binding;
 
     VkDescriptorSetLayout ds_layout;
-    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
@@ -3007,7 +3007,7 @@
         sampler_ci.unnormalizedCoordinates = VK_FALSE;
 
     VkSampler sampler;
-    err = vkCreateSampler(m_device->device(), &sampler_ci, &sampler);
+    err = vkCreateSampler(m_device->device(), &sampler_ci, NULL, &sampler);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorImageInfo info = {};
@@ -3031,9 +3031,9 @@
         FAIL() << "Error received was not 'Descriptor update type of VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET is out of bounds for matching binding...'";
     }
 
-    vkDestroySampler(m_device->device(), sampler);
-    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
-    vkDestroyDescriptorPool(m_device->device(), ds_pool);
+    vkDestroySampler(m_device->device(), sampler, NULL);
+    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+    vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
 }
 
 TEST_F(VkLayerTest, InvalidDSUpdateIndex)
@@ -3058,7 +3058,7 @@
         ds_pool_ci.pTypeCounts = &ds_type_count;
 
     VkDescriptorPool ds_pool;
-    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -3073,7 +3073,7 @@
         ds_layout_ci.bindingCount = 1;
         ds_layout_ci.pBindings = &dsl_binding;
     VkDescriptorSetLayout ds_layout;
-    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
@@ -3104,7 +3104,7 @@
         sampler_ci.unnormalizedCoordinates = VK_FALSE;
 
     VkSampler sampler;
-    err = vkCreateSampler(m_device->device(), &sampler_ci, &sampler);
+    err = vkCreateSampler(m_device->device(), &sampler_ci, NULL, &sampler);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorImageInfo info = {};
@@ -3128,9 +3128,9 @@
         FAIL() << "Error received was not 'Descriptor Set <blah> does not have binding to match update binding '";
     }
 
-    vkDestroySampler(m_device->device(), sampler);
-    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
-    vkDestroyDescriptorPool(m_device->device(), ds_pool);
+    vkDestroySampler(m_device->device(), sampler, NULL);
+    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+    vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
 }
 
 TEST_F(VkLayerTest, InvalidDSUpdateStruct)
@@ -3155,7 +3155,7 @@
         ds_pool_ci.pTypeCounts = &ds_type_count;
 
     VkDescriptorPool ds_pool;
-    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
     ASSERT_VK_SUCCESS(err);
     VkDescriptorSetLayoutBinding dsl_binding = {};
         dsl_binding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
@@ -3170,7 +3170,7 @@
         ds_layout_ci.pBindings = &dsl_binding;
 
     VkDescriptorSetLayout ds_layout;
-    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
@@ -3200,7 +3200,7 @@
         sampler_ci.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
         sampler_ci.unnormalizedCoordinates = VK_FALSE;
     VkSampler sampler;
-    err = vkCreateSampler(m_device->device(), &sampler_ci, &sampler);
+    err = vkCreateSampler(m_device->device(), &sampler_ci, NULL, &sampler);
     ASSERT_VK_SUCCESS(err);
 
 
@@ -3224,9 +3224,9 @@
         FAIL() << "Error received was not 'Unexpected UPDATE struct of type '";
     }
 
-    vkDestroySampler(m_device->device(), sampler);
-    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
-    vkDestroyDescriptorPool(m_device->device(), ds_pool);
+    vkDestroySampler(m_device->device(), sampler, NULL);
+    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+    vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
 }
 
 TEST_F(VkLayerTest, SampleDescriptorUpdateError)
@@ -3251,7 +3251,7 @@
         ds_pool_ci.pTypeCounts = &ds_type_count;
 
     VkDescriptorPool ds_pool;
-    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -3266,7 +3266,7 @@
         ds_layout_ci.bindingCount = 1;
         ds_layout_ci.pBindings = &dsl_binding;
     VkDescriptorSetLayout ds_layout;
-    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
@@ -3301,8 +3301,8 @@
         FAIL() << "Error received was not 'Attempt to update descriptor with invalid sampler...' but instead '" << msgString.c_str() << "'";
     }
 
-    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
-    vkDestroyDescriptorPool(m_device->device(), ds_pool);
+    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+    vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
 }
 
 TEST_F(VkLayerTest, ImageViewDescriptorUpdateError)
@@ -3326,7 +3326,7 @@
         ds_pool_ci.pTypeCounts = &ds_type_count;
 
     VkDescriptorPool ds_pool;
-    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -3341,7 +3341,7 @@
         ds_layout_ci.bindingCount = 1;
         ds_layout_ci.pBindings = &dsl_binding;
     VkDescriptorSetLayout ds_layout;
-    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
@@ -3372,7 +3372,7 @@
         sampler_ci.unnormalizedCoordinates = VK_FALSE;
 
     VkSampler sampler;
-    err = vkCreateSampler(m_device->device(), &sampler_ci, &sampler);
+    err = vkCreateSampler(m_device->device(), &sampler_ci, NULL, &sampler);
     ASSERT_VK_SUCCESS(err);
 
     VkImageView view = (VkImageView) 0xbaadbeef; // invalid imageView object
@@ -3399,9 +3399,9 @@
         FAIL() << "Error received was not 'Attempt to update descriptor with invalid imageView...' but instead '" << msgString.c_str() << "'";
     }
 
-    vkDestroySampler(m_device->device(), sampler);
-    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
-    vkDestroyDescriptorPool(m_device->device(), ds_pool);
+    vkDestroySampler(m_device->device(), sampler, NULL);
+    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+    vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
 }
 
 TEST_F(VkLayerTest, CopyDescriptorUpdateErrors)
@@ -3428,7 +3428,7 @@
         ds_pool_ci.pTypeCounts = ds_type_count;
 
     VkDescriptorPool ds_pool;
-    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
     ASSERT_VK_SUCCESS(err);
     VkDescriptorSetLayoutBinding dsl_binding[2] = {};
         dsl_binding[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
@@ -3447,7 +3447,7 @@
         ds_layout_ci.pBindings = dsl_binding;
 
     VkDescriptorSetLayout ds_layout;
-    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
@@ -3478,7 +3478,7 @@
         sampler_ci.unnormalizedCoordinates = VK_FALSE;
 
     VkSampler sampler;
-    err = vkCreateSampler(m_device->device(), &sampler_ci, &sampler);
+    err = vkCreateSampler(m_device->device(), &sampler_ci, NULL, &sampler);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorImageInfo info = {};
@@ -3541,9 +3541,9 @@
         FAIL() << "Error received was not 'Copy descriptor src update is out of bounds for matching binding 1...' but instead '" << msgString.c_str() << "'";
     }
 
-    vkDestroySampler(m_device->device(), sampler);
-    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
-    vkDestroyDescriptorPool(m_device->device(), ds_pool);
+    vkDestroySampler(m_device->device(), sampler, NULL);
+    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+    vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
 }
 
 TEST_F(VkLayerTest, NumSamplesMismatch)
@@ -3568,7 +3568,7 @@
         ds_pool_ci.pTypeCounts = &ds_type_count;
 
     VkDescriptorPool ds_pool;
-    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -3584,7 +3584,7 @@
     ds_layout_ci.pBindings = &dsl_binding;
 
     VkDescriptorSetLayout ds_layout;
-    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
@@ -3611,7 +3611,7 @@
         pipeline_layout_ci.pSetLayouts = &ds_layout;
 
     VkPipelineLayout pipeline_layout;
-    err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, &pipeline_layout);
+    err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
@@ -3632,9 +3632,9 @@
         FAIL() << "Error received was not 'Num samples mismatch!...'";
     }
 
-    vkDestroyPipelineLayout(m_device->device(), pipeline_layout);
-    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
-    vkDestroyDescriptorPool(m_device->device(), ds_pool);
+    vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);
+    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+    vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
 }
 
 TEST_F(VkLayerTest, ClearCmdNoDraw)
@@ -3660,7 +3660,7 @@
         ds_pool_ci.pTypeCounts = &ds_type_count;
 
     VkDescriptorPool ds_pool;
-    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -3676,7 +3676,7 @@
         ds_layout_ci.pBindings = &dsl_binding;
 
     VkDescriptorSetLayout ds_layout;
-    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
@@ -3703,7 +3703,7 @@
         pipeline_layout_ci.pSetLayouts = &ds_layout;
 
     VkPipelineLayout pipeline_layout;
-    err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, &pipeline_layout);
+    err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
@@ -3736,9 +3736,9 @@
         FAIL() << "Error received was not 'vkCmdClearAttachments() issued on CB object...'";
     }
 
-    vkDestroyPipelineLayout(m_device->device(), pipeline_layout);
-    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
-    vkDestroyDescriptorPool(m_device->device(), ds_pool);
+    vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);
+    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+    vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
 }
 
 TEST_F(VkLayerTest, VtxBufferBadIndex)
@@ -3765,7 +3765,7 @@
         ds_pool_ci.pTypeCounts = &ds_type_count;
 
     VkDescriptorPool ds_pool;
-    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -3781,7 +3781,7 @@
         ds_layout_ci.pBindings = &dsl_binding;
 
     VkDescriptorSetLayout ds_layout;
-    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
@@ -3808,7 +3808,7 @@
         pipeline_layout_ci.pSetLayouts = &ds_layout;
         VkPipelineLayout pipeline_layout;
 
-    err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, &pipeline_layout);
+    err = vkCreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
@@ -3836,9 +3836,9 @@
         FAIL() << "Error received was not 'Vtx Buffer Index 0 was bound, but no vtx buffers are attached to PSO.' but instead was '" << msgString.c_str() << "'";
     }
 
-    vkDestroyPipelineLayout(m_device->device(), pipeline_layout);
-    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
-    vkDestroyDescriptorPool(m_device->device(), ds_pool);
+    vkDestroyPipelineLayout(m_device->device(), pipeline_layout, NULL);
+    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+    vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
 }
 #endif // DRAW_STATE_TESTS
 
@@ -3889,7 +3889,7 @@
     memset(&event_info, 0, sizeof(event_info));
     event_info.sType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO;
 
-    err = vkCreateEvent(device(), &event_info, &event);
+    err = vkCreateEvent(device(), &event_info, NULL, &event);
     ASSERT_VK_SUCCESS(err);
 
     err = vkResetEvent(device(), event);
@@ -3914,7 +3914,7 @@
         FAIL() << "Error received was not 'THREADING ERROR'";
     }
 
-    vkDestroyEvent(device(), event);
+    vkDestroyEvent(device(), event, NULL);
 }
 #endif // GTEST_IS_THREADSAFE
 #endif // THREADING_TESTS
@@ -3942,7 +3942,7 @@
     moduleCreateInfo.pCode = (const uint32_t *) &spv;
     moduleCreateInfo.codeSize = 4;
     moduleCreateInfo.flags = 0;
-    vkCreateShaderModule(m_device->device(), &moduleCreateInfo, &module);
+    vkCreateShaderModule(m_device->device(), &moduleCreateInfo, NULL, &module);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
 
@@ -3974,7 +3974,7 @@
     moduleCreateInfo.pCode = (const uint32_t *) &spv;
     moduleCreateInfo.codeSize = sizeof(spv) + 10;
     moduleCreateInfo.flags = 0;
-    vkCreateShaderModule(m_device->device(), &moduleCreateInfo, &module);
+    vkCreateShaderModule(m_device->device(), &moduleCreateInfo, NULL, &module);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
 
@@ -4007,7 +4007,7 @@
     moduleCreateInfo.pCode = (const uint32_t *) &spv;
     moduleCreateInfo.codeSize = sizeof(spv) + 10;
     moduleCreateInfo.flags = 0;
-    vkCreateShaderModule(m_device->device(), &moduleCreateInfo, &module);
+    vkCreateShaderModule(m_device->device(), &moduleCreateInfo, NULL, &module);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
 
@@ -4636,7 +4636,7 @@
 
     // Introduce error by sending down a bogus width extent
     image_create_info.extent.width = 65536;
-    vkCreateImage(m_device->device(), &image_create_info, &image);
+    vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive an error while creating an image" <<
@@ -4684,7 +4684,7 @@
     image_create_info.arrayLayers     = 4;
     image_create_info.samples       = 2;
     image_create_info.format        = VK_FORMAT_R8G8B8A8_UNORM;
-    vkCreateImage(m_device->device(), &image_create_info, &image);
+    vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive an error while creating an image" <<
@@ -4787,7 +4787,7 @@
         image_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT;
         image_create_info.flags = 0;
 
-    err = vkCreateImage(m_device->device(), &image_create_info, &image);
+    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
     ASSERT_VK_SUCCESS(err);
 
     VkImageViewCreateInfo image_view_create_info = {};
@@ -4801,7 +4801,7 @@
         image_view_create_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
 
     VkImageView view;
-    err = vkCreateImageView(m_device->device(), &image_view_create_info, &view);
+    err = vkCreateImageView(m_device->device(), &image_view_create_info, NULL, &view);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive an error while creating an invalid ImageView";
@@ -4840,7 +4840,7 @@
         image_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT;
         image_create_info.flags = 0;
 
-    err = vkCreateImage(m_device->device(), &image_create_info, &image);
+    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
     ASSERT_VK_SUCCESS(err);
 
     VkImageViewCreateInfo image_view_create_info = {};
@@ -4854,7 +4854,7 @@
         image_view_create_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_METADATA_BIT;
 
     VkImageView view;
-    err = vkCreateImageView(m_device->device(), &image_view_create_info, &view);
+    err = vkCreateImageView(m_device->device(), &image_view_create_info, NULL, &view);
 
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive an error when specifying an invalid ImageView aspect";
@@ -4895,13 +4895,13 @@
         image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT;
         image_create_info.flags = 0;
 
-    err = vkCreateImage(m_device->device(), &image_create_info, &srcImage);
+    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &srcImage);
     ASSERT_VK_SUCCESS(err);
 
         image_create_info.imageType = VK_IMAGE_TYPE_1D;
         image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT;
 
-    err = vkCreateImage(m_device->device(), &image_create_info, &destImage);
+    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &destImage);
     ASSERT_VK_SUCCESS(err);
 
     // Allocate memory
@@ -4915,14 +4915,14 @@
     memAlloc.allocationSize = memReqs.size;
     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
     ASSERT_TRUE(pass);
-    err = vkAllocMemory(m_device->device(), &memAlloc, &srcMem);
+    err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &srcMem);
     ASSERT_VK_SUCCESS(err);
 
     vkGetImageMemoryRequirements(m_device->device(), destImage, &memReqs);
     memAlloc.allocationSize = memReqs.size;
     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
     ASSERT_VK_SUCCESS(err);
-    err = vkAllocMemory(m_device->device(), &memAlloc, &destMem);
+    err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &destMem);
     ASSERT_VK_SUCCESS(err);
 
     err = vkBindImageMemory(m_device->device(), srcImage, srcMem, 0);
@@ -4958,10 +4958,10 @@
         FAIL() << "Error received was not 'vkCmdCopyImage called with unmatched source and dest image types' but instead '" << msgString.c_str() << "'";
     }
 
-    vkDestroyImage(m_device->device(), srcImage);
-    vkDestroyImage(m_device->device(), destImage);
-    vkFreeMemory(m_device->device(), srcMem);
-    vkFreeMemory(m_device->device(), destMem);
+    vkDestroyImage(m_device->device(), srcImage, NULL);
+    vkDestroyImage(m_device->device(), destImage, NULL);
+    vkFreeMemory(m_device->device(), srcMem, NULL);
+    vkFreeMemory(m_device->device(), destMem, NULL);
 }
 
 TEST_F(VkLayerTest, CopyImageFormatSizeMismatch)
@@ -5001,13 +5001,13 @@
         image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT;
         image_create_info.flags = 0;
 
-    err = vkCreateImage(m_device->device(), &image_create_info, &srcImage);
+    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &srcImage);
     ASSERT_VK_SUCCESS(err);
 
         image_create_info.imageType = VK_IMAGE_TYPE_1D;
         image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT;
 
-    err = vkCreateImage(m_device->device(), &image_create_info, &destImage);
+    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &destImage);
     ASSERT_VK_SUCCESS(err);
 
     // Allocate memory
@@ -5021,14 +5021,14 @@
     memAlloc.allocationSize = memReqs.size;
     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
     ASSERT_TRUE(pass);
-    err = vkAllocMemory(m_device->device(), &memAlloc, &srcMem);
+    err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &srcMem);
     ASSERT_VK_SUCCESS(err);
 
     vkGetImageMemoryRequirements(m_device->device(), destImage, &memReqs);
     memAlloc.allocationSize = memReqs.size;
     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
     ASSERT_TRUE(pass);
-    err = vkAllocMemory(m_device->device(), &memAlloc, &destMem);
+    err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &destMem);
     ASSERT_VK_SUCCESS(err);
 
     err = vkBindImageMemory(m_device->device(), srcImage, srcMem, 0);
@@ -5064,10 +5064,10 @@
         FAIL() << "Error received was not 'vkCmdCopyImage called with unmatched source and dest image types' but instead '" << msgString.c_str() << "'";
     }
 
-    vkDestroyImage(m_device->device(), srcImage);
-    vkDestroyImage(m_device->device(), destImage);
-    vkFreeMemory(m_device->device(), srcMem);
-    vkFreeMemory(m_device->device(), destMem);
+    vkDestroyImage(m_device->device(), srcImage, NULL);
+    vkDestroyImage(m_device->device(), destImage, NULL);
+    vkFreeMemory(m_device->device(), srcMem, NULL);
+    vkFreeMemory(m_device->device(), destMem, NULL);
 }
 
 TEST_F(VkLayerTest, ResolveImageLowSampleCount)
@@ -5102,13 +5102,13 @@
         image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT;
         image_create_info.flags = 0;
 
-    err = vkCreateImage(m_device->device(), &image_create_info, &srcImage);
+    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &srcImage);
     ASSERT_VK_SUCCESS(err);
 
         image_create_info.imageType = VK_IMAGE_TYPE_1D;
         image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT;
 
-    err = vkCreateImage(m_device->device(), &image_create_info, &destImage);
+    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &destImage);
     ASSERT_VK_SUCCESS(err);
 
     // Allocate memory
@@ -5122,14 +5122,14 @@
     memAlloc.allocationSize = memReqs.size;
     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
     ASSERT_TRUE(pass);
-    err = vkAllocMemory(m_device->device(), &memAlloc, &srcMem);
+    err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &srcMem);
     ASSERT_VK_SUCCESS(err);
 
     vkGetImageMemoryRequirements(m_device->device(), destImage, &memReqs);
     memAlloc.allocationSize = memReqs.size;
     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
     ASSERT_TRUE(pass);
-    err = vkAllocMemory(m_device->device(), &memAlloc, &destMem);
+    err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &destMem);
     ASSERT_VK_SUCCESS(err);
 
     err = vkBindImageMemory(m_device->device(), srcImage, srcMem, 0);
@@ -5168,10 +5168,10 @@
         FAIL() << "Error received was not 'vkCmdResolveImage called with source sample count less than 2.' but instead '" << msgString.c_str() << "'";
     }
 
-    vkDestroyImage(m_device->device(), srcImage);
-    vkDestroyImage(m_device->device(), destImage);
-    vkFreeMemory(m_device->device(), srcMem);
-    vkFreeMemory(m_device->device(), destMem);
+    vkDestroyImage(m_device->device(), srcImage, NULL);
+    vkDestroyImage(m_device->device(), destImage, NULL);
+    vkFreeMemory(m_device->device(), srcMem, NULL);
+    vkFreeMemory(m_device->device(), destMem, NULL);
 }
 
 TEST_F(VkLayerTest, ResolveImageHighSampleCount)
@@ -5207,14 +5207,14 @@
         image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
         image_create_info.flags = 0;
 
-    err = vkCreateImage(m_device->device(), &image_create_info, &srcImage);
+    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &srcImage);
     ASSERT_VK_SUCCESS(err);
 
         image_create_info.imageType = VK_IMAGE_TYPE_1D;
         // Note: Some implementations expect color attachment usage for any multisample surface
         image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
 
-    err = vkCreateImage(m_device->device(), &image_create_info, &destImage);
+    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &destImage);
     ASSERT_VK_SUCCESS(err);
 
     // Allocate memory
@@ -5228,14 +5228,14 @@
     memAlloc.allocationSize = memReqs.size;
     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
     ASSERT_TRUE(pass);
-    err = vkAllocMemory(m_device->device(), &memAlloc, &srcMem);
+    err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &srcMem);
     ASSERT_VK_SUCCESS(err);
 
     vkGetImageMemoryRequirements(m_device->device(), destImage, &memReqs);
     memAlloc.allocationSize = memReqs.size;
     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
     ASSERT_TRUE(pass);
-    err = vkAllocMemory(m_device->device(), &memAlloc, &destMem);
+    err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &destMem);
     ASSERT_VK_SUCCESS(err);
 
     err = vkBindImageMemory(m_device->device(), srcImage, srcMem, 0);
@@ -5274,10 +5274,10 @@
         FAIL() << "Error received was not 'vkCmdResolveImage called with dest sample count greater than 1.' but instead '" << msgString.c_str() << "'";
     }
 
-    vkDestroyImage(m_device->device(), srcImage);
-    vkDestroyImage(m_device->device(), destImage);
-    vkFreeMemory(m_device->device(), srcMem);
-    vkFreeMemory(m_device->device(), destMem);
+    vkDestroyImage(m_device->device(), srcImage, NULL);
+    vkDestroyImage(m_device->device(), destImage, NULL);
+    vkFreeMemory(m_device->device(), srcMem, NULL);
+    vkFreeMemory(m_device->device(), destMem, NULL);
 }
 
 TEST_F(VkLayerTest, ResolveImageFormatMismatch)
@@ -5313,7 +5313,7 @@
         image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
         image_create_info.flags = 0;
 
-    err = vkCreateImage(m_device->device(), &image_create_info, &srcImage);
+    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &srcImage);
     ASSERT_VK_SUCCESS(err);
 
         // Set format to something other than source image
@@ -5322,7 +5322,7 @@
         image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
         image_create_info.samples = 1;
 
-    err = vkCreateImage(m_device->device(), &image_create_info, &destImage);
+    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &destImage);
     ASSERT_VK_SUCCESS(err);
 
     // Allocate memory
@@ -5336,14 +5336,14 @@
     memAlloc.allocationSize = memReqs.size;
     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
     ASSERT_TRUE(pass);
-    err = vkAllocMemory(m_device->device(), &memAlloc, &srcMem);
+    err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &srcMem);
     ASSERT_VK_SUCCESS(err);
 
     vkGetImageMemoryRequirements(m_device->device(), destImage, &memReqs);
     memAlloc.allocationSize = memReqs.size;
     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
     ASSERT_TRUE(pass);
-    err = vkAllocMemory(m_device->device(), &memAlloc, &destMem);
+    err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &destMem);
     ASSERT_VK_SUCCESS(err);
 
     err = vkBindImageMemory(m_device->device(), srcImage, srcMem, 0);
@@ -5382,10 +5382,10 @@
         FAIL() << "Error received was not 'vkCmdResolveImage called with unmatched source and dest formats.' but instead '" << msgString.c_str() << "'";
     }
 
-    vkDestroyImage(m_device->device(), srcImage);
-    vkDestroyImage(m_device->device(), destImage);
-    vkFreeMemory(m_device->device(), srcMem);
-    vkFreeMemory(m_device->device(), destMem);
+    vkDestroyImage(m_device->device(), srcImage, NULL);
+    vkDestroyImage(m_device->device(), destImage, NULL);
+    vkFreeMemory(m_device->device(), srcMem, NULL);
+    vkFreeMemory(m_device->device(), destMem, NULL);
 }
 
 TEST_F(VkLayerTest, ResolveImageTypeMismatch)
@@ -5421,7 +5421,7 @@
         image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
         image_create_info.flags = 0;
 
-    err = vkCreateImage(m_device->device(), &image_create_info, &srcImage);
+    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &srcImage);
     ASSERT_VK_SUCCESS(err);
 
         image_create_info.imageType = VK_IMAGE_TYPE_1D;
@@ -5429,7 +5429,7 @@
         image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
         image_create_info.samples = 1;
 
-    err = vkCreateImage(m_device->device(), &image_create_info, &destImage);
+    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &destImage);
     ASSERT_VK_SUCCESS(err);
 
     // Allocate memory
@@ -5443,14 +5443,14 @@
     memAlloc.allocationSize = memReqs.size;
     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
     ASSERT_TRUE(pass);
-    err = vkAllocMemory(m_device->device(), &memAlloc, &srcMem);
+    err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &srcMem);
     ASSERT_VK_SUCCESS(err);
 
     vkGetImageMemoryRequirements(m_device->device(), destImage, &memReqs);
     memAlloc.allocationSize = memReqs.size;
     pass = m_device->phy().set_memory_type(memReqs.memoryTypeBits, &memAlloc, 0);
     ASSERT_TRUE(pass);
-    err = vkAllocMemory(m_device->device(), &memAlloc, &destMem);
+    err = vkAllocMemory(m_device->device(), &memAlloc, NULL, &destMem);
     ASSERT_VK_SUCCESS(err);
 
     err = vkBindImageMemory(m_device->device(), srcImage, srcMem, 0);
@@ -5489,10 +5489,10 @@
         FAIL() << "Error received was not 'vkCmdResolveImage called with unmatched source and dest image types.' but instead '" << msgString.c_str() << "'";
     }
 
-    vkDestroyImage(m_device->device(), srcImage);
-    vkDestroyImage(m_device->device(), destImage);
-    vkFreeMemory(m_device->device(), srcMem);
-    vkFreeMemory(m_device->device(), destMem);
+    vkDestroyImage(m_device->device(), srcImage, NULL);
+    vkDestroyImage(m_device->device(), destImage, NULL);
+    vkFreeMemory(m_device->device(), srcMem, NULL);
+    vkFreeMemory(m_device->device(), destMem, NULL);
 }
 
 TEST_F(VkLayerTest, DepthStencilImageViewWithColorAspectBitError)
@@ -5519,7 +5519,7 @@
         ds_pool_ci.pTypeCounts = &ds_type_count;
 
     VkDescriptorPool ds_pool;
-    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, &ds_pool);
+    err = vkCreateDescriptorPool(m_device->device(), &ds_pool_ci, NULL, &ds_pool);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSetLayoutBinding dsl_binding = {};
@@ -5534,7 +5534,7 @@
         ds_layout_ci.bindingCount = 1;
         ds_layout_ci.pBindings = &dsl_binding;
     VkDescriptorSetLayout ds_layout;
-    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, &ds_layout);
+    err = vkCreateDescriptorSetLayout(m_device->device(), &ds_layout_ci, NULL, &ds_layout);
     ASSERT_VK_SUCCESS(err);
 
     VkDescriptorSet descriptorSet;
@@ -5569,11 +5569,11 @@
         image_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
         image_create_info.flags = 0;
 
-    err = vkCreateImage(m_device->device(), &image_create_info, &image_bad);
+    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image_bad);
     ASSERT_VK_SUCCESS(err);
     image_create_info.format = tex_format_good;
     image_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
-    err = vkCreateImage(m_device->device(), &image_create_info, &image_good);
+    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image_good);
     ASSERT_VK_SUCCESS(err);
 
     VkImageViewCreateInfo image_view_create_info = {};
@@ -5588,18 +5588,18 @@
         image_view_create_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
 
     VkImageView view;
-    err = vkCreateImageView(m_device->device(), &image_view_create_info, &view);
+    err = vkCreateImageView(m_device->device(), &image_view_create_info, NULL, &view);
     msgFlags = m_errorMonitor->GetState(&msgString);
     ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive error after creating ImageView for DS image w/ COLOR aspect bit set.";
     if (!strstr(msgString.c_str(),"Combination depth/stencil image formats can have only the ")) {
         FAIL() << "Error received was not 'Combination depth/stencil image formats can have only the....' but instead '" << msgString.c_str() << "'";
     }
 
-    vkDestroyImage(m_device->device(), image_bad);
-    vkDestroyImage(m_device->device(), image_good);
-    vkDestroyImageView(m_device->device(), view);
-    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout);
-    vkDestroyDescriptorPool(m_device->device(), ds_pool);
+    vkDestroyImage(m_device->device(), image_bad, NULL);
+    vkDestroyImage(m_device->device(), image_good, NULL);
+    vkDestroyImageView(m_device->device(), view, NULL);
+    vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, NULL);
+    vkDestroyDescriptorPool(m_device->device(), ds_pool, NULL);
 }
 
 #endif // IMAGE_TESTS
diff --git a/tests/test_environment.cpp b/tests/test_environment.cpp
index 0709744..bdd0808 100644
--- a/tests/test_environment.cpp
+++ b/tests/test_environment.cpp
@@ -87,12 +87,11 @@
     inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
     inst_info.pNext = NULL;
     inst_info.pAppInfo = &app_;
-    inst_info.pAllocCb = NULL;
     inst_info.enabledExtensionNameCount = instance_extension_names.size();
     inst_info.ppEnabledExtensionNames = (instance_extension_names.size()) ? &instance_extension_names[0] : NULL;
     inst_info.enabledLayerNameCount = 0;
     inst_info.ppEnabledLayerNames = NULL;
-    err = vkCreateInstance(&inst_info, &inst);
+    err = vkCreateInstance(&inst_info, NULL, &inst);
     ASSERT_EQ(VK_SUCCESS, err);
     err = vkEnumeratePhysicalDevices(inst, &count, NULL);
     ASSERT_EQ(VK_SUCCESS, err);
@@ -132,6 +131,6 @@
     devs_.clear();
 
     if (inst)
-        vkDestroyInstance(inst);
+        vkDestroyInstance(inst, NULL);
 }
 } // vk_testing namespace
diff --git a/tests/vkrenderframework.cpp b/tests/vkrenderframework.cpp
index 1d868d5..2963b86 100644
--- a/tests/vkrenderframework.cpp
+++ b/tests/vkrenderframework.cpp
@@ -98,12 +98,11 @@
     instInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
     instInfo.pNext = NULL;
     instInfo.pAppInfo = &app_info;
-    instInfo.pAllocCb = NULL;
     instInfo.enabledLayerNameCount = instance_layer_names.size();
     instInfo.ppEnabledLayerNames = instance_layer_names.data();
     instInfo.enabledExtensionNameCount = instance_extension_names.size();
     instInfo.ppEnabledExtensionNames = instance_extension_names.data();
-    err = vkCreateInstance(&instInfo, &this->inst);
+    err = vkCreateInstance(&instInfo, NULL, &this->inst);
     ASSERT_VK_SUCCESS(err);
 
     err = vkEnumeratePhysicalDevices(inst, &this->gpu_count, NULL);
@@ -151,17 +150,17 @@
 {
     if (m_cmdBuffer)
         delete m_cmdBuffer;
-    if (m_cmdPool) vkDestroyCommandPool(device(), m_cmdPool);
-    if (m_framebuffer) vkDestroyFramebuffer(device(), m_framebuffer);
-    if (m_renderPass) vkDestroyRenderPass(device(), m_renderPass);
+    if (m_cmdPool) vkDestroyCommandPool(device(), m_cmdPool, NULL);
+    if (m_framebuffer) vkDestroyFramebuffer(device(), m_framebuffer, NULL);
+    if (m_renderPass) vkDestroyRenderPass(device(), m_renderPass, NULL);
 
     if (m_globalMsgCallback) m_dbgDestroyMsgCallback(this->inst, m_globalMsgCallback);
     if (m_devMsgCallback) m_dbgDestroyMsgCallback(this->inst, m_devMsgCallback);
 
     while (!m_renderTargets.empty()) {
-        vkDestroyImageView(device(), m_renderTargets.back()->targetView(m_render_target_fmt));
-        vkDestroyImage(device(), m_renderTargets.back()->image());
-        vkFreeMemory(device(), m_renderTargets.back()->memory());
+        vkDestroyImageView(device(), m_renderTargets.back()->targetView(m_render_target_fmt), NULL);
+        vkDestroyImage(device(), m_renderTargets.back()->image(), NULL);
+        vkFreeMemory(device(), m_renderTargets.back()->memory(), NULL);
         m_renderTargets.pop_back();
     }
 
@@ -174,7 +173,7 @@
 
     // reset the driver
     delete m_device;
-    if (this->inst) vkDestroyInstance(this->inst);
+    if (this->inst) vkDestroyInstance(this->inst, NULL);
 }
 
 void VkRenderFramework::InitState()
@@ -224,7 +223,7 @@
     cmd_pool_info.pNext = NULL,
     cmd_pool_info.queueFamilyIndex = m_device->graphics_queue_node_index_;
     cmd_pool_info.flags = 0,
-    err = vkCreateCommandPool(device(), &cmd_pool_info, &m_cmdPool);
+    err = vkCreateCommandPool(device(), &cmd_pool_info, NULL, &m_cmdPool);
     assert(!err);
 
     m_cmdBuffer = new VkCommandBufferObj(m_device, m_cmdPool);
@@ -377,7 +376,7 @@
     rp_info.subpassCount = 1;
     rp_info.pSubpasses = &subpass;
 
-    vkCreateRenderPass(device(), &rp_info, &m_renderPass);
+    vkCreateRenderPass(device(), &rp_info, NULL, &m_renderPass);
 
     // Create Framebuffer and RenderPass with color attachments and any depth/stencil attachment
     VkFramebufferCreateInfo fb_info = {};
@@ -390,7 +389,7 @@
     fb_info.height = (uint32_t)m_height;
     fb_info.layers = 1;
 
-    vkCreateFramebuffer(device(), &fb_info, &m_framebuffer);
+    vkCreateFramebuffer(device(), &fb_info, NULL, &m_framebuffer);
 
     m_renderPassBeginInfo.renderPass = m_renderPass;
     m_renderPassBeginInfo.framebuffer = m_framebuffer;
diff --git a/tests/vktestbinding.cpp b/tests/vktestbinding.cpp
index 3f8cf56..90944de 100644
--- a/tests/vktestbinding.cpp
+++ b/tests/vktestbinding.cpp
@@ -31,7 +31,7 @@
 #define NON_DISPATCHABLE_HANDLE_INIT(create_func, dev, ...)                         \
     do {                                                                            \
         handle_type handle;                                                         \
-        if (EXPECT(create_func(dev.handle(), __VA_ARGS__, &handle) == VK_SUCCESS))  \
+        if (EXPECT(create_func(dev.handle(), __VA_ARGS__, NULL, &handle) == VK_SUCCESS)) \
             NonDispHandle::init(dev.handle(), handle);                              \
     } while (0)
 
@@ -39,7 +39,7 @@
     cls::~cls()                                                                     \
     {                                                                               \
         if (initialized())                                                          \
-            destroy_func(device(), handle());                                       \
+            destroy_func(device(), handle(), NULL);                                 \
     }
 
 #define STRINGIFY(x) #x
@@ -260,7 +260,7 @@
         queues_[i].clear();
     }
 
-    vkDestroyDevice(handle());
+    vkDestroyDevice(handle(), NULL);
 }
 
 void Device::init(std::vector<const char *> &layers, std::vector<const char *> &extensions)
@@ -300,7 +300,7 @@
 {
     VkDevice dev;
 
-    if (EXPECT(vkCreateDevice(phy_.handle(), &info, &dev) == VK_SUCCESS))
+    if (EXPECT(vkCreateDevice(phy_.handle(), &info, NULL, &dev) == VK_SUCCESS))
         Handle::init(dev);
 
     init_queues();
@@ -427,7 +427,7 @@
 DeviceMemory::~DeviceMemory()
 {
     if (initialized())
-        vkFreeMemory(device(), handle());
+        vkFreeMemory(device(), handle(), NULL);
 }
 
 void DeviceMemory::init(const Device &dev, const VkMemoryAllocInfo &info)
@@ -632,7 +632,7 @@
 {
     VkShaderModule mod;
 
-    VkResult err = vkCreateShaderModule(dev.handle(), &info, &mod);
+    VkResult err = vkCreateShaderModule(dev.handle(), &info, NULL, &mod);
     if (err == VK_SUCCESS)
         NonDispHandle::init(dev.handle(), mod);
 
@@ -650,7 +650,7 @@
 {
     VkShader sh;
 
-    VkResult err = vkCreateShader(dev.handle(), &info, &sh);
+    VkResult err = vkCreateShader(dev.handle(), &info, NULL, &sh);
     if (err == VK_SUCCESS)
         NonDispHandle::init(dev.handle(), sh);
 
@@ -665,10 +665,10 @@
     VkPipelineCacheCreateInfo ci;
     memset((void *) &ci, 0, sizeof(VkPipelineCacheCreateInfo));
     ci.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
-    VkResult err = vkCreatePipelineCache(dev.handle(), &ci, &cache);
+    VkResult err = vkCreatePipelineCache(dev.handle(), &ci, NULL, &cache);
     if (err == VK_SUCCESS) {
         NON_DISPATCHABLE_HANDLE_INIT(vkCreateGraphicsPipelines, dev, cache, 1, &info);
-        vkDestroyPipelineCache(dev.handle(), cache);
+        vkDestroyPipelineCache(dev.handle(), cache, NULL);
     }
 }
 
@@ -679,14 +679,14 @@
     VkPipelineCacheCreateInfo ci;
     memset((void *) &ci, 0, sizeof(VkPipelineCacheCreateInfo));
     ci.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
-    VkResult err = vkCreatePipelineCache(dev.handle(), &ci, &cache);
+    VkResult err = vkCreatePipelineCache(dev.handle(), &ci, NULL, &cache);
     EXPECT(err == VK_SUCCESS);
     if (err == VK_SUCCESS) {
-        err = vkCreateGraphicsPipelines(dev.handle(), cache, 1, &info, &pipe);
+        err = vkCreateGraphicsPipelines(dev.handle(), cache, 1, &info, NULL, &pipe);
         if (err == VK_SUCCESS) {
             NonDispHandle::init(dev.handle(), pipe);
         }
-        vkDestroyPipelineCache(dev.handle(), cache);
+        vkDestroyPipelineCache(dev.handle(), cache, NULL);
     }
 
     return err;
@@ -698,10 +698,10 @@
     VkPipelineCacheCreateInfo ci;
     memset((void *) &ci, 0, sizeof(VkPipelineCacheCreateInfo));
     ci.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
-    VkResult err = vkCreatePipelineCache(dev.handle(), &ci, &cache);
+    VkResult err = vkCreatePipelineCache(dev.handle(), &ci, NULL, &cache);
     if (err == VK_SUCCESS) {
         NON_DISPATCHABLE_HANDLE_INIT(vkCreateComputePipelines, dev, cache, 1, &info);
-        vkDestroyPipelineCache(dev.handle(), cache);
+        vkDestroyPipelineCache(dev.handle(), cache, NULL);
     }
 }
 
diff --git a/tests/vktestframework.cpp b/tests/vktestframework.cpp
index 1cab1c0..33a090d 100644
--- a/tests/vktestframework.cpp
+++ b/tests/vktestframework.cpp
@@ -522,7 +522,7 @@
 
     err = vkCreateSemaphore(m_device.handle(),
                             &presentCompleteSemaphoreCreateInfo,
-                            &presentCompleteSemaphore);
+                            NULL, &presentCompleteSemaphore);
     assert(!err);
 
     // Get the index of the next available swapchain image:
@@ -597,7 +597,7 @@
     vkQueueSubmit(m_queue.handle(), 1, &submit_info, nullFence);
     m_queue.wait();
 
-    vkDestroySemaphore(m_device.handle(), presentCompleteSemaphore);
+    vkDestroySemaphore(m_device.handle(), presentCompleteSemaphore, NULL);
 
     VkPresentInfoKHR present = {};
     present.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
@@ -966,7 +966,7 @@
 
         color_image_view.image = m_buffers[i].image;
         err = vkCreateImageView(m_device.handle(),
-                &color_image_view, &m_buffers[i].view);
+                &color_image_view, NULL, &m_buffers[i].view);
         assert(!err);
 
         /* Set image layout to PRESENT_SOURCE_KHR so that before the copy, it can be set to */
@@ -1188,7 +1188,7 @@
     m_fpDestroySwapchainKHR(m_device.handle(), m_swap_chain);
 
     for (uint32_t i = 0; i < m_swapchainImageCount; i++) {
-        vkDestroyImageView(m_device.handle(), m_buffers[i].view);
+        vkDestroyImageView(m_device.handle(), m_buffers[i].view, NULL);
     }
 #ifndef _WIN32
     xcb_destroy_window(m_connection, m_window);
diff --git a/vk-layer-generate.py b/vk-layer-generate.py
index 4cef744..65b737a 100755
--- a/vk-layer-generate.py
+++ b/vk-layer-generate.py
@@ -687,7 +687,7 @@
                          '{\n'
                          '    dispatch_key key = get_dispatch_key(device);\n'
                          '    VkLayerDispatchTable *pDisp  =  device_dispatch_table(device);\n'
-                         '    pDisp->DestroyDevice(device);\n'
+                         '    pDisp->DestroyDevice(device, pAllocator);\n'
                          '    deviceExtMap.erase(pDisp);\n'
                          '    destroy_device_dispatch_table(key);\n'
                          '}\n' % (qual, decl))
@@ -697,7 +697,7 @@
                          '{\n'
                          '    dispatch_key key = get_dispatch_key(instance);\n'
                          '    VkLayerInstanceDispatchTable *pDisp  =  instance_dispatch_table(instance);\n'
-                         '    pDisp->DestroyInstance(instance);\n'
+                         '    pDisp->DestroyInstance(instance, pAllocator);\n'
                          '    // Clean up logging callback, if any\n'
                          '    layer_data *my_data = get_my_data_ptr(key, layer_data_map);\n'
                          '    if (my_data->logging_callback) {\n'
@@ -1367,7 +1367,8 @@
         gedi_txt = []
         gedi_txt.append('%s' % self.lineinfo.get())
         gedi_txt.append('void vkDestroyInstance(')
-        gedi_txt.append('VkInstance instance)')
+        gedi_txt.append('VkInstance instance,')
+        gedi_txt.append('const VkAllocCallbacks* pAllocator)')
         gedi_txt.append('{')
         gedi_txt.append('    loader_platform_thread_lock_mutex(&objLock);')
         gedi_txt.append('    validate_object(instance, instance);')
@@ -1387,7 +1388,7 @@
             gedi_txt.append('')
         gedi_txt.append('    dispatch_key key = get_dispatch_key(instance);')
         gedi_txt.append('    VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(ObjectTracker_instance_table_map, instance);')
-        gedi_txt.append('    pInstanceTable->DestroyInstance(instance);')
+        gedi_txt.append('    pInstanceTable->DestroyInstance(instance, pAllocator);')
         gedi_txt.append('')
         gedi_txt.append('    // Clean up logging callback, if any')
         gedi_txt.append('    layer_data *my_data = get_my_data_ptr(key, layer_data_map);')
@@ -1415,7 +1416,8 @@
         gedd_txt = []
         gedd_txt.append('%s' % self.lineinfo.get())
         gedd_txt.append('void vkDestroyDevice(')
-        gedd_txt.append('VkDevice device)')
+        gedd_txt.append('VkDevice device,')
+        gedd_txt.append('const VkAllocCallbacks* pAllocator)')
         gedd_txt.append('{')
         gedd_txt.append('    loader_platform_thread_lock_mutex(&objLock);')
         gedd_txt.append('    validate_object(device, device);')
@@ -1443,7 +1445,7 @@
         gedd_txt.append('')
         gedd_txt.append('    dispatch_key key = get_dispatch_key(device);')
         gedd_txt.append('    VkLayerDispatchTable *pDisp = get_dispatch_table(ObjectTracker_device_table_map, device);')
-        gedd_txt.append('    pDisp->DestroyDevice(device);')
+        gedd_txt.append('    pDisp->DestroyDevice(device, pAllocator);')
         gedd_txt.append('    ObjectTracker_device_table_map.erase(key);')
         gedd_txt.append('    assert(ObjectTracker_device_table_map.size() == 0 && "Should not have any instance mappings hanging around");')
         gedd_txt.append('')
@@ -1585,7 +1587,7 @@
                 funcs.append('%s\n' % self.lineinfo.get())
                 destroy_line =  '    loader_platform_thread_lock_mutex(&objLock);\n'
 #                destroy_line += '    if (result == VK_SUCCESS) {\n'
-                destroy_line += '    destroy_obj(%s, %s);\n' % (param0_name, proto.params[-1].name)
+                destroy_line += '    destroy_obj(%s, %s);\n' % (param0_name, proto.params[-2].name)
 #                destroy_line += '    }\n'
                 destroy_line += '    loader_platform_thread_unlock_mutex(&objLock);\n'
             if len(loop_params) > 0:
@@ -1904,7 +1906,7 @@
             funcs.append('%s%s\n'
                          '{\n'
                          '    VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(Threading_instance_table_map, *pInstance);\n'
-                         '    VkResult result = pInstanceTable->CreateInstance(pCreateInfo, pInstance);\n'
+                         '    VkResult result = pInstanceTable->CreateInstance(pCreateInfo, pAllocator, pInstance);\n'
                          '\n'
                          '    if (result == VK_SUCCESS) {\n'
                          '        layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);\n'
diff --git a/vktrace/src/vktrace_extensions/vktracevulkan/vkreplay/vkreplay_vkreplay.cpp b/vktrace/src/vktrace_extensions/vktracevulkan/vkreplay/vkreplay_vkreplay.cpp
index 860565a..57743e3 100644
--- a/vktrace/src/vktrace_extensions/vktracevulkan/vkreplay/vkreplay_vkreplay.cpp
+++ b/vktrace/src/vktrace_extensions/vktracevulkan/vkreplay/vkreplay_vkreplay.cpp
@@ -243,21 +243,18 @@
             createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
             createInfo.pNext = NULL;
             createInfo.pAppInfo = pPacket->pCreateInfo->pAppInfo;
-            createInfo.pAllocCb = NULL;
             createInfo.enabledLayerNameCount = 0;
             createInfo.ppEnabledLayerNames = NULL;
             createInfo.enabledExtensionNameCount = instance_extension_count;
             //                createInfo.ppEnabledExtensionNames = requiredLayerNames;
 
             // make the call
-            replayResult = m_vkFuncs.real_vkCreateInstance(&createInfo, &inst);
+            replayResult = m_vkFuncs.real_vkCreateInstance(&createInfo, NULL, &inst);
 
             // clean up
             free(instance_extensions);
         } else {
-            VkAllocCallbacks **pACB = (VkAllocCallbacks**) & pPacket->pCreateInfo->pAllocCb;
             const char strScreenShot[] = "ScreenShot";
-            *pACB = NULL;
             pCreateInfo = (VkInstanceCreateInfo *) pPacket->pCreateInfo;
             if (g_pReplaySettings->screenshotList != NULL) {
                 // enable screenshot layer if it is available and not already in list
@@ -296,7 +293,7 @@
                     vktrace_free(props);
                 }
             }
-            replayResult = m_vkFuncs.real_vkCreateInstance(pPacket->pCreateInfo, &inst);
+            replayResult = m_vkFuncs.real_vkCreateInstance(pPacket->pCreateInfo, NULL, &inst);
             if (ppEnabledLayerNames) {
                 // restore the packets CreateInfo struct
                 vktrace_free(ppEnabledLayerNames[pCreateInfo->enabledLayerNameCount - 1]);
@@ -370,7 +367,7 @@
                 vktrace_free(props);
             }
         }
-        replayResult = m_vkFuncs.real_vkCreateDevice(remappedPhysicalDevice, pPacket->pCreateInfo, &device);
+        replayResult = m_vkFuncs.real_vkCreateDevice(remappedPhysicalDevice, pPacket->pCreateInfo, NULL, &device);
         if (ppEnabledLayerNames)
         {
             // restore the packets CreateInfo struct
@@ -838,7 +835,7 @@
     // End manual code
 
     // No need to remap pCreateInfo
-    replayResult = m_vkFuncs.real_vkCreateShader(remappeddevice, pPacket->pCreateInfo, &local_pShader);
+    replayResult = m_vkFuncs.real_vkCreateShader(remappeddevice, pPacket->pCreateInfo, NULL, &local_pShader);
     if (replayResult == VK_SUCCESS)
     {
         m_objMapper.add_to_shaders_map(*(pPacket->pShader), local_pShader);
@@ -1046,7 +1043,7 @@
         pInfo = (VkDescriptorSetLayoutCreateInfo*)pPacket->pCreateInfo->pNext;
     }
     VkDescriptorSetLayout setLayout;
-    replayResult = m_vkFuncs.real_vkCreateDescriptorSetLayout(remappedDevice, pPacket->pCreateInfo, &setLayout);
+    replayResult = m_vkFuncs.real_vkCreateDescriptorSetLayout(remappedDevice, pPacket->pCreateInfo, NULL, &setLayout);
     if (replayResult == VK_SUCCESS)
     {
         m_objMapper.add_to_descriptorsetlayouts_map(*(pPacket->pSetLayout), setLayout);
@@ -1062,7 +1059,7 @@
         return;
     }
 
-    m_vkFuncs.real_vkDestroyDescriptorSetLayout(remappedDevice, pPacket->descriptorSetLayout);
+    m_vkFuncs.real_vkDestroyDescriptorSetLayout(remappedDevice, pPacket->descriptorSetLayout, NULL);
     m_objMapper.rm_from_descriptorsetlayouts_map(pPacket->descriptorSetLayout);
 }
 
@@ -1274,7 +1271,7 @@
 
     VkPipeline *local_pPipelines = VKTRACE_NEW_ARRAY(VkPipeline, pPacket->createInfoCount);
 
-    replayResult = m_vkFuncs.real_vkCreateGraphicsPipelines(remappedDevice, pipelineCache, createInfoCount, pLocalCIs, local_pPipelines);
+    replayResult = m_vkFuncs.real_vkCreateGraphicsPipelines(remappedDevice, pipelineCache, createInfoCount, pLocalCIs, NULL, local_pPipelines);
 
     if (replayResult == VK_SUCCESS)
     {
@@ -1311,7 +1308,7 @@
         *pSL = m_objMapper.remap_descriptorsetlayouts(pPacket->pCreateInfo->pSetLayouts[i]);
     }
     VkPipelineLayout localPipelineLayout;
-    replayResult = m_vkFuncs.real_vkCreatePipelineLayout(remappedDevice, pPacket->pCreateInfo, &localPipelineLayout);
+    replayResult = m_vkFuncs.real_vkCreatePipelineLayout(remappedDevice, pPacket->pCreateInfo, NULL, &localPipelineLayout);
     if (replayResult == VK_SUCCESS)
     {
         m_objMapper.add_to_pipelinelayouts_map(*(pPacket->pPipelineLayout), localPipelineLayout);
@@ -1452,7 +1449,7 @@
     pInfo->renderPass = m_objMapper.remap_renderpasss(pPacket->pCreateInfo->renderPass);
 
     VkFramebuffer local_framebuffer;
-    replayResult = m_vkFuncs.real_vkCreateFramebuffer(remappedDevice, pPacket->pCreateInfo, &local_framebuffer);
+    replayResult = m_vkFuncs.real_vkCreateFramebuffer(remappedDevice, pPacket->pCreateInfo, NULL, &local_framebuffer);
     pInfo->pAttachments = pSavedAttachments;
     pInfo->renderPass = savedRP;
     if (replayResult == VK_SUCCESS)
@@ -1475,7 +1472,7 @@
         return VK_ERROR_VALIDATION_FAILED;
 
     VkRenderPass local_renderpass;
-    replayResult = m_vkFuncs.real_vkCreateRenderPass(remappedDevice, pPacket->pCreateInfo, &local_renderpass);
+    replayResult = m_vkFuncs.real_vkCreateRenderPass(remappedDevice, pPacket->pCreateInfo, NULL, &local_renderpass);
     if (replayResult == VK_SUCCESS)
     {
         m_objMapper.add_to_renderpasss_map(*(pPacket->pRenderPass), local_renderpass);
@@ -1614,7 +1611,7 @@
     gpuMemObj local_mem;
 
     if (!m_objMapper.m_adjustForGPU)
-        replayResult = m_vkFuncs.real_vkAllocMemory(remappedDevice, pPacket->pAllocInfo, &local_mem.replayGpuMem);
+        replayResult = m_vkFuncs.real_vkAllocMemory(remappedDevice, pPacket->pAllocInfo, NULL, &local_mem.replayGpuMem);
     if (replayResult == VK_SUCCESS || m_objMapper.m_adjustForGPU)
     {
         local_mem.pGpuMem = new (gpuMemory);
@@ -1636,7 +1633,7 @@
     gpuMemObj local_mem;
     local_mem = m_objMapper.m_devicememorys.find(pPacket->mem)->second;
     // TODO how/when to free pendingAlloc that did not use and existing gpuMemObj
-    m_vkFuncs.real_vkFreeMemory(remappedDevice, local_mem.replayGpuMem);
+    m_vkFuncs.real_vkFreeMemory(remappedDevice, local_mem.replayGpuMem, NULL);
     delete local_mem.pGpuMem;
     m_objMapper.rm_from_devicememorys_map(pPacket->mem);
 }
diff --git a/vktrace/src/vktrace_layer/vktrace_lib_trace.cpp b/vktrace/src/vktrace_layer/vktrace_lib_trace.cpp
index 4ebcf69..cb29767 100644
--- a/vktrace/src/vktrace_layer/vktrace_lib_trace.cpp
+++ b/vktrace/src/vktrace_layer/vktrace_lib_trace.cpp
@@ -113,21 +113,24 @@
 VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkAllocMemory(
     VkDevice device,
     const VkMemoryAllocInfo* pAllocInfo,
+    const VkAllocCallbacks* pAllocator,
     VkDeviceMemory* pMem)
 {
     vktrace_trace_packet_header* pHeader;
     VkResult result;
     packet_vkAllocMemory* pPacket = NULL;
     CREATE_TRACE_PACKET(vkAllocMemory, get_struct_chain_size((void*)pAllocInfo) + sizeof(VkDeviceMemory));
-    result = mdd(device)->devTable.AllocMemory(device, pAllocInfo, pMem);
+    result = mdd(device)->devTable.AllocMemory(device, pAllocInfo, pAllocator, pMem);
     vktrace_set_packet_entrypoint_end_time(pHeader);
     pPacket = interpret_body_as_vkAllocMemory(pHeader);
     pPacket->device = device;
     vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocInfo), sizeof(VkMemoryAllocInfo), pAllocInfo);
     add_alloc_memory_to_trace_packet(pHeader, (void**)&(pPacket->pAllocInfo->pNext), pAllocInfo->pNext);
+    vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocator), sizeof(VkAllocCallbacks), pAllocator);
     vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pMem), sizeof(VkDeviceMemory), pMem);
     pPacket->result = result;
     vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocInfo));
+    vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocator));
     vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pMem));
     FINISH_TRACE_PACKET();
     // begin custom code
@@ -207,16 +210,19 @@
 
 VKTRACER_EXPORT void VKAPI __HOOKED_vkFreeMemory(
     VkDevice device,
-    VkDeviceMemory mem)
+    VkDeviceMemory mem,
+    const VkAllocCallbacks* pAllocator)
 {
     vktrace_trace_packet_header* pHeader;
     packet_vkFreeMemory* pPacket = NULL;
     CREATE_TRACE_PACKET(vkFreeMemory, 0);
-    mdd(device)->devTable.FreeMemory(device, mem);
+    mdd(device)->devTable.FreeMemory(device, mem, pAllocator);
     vktrace_set_packet_entrypoint_end_time(pHeader);
     pPacket = interpret_body_as_vkFreeMemory(pHeader);
     pPacket->device = device;
     pPacket->mem = mem;
+    vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocator), sizeof(VkAllocCallbacks), pAllocator);
+    vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocator));
     FINISH_TRACE_PACKET();
     // begin custom code
     rm_handle_from_mem_info(mem);
@@ -294,6 +300,7 @@
 VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkCreateDescriptorPool(
     VkDevice device,
     const VkDescriptorPoolCreateInfo* pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkDescriptorPool* pDescriptorPool)
 {
     vktrace_trace_packet_header* pHeader;
@@ -302,16 +309,18 @@
     // begin custom code (needs to use get_struct_chain_size)
     CREATE_TRACE_PACKET(vkCreateDescriptorPool,  get_struct_chain_size((void*)pCreateInfo) + sizeof(VkDescriptorPool));
     // end custom code
-    result = mdd(device)->devTable.CreateDescriptorPool(device, pCreateInfo, pDescriptorPool);
+    result = mdd(device)->devTable.CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
     vktrace_set_packet_entrypoint_end_time(pHeader);
     pPacket = interpret_body_as_vkCreateDescriptorPool(pHeader);
     pPacket->device = device;
     vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkDescriptorPoolCreateInfo), pCreateInfo);
     vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pTypeCounts), pCreateInfo->typeCount * sizeof(VkDescriptorTypeCount), pCreateInfo->pTypeCounts);
+    vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocator), sizeof(VkAllocCallbacks), pAllocator);
     vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDescriptorPool), sizeof(VkDescriptorPool), pDescriptorPool);
     pPacket->result = result;
     vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pTypeCounts));
     vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
+    vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocator));
     vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pDescriptorPool));
     FINISH_TRACE_PACKET();
     return result;
@@ -320,6 +329,7 @@
 VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkCreateDevice(
     VkPhysicalDevice physicalDevice,
     const VkDeviceCreateInfo* pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkDevice* pDevice)
 {
     vktrace_trace_packet_header* pHeader;
@@ -327,7 +337,7 @@
     packet_vkCreateDevice* pPacket = NULL;
 
     CREATE_TRACE_PACKET(vkCreateDevice, get_struct_chain_size((void*)pCreateInfo) + sizeof(VkDevice));
-    result = mdd(*pDevice)->devTable.CreateDevice(physicalDevice, pCreateInfo, pDevice);
+    result = mdd(*pDevice)->devTable.CreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
     if (result == VK_SUCCESS)
         ext_init_create_device(mdd(*pDevice), *pDevice, pCreateInfo->enabledExtensionNameCount, pCreateInfo->ppEnabledExtensionNames);
 
@@ -335,8 +345,10 @@
     pPacket = interpret_body_as_vkCreateDevice(pHeader);
     pPacket->physicalDevice = physicalDevice;
     add_VkDeviceCreateInfo_to_packet(pHeader, (VkDeviceCreateInfo**) &(pPacket->pCreateInfo), pCreateInfo);
+    vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocator), sizeof(VkAllocCallbacks), pAllocator);
     vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDevice), sizeof(VkDevice), pDevice);
     pPacket->result = result;
+    vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocator));
     vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pDevice));
     FINISH_TRACE_PACKET();
     return result;
@@ -345,6 +357,7 @@
 VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkCreateFramebuffer(
     VkDevice device,
     const VkFramebufferCreateInfo* pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkFramebuffer* pFramebuffer)
 {
     vktrace_trace_packet_header* pHeader;
@@ -354,16 +367,18 @@
     uint32_t attachmentCount = (pCreateInfo != NULL && pCreateInfo->pAttachments != NULL) ? pCreateInfo->attachmentCount : 0;
     CREATE_TRACE_PACKET(vkCreateFramebuffer, get_struct_chain_size((void*)pCreateInfo) + sizeof(VkFramebuffer));
     // end custom code
-    result = mdd(device)->devTable.CreateFramebuffer(device, pCreateInfo, pFramebuffer);
+    result = mdd(device)->devTable.CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
     vktrace_set_packet_entrypoint_end_time(pHeader);
     pPacket = interpret_body_as_vkCreateFramebuffer(pHeader);
     pPacket->device = device;
     vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo), sizeof(VkFramebufferCreateInfo), pCreateInfo);
     vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pAttachments), attachmentCount * sizeof(VkImageView), pCreateInfo->pAttachments);
+    vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocator), sizeof(VkAllocCallbacks), pAllocator);
     vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pFramebuffer), sizeof(VkFramebuffer), pFramebuffer);
     pPacket->result = result;
     vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pAttachments));
     vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
+    vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocator));
     vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pFramebuffer));
     FINISH_TRACE_PACKET();
     return result;
@@ -371,6 +386,7 @@
 
 VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkCreateInstance(
     const VkInstanceCreateInfo* pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkInstance* pInstance)
 {
     vktrace_trace_packet_header* pHeader;
@@ -381,7 +397,7 @@
     uint64_t vktraceStartTime = vktrace_get_time();
     SEND_ENTRYPOINT_ID(vkCreateInstance);
     startTime = vktrace_get_time();
-    result = mid(*pInstance)->instTable.CreateInstance(pCreateInfo, pInstance);
+    result = mid(*pInstance)->instTable.CreateInstance(pCreateInfo, pAllocator, pInstance);
     endTime = vktrace_get_time();
     if (result == VK_SUCCESS)
         ext_init_create_instance(mid(*pInstance), *pInstance, pCreateInfo->enabledExtensionNameCount, pCreateInfo->ppEnabledExtensionNames);
@@ -393,8 +409,10 @@
     pPacket = interpret_body_as_vkCreateInstance(pHeader);
 
     add_VkInstanceCreateInfo_to_packet(pHeader, (VkInstanceCreateInfo**)&(pPacket->pCreateInfo), (VkInstanceCreateInfo*) pCreateInfo);
+    vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocator), sizeof(VkAllocCallbacks), pAllocator);
     vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pInstance), sizeof(VkInstance), pInstance);
     pPacket->result = result;
+    vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocator));
     vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pInstance));
     FINISH_TRACE_PACKET();
     return result;
@@ -403,6 +421,7 @@
 VKTRACER_EXPORT VkResult VKAPI __HOOKED_vkCreateRenderPass(
     VkDevice device,
     const VkRenderPassCreateInfo* pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkRenderPass* pRenderPass)
 {
     vktrace_trace_packet_header* pHeader;
@@ -414,7 +433,7 @@
     uint32_t subpassCount = (pCreateInfo != NULL && (pCreateInfo->pSubpasses != NULL)) ? pCreateInfo->subpassCount : 0;
     CREATE_TRACE_PACKET(vkCreateRenderPass, get_struct_chain_size((void*)pCreateInfo) + sizeof(VkRenderPass));
     // end custom code
-    result = mdd(device)->devTable.CreateRenderPass(device, pCreateInfo, pRenderPass);
+    result = mdd(device)->devTable.CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
     vktrace_set_packet_entrypoint_end_time(pHeader);
     pPacket = interpret_body_as_vkCreateRenderPass(pHeader);
     pPacket->device = device;
@@ -435,12 +454,14 @@
         vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pSubpass->pPreserveAttachments), pSubpass->preserveAttachmentCount * sizeof(VkAttachmentReference), pSp->pPreserveAttachments);
         vktrace_finalize_buffer_address(pHeader, (void**)&(pSubpass->pPreserveAttachments));
     }
+    vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocator), sizeof(VkAllocCallbacks), pAllocator);
     vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pRenderPass), sizeof(VkRenderPass), pRenderPass);
     pPacket->result = result;
     vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pAttachments));
     vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pDependencies));
     vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pSubpasses));
     vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo));
+    vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocator));
     vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pRenderPass));
     FINISH_TRACE_PACKET();
     return result;
@@ -861,6 +882,7 @@
     VkPipelineCache pipelineCache,
     uint32_t createInfoCount,
     const VkGraphicsPipelineCreateInfo* pCreateInfos,
+    const VkAllocCallbacks* pAllocator,
     VkPipeline* pPipelines)
 {
     vktrace_trace_packet_header* pHeader;
@@ -872,7 +894,7 @@
         total_size += get_struct_chain_size((void*)&pCreateInfos[i]);
     }
     CREATE_TRACE_PACKET(vkCreateGraphicsPipelines, total_size + createInfoCount*sizeof(VkPipeline));
-    result = mdd(device)->devTable.CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pPipelines);
+    result = mdd(device)->devTable.CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
     vktrace_set_packet_entrypoint_end_time(pHeader);
     pPacket = interpret_body_as_vkCreateGraphicsPipelines(pHeader);
     pPacket->device = device;
@@ -880,9 +902,11 @@
     pPacket->createInfoCount = createInfoCount;
     vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfos), createInfoCount*sizeof(VkGraphicsPipelineCreateInfo), pCreateInfos);
     add_VkGraphicsPipelineCreateInfos_to_trace_packet(pHeader, (VkGraphicsPipelineCreateInfo*)pPacket->pCreateInfos, pCreateInfos, createInfoCount);
+    vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocator), sizeof(VkAllocCallbacks), pAllocator);
     vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pPipelines), createInfoCount*sizeof(VkPipeline), pPipelines);
     pPacket->result = result;
     vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfos));
+    vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocator));
     vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pPipelines));
     FINISH_TRACE_PACKET();
     return result;
@@ -893,13 +917,14 @@
     VkPipelineCache pipelineCache,
     uint32_t createInfoCount,
     const VkComputePipelineCreateInfo* pCreateInfos,
+    const VkAllocCallbacks* pAllocator,
     VkPipeline* pPipelines)
 {
     vktrace_trace_packet_header* pHeader;
     VkResult result;
     packet_vkCreateComputePipelines* pPacket = NULL;
     CREATE_TRACE_PACKET(vkCreateComputePipelines, createInfoCount*sizeof(VkComputePipelineCreateInfo) + sizeof(VkPipeline));
-    result = mdd(device)->devTable.CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pPipelines);
+    result = mdd(device)->devTable.CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
     vktrace_set_packet_entrypoint_end_time(pHeader);
     pPacket = interpret_body_as_vkCreateComputePipelines(pHeader);
     pPacket->device = device;
@@ -907,9 +932,11 @@
     pPacket->createInfoCount = createInfoCount;
     vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfos), createInfoCount*sizeof(VkComputePipelineCreateInfo), pCreateInfos);
     add_VkComputePipelineCreateInfos_to_trace_packet(pHeader, (VkComputePipelineCreateInfo*)pPacket->pCreateInfos, pCreateInfos, createInfoCount);
+    vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocator), sizeof(VkAllocCallbacks), pAllocator);
     vktrace_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pPipelines), createInfoCount*sizeof(VkPipeline), pPipelines);
     pPacket->result = result;
     vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfos));
+    vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocator));
     vktrace_finalize_buffer_address(pHeader, (void**)&(pPacket->pPipelines));
     FINISH_TRACE_PACKET();
     return result;
diff --git a/vktrace/vktrace_generate.py b/vktrace/vktrace_generate.py
index ad5cc36..729f951 100755
--- a/vktrace/vktrace_generate.py
+++ b/vktrace/vktrace_generate.py
@@ -554,8 +554,6 @@
         pid_enum.append('{')
         pid_enum.append('    vktrace_add_buffer_to_trace_packet(pHeader, (void**)ppStruct, sizeof(VkInstanceCreateInfo), pInStruct);')
         pid_enum.append('    add_VkApplicationInfo_to_packet(pHeader, (VkApplicationInfo**)&((*ppStruct)->pAppInfo), pInStruct->pAppInfo);')
-        pid_enum.append('    vktrace_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->pAllocCb), sizeof(VkAllocCallbacks), pInStruct->pAllocCb);')
-        pid_enum.append('    vktrace_finalize_buffer_address(pHeader, (void**)&((*ppStruct)->pAllocCb));')
         # TODO138 : This is an initial pass at getting the extension/layer arrays correct, needs to be validated.
         pid_enum.append('    uint32_t i, siz = 0;')
         pid_enum.append('    vktrace_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->ppEnabledLayerNames), pInStruct->enabledLayerNameCount * sizeof(char*), pInStruct->ppEnabledLayerNames);')
@@ -627,7 +625,6 @@
         pid_enum.append('    if (pVkInstanceCreateInfo != NULL)')
         pid_enum.append('    {')
         pid_enum.append('        pVkInstanceCreateInfo->pAppInfo = (VkApplicationInfo*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkInstanceCreateInfo->pAppInfo);')
-        pid_enum.append('        pVkInstanceCreateInfo->pAllocCb = (VkAllocCallbacks*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkInstanceCreateInfo->pAllocCb);')
         pid_enum.append('        VkApplicationInfo** ppAppInfo = (VkApplicationInfo**) &pVkInstanceCreateInfo->pAppInfo;')
         pid_enum.append('        (*ppAppInfo)->pAppName = (const char*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkInstanceCreateInfo->pAppInfo->pAppName);')
         pid_enum.append('        (*ppAppInfo)->pEngineName = (const char*)vktrace_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVkInstanceCreateInfo->pAppInfo->pEngineName);')
@@ -1424,7 +1421,7 @@
         ci_body.append('            {')
         ci_body.append('                return vktrace_replay::VKTRACE_REPLAY_ERROR;')
         ci_body.append('            }')
-        ci_body.append('            replayResult = m_vkFuncs.real_vkCreateImage(remappedDevice, pPacket->pCreateInfo, &local_imageObj.replayImage);')
+        ci_body.append('            replayResult = m_vkFuncs.real_vkCreateImage(remappedDevice, pPacket->pCreateInfo, NULL, &local_imageObj.replayImage);')
         ci_body.append('            if (replayResult == VK_SUCCESS)')
         ci_body.append('            {')
         ci_body.append('                m_objMapper.add_to_images_map(*(pPacket->pImage), local_imageObj);')
@@ -1439,7 +1436,7 @@
         cb_body.append('            {')
         cb_body.append('                return vktrace_replay::VKTRACE_REPLAY_ERROR;')
         cb_body.append('            }')
-        cb_body.append('            replayResult = m_vkFuncs.real_vkCreateBuffer(remappedDevice, pPacket->pCreateInfo, &local_bufferObj.replayBuffer);')
+        cb_body.append('            replayResult = m_vkFuncs.real_vkCreateBuffer(remappedDevice, pPacket->pCreateInfo, NULL, &local_bufferObj.replayBuffer);')
         cb_body.append('            if (replayResult == VK_SUCCESS)')
         cb_body.append('            {')
         cb_body.append('                m_objMapper.add_to_buffers_map(*(pPacket->pBuffer), local_bufferObj);')
@@ -1644,7 +1641,8 @@
                     rr_string += ');'
                 elif create_view:
                     rr_list = rr_string.split(', ')
-                    rr_list[-2] = '&createInfo'
+                    rr_list[-3] = '&createInfo'
+                    rr_list[-2] = 'NULL'
                     rr_list[-1] = '&local_%s);' % proto.params[-1].name
                     rr_string = ', '.join(rr_list)
                     # this is a sneaky shortcut to use generic create code below to add_to_map
diff --git a/vulkan.py b/vulkan.py
index a57d199..3f0c706 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -213,10 +213,12 @@
     protos=[
         Proto("VkResult", "CreateInstance",
             [Param("const VkInstanceCreateInfo*", "pCreateInfo"),
+             Param("const VkAllocCallbacks*", "pAllocator"),
              Param("VkInstance*", "pInstance")]),
 
         Proto("void", "DestroyInstance",
-            [Param("VkInstance", "instance")]),
+            [Param("VkInstance", "instance"),
+             Param("const VkAllocCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "EnumeratePhysicalDevices",
             [Param("VkInstance", "instance"),
@@ -265,10 +267,12 @@
         Proto("VkResult", "CreateDevice",
             [Param("VkPhysicalDevice", "physicalDevice"),
              Param("const VkDeviceCreateInfo*", "pCreateInfo"),
+             Param("const VkAllocCallbacks*", "pAllocator"),
              Param("VkDevice*", "pDevice")]),
 
         Proto("void", "DestroyDevice",
-            [Param("VkDevice", "device")]),
+            [Param("VkDevice", "device"),
+             Param("const VkAllocCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "EnumerateInstanceExtensionProperties",
             [Param("const char*", "pLayerName"),
@@ -311,11 +315,13 @@
         Proto("VkResult", "AllocMemory",
             [Param("VkDevice", "device"),
              Param("const VkMemoryAllocInfo*", "pAllocInfo"),
+             Param("const VkAllocCallbacks*", "pAllocator"),
              Param("VkDeviceMemory*", "pMem")]),
 
         Proto("void", "FreeMemory",
             [Param("VkDevice", "device"),
-             Param("VkDeviceMemory", "mem")]),
+             Param("VkDeviceMemory", "mem"),
+             Param("const VkAllocCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "MapMemory",
             [Param("VkDevice", "device"),
@@ -403,11 +409,13 @@
         Proto("VkResult", "CreateFence",
             [Param("VkDevice", "device"),
              Param("const VkFenceCreateInfo*", "pCreateInfo"),
+             Param("const VkAllocCallbacks*", "pAllocator"),
              Param("VkFence*", "pFence")]),
 
         Proto("void", "DestroyFence",
             [Param("VkDevice", "device"),
-             Param("VkFence", "fence")]),
+             Param("VkFence", "fence"),
+             Param("const VkAllocCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "ResetFences",
             [Param("VkDevice", "device"),
@@ -428,20 +436,24 @@
         Proto("VkResult", "CreateSemaphore",
             [Param("VkDevice", "device"),
              Param("const VkSemaphoreCreateInfo*", "pCreateInfo"),
+             Param("const VkAllocCallbacks*", "pAllocator"),
              Param("VkSemaphore*", "pSemaphore")]),
 
         Proto("void", "DestroySemaphore",
             [Param("VkDevice", "device"),
-             Param("VkSemaphore", "semaphore")]),
+             Param("VkSemaphore", "semaphore"),
+             Param("const VkAllocCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "CreateEvent",
             [Param("VkDevice", "device"),
              Param("const VkEventCreateInfo*", "pCreateInfo"),
+             Param("const VkAllocCallbacks*", "pAllocator"),
              Param("VkEvent*", "pEvent")]),
 
         Proto("void", "DestroyEvent",
             [Param("VkDevice", "device"),
-             Param("VkEvent", "event")]),
+             Param("VkEvent", "event"),
+             Param("const VkAllocCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "GetEventStatus",
             [Param("VkDevice", "device"),
@@ -458,11 +470,13 @@
         Proto("VkResult", "CreateQueryPool",
             [Param("VkDevice", "device"),
              Param("const VkQueryPoolCreateInfo*", "pCreateInfo"),
+             Param("const VkAllocCallbacks*", "pAllocator"),
              Param("VkQueryPool*", "pQueryPool")]),
 
         Proto("void", "DestroyQueryPool",
             [Param("VkDevice", "device"),
-             Param("VkQueryPool", "queryPool")]),
+             Param("VkQueryPool", "queryPool"),
+             Param("const VkAllocCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "GetQueryPoolResults",
             [Param("VkDevice", "device"),
@@ -477,29 +491,35 @@
         Proto("VkResult", "CreateBuffer",
             [Param("VkDevice", "device"),
              Param("const VkBufferCreateInfo*", "pCreateInfo"),
+             Param("const VkAllocCallbacks*", "pAllocator"),
              Param("VkBuffer*", "pBuffer")]),
 
         Proto("void", "DestroyBuffer",
             [Param("VkDevice", "device"),
-             Param("VkBuffer", "buffer")]),
+             Param("VkBuffer", "buffer"),
+             Param("const VkAllocCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "CreateBufferView",
             [Param("VkDevice", "device"),
              Param("const VkBufferViewCreateInfo*", "pCreateInfo"),
+             Param("const VkAllocCallbacks*", "pAllocator"),
              Param("VkBufferView*", "pView")]),
 
         Proto("void", "DestroyBufferView",
             [Param("VkDevice", "device"),
-             Param("VkBufferView", "bufferView")]),
+             Param("VkBufferView", "bufferView"),
+             Param("const VkAllocCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "CreateImage",
             [Param("VkDevice", "device"),
              Param("const VkImageCreateInfo*", "pCreateInfo"),
+             Param("const VkAllocCallbacks*", "pAllocator"),
              Param("VkImage*", "pImage")]),
 
         Proto("void", "DestroyImage",
             [Param("VkDevice", "device"),
-             Param("VkImage", "image")]),
+             Param("VkImage", "image"),
+             Param("const VkAllocCallbacks*", "pAllocator")]),
 
         Proto("void", "GetImageSubresourceLayout",
             [Param("VkDevice", "device"),
@@ -510,38 +530,46 @@
         Proto("VkResult", "CreateImageView",
             [Param("VkDevice", "device"),
              Param("const VkImageViewCreateInfo*", "pCreateInfo"),
+             Param("const VkAllocCallbacks*", "pAllocator"),
              Param("VkImageView*", "pView")]),
 
         Proto("void", "DestroyImageView",
             [Param("VkDevice", "device"),
-             Param("VkImageView", "imageView")]),
+             Param("VkImageView", "imageView"),
+             Param("const VkAllocCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "CreateShaderModule",
             [Param("VkDevice", "device"),
              Param("const VkShaderModuleCreateInfo*", "pCreateInfo"),
+             Param("const VkAllocCallbacks*", "pAllocator"),
              Param("VkShaderModule*", "pShaderModule")]),
 
         Proto("void", "DestroyShaderModule",
             [Param("VkDevice", "device"),
-             Param("VkShaderModule", "shaderModule")]),
+             Param("VkShaderModule", "shaderModule"),
+             Param("const VkAllocCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "CreateShader",
             [Param("VkDevice", "device"),
              Param("const VkShaderCreateInfo*", "pCreateInfo"),
+             Param("const VkAllocCallbacks*", "pAllocator"),
              Param("VkShader*", "pShader")]),
 
         Proto("void", "DestroyShader",
             [Param("VkDevice", "device"),
-             Param("VkShader", "shader")]),
+             Param("VkShader", "shader"),
+             Param("const VkAllocCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "CreatePipelineCache",
             [Param("VkDevice", "device"),
              Param("const VkPipelineCacheCreateInfo*", "pCreateInfo"),
+             Param("const VkAllocCallbacks*", "pAllocator"),
              Param("VkPipelineCache*", "pPipelineCache")]),
 
         Proto("void", "DestroyPipelineCache",
             [Param("VkDevice", "device"),
-             Param("VkPipelineCache", "pipelineCache")]),
+             Param("VkPipelineCache", "pipelineCache"),
+             Param("const VkAllocCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "GetPipelineCacheData",
             [Param("VkDevice", "device"),
@@ -560,6 +588,7 @@
              Param("VkPipelineCache", "pipelineCache"),
              Param("uint32_t", "createInfoCount"),
              Param("const VkGraphicsPipelineCreateInfo*", "pCreateInfos"),
+             Param("const VkAllocCallbacks*", "pAllocator"),
              Param("VkPipeline*", "pPipelines")]),
 
         Proto("VkResult", "CreateComputePipelines",
@@ -567,47 +596,57 @@
              Param("VkPipelineCache", "pipelineCache"),
              Param("uint32_t", "createInfoCount"),
              Param("const VkComputePipelineCreateInfo*", "pCreateInfos"),
+             Param("const VkAllocCallbacks*", "pAllocator"),
              Param("VkPipeline*", "pPipelines")]),
 
         Proto("void", "DestroyPipeline",
             [Param("VkDevice", "device"),
-             Param("VkPipeline", "pipeline")]),
+             Param("VkPipeline", "pipeline"),
+             Param("const VkAllocCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "CreatePipelineLayout",
             [Param("VkDevice", "device"),
              Param("const VkPipelineLayoutCreateInfo*", "pCreateInfo"),
+             Param("const VkAllocCallbacks*", "pAllocator"),
              Param("VkPipelineLayout*", "pPipelineLayout")]),
 
         Proto("void", "DestroyPipelineLayout",
             [Param("VkDevice", "device"),
-             Param("VkPipelineLayout", "pipelineLayout")]),
+             Param("VkPipelineLayout", "pipelineLayout"),
+             Param("const VkAllocCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "CreateSampler",
             [Param("VkDevice", "device"),
              Param("const VkSamplerCreateInfo*", "pCreateInfo"),
+             Param("const VkAllocCallbacks*", "pAllocator"),
              Param("VkSampler*", "pSampler")]),
 
         Proto("void", "DestroySampler",
             [Param("VkDevice", "device"),
-             Param("VkSampler", "sampler")]),
+             Param("VkSampler", "sampler"),
+             Param("const VkAllocCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "CreateDescriptorSetLayout",
             [Param("VkDevice", "device"),
              Param("const VkDescriptorSetLayoutCreateInfo*", "pCreateInfo"),
+             Param("const VkAllocCallbacks*", "pAllocator"),
              Param("VkDescriptorSetLayout*", "pSetLayout")]),
 
         Proto("void", "DestroyDescriptorSetLayout",
             [Param("VkDevice", "device"),
-             Param("VkDescriptorSetLayout", "descriptorSetLayout")]),
+             Param("VkDescriptorSetLayout", "descriptorSetLayout"),
+             Param("const VkAllocCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "CreateDescriptorPool",
             [Param("VkDevice", "device"),
              Param("const VkDescriptorPoolCreateInfo*", "pCreateInfo"),
+             Param("const VkAllocCallbacks*", "pAllocator"),
              Param("VkDescriptorPool*", "pDescriptorPool")]),
 
         Proto("void", "DestroyDescriptorPool",
             [Param("VkDevice", "device"),
-             Param("VkDescriptorPool", "descriptorPool")]),
+             Param("VkDescriptorPool", "descriptorPool"),
+             Param("const VkAllocCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "ResetDescriptorPool",
             [Param("VkDevice", "device"),
@@ -635,20 +674,24 @@
         Proto("VkResult", "CreateFramebuffer",
             [Param("VkDevice", "device"),
              Param("const VkFramebufferCreateInfo*", "pCreateInfo"),
+             Param("const VkAllocCallbacks*", "pAllocator"),
              Param("VkFramebuffer*", "pFramebuffer")]),
 
         Proto("void", "DestroyFramebuffer",
             [Param("VkDevice", "device"),
-             Param("VkFramebuffer", "framebuffer")]),
+             Param("VkFramebuffer", "framebuffer"),
+             Param("const VkAllocCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "CreateRenderPass",
             [Param("VkDevice", "device"),
              Param("const VkRenderPassCreateInfo*", "pCreateInfo"),
+             Param("const VkAllocCallbacks*", "pAllocator"),
              Param("VkRenderPass*", "pRenderPass")]),
 
         Proto("void", "DestroyRenderPass",
             [Param("VkDevice", "device"),
-             Param("VkRenderPass", "renderPass")]),
+             Param("VkRenderPass", "renderPass"),
+             Param("const VkAllocCallbacks*", "pAllocator")]),
 
         Proto("void", "GetRenderAreaGranularity",
             [Param("VkDevice", "device"),
@@ -658,11 +701,13 @@
         Proto("VkResult", "CreateCommandPool",
             [Param("VkDevice", "device"),
              Param("const VkCmdPoolCreateInfo*", "pCreateInfo"),
+             Param("const VkAllocCallbacks*", "pAllocator"),
              Param("VkCmdPool*", "pCmdPool")]),
 
         Proto("void", "DestroyCommandPool",
             [Param("VkDevice", "device"),
-             Param("VkCmdPool", "cmdPool")]),
+             Param("VkCmdPool", "cmdPool"),
+             Param("const VkAllocCallbacks*", "pAllocator")]),
 
         Proto("VkResult", "ResetCommandPool",
             [Param("VkDevice", "device"),