bug 12921: Memory callback (WIP)

The per-object allocator is ignored for now.

https://cvs.khronos.org/bugzilla/show_bug.cgi?id=12921

25 files changed, 853 insertions, 623 deletions

diff --git a/demos/cube.c b/demos/cube.c
index 77a9410c..2880cf9b 100644
--- a/demos/cube.c
+++ b/demos/cube.c
@@ -637,6 +637,7 @@ static void demo_draw(struct demo *demo)
 
     err = vkCreateSemaphore(demo->device,
                             &presentCompleteSemaphoreCreateInfo,
+                            NULL,
                             &presentCompleteSemaphore);
     assert(!err);
 
@@ -650,7 +651,7 @@ static void demo_draw(struct demo *demo)
         // 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 @@ static void demo_draw(struct demo *demo)
     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 @@ static void demo_prepare_buffers(struct demo *demo)
         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 @@ static void demo_prepare_depth(struct demo *demo)
     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 @@ static void demo_prepare_depth(struct demo *demo)
     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 @@ static void demo_prepare_depth(struct demo *demo)
 
     /* 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 @@ static void demo_prepare_texture_image(struct demo *demo,
 
     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 @@ static void demo_prepare_texture_image(struct demo *demo,
     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_prepare_texture_image(struct demo *demo,
 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 @@ static void demo_prepare_textures(struct demo *demo)
         };
 
         /* 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 @@ void demo_prepare_cube_data_buffer(struct demo *demo)
     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 @@ void demo_prepare_cube_data_buffer(struct demo *demo)
                                       &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 @@ static void demo_prepare_descriptor_layout(struct demo *demo)
     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 @@ static void demo_prepare_descriptor_layout(struct demo *demo)
 
     err = vkCreatePipelineLayout(demo->device,
                                  &pPipelineLayoutCreateInfo,
+                                 NULL,
                                  &demo->pipeline_layout);
     assert(!err);
 }
@@ -1384,7 +1389,7 @@ static void demo_prepare_render_pass(struct demo *demo)
     };
     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 @@ static VkShader demo_prepare_shader(struct demo* demo,
         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 @@ static VkShader demo_prepare_shader(struct demo* demo,
         ((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 @@ static VkShader demo_prepare_shader(struct demo* demo,
         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 @@ static void demo_prepare_pipeline(struct demo *demo)
     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 @@ static void demo_prepare_pipeline(struct demo *demo)
 
     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 @@ static void demo_prepare_descriptor_pool(struct demo *demo)
     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 @@ static void demo_prepare_framebuffers(struct demo *demo)
 
     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 @@ static void demo_prepare(struct demo *demo)
         .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 @@ static void demo_cleanup(struct demo *demo)
     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 @@ static void demo_resize(struct demo *demo)
     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 @@ static void demo_init_vk(struct demo *demo)
         .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 @@ static void demo_init_vk(struct demo *demo)
 
     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 @@ static void demo_init_vk(struct demo *demo)
         .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 83f99b75..bd4f8eb2 100644
--- a/demos/tri.c
+++ b/demos/tri.c
@@ -169,6 +169,8 @@ struct demo {
     bool use_staging_buffer;
     bool use_glsl;
 
+    VkAllocCallbacks allocator;
+
     VkInstance inst;
     VkPhysicalDevice gpu;
     VkDevice device;
@@ -454,6 +456,7 @@ static void demo_draw(struct demo *demo)
 
     err = vkCreateSemaphore(demo->device,
                             &presentCompleteSemaphoreCreateInfo,
+                            NULL,
                             &presentCompleteSemaphore);
     assert(!err);
 
@@ -467,7 +470,7 @@ static void demo_draw(struct demo *demo)
         // 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 @@ static void demo_draw(struct demo *demo)
     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 @@ static void demo_prepare_buffers(struct demo *demo)
         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 @@ static void demo_prepare_depth(struct demo *demo)
     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 @@ static void demo_prepare_depth(struct demo *demo)
     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 @@ static void demo_prepare_depth(struct demo *demo)
 
     /* 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 @@ static void demo_prepare_texture_image(struct demo *demo,
 
     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 @@ static void demo_prepare_texture_image(struct demo *demo,
     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_prepare_texture_image(struct demo *demo,
 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 @@ static void demo_prepare_textures(struct demo *demo)
         };
 
         /* 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 @@ static void demo_prepare_vertices(struct demo *demo)
 
     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 @@ static void demo_prepare_vertices(struct demo *demo)
                                       &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 @@ static void demo_prepare_descriptor_layout(struct demo *demo)
     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 @@ static void demo_prepare_descriptor_layout(struct demo *demo)
 
     err = vkCreatePipelineLayout(demo->device,
                                  &pPipelineLayoutCreateInfo,
+                                 NULL,
                                  &demo->pipeline_layout);
     assert(!err);
 }
@@ -1144,7 +1148,7 @@ static void demo_prepare_render_pass(struct demo *demo)
     };
     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 @@ static VkShader demo_prepare_shader(struct demo *demo,
         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 @@ static VkShader demo_prepare_shader(struct demo *demo,
         ((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 @@ static void demo_prepare_pipeline(struct demo *demo)
     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 @@ static void demo_prepare_descriptor_pool(struct demo *demo)
     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 @@ static void demo_prepare_framebuffers(struct demo *demo)
 
     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 @@ static void demo_prepare(struct demo *demo)
         .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* VKAPI myalloc(
     void*                           pUserData,
     size_t                          size,
     size_t                          alignment,
-    VkSystemAllocType               allocType)
+    VkSystemAllocScope              allocScope)
 {
     return malloc(size);
 }
@@ -1850,16 +1855,10 @@ static void demo_init_vk(struct demo *demo)
         .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 @@ static void demo_init_vk(struct demo *demo)
     };
     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 @@ static void demo_init_vk(struct demo *demo)
     }
 
 
-    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 @@ static void demo_cleanup(struct demo *demo)
     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 @@ static void demo_resize(struct demo *demo)
     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 91ded08e..69b28969 100644
--- a/demos/vulkaninfo.c
+++ b/demos/vulkaninfo.c
@@ -480,7 +480,7 @@ static void app_dev_init(struct app_dev *dev, struct app_gpu *gpu)
     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_init(struct app_dev *dev, struct app_gpu *gpu)
 
 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 @@ static void app_create_instance(struct app_instance *inst)
         .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
         .pNext = NULL,
         .pAppInfo = &app_info,
-        .pAllocCb = NULL,
         .enabledLayerNameCount = 0,
         .ppEnabledLayerNames = NULL,
         .enabledExtensionNameCount = 0,
@@ -613,7 +612,7 @@ static void app_create_instance(struct app_instance *inst)
     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_create_instance(struct app_instance *inst)
 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 9941b65f..050eac38 100644
--- a/icd/common/icd-enumerate-drm.c
+++ b/icd/common/icd-enumerate-drm.c
@@ -125,7 +125,7 @@ static struct icd_drm_device *probe_syspath(const struct icd_instance *instance,
         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 b7920486..20febdaf 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 @@ struct icd_instance *icd_instance_create(const VkApplicationInfo *app_info,
         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 @@ struct icd_instance *icd_instance_create(const VkApplicationInfo *app_info,
     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 @@ VkResult icd_instance_create_logger(
 //    }
 
     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 400c642d..d54af4e9 100644
--- a/icd/common/icd-instance.h
+++ b/icd/common/icd-instance.h
@@ -57,10 +57,10 @@ void icd_instance_destroy(struct icd_instance *instance);
 
 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/nulldrv/nulldrv.c b/icd/nulldrv/nulldrv.c
index b217e226..a0e175a1 100644
--- a/icd/nulldrv/nulldrv.c
+++ b/icd/nulldrv/nulldrv.c
@@ -611,6 +611,7 @@ static VkResult nulldrv_buf_view_create(struct nulldrv_dev *dev,
 ICD_EXPORT VkResult VKAPI vkCreateBuffer(
     VkDevice                                  device,
     const VkBufferCreateInfo*               pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkBuffer*                                 pBuffer)
 {
     NULLDRV_LOG_FUNC;
@@ -621,7 +622,8 @@ ICD_EXPORT VkResult VKAPI vkCreateBuffer(
 
 ICD_EXPORT void VKAPI vkDestroyBuffer(
     VkDevice                                  device,
-    VkBuffer                                  buffer)
+    VkBuffer                                  buffer,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -629,6 +631,7 @@ ICD_EXPORT void VKAPI vkDestroyBuffer(
 ICD_EXPORT VkResult VKAPI vkCreateCommandPool(
     VkDevice                                    device,
     const VkCmdPoolCreateInfo*                  pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkCmdPool*                                  pCmdPool)
 {
     NULLDRV_LOG_FUNC;
@@ -637,7 +640,8 @@ ICD_EXPORT VkResult VKAPI vkCreateCommandPool(
 
 ICD_EXPORT void VKAPI vkDestroyCommandPool(
     VkDevice                                    device,
-    VkCmdPool                                   cmdPool)
+    VkCmdPool                                   cmdPool,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -1237,6 +1241,7 @@ void VKAPI vkCmdPipelineBarrier(
 ICD_EXPORT VkResult VKAPI vkCreateDevice(
     VkPhysicalDevice                            gpu_,
     const VkDeviceCreateInfo*               pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkDevice*                                 pDevice)
 {
     NULLDRV_LOG_FUNC;
@@ -1245,7 +1250,8 @@ ICD_EXPORT VkResult VKAPI vkCreateDevice(
 }
 
 ICD_EXPORT void VKAPI vkDestroyDevice(
-    VkDevice                                  device)
+    VkDevice                                  device,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -1271,6 +1277,7 @@ ICD_EXPORT VkResult VKAPI vkDeviceWaitIdle(
 ICD_EXPORT VkResult VKAPI vkCreateEvent(
     VkDevice                                  device,
     const VkEventCreateInfo*                pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkEvent*                                  pEvent)
 {
     NULLDRV_LOG_FUNC;
@@ -1279,7 +1286,8 @@ ICD_EXPORT VkResult VKAPI vkCreateEvent(
 
 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 vkResetEvent(
 ICD_EXPORT VkResult VKAPI vkCreateFence(
     VkDevice                                  device,
     const VkFenceCreateInfo*                pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkFence*                                  pFence)
 {
     NULLDRV_LOG_FUNC;
@@ -1322,7 +1331,8 @@ ICD_EXPORT VkResult VKAPI vkCreateFence(
 
 ICD_EXPORT void VKAPI vkDestroyFence(
     VkDevice                                  device,
-    VkFence                                  fence)
+    VkFence                                  fence,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -1468,6 +1478,7 @@ VkResult VKAPI vkEnumerateDeviceExtensionProperties(
 ICD_EXPORT VkResult VKAPI vkCreateImage(
     VkDevice                                  device,
     const VkImageCreateInfo*                pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkImage*                                  pImage)
 {
     NULLDRV_LOG_FUNC;
@@ -1479,7 +1490,8 @@ ICD_EXPORT VkResult VKAPI vkCreateImage(
 
 ICD_EXPORT void VKAPI vkDestroyImage(
     VkDevice                                  device,
-    VkImage                                   image)
+    VkImage                                   image,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -1501,6 +1513,7 @@ ICD_EXPORT void VKAPI vkGetImageSubresourceLayout(
 ICD_EXPORT VkResult VKAPI vkAllocMemory(
     VkDevice                                  device,
     const VkMemoryAllocInfo*                pAllocInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkDeviceMemory*                             pMem)
 {
     NULLDRV_LOG_FUNC;
@@ -1511,7 +1524,8 @@ ICD_EXPORT VkResult VKAPI vkAllocMemory(
 
 ICD_EXPORT void VKAPI vkFreeMemory(
     VkDevice                                    device,
-    VkDeviceMemory                              mem_)
+    VkDeviceMemory                              mem_,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -1567,6 +1581,7 @@ ICD_EXPORT void VKAPI vkGetDeviceMemoryCommitment(
 
 ICD_EXPORT VkResult VKAPI vkCreateInstance(
     const VkInstanceCreateInfo*             pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkInstance*                               pInstance)
 {
     NULLDRV_LOG_FUNC;
@@ -1585,7 +1600,8 @@ ICD_EXPORT VkResult VKAPI vkCreateInstance(
 }
 
 ICD_EXPORT void VKAPI vkDestroyInstance(
-    VkInstance                                pInstance)
+    VkInstance                                pInstance,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -1712,6 +1728,7 @@ ICD_EXPORT VkResult VKAPI vkQueueBindSparseImageMemory(
 ICD_EXPORT VkResult VKAPI vkCreatePipelineCache(
     VkDevice                                    device,
     const VkPipelineCacheCreateInfo*            pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkPipelineCache*                            pPipelineCache)
 {
 
@@ -1721,14 +1738,16 @@ ICD_EXPORT VkResult VKAPI vkCreatePipelineCache(
 
 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 @@ ICD_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(
     VkPipelineCache                           pipelineCache,
     uint32_t                                  createInfoCount,
     const VkGraphicsPipelineCreateInfo*    pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkPipeline*                               pPipeline)
 {
     NULLDRV_LOG_FUNC;
@@ -1773,6 +1793,7 @@ ICD_EXPORT VkResult VKAPI vkCreateComputePipelines(
     VkPipelineCache                           pipelineCache,
     uint32_t                                  createInfoCount,
     const VkComputePipelineCreateInfo*     pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkPipeline*                               pPipeline)
 {
     NULLDRV_LOG_FUNC;
@@ -1786,6 +1807,7 @@ ICD_EXPORT VkResult VKAPI vkCreateComputePipelines(
 ICD_EXPORT VkResult VKAPI vkCreateQueryPool(
     VkDevice                                  device,
     const VkQueryPoolCreateInfo*           pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkQueryPool*                             pQueryPool)
 {
     NULLDRV_LOG_FUNC;
@@ -1794,7 +1816,8 @@ ICD_EXPORT VkResult VKAPI vkCreateQueryPool(
 
 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 vkQueueSubmit(
 ICD_EXPORT VkResult VKAPI vkCreateSemaphore(
     VkDevice                                  device,
     const VkSemaphoreCreateInfo*            pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkSemaphore*                              pSemaphore)
 {
     NULLDRV_LOG_FUNC;
@@ -1841,7 +1865,8 @@ ICD_EXPORT VkResult VKAPI vkCreateSemaphore(
 
 ICD_EXPORT void VKAPI vkDestroySemaphore(
     VkDevice                                  device,
-    VkSemaphore                               semaphore)
+    VkSemaphore                               semaphore,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -1849,6 +1874,7 @@ ICD_EXPORT void VKAPI vkDestroySemaphore(
 ICD_EXPORT VkResult VKAPI vkCreateSampler(
     VkDevice                                  device,
     const VkSamplerCreateInfo*              pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkSampler*                                pSampler)
 {
     NULLDRV_LOG_FUNC;
@@ -1860,7 +1886,8 @@ ICD_EXPORT VkResult VKAPI vkCreateSampler(
 
 ICD_EXPORT void VKAPI vkDestroySampler(
     VkDevice                                  device,
-    VkSampler                                 sampler)
+    VkSampler                                 sampler,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -1868,6 +1895,7 @@ ICD_EXPORT void VKAPI vkDestroySampler(
 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 VkResult VKAPI vkCreateShaderModule(
 
 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 void VKAPI vkDestroyShaderModule(
 ICD_EXPORT VkResult VKAPI vkCreateShader(
         VkDevice                                  device,
         const VkShaderCreateInfo*               pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
         VkShader*                                 pShader)
 {
     NULLDRV_LOG_FUNC;
@@ -1896,7 +1926,8 @@ ICD_EXPORT VkResult VKAPI vkCreateShader(
 
 ICD_EXPORT void VKAPI vkDestroyShader(
     VkDevice                                  device,
-    VkShader                                  shader)
+    VkShader                                  shader,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -1904,6 +1935,7 @@ ICD_EXPORT void VKAPI vkDestroyShader(
 ICD_EXPORT VkResult VKAPI vkCreateBufferView(
     VkDevice                                  device,
     const VkBufferViewCreateInfo*          pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkBufferView*                            pView)
 {
     NULLDRV_LOG_FUNC;
@@ -1915,7 +1947,8 @@ ICD_EXPORT VkResult VKAPI vkCreateBufferView(
 
 ICD_EXPORT void VKAPI vkDestroyBufferView(
     VkDevice                                  device,
-    VkBufferView                              bufferView)
+    VkBufferView                              bufferView,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -1923,6 +1956,7 @@ ICD_EXPORT void VKAPI vkDestroyBufferView(
 ICD_EXPORT VkResult VKAPI vkCreateImageView(
     VkDevice                                  device,
     const VkImageViewCreateInfo*           pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkImageView*                             pView)
 {
     NULLDRV_LOG_FUNC;
@@ -1934,7 +1968,8 @@ ICD_EXPORT VkResult VKAPI vkCreateImageView(
 
 ICD_EXPORT void VKAPI vkDestroyImageView(
     VkDevice                                  device,
-    VkImageView                               imageView)
+    VkImageView                               imageView,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -1942,6 +1977,7 @@ ICD_EXPORT void VKAPI vkDestroyImageView(
 ICD_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(
     VkDevice                                   device,
     const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkDescriptorSetLayout*                   pSetLayout)
 {
     NULLDRV_LOG_FUNC;
@@ -1953,7 +1989,8 @@ ICD_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(
 
 ICD_EXPORT void VKAPI vkDestroyDescriptorSetLayout(
     VkDevice                                  device,
-    VkDescriptorSetLayout                     descriptorSetLayout)
+    VkDescriptorSetLayout                     descriptorSetLayout,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -1961,6 +1998,7 @@ ICD_EXPORT void VKAPI vkDestroyDescriptorSetLayout(
 ICD_EXPORT VkResult VKAPI  vkCreatePipelineLayout(
     VkDevice                                device,
     const VkPipelineLayoutCreateInfo*       pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkPipelineLayout*                       pPipelineLayout)
 {
     NULLDRV_LOG_FUNC;
@@ -1973,7 +2011,8 @@ ICD_EXPORT VkResult VKAPI  vkCreatePipelineLayout(
 
 ICD_EXPORT void VKAPI vkDestroyPipelineLayout(
     VkDevice                                  device,
-    VkPipelineLayout                          pipelineLayout)
+    VkPipelineLayout                          pipelineLayout,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -1981,6 +2020,7 @@ ICD_EXPORT void VKAPI vkDestroyPipelineLayout(
 ICD_EXPORT VkResult VKAPI vkCreateDescriptorPool(
     VkDevice                                    device,
     const VkDescriptorPoolCreateInfo*           pCreateInfo,
+    const VkAllocCallbacks*                     pAllocator,
     VkDescriptorPool*                           pDescriptorPool)
 {
     NULLDRV_LOG_FUNC;
@@ -1992,7 +2032,8 @@ ICD_EXPORT VkResult VKAPI vkCreateDescriptorPool(
 
 ICD_EXPORT void VKAPI vkDestroyDescriptorPool(
     VkDevice                                  device,
-    VkDescriptorPool                          descriptorPool)
+    VkDescriptorPool                          descriptorPool,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -2053,6 +2094,7 @@ ICD_EXPORT void VKAPI vkUpdateDescriptorSets(
 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 VkResult VKAPI vkCreateFramebuffer(
 
 ICD_EXPORT void VKAPI vkDestroyFramebuffer(
     VkDevice                                  device,
-    VkFramebuffer                             framebuffer)
+    VkFramebuffer                             framebuffer,
+    const VkAllocCallbacks*                     pAllocator)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -2071,6 +2114,7 @@ ICD_EXPORT void VKAPI vkDestroyFramebuffer(
 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 VkResult VKAPI vkCreateRenderPass(
 
 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 6624b8e3..f7e6cc3e 100644
--- a/include/vulkan.h
+++ b/include/vulkan.h
@@ -189,16 +189,24 @@ typedef enum {
 } 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 enum {
 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 @@ typedef struct {
 } 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 @@ typedef struct {
 } 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 @@ typedef struct {
 } 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_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDev
 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 void (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamily
 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 void (VKAPI *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysi
 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 @@ typedef void (VKAPI *PFN_vkCmdExecuteCommands)(VkCmdBuffer cmdBuffer, uint32_t c
 #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 @@ PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(
 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 vkDeviceWaitIdle(
 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 vkQueueBindSparseImageMemory(
 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 vkWaitForFences(
 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 vkResetEvent(
 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 vkGetQueryPoolResults(
 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 @@ void VKAPI vkGetImageSubresourceLayout(
 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 @@ VkResult VKAPI vkCreateGraphicsPipelines(
     VkPipelineCache                             pipelineCache,
     uint32_t                                    createInfoCount,
     const VkGraphicsPipelineCreateInfo*         pCreateInfos,
+    const VkAllocCallbacks*                     pAllocator,
     VkPipeline*                                 pPipelines);
 
 VkResult VKAPI vkCreateComputePipelines(
@@ -2546,47 +2604,57 @@ VkResult VKAPI vkCreateComputePipelines(
     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 @@ void VKAPI vkUpdateDescriptorSets(
 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 @@ void VKAPI vkGetRenderAreaGranularity(
 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 778a3629..f416d5a5 100644
--- a/layers/basic.cpp
+++ b/layers/basic.cpp
@@ -95,27 +95,27 @@ VK_LAYER_EXPORT VkResult VKAPI basic_EnumeratePhysicalDevices(
     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 1d686dd1..eb21585f 100644
--- a/layers/device_limits.cpp
+++ b/layers/device_limits.cpp
@@ -158,11 +158,11 @@ VK_LAYER_EXPORT VkResult VKAPI vkEnumerateInstanceLayerProperties(
                                    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 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCre
 }
 
 /* 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 @@ static VkBool32 validate_features_request(layer_data *phy_dev_data)
     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 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDevi
         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 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDevi
     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 void VKAPI vkGetDeviceQueue(VkDevice device, uint32_t queueFamil
 VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(
     VkDevice                 device,
     const VkImageCreateInfo *pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkImage                 *pImage)
 {
     VkBool32                skipCall       = VK_FALSE;
@@ -536,7 +537,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(
                         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 bbcc4b05..c823e980 100755
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -1565,11 +1565,11 @@ static void init_draw_state(layer_data *my_data)
     }
 }
 
-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 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCre
 }
 
 /* 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 @@ static void createDeviceRegisterExtensions(const VkDeviceCreateInfo* pCreateInfo
     }
 }
 
-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 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDevi
 }
 // 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 @@ VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device)
     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 @@ VK_LAYER_EXPORT VkResult VKAPI vkQueueSubmit(VkQueue queue, uint32_t submitCount
     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 @@ VK_LAYER_EXPORT void VKAPI vkFreeCommandBuffers(VkDevice device, VkCmdPool cmdPo
     // 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 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateBuffer(VkDevice device, const VkBufferCre
     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 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBuffe
     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 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreat
     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 vkCreateImageView(VkDevice device, const VkImageV
 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 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateShader(
 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 @@ VkResult VKAPI vkMergePipelineCaches(
     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 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(VkDevice device, VkPipe
     }
     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 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(VkDevice device, VkPipe
     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 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerC
     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 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, cons
     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 @@ VkResult VKAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCre
     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 @@ VK_LAYER_EXPORT void VKAPI vkCmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkPipeline
         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 @@ bool validateDependencies(const layer_data* my_data, VkDevice device, const VkRe
     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 8ae7a12f..c615109a 100644
--- a/layers/image.cpp
+++ b/layers/image.cpp
@@ -112,11 +112,11 @@ VK_LAYER_EXPORT VkResult VKAPI vkDbgDestroyMsgCallback(
     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 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCre
     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 void VKAPI vkDestroyInstance(VkInstance instance)
 
 }
 
-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 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice physicalDevice, c
     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 @@ bool is_depth_format(VkFormat format)
     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 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreat
     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 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreat
     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 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRende
     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 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageV
     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 cd606271..c9ea4694 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -925,13 +925,13 @@ static void init_mem_tracker(
 }
 
 // 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 @@ VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance)
 
 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 @@ static void createDeviceRegisterExtensions(const VkDeviceCreateInfo* pCreateInfo
 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 VkResult VKAPI vkCreateDevice(
 }
 
 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 @@ VK_LAYER_EXPORT void VKAPI vkDestroyDevice(
 #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 vkQueueSubmit(
 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 VkResult VKAPI vkAllocMemory(
 
 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 @@ VK_LAYER_EXPORT void VKAPI vkFreeMemory(
     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 @@ VK_LAYER_EXPORT void VKAPI vkUnmapMemory(
     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 @@ VK_LAYER_EXPORT void VKAPI vkDestroyFence(VkDevice device, VkFence fence)
         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 @@ VK_LAYER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer)
     }
     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 @@ VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image)
     }
     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 vkQueueBindSparseBufferMemory(
 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 vkDeviceWaitIdle(
 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 vkCreateBuffer(
 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 vkCreateImage(
 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 vkCreateImageView(
 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 vkAcquireNextImageKHR(
 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 VkResult VKAPI vkCreateSemaphore(
 
 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 @@ VK_LAYER_EXPORT void VKAPI vkDestroySemaphore(
         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 1db6b6f2..52344625 100644
--- a/layers/multi.cpp
+++ b/layers/multi.cpp
@@ -40,23 +40,23 @@ static device_table_map multi1_device_table_map;
 /******************************** 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 @@ VK_LAYER_EXPORT VkResult VKAPI multi1CreateGraphicsPipelines(
                                 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 @@ VK_LAYER_EXPORT void VKAPI multi2GetPhysicalDeviceFeatures(
 }
 
 /* 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 6969b6fb..ed611e97 100644
--- a/layers/object_track.h
+++ b/layers/object_track.h
@@ -634,11 +634,12 @@ static void destroy_obj(VkDevice dispatchable_object, VkSwapchainKHR object)
 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 @@ VkResult
 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 @@ explicit_DestroySwapchainKHR(
 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 359a8c2e..638bce53 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -1822,10 +1822,11 @@ std::string EnumeratorString(VkQueryControlFlagBits const& enumerator)
 
 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 VkResult VKAPI vkCreateInstance(
 }
 
 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 void VKAPI vkGetPhysicalDeviceMemoryProperties(
 VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(
     VkPhysicalDevice physicalDevice,
     const VkDeviceCreateInfo* pCreateInfo,
+    const VkAllocCallbacks* pAllocator,
     VkDevice* pDevice)
 {
     /*
@@ -2095,7 +2098,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(
      * 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 VkResult VKAPI vkCreateDevice(
 }
 
 VK_LAYER_EXPORT void VKAPI vkDestroyDevice(
-    VkDevice device)
+    VkDevice device,
+    const VkAllocCallbacks* pAllocator)
 {
     layer_debug_report_destroy_device(device);
 
@@ -2116,7 +2120,7 @@ VK_LAYER_EXPORT void VKAPI vkDestroyDevice(
     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 @@ bool PostAllocMemory(
 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 @@ bool PostCreateFence(
 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 @@ bool PostCreateSemaphore(
 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 @@ bool PostCreateEvent(
 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 @@ bool PostCreateQueryPool(
 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 @@ bool PostCreateBuffer(
 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 @@ bool PostCreateBufferView(
 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 @@ bool PostCreateImage(
 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 @@ bool PostCreateImageView(
 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 @@ bool PostCreateShaderModule(
 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 @@ bool PostCreateShader(
 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 @@ bool PostCreatePipelineCache(
 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 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(
     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 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateComputePipelines(
     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 @@ bool PostCreatePipelineLayout(
 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 @@ bool PostCreateSampler(
 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 @@ bool PostCreateDescriptorSetLayout(
 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 @@ bool PostCreateDescriptorPool(
 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 @@ bool PostCreateFramebuffer(
 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 @@ bool PostCreateRenderPass(
 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 @@ bool PostCreateCommandPool(
 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 eae5867b..c53d7763 100644
--- a/layers/screenshot.cpp
+++ b/layers/screenshot.cpp
@@ -207,7 +207,7 @@ static void writePPM( const char *filename, VkImage image1)
     //     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 @@ static void writePPM( const char *filename, VkImage image1)
                                 &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 @@ static void writePPM( const char *filename, VkImage image1)
 
     // 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 @@ static void createDeviceRegisterExtensions(const VkDeviceCreateInfo* pCreateInfo
 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 void VKAPI vkGetDeviceQueue(
 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 53efcad7..9e417f62 100644
--- a/layers/shader_checker.cpp
+++ b/layers/shader_checker.cpp
@@ -138,11 +138,12 @@ static loader_platform_thread_mutex globalLock;
 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 vkCreateDescriptorSetLayout(
 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 @@ collect_interface_by_descriptor_slot(layer_data *my_data, VkDevice dev,
 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 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateShaderModule(
         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 vkCreateShaderModule(
 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 vkCreateShader(
 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 @@ vkCreateGraphicsPipelines(VkDevice device,
                          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 @@ vkCreateGraphicsPipelines(VkDevice device,
         /* 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 @@ vkCreateGraphicsPipelines(VkDevice device,
 }
 
 
-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 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDevi
 }
 
 /* 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 @@ VkResult VKAPI vkCreateInstance(
 }
 
 /* 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 42cf7a83..0075b6f8 100644
--- a/layers/swapchain.cpp
+++ b/layers/swapchain.cpp
@@ -197,12 +197,12 @@ static const char *presentModeStr(VkPresentModeKHR value)
 }
 
 
-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 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCre
     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 @@ VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance)
 
     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 @@ VK_LAYER_EXPORT VkResult VKAPI vkEnumeratePhysicalDevices(VkInstance instance, u
     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 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice physicalDevice, c
     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 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice physicalDevice, c
     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 @@ VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device)
 
     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 d8d34503..c1cca4f1 100644
--- a/loader/debug_report.c
+++ b/loader/debug_report.c
@@ -74,7 +74,7 @@ static VkResult debug_report_DbgCreateMsgCallback(
         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 6b06b311..53fdbf37 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -111,11 +111,11 @@ LOADER_PLATFORM_THREAD_ONCE_DECLARATION(once_init);
 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* loader_heap_realloc(
     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 @@ void* loader_heap_realloc(
             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_heap_realloc(
 
 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 @@ static struct loader_layer_properties *loader_get_next_layer_property(
     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 @@ static struct loader_layer_properties *loader_get_next_layer_property(
         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 @@ static bool loader_init_ext_list(const struct loader_instance *inst,
                                  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 @@ void loader_add_to_ext_list(
                                                  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 @@ static bool loader_init_layer_list(const struct loader_instance *inst,
                                    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 @@ static bool loader_init_layer_library_list(const struct loader_instance *inst,
                                            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 @@ void loader_add_to_layer_library_list(
                                              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 @@ void loader_add_to_layer_list(
                                              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 @@ static struct loader_device *loader_add_logical_device(
 {
     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 @@ static struct loader_icd * loader_icd_create(const struct loader_instance *inst)
 {
     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 @@ static void loader_scanned_icd_init(const struct loader_instance *inst,
 {
     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 @@ static void loader_scanned_icd_add(
                                                  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 @@ static void loader_scanned_icd_add(
 
     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 @@ static void loader_copy_layer_properties(
                                         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 @@ static void loader_copy_layer_properties(
                                         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 @@ static void loader_get_manifest_files(const struct loader_instance *inst,
                     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 @@ static void loader_get_manifest_files(const struct loader_instance *inst,
                     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 @@ static loader_platform_dl_handle loader_add_layer_lib(
                                             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 @@ static void loader_remove_layer_lib(
     /* 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 loader_enable_device_layers(
 static VkResult VKAPI scratch_vkCreateDevice(
     VkPhysicalDevice          gpu,
     const VkDeviceCreateInfo *pCreateInfo,
+    const VkAllocCallbacks*   pAllocator,
     VkDevice                 *pDevice)
 {
     return VK_SUCCESS;
@@ -2456,7 +2457,7 @@ static uint32_t loader_activate_device_layers(
 
     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 loader_validate_device_extensions(
 
 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 @@ VkResult VKAPI loader_CreateInstance(
     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 @@ VkResult VKAPI loader_CreateInstance(
             }
 
             res = ptr_instance->icd_libs.list[i].CreateInstance(&icd_create_info,
+                                           pAllocator,
                                            &(icd->instance));
             success = loader_icd_init_entrys(
                                 icd,
@@ -2690,7 +2692,8 @@ VkResult VKAPI loader_CreateInstance(
 }
 
 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 @@ void VKAPI loader_DestroyInstance(
 
     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 @@ VkResult loader_init_physical_device_info(
         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 @@ void VKAPI loader_GetPhysicalDeviceSparseImageFormatProperties(
 VkResult VKAPI loader_CreateDevice(
         VkPhysicalDevice                        gpu,
         const VkDeviceCreateInfo*               pCreateInfo,
+        const VkAllocCallbacks*                 pAllocator,
         VkDevice*                               pDevice)
 {
     uint32_t gpu_index;
@@ -2997,7 +3001,7 @@ VkResult VKAPI loader_CreateDevice(
 
     // 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 @@ VkResult VKAPI loader_CreateDevice(
     }
     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 3e4ce1bf..96dd2773 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -265,10 +265,12 @@ VkResult loader_validate_instance_extensions(
 /* 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 @@ void VKAPI loader_GetPhysicalDeviceMemoryProperties (
 VkResult VKAPI loader_CreateDevice(
         VkPhysicalDevice                        gpu,
         const VkDeviceCreateInfo*               pCreateInfo,
+        const VkAllocCallbacks*                 pAllocator,
         VkDevice*                               pDevice);
 
 /* helper function definitions */
@@ -390,7 +393,7 @@ void loader_activate_instance_layer_extensions(struct loader_instance *inst);
 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 a73e922e..219827cc 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_EXPORT VkResult VKAPI vkCreateInstance(
 
     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_EXPORT VkResult VKAPI vkCreateInstance(
     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 @@ LOADER_EXPORT VkResult VKAPI vkCreateInstance(
     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 @@ LOADER_EXPORT VkResult VKAPI vkCreateInstance(
 
     *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 VkResult VKAPI vkCreateInstance(
 }
 
 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_EXPORT void VKAPI vkDestroyInstance(
     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 void VKAPI vkGetPhysicalDeviceMemoryProperties(
 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 @@ LOADER_EXPORT void VKAPI vkDestroyDevice(VkDevice device)
     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 @@ LOADER_EXPORT VkResult VKAPI vkDeviceWaitIdle(VkDevice device)
     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 @@ LOADER_EXPORT VkResult VKAPI vkQueueBindSparseImageMemory(VkQueue queue, VkImage
     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 @@ LOADER_EXPORT VkResult VKAPI vkWaitForFences(VkDevice device, uint32_t fenceCoun
     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 @@ LOADER_EXPORT VkResult VKAPI vkResetEvent(VkDevice device, VkEvent event)
     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 @@ LOADER_EXPORT VkResult VKAPI vkGetQueryPoolResults(VkDevice device, VkQueryPool
     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 @@ LOADER_EXPORT void VKAPI vkGetImageSubresourceLayout(VkDevice device, VkImage im
     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 @@ LOADER_EXPORT VkResult VKAPI vkMergePipelineCaches(VkDevice device, VkPipelineCa
     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 @@ LOADER_EXPORT void VKAPI vkUpdateDescriptorSets(VkDevice device, uint32_t writeC
     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 @@ LOADER_EXPORT void VKAPI vkGetRenderAreaGranularity(VkDevice device, VkRenderPas
     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/vk-layer-generate.py b/vk-layer-generate.py
index 4cef7440..65b737a6 100755
--- a/vk-layer-generate.py
+++ b/vk-layer-generate.py
@@ -687,7 +687,7 @@ class GenericLayerSubcommand(Subcommand):
                          '{\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 @@ class GenericLayerSubcommand(Subcommand):
                          '{\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 @@ class ObjectTrackerSubcommand(Subcommand):
         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 @@ class ObjectTrackerSubcommand(Subcommand):
             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 @@ class ObjectTrackerSubcommand(Subcommand):
         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 @@ class ObjectTrackerSubcommand(Subcommand):
         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 @@ class ObjectTrackerSubcommand(Subcommand):
                 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 @@ class ThreadingSubcommand(Subcommand):
             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/vulkan.py b/vulkan.py
index a57d1993..3f0c7063 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -213,10 +213,12 @@ core = Extension(
     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 @@ core = Extension(
         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 @@ core = Extension(
         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 @@ core = Extension(
         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 @@ core = Extension(
         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 @@ core = Extension(
         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 @@ core = Extension(
         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 @@ core = Extension(
         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 @@ core = Extension(
              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 @@ core = Extension(
              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 @@ core = Extension(
         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 @@ core = Extension(
         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"),