bug 12921: Memory callback (WIP)

The per-object allocator is ignored for now.

https://cvs.khronos.org/bugzilla/show_bug.cgi?id=12921
diff --git a/demos/tri.c b/demos/tri.c
index 83f99b7..bd4f8eb 100644
--- a/demos/tri.c
+++ b/demos/tri.c
@@ -169,6 +169,8 @@
     bool use_staging_buffer;
     bool use_glsl;
 
+    VkAllocCallbacks allocator;
+
     VkInstance inst;
     VkPhysicalDevice gpu;
     VkDevice device;
@@ -454,6 +456,7 @@
 
     err = vkCreateSemaphore(demo->device,
                             &presentCompleteSemaphoreCreateInfo,
+                            NULL,
                             &presentCompleteSemaphore);
     assert(!err);
 
@@ -467,7 +470,7 @@
         // must be recreated:
         demo_resize(demo);
         demo_draw(demo);
-        vkDestroySemaphore(demo->device, presentCompleteSemaphore);
+        vkDestroySemaphore(demo->device, presentCompleteSemaphore, NULL);
         return;
     } else if (err == VK_SUBOPTIMAL_KHR) {
         // demo->swapchain is not as optimal as it could be, but the platform's
@@ -531,7 +534,7 @@
     err = vkQueueWaitIdle(demo->queue);
     assert(err == VK_SUCCESS);
 
-    vkDestroySemaphore(demo->device, presentCompleteSemaphore);
+    vkDestroySemaphore(demo->device, presentCompleteSemaphore, NULL);
 }
 
 static void demo_prepare_buffers(struct demo *demo)
@@ -679,7 +682,7 @@
         color_attachment_view.image = demo->buffers[i].image;
 
         err = vkCreateImageView(demo->device,
-                &color_attachment_view, &demo->buffers[i].view);
+                &color_attachment_view, NULL, &demo->buffers[i].view);
         assert(!err);
     }
 
@@ -731,7 +734,7 @@
     demo->depth.format = depth_format;
 
     /* create image */
-    err = vkCreateImage(demo->device, &image,
+    err = vkCreateImage(demo->device, &image, NULL,
             &demo->depth.image);
     assert(!err);
 
@@ -748,7 +751,7 @@
     assert(pass);
 
     /* allocate memory */
-    err = vkAllocMemory(demo->device, &mem_alloc, &demo->depth.mem);
+    err = vkAllocMemory(demo->device, &mem_alloc, NULL, &demo->depth.mem);
     assert(!err);
 
     /* bind memory */
@@ -763,7 +766,7 @@
 
     /* create image view */
     view.image = demo->depth.image;
-    err = vkCreateImageView(demo->device, &view, &demo->depth.view);
+    err = vkCreateImageView(demo->device, &view, NULL, &demo->depth.view);
     assert(!err);
 }
 
@@ -805,7 +808,7 @@
 
     VkMemoryRequirements mem_reqs;
 
-    err = vkCreateImage(demo->device, &image_create_info,
+    err = vkCreateImage(demo->device, &image_create_info, NULL,
             &tex_obj->image);
     assert(!err);
 
@@ -816,7 +819,7 @@
     assert(pass);
 
     /* allocate memory */
-    err = vkAllocMemory(demo->device, &mem_alloc, &tex_obj->mem);
+    err = vkAllocMemory(demo->device, &mem_alloc, NULL, &tex_obj->mem);
     assert(!err);
 
     /* bind memory */
@@ -859,8 +862,8 @@
 static void demo_destroy_texture_image(struct demo *demo, struct texture_object *tex_obj)
 {
     /* clean up staging resources */
-    vkDestroyImage(demo->device, tex_obj->image);
-    vkFreeMemory(demo->device, tex_obj->mem);
+    vkDestroyImage(demo->device, tex_obj->image, NULL);
+    vkFreeMemory(demo->device, tex_obj->mem, NULL);
 }
 
 static void demo_prepare_textures(struct demo *demo)
@@ -960,13 +963,13 @@
         };
 
         /* create sampler */
-        err = vkCreateSampler(demo->device, &sampler,
+        err = vkCreateSampler(demo->device, &sampler, NULL,
                 &demo->textures[i].sampler);
         assert(!err);
 
         /* create image view */
         view.image = demo->textures[i].image;
-        err = vkCreateImageView(demo->device, &view,
+        err = vkCreateImageView(demo->device, &view, NULL,
                                  &demo->textures[i].view);
         assert(!err);
     }
@@ -1000,7 +1003,7 @@
 
     memset(&demo->vertices, 0, sizeof(demo->vertices));
 
-    err = vkCreateBuffer(demo->device, &buf_info, &demo->vertices.buf);
+    err = vkCreateBuffer(demo->device, &buf_info, NULL, &demo->vertices.buf);
     assert(!err);
 
     vkGetBufferMemoryRequirements(demo->device,
@@ -1014,7 +1017,7 @@
                                       &mem_alloc.memoryTypeIndex);
     assert(pass);
 
-    err = vkAllocMemory(demo->device, &mem_alloc, &demo->vertices.mem);
+    err = vkAllocMemory(demo->device, &mem_alloc, NULL, &demo->vertices.mem);
     assert(!err);
 
     err = vkMapMemory(demo->device, demo->vertices.mem, 0, mem_alloc.allocationSize, 0, &data);
@@ -1067,7 +1070,7 @@
     VkResult U_ASSERT_ONLY err;
 
     err = vkCreateDescriptorSetLayout(demo->device,
-            &descriptor_layout, &demo->desc_layout);
+            &descriptor_layout, NULL, &demo->desc_layout);
     assert(!err);
 
     const VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo = {
@@ -1079,6 +1082,7 @@
 
     err = vkCreatePipelineLayout(demo->device,
                                  &pPipelineLayoutCreateInfo,
+                                 NULL,
                                  &demo->pipeline_layout);
     assert(!err);
 }
@@ -1144,7 +1148,7 @@
     };
     VkResult U_ASSERT_ONLY err;
 
-    err = vkCreateRenderPass(demo->device, &rp_info, &demo->render_pass);
+    err = vkCreateRenderPass(demo->device, &rp_info, NULL, &demo->render_pass);
     assert(!err);
 }
 
@@ -1170,14 +1174,14 @@
         moduleCreateInfo.codeSize = size;
         moduleCreateInfo.pCode = code;
         moduleCreateInfo.flags = 0;
-        err = vkCreateShaderModule(demo->device, &moduleCreateInfo, pShaderModule);
+        err = vkCreateShaderModule(demo->device, &moduleCreateInfo, NULL, pShaderModule);
         assert(!err);
 
         shaderCreateInfo.flags = 0;
         shaderCreateInfo.module = *pShaderModule;
         shaderCreateInfo.pName = "main";
         shaderCreateInfo.stage = stage;
-        err = vkCreateShader(demo->device, &shaderCreateInfo, &shader);
+        err = vkCreateShader(demo->device, &shaderCreateInfo, NULL, &shader);
         assert(!err);
     } else {
         // Create fake SPV structure to feed GLSL
@@ -1192,14 +1196,14 @@
         ((uint32_t *) moduleCreateInfo.pCode)[2] = stage;
         memcpy(((uint32_t *) moduleCreateInfo.pCode + 3), code, size + 1);
 
-        err = vkCreateShaderModule(demo->device, &moduleCreateInfo, pShaderModule);
+        err = vkCreateShaderModule(demo->device, &moduleCreateInfo, NULL, pShaderModule);
         assert(!err);
 
         shaderCreateInfo.flags = 0;
         shaderCreateInfo.module = *pShaderModule;
         shaderCreateInfo.pName = "main";
         shaderCreateInfo.stage = stage;
-        err = vkCreateShader(demo->device, &shaderCreateInfo, &shader);
+        err = vkCreateShader(demo->device, &shaderCreateInfo, NULL, &shader);
         assert(!err);
         free((void *) moduleCreateInfo.pCode);
     }
@@ -1397,18 +1401,19 @@
     memset(&pipelineCache, 0, sizeof(pipelineCache));
     pipelineCache.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
 
-    err = vkCreatePipelineCache(demo->device, &pipelineCache, &demo->pipelineCache);
+    err = vkCreatePipelineCache(demo->device, &pipelineCache, NULL, &demo->pipelineCache);
     assert(!err);
-    err = vkCreateGraphicsPipelines(demo->device, demo->pipelineCache, 1, &pipeline, &demo->pipeline);
+    err = vkCreateGraphicsPipelines(demo->device, demo->pipelineCache,
+            1, &pipeline, NULL, &demo->pipeline);
     assert(!err);
 
-    vkDestroyPipelineCache(demo->device, demo->pipelineCache);
+    vkDestroyPipelineCache(demo->device, demo->pipelineCache, NULL);
 
     for (uint32_t i = 0; i < pipeline.stageCount; i++) {
-        vkDestroyShader(demo->device, shaderStages[i].shader);
+        vkDestroyShader(demo->device, shaderStages[i].shader, NULL);
     }
-    vkDestroyShaderModule(demo->device, demo->frag_shader_module);
-    vkDestroyShaderModule(demo->device, demo->vert_shader_module);
+    vkDestroyShaderModule(demo->device, demo->frag_shader_module, NULL);
+    vkDestroyShaderModule(demo->device, demo->vert_shader_module, NULL);
 }
 
 static void demo_prepare_descriptor_pool(struct demo *demo)
@@ -1427,7 +1432,7 @@
     VkResult U_ASSERT_ONLY err;
 
     err = vkCreateDescriptorPool(demo->device,
-            &descriptor_pool, &demo->desc_pool);
+            &descriptor_pool, NULL, &demo->desc_pool);
     assert(!err);
 }
 
@@ -1488,7 +1493,7 @@
 
     for (i = 0; i < demo->swapchainImageCount; i++) {
         attachments[0]= demo->buffers[i].view;
-        err = vkCreateFramebuffer(demo->device, &fb_info, &demo->framebuffers[i]);
+        err = vkCreateFramebuffer(demo->device, &fb_info, NULL, &demo->framebuffers[i]);
         assert(!err);
     }
 }
@@ -1503,7 +1508,7 @@
         .queueFamilyIndex = demo->graphics_queue_node_index,
         .flags = 0,
     };
-    err = vkCreateCommandPool(demo->device, &cmd_pool_info, &demo->cmd_pool);
+    err = vkCreateCommandPool(demo->device, &cmd_pool_info, NULL, &demo->cmd_pool);
     assert(!err);
 
     const VkCmdBufferAllocInfo cmd = {
@@ -1759,7 +1764,7 @@
     void*                           pUserData,
     size_t                          size,
     size_t                          alignment,
-    VkSystemAllocType               allocType)
+    VkSystemAllocScope              allocScope)
 {
     return malloc(size);
 }
@@ -1850,16 +1855,10 @@
         .engineVersion = 0,
         .apiVersion = VK_API_VERSION,
     };
-    VkAllocCallbacks cb = {
-        .pUserData = NULL,
-        .pfnAlloc = myalloc,
-        .pfnFree = myfree,
-    };
     VkInstanceCreateInfo inst_info = {
         .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
         .pNext = NULL,
         .pAppInfo = &app,
-        .pAllocCb = &cb,
         .enabledLayerNameCount = enabled_layer_count,
         .ppEnabledLayerNames = (const char *const*) layer_names,
         .enabledExtensionNameCount = enabled_extension_count,
@@ -1875,7 +1874,10 @@
     };
     uint32_t gpu_count;
 
-    err = vkCreateInstance(&inst_info, &demo->inst);
+    demo->allocator.pfnAlloc = myalloc;
+    demo->allocator.pfnFree = myfree;
+
+    err = vkCreateInstance(&inst_info, &demo->allocator, &demo->inst);
     if (err == VK_ERROR_INCOMPATIBLE_DRIVER) {
         ERR_EXIT("Cannot find a compatible Vulkan installable client driver "
                  "(ICD).\n\nPlease look at the Getting Started guide for "
@@ -1996,7 +1998,7 @@
     }
 
 
-    err = vkCreateDevice(demo->gpu, &device, &demo->device);
+    err = vkCreateDevice(demo->gpu, &device, NULL, &demo->device);
     assert(!err);
 
     GET_INSTANCE_PROC_ADDR(demo->inst, GetPhysicalDeviceSurfaceSupportKHR);
@@ -2207,45 +2209,45 @@
     demo->prepared = false;
 
     for (i = 0; i < demo->swapchainImageCount; i++) {
-        vkDestroyFramebuffer(demo->device, demo->framebuffers[i]);
+        vkDestroyFramebuffer(demo->device, demo->framebuffers[i], NULL);
     }
     free(demo->framebuffers);
-    vkDestroyDescriptorPool(demo->device, demo->desc_pool);
+    vkDestroyDescriptorPool(demo->device, demo->desc_pool, NULL);
 
     if (demo->setup_cmd) {
         vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, &demo->setup_cmd);
     }
     vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, &demo->draw_cmd);
-    vkDestroyCommandPool(demo->device, demo->cmd_pool);
+    vkDestroyCommandPool(demo->device, demo->cmd_pool, NULL);
 
-    vkDestroyPipeline(demo->device, demo->pipeline);
-    vkDestroyRenderPass(demo->device, demo->render_pass);
-    vkDestroyPipelineLayout(demo->device, demo->pipeline_layout);
-    vkDestroyDescriptorSetLayout(demo->device, demo->desc_layout);
+    vkDestroyPipeline(demo->device, demo->pipeline, NULL);
+    vkDestroyRenderPass(demo->device, demo->render_pass, NULL);
+    vkDestroyPipelineLayout(demo->device, demo->pipeline_layout, NULL);
+    vkDestroyDescriptorSetLayout(demo->device, demo->desc_layout, NULL);
 
-    vkDestroyBuffer(demo->device, demo->vertices.buf);
-    vkFreeMemory(demo->device, demo->vertices.mem);
+    vkDestroyBuffer(demo->device, demo->vertices.buf, NULL);
+    vkFreeMemory(demo->device, demo->vertices.mem, NULL);
 
     for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
-        vkDestroyImageView(demo->device, demo->textures[i].view);
-        vkDestroyImage(demo->device, demo->textures[i].image);
-        vkFreeMemory(demo->device, demo->textures[i].mem);
-        vkDestroySampler(demo->device, demo->textures[i].sampler);
+        vkDestroyImageView(demo->device, demo->textures[i].view, NULL);
+        vkDestroyImage(demo->device, demo->textures[i].image, NULL);
+        vkFreeMemory(demo->device, demo->textures[i].mem, NULL);
+        vkDestroySampler(demo->device, demo->textures[i].sampler, NULL);
     }
 
     for (i = 0; i < demo->swapchainImageCount; i++) {
-        vkDestroyImageView(demo->device, demo->buffers[i].view);
+        vkDestroyImageView(demo->device, demo->buffers[i].view, NULL);
     }
 
-    vkDestroyImageView(demo->device, demo->depth.view);
-    vkDestroyImage(demo->device, demo->depth.image);
-    vkFreeMemory(demo->device, demo->depth.mem);
+    vkDestroyImageView(demo->device, demo->depth.view, NULL);
+    vkDestroyImage(demo->device, demo->depth.image, NULL);
+    vkFreeMemory(demo->device, demo->depth.mem, NULL);
 
     demo->fpDestroySwapchainKHR(demo->device, demo->swapchain);
     free(demo->buffers);
 
-    vkDestroyDevice(demo->device);
-    vkDestroyInstance(demo->inst);
+    vkDestroyDevice(demo->device, NULL);
+    vkDestroyInstance(demo->inst, &demo->allocator);
 
     free(demo->queue_props);
 
@@ -2271,39 +2273,39 @@
     demo->prepared = false;
 
     for (i = 0; i < demo->swapchainImageCount; i++) {
-        vkDestroyFramebuffer(demo->device, demo->framebuffers[i]);
+        vkDestroyFramebuffer(demo->device, demo->framebuffers[i], NULL);
     }
     free(demo->framebuffers);
-    vkDestroyDescriptorPool(demo->device, demo->desc_pool);
+    vkDestroyDescriptorPool(demo->device, demo->desc_pool, NULL);
 
     if (demo->setup_cmd) {
         vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, &demo->setup_cmd);
     }
     vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, &demo->draw_cmd);
-    vkDestroyCommandPool(demo->device, demo->cmd_pool);
+    vkDestroyCommandPool(demo->device, demo->cmd_pool, NULL);
 
-    vkDestroyPipeline(demo->device, demo->pipeline);
-    vkDestroyRenderPass(demo->device, demo->render_pass);
-    vkDestroyPipelineLayout(demo->device, demo->pipeline_layout);
-    vkDestroyDescriptorSetLayout(demo->device, demo->desc_layout);
+    vkDestroyPipeline(demo->device, demo->pipeline, NULL);
+    vkDestroyRenderPass(demo->device, demo->render_pass, NULL);
+    vkDestroyPipelineLayout(demo->device, demo->pipeline_layout, NULL);
+    vkDestroyDescriptorSetLayout(demo->device, demo->desc_layout, NULL);
 
-    vkDestroyBuffer(demo->device, demo->vertices.buf);
-    vkFreeMemory(demo->device, demo->vertices.mem);
+    vkDestroyBuffer(demo->device, demo->vertices.buf, NULL);
+    vkFreeMemory(demo->device, demo->vertices.mem, NULL);
 
     for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
-        vkDestroyImageView(demo->device, demo->textures[i].view);
-        vkDestroyImage(demo->device, demo->textures[i].image);
-        vkFreeMemory(demo->device, demo->textures[i].mem);
-        vkDestroySampler(demo->device, demo->textures[i].sampler);
+        vkDestroyImageView(demo->device, demo->textures[i].view, NULL);
+        vkDestroyImage(demo->device, demo->textures[i].image, NULL);
+        vkFreeMemory(demo->device, demo->textures[i].mem, NULL);
+        vkDestroySampler(demo->device, demo->textures[i].sampler, NULL);
     }
 
     for (i = 0; i < demo->swapchainImageCount; i++) {
-        vkDestroyImageView(demo->device, demo->buffers[i].view);
+        vkDestroyImageView(demo->device, demo->buffers[i].view, NULL);
     }
 
-    vkDestroyImageView(demo->device, demo->depth.view);
-    vkDestroyImage(demo->device, demo->depth.image);
-    vkFreeMemory(demo->device, demo->depth.mem);
+    vkDestroyImageView(demo->device, demo->depth.view, NULL);
+    vkDestroyImage(demo->device, demo->depth.image, NULL);
+    vkFreeMemory(demo->device, demo->depth.mem, NULL);
 
     free(demo->buffers);