Merge "Add support for custom allocators in vk::Move<> and vk::Unique<>" into vulkan

diff --git a/external/vulkancts/framework/vulkan/vkRef.hpp b/external/vulkancts/framework/vulkan/vkRef.hpp
index dcf36e8..19fdc66 100644 (file)
--- a/external/vulkancts/framework/vulkan/vkRef.hpp
+++ b/external/vulkancts/framework/vulkan/vkRef.hpp
@@ -85,54 +85,63 @@ template<typename T>
 class Deleter
 {
 public:
-                                                       Deleter         (const DeviceInterface& deviceIface, VkDevice device)
-                                                               : m_deviceIface (&deviceIface)
-                                                               , m_device              (device)
-                                                       {}
-                                                       Deleter         (void)
-                                                               : m_deviceIface (DE_NULL)
-                                                               , m_device              (DE_NULL)
-                                                       {}
-
-       void                                    operator()      (T obj) const;
+                                                                       Deleter         (const DeviceInterface& deviceIface, VkDevice device, const VkAllocationCallbacks* allocator)
+                                                                               : m_deviceIface (&deviceIface)
+                                                                               , m_device              (device)
+                                                                               , m_allocator   (allocator)
+                                                                       {}
+                                                                       Deleter         (void)
+                                                                               : m_deviceIface (DE_NULL)
+                                                                               , m_device              (DE_NULL)
+                                                                               , m_allocator   (DE_NULL)
+                                                                       {}
+
+       void                                                    operator()      (T obj) const;
 
 private:
-       const DeviceInterface*  m_deviceIface;
-       VkDevice                                m_device;
+       const DeviceInterface*                  m_deviceIface;
+       VkDevice                                                m_device;
+       const VkAllocationCallbacks*    m_allocator;
 };
 
 template<>
 class Deleter<VkInstance>
 {
 public:
-                                                       Deleter         (const PlatformInterface& platformIface, VkInstance instance)
-                                                               : m_destroyInstance((DestroyInstanceFunc)platformIface.getInstanceProcAddr(instance, "vkDestroyInstance"))
-                                                       {}
-                                                       Deleter         (void)
-                                                               : m_destroyInstance((DestroyInstanceFunc)DE_NULL)
-                                                       {}
+                                                                       Deleter         (const PlatformInterface& platformIface, VkInstance instance, const VkAllocationCallbacks* allocator)
+                                                                               : m_destroyInstance     ((DestroyInstanceFunc)platformIface.getInstanceProcAddr(instance, "vkDestroyInstance"))
+                                                                               , m_allocator           (allocator)
+                                                                       {}
+                                                                       Deleter         (void)
+                                                                               : m_destroyInstance     ((DestroyInstanceFunc)DE_NULL)
+                                                                               , m_allocator           (DE_NULL)
+                                                                       {}
 
-       void                                    operator()      (VkInstance obj) const { m_destroyInstance(obj, DE_NULL); }
+       void                                                    operator()      (VkInstance obj) const { m_destroyInstance(obj, m_allocator); }
 
 private:
-       DestroyInstanceFunc             m_destroyInstance;
+       DestroyInstanceFunc                             m_destroyInstance;
+       const VkAllocationCallbacks*    m_allocator;
 };
 
 template<>
 class Deleter<VkDevice>
 {
 public:
-                                                       Deleter         (const InstanceInterface& instanceIface, VkDevice device)
-                                                               : m_destroyDevice((DestroyDeviceFunc)instanceIface.getDeviceProcAddr(device, "vkDestroyDevice"))
-                                                       {}
-                                                       Deleter         (void)
-                                                               : m_destroyDevice((DestroyDeviceFunc)DE_NULL)
-                                                       {}
+                                                                       Deleter         (const InstanceInterface& instanceIface, VkDevice device, const VkAllocationCallbacks* allocator)
+                                                                               : m_destroyDevice       ((DestroyDeviceFunc)instanceIface.getDeviceProcAddr(device, "vkDestroyDevice"))
+                                                                               , m_allocator           (allocator)
+                                                                       {}
+                                                                       Deleter         (void)
+                                                                               : m_destroyDevice       ((DestroyDeviceFunc)DE_NULL)
+                                                                               , m_allocator           (DE_NULL)
+                                                                       {}
 
-       void                                    operator()      (VkDevice obj) const { m_destroyDevice(obj, DE_NULL); }
+       void                                                    operator()      (VkDevice obj) const { m_destroyDevice(obj, m_allocator); }
 
 private:
-       DestroyDeviceFunc               m_destroyDevice;
+       DestroyDeviceFunc                               m_destroyDevice;
+       const VkAllocationCallbacks*    m_allocator;
 };
 
 template<>

diff --git a/external/vulkancts/framework/vulkan/vkRefUtil.cpp b/external/vulkancts/framework/vulkan/vkRefUtil.cpp
index a878bc9..1ef4f96 100644 (file)
--- a/external/vulkancts/framework/vulkan/vkRefUtil.cpp
+++ b/external/vulkancts/framework/vulkan/vkRefUtil.cpp
@@ -39,18 +39,26 @@ namespace vk
 
 #include "vkRefUtilImpl.inl"
 
-Move<VkPipeline> createGraphicsPipeline (const DeviceInterface& vk, VkDevice device, VkPipelineCache pipelineCache, const VkGraphicsPipelineCreateInfo* pCreateInfo)
+Move<VkPipeline> createGraphicsPipeline (const DeviceInterface&                                        vk,
+                                                                                VkDevice                                                               device,
+                                                                                VkPipelineCache                                                pipelineCache,
+                                                                                const VkGraphicsPipelineCreateInfo*    pCreateInfo,
+                                                                                const VkAllocationCallbacks*                   pAllocator)
 {
        VkPipeline object = 0;
-       VK_CHECK(vk.createGraphicsPipelines(device, pipelineCache, 1u, pCreateInfo, DE_NULL, &object));
-       return Move<VkPipeline>(check<VkPipeline>(object), Deleter<VkPipeline>(vk, device));
+       VK_CHECK(vk.createGraphicsPipelines(device, pipelineCache, 1u, pCreateInfo, pAllocator, &object));
+       return Move<VkPipeline>(check<VkPipeline>(object), Deleter<VkPipeline>(vk, device, pAllocator));
 }
 
-Move<VkPipeline> createComputePipeline (const DeviceInterface& vk, VkDevice device, VkPipelineCache pipelineCache, const VkComputePipelineCreateInfo* pCreateInfo)
+Move<VkPipeline> createComputePipeline (const DeviceInterface&                         vk,
+                                                                               VkDevice                                                        device,
+                                                                               VkPipelineCache                                         pipelineCache,
+                                                                               const VkComputePipelineCreateInfo*      pCreateInfo,
+                                                                               const VkAllocationCallbacks*            pAllocator)
 {
        VkPipeline object = 0;
-       VK_CHECK(vk.createComputePipelines(device, pipelineCache, 1u, pCreateInfo, DE_NULL, &object));
-       return Move<VkPipeline>(check<VkPipeline>(object), Deleter<VkPipeline>(vk, device));
+       VK_CHECK(vk.createComputePipelines(device, pipelineCache, 1u, pCreateInfo, pAllocator, &object));
+       return Move<VkPipeline>(check<VkPipeline>(object), Deleter<VkPipeline>(vk, device, pAllocator));
 }
 
 Move<VkCommandBuffer> allocateCommandBuffer (const DeviceInterface& vk, VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo)

diff --git a/external/vulkancts/framework/vulkan/vkRefUtil.hpp b/external/vulkancts/framework/vulkan/vkRefUtil.hpp
index 82bfa61..fc2e46f 100644 (file)
--- a/external/vulkancts/framework/vulkan/vkRefUtil.hpp
+++ b/external/vulkancts/framework/vulkan/vkRefUtil.hpp
@@ -42,8 +42,16 @@ namespace vk
 
 #include "vkRefUtil.inl"
 
-Move<VkPipeline>               createGraphicsPipeline  (const DeviceInterface& vk, VkDevice device, VkPipelineCache pipelineCache, const VkGraphicsPipelineCreateInfo* pCreateInfo);
-Move<VkPipeline>               createComputePipeline   (const DeviceInterface& vk, VkDevice device, VkPipelineCache pipelineCache, const VkComputePipelineCreateInfo* pCreateInfo);
+Move<VkPipeline>               createGraphicsPipeline  (const DeviceInterface&                                 vk,
+                                                                                                VkDevice                                                               device,
+                                                                                                VkPipelineCache                                                pipelineCache,
+                                                                                                const VkGraphicsPipelineCreateInfo*    pCreateInfo,
+                                                                                                const VkAllocationCallbacks*                   pAllocator = DE_NULL);
+Move<VkPipeline>               createComputePipeline   (const DeviceInterface&                                 vk,
+                                                                                                VkDevice                                                               device,
+                                                                                                VkPipelineCache                                                pipelineCache,
+                                                                                                const VkComputePipelineCreateInfo*             pCreateInfo,
+                                                                                                const VkAllocationCallbacks*                   pAllocator = DE_NULL);
 Move<VkCommandBuffer>  allocateCommandBuffer   (const DeviceInterface& vk, VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo);
 Move<VkDescriptorSet>  allocateDescriptorSet   (const DeviceInterface& vk, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo);
 

diff --git a/external/vulkancts/framework/vulkan/vkRefUtil.inl b/external/vulkancts/framework/vulkan/vkRefUtil.inl
index 26d94b4..2d2a5fd 100644 (file)
--- a/external/vulkancts/framework/vulkan/vkRefUtil.inl
+++ b/external/vulkancts/framework/vulkan/vkRefUtil.inl
@@ -1,25 +1,25 @@
 /* WARNING: This is auto-generated file. Do not modify, since changes will
  * be lost! Modify the generating script instead.
  */
-Move<VkInstance>                       createInstance                          (const PlatformInterface& vk, const VkInstanceCreateInfo* pCreateInfo);
-Move<VkDevice>                         createDevice                            (const InstanceInterface& vk, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo);
-Move<VkDeviceMemory>           allocateMemory                          (const DeviceInterface& vk, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo);
-Move<VkFence>                          createFence                                     (const DeviceInterface& vk, VkDevice device, const VkFenceCreateInfo* pCreateInfo);
-Move<VkSemaphore>                      createSemaphore                         (const DeviceInterface& vk, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo);
-Move<VkEvent>                          createEvent                                     (const DeviceInterface& vk, VkDevice device, const VkEventCreateInfo* pCreateInfo);
-Move<VkQueryPool>                      createQueryPool                         (const DeviceInterface& vk, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo);
-Move<VkBuffer>                         createBuffer                            (const DeviceInterface& vk, VkDevice device, const VkBufferCreateInfo* pCreateInfo);
-Move<VkBufferView>                     createBufferView                        (const DeviceInterface& vk, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo);
-Move<VkImage>                          createImage                                     (const DeviceInterface& vk, VkDevice device, const VkImageCreateInfo* pCreateInfo);
-Move<VkImageView>                      createImageView                         (const DeviceInterface& vk, VkDevice device, const VkImageViewCreateInfo* pCreateInfo);
-Move<VkShaderModule>           createShaderModule                      (const DeviceInterface& vk, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo);
-Move<VkPipelineCache>          createPipelineCache                     (const DeviceInterface& vk, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo);
-Move<VkPipeline>                       createGraphicsPipelines         (const DeviceInterface& vk, VkDevice device, VkPipelineCache pipelineCache, deUint32 createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos);
-Move<VkPipeline>                       createComputePipelines          (const DeviceInterface& vk, VkDevice device, VkPipelineCache pipelineCache, deUint32 createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos);
-Move<VkPipelineLayout>         createPipelineLayout            (const DeviceInterface& vk, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo);
-Move<VkSampler>                                createSampler                           (const DeviceInterface& vk, VkDevice device, const VkSamplerCreateInfo* pCreateInfo);
-Move<VkDescriptorSetLayout>    createDescriptorSetLayout       (const DeviceInterface& vk, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo);
-Move<VkDescriptorPool>         createDescriptorPool            (const DeviceInterface& vk, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo);
-Move<VkFramebuffer>                    createFramebuffer                       (const DeviceInterface& vk, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo);
-Move<VkRenderPass>                     createRenderPass                        (const DeviceInterface& vk, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo);
-Move<VkCommandPool>                    createCommandPool                       (const DeviceInterface& vk, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo);
+Move<VkInstance>                       createInstance                          (const PlatformInterface& vk, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkDevice>                         createDevice                            (const InstanceInterface& vk, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkDeviceMemory>           allocateMemory                          (const DeviceInterface& vk, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkFence>                          createFence                                     (const DeviceInterface& vk, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkSemaphore>                      createSemaphore                         (const DeviceInterface& vk, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkEvent>                          createEvent                                     (const DeviceInterface& vk, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkQueryPool>                      createQueryPool                         (const DeviceInterface& vk, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkBuffer>                         createBuffer                            (const DeviceInterface& vk, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkBufferView>                     createBufferView                        (const DeviceInterface& vk, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkImage>                          createImage                                     (const DeviceInterface& vk, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkImageView>                      createImageView                         (const DeviceInterface& vk, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkShaderModule>           createShaderModule                      (const DeviceInterface& vk, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkPipelineCache>          createPipelineCache                     (const DeviceInterface& vk, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkPipeline>                       createGraphicsPipelines         (const DeviceInterface& vk, VkDevice device, VkPipelineCache pipelineCache, deUint32 createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkPipeline>                       createComputePipelines          (const DeviceInterface& vk, VkDevice device, VkPipelineCache pipelineCache, deUint32 createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkPipelineLayout>         createPipelineLayout            (const DeviceInterface& vk, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkSampler>                                createSampler                           (const DeviceInterface& vk, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkDescriptorSetLayout>    createDescriptorSetLayout       (const DeviceInterface& vk, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkDescriptorPool>         createDescriptorPool            (const DeviceInterface& vk, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkFramebuffer>                    createFramebuffer                       (const DeviceInterface& vk, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkRenderPass>                     createRenderPass                        (const DeviceInterface& vk, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkCommandPool>                    createCommandPool                       (const DeviceInterface& vk, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);

diff --git a/external/vulkancts/framework/vulkan/vkRefUtilImpl.inl b/external/vulkancts/framework/vulkan/vkRefUtilImpl.inl
index b0328c4..021e48b 100644 (file)
--- a/external/vulkancts/framework/vulkan/vkRefUtilImpl.inl
+++ b/external/vulkancts/framework/vulkan/vkRefUtilImpl.inl
@@ -7,270 +7,270 @@ namespace refdetails
 template<>
 void Deleter<VkDeviceMemory>::operator() (VkDeviceMemory obj) const
 {
-       m_deviceIface->freeMemory(m_device, obj, DE_NULL);
+       m_deviceIface->freeMemory(m_device, obj, m_allocator);
 }
 
 template<>
 void Deleter<VkFence>::operator() (VkFence obj) const
 {
-       m_deviceIface->destroyFence(m_device, obj, DE_NULL);
+       m_deviceIface->destroyFence(m_device, obj, m_allocator);
 }
 
 template<>
 void Deleter<VkSemaphore>::operator() (VkSemaphore obj) const
 {
-       m_deviceIface->destroySemaphore(m_device, obj, DE_NULL);
+       m_deviceIface->destroySemaphore(m_device, obj, m_allocator);
 }
 
 template<>
 void Deleter<VkEvent>::operator() (VkEvent obj) const
 {
-       m_deviceIface->destroyEvent(m_device, obj, DE_NULL);
+       m_deviceIface->destroyEvent(m_device, obj, m_allocator);
 }
 
 template<>
 void Deleter<VkQueryPool>::operator() (VkQueryPool obj) const
 {
-       m_deviceIface->destroyQueryPool(m_device, obj, DE_NULL);
+       m_deviceIface->destroyQueryPool(m_device, obj, m_allocator);
 }
 
 template<>
 void Deleter<VkBuffer>::operator() (VkBuffer obj) const
 {
-       m_deviceIface->destroyBuffer(m_device, obj, DE_NULL);
+       m_deviceIface->destroyBuffer(m_device, obj, m_allocator);
 }
 
 template<>
 void Deleter<VkBufferView>::operator() (VkBufferView obj) const
 {
-       m_deviceIface->destroyBufferView(m_device, obj, DE_NULL);
+       m_deviceIface->destroyBufferView(m_device, obj, m_allocator);
 }
 
 template<>
 void Deleter<VkImage>::operator() (VkImage obj) const
 {
-       m_deviceIface->destroyImage(m_device, obj, DE_NULL);
+       m_deviceIface->destroyImage(m_device, obj, m_allocator);
 }
 
 template<>
 void Deleter<VkImageView>::operator() (VkImageView obj) const
 {
-       m_deviceIface->destroyImageView(m_device, obj, DE_NULL);
+       m_deviceIface->destroyImageView(m_device, obj, m_allocator);
 }
 
 template<>
 void Deleter<VkShaderModule>::operator() (VkShaderModule obj) const
 {
-       m_deviceIface->destroyShaderModule(m_device, obj, DE_NULL);
+       m_deviceIface->destroyShaderModule(m_device, obj, m_allocator);
 }
 
 template<>
 void Deleter<VkPipelineCache>::operator() (VkPipelineCache obj) const
 {
-       m_deviceIface->destroyPipelineCache(m_device, obj, DE_NULL);
+       m_deviceIface->destroyPipelineCache(m_device, obj, m_allocator);
 }
 
 template<>
 void Deleter<VkPipeline>::operator() (VkPipeline obj) const
 {
-       m_deviceIface->destroyPipeline(m_device, obj, DE_NULL);
+       m_deviceIface->destroyPipeline(m_device, obj, m_allocator);
 }
 
 template<>
 void Deleter<VkPipelineLayout>::operator() (VkPipelineLayout obj) const
 {
-       m_deviceIface->destroyPipelineLayout(m_device, obj, DE_NULL);
+       m_deviceIface->destroyPipelineLayout(m_device, obj, m_allocator);
 }
 
 template<>
 void Deleter<VkSampler>::operator() (VkSampler obj) const
 {
-       m_deviceIface->destroySampler(m_device, obj, DE_NULL);
+       m_deviceIface->destroySampler(m_device, obj, m_allocator);
 }
 
 template<>
 void Deleter<VkDescriptorSetLayout>::operator() (VkDescriptorSetLayout obj) const
 {
-       m_deviceIface->destroyDescriptorSetLayout(m_device, obj, DE_NULL);
+       m_deviceIface->destroyDescriptorSetLayout(m_device, obj, m_allocator);
 }
 
 template<>
 void Deleter<VkDescriptorPool>::operator() (VkDescriptorPool obj) const
 {
-       m_deviceIface->destroyDescriptorPool(m_device, obj, DE_NULL);
+       m_deviceIface->destroyDescriptorPool(m_device, obj, m_allocator);
 }
 
 template<>
 void Deleter<VkFramebuffer>::operator() (VkFramebuffer obj) const
 {
-       m_deviceIface->destroyFramebuffer(m_device, obj, DE_NULL);
+       m_deviceIface->destroyFramebuffer(m_device, obj, m_allocator);
 }
 
 template<>
 void Deleter<VkRenderPass>::operator() (VkRenderPass obj) const
 {
-       m_deviceIface->destroyRenderPass(m_device, obj, DE_NULL);
+       m_deviceIface->destroyRenderPass(m_device, obj, m_allocator);
 }
 
 template<>
 void Deleter<VkCommandPool>::operator() (VkCommandPool obj) const
 {
-       m_deviceIface->destroyCommandPool(m_device, obj, DE_NULL);
+       m_deviceIface->destroyCommandPool(m_device, obj, m_allocator);
 }
 
 } // refdetails
 
-Move<VkInstance> createInstance (const PlatformInterface& vk, const VkInstanceCreateInfo* pCreateInfo)
+Move<VkInstance> createInstance (const PlatformInterface& vk, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 {
        VkInstance object = 0;
-       VK_CHECK(vk.createInstance(pCreateInfo, DE_NULL, &object));
-       return Move<VkInstance>(check<VkInstance>(object), Deleter<VkInstance>(vk, object));
+       VK_CHECK(vk.createInstance(pCreateInfo, pAllocator, &object));
+       return Move<VkInstance>(check<VkInstance>(object), Deleter<VkInstance>(vk, object, pAllocator));
 }
 
-Move<VkDevice> createDevice (const InstanceInterface& vk, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo)
+Move<VkDevice> createDevice (const InstanceInterface& vk, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 {
        VkDevice object = 0;
-       VK_CHECK(vk.createDevice(physicalDevice, pCreateInfo, DE_NULL, &object));
-       return Move<VkDevice>(check<VkDevice>(object), Deleter<VkDevice>(vk, object));
+       VK_CHECK(vk.createDevice(physicalDevice, pCreateInfo, pAllocator, &object));
+       return Move<VkDevice>(check<VkDevice>(object), Deleter<VkDevice>(vk, object, pAllocator));
 }
 
-Move<VkDeviceMemory> allocateMemory (const DeviceInterface& vk, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo)
+Move<VkDeviceMemory> allocateMemory (const DeviceInterface& vk, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator)
 {
        VkDeviceMemory object = 0;
-       VK_CHECK(vk.allocateMemory(device, pAllocateInfo, DE_NULL, &object));
-       return Move<VkDeviceMemory>(check<VkDeviceMemory>(object), Deleter<VkDeviceMemory>(vk, device));
+       VK_CHECK(vk.allocateMemory(device, pAllocateInfo, pAllocator, &object));
+       return Move<VkDeviceMemory>(check<VkDeviceMemory>(object), Deleter<VkDeviceMemory>(vk, device, pAllocator));
 }
 
-Move<VkFence> createFence (const DeviceInterface& vk, VkDevice device, const VkFenceCreateInfo* pCreateInfo)
+Move<VkFence> createFence (const DeviceInterface& vk, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 {
        VkFence object = 0;
-       VK_CHECK(vk.createFence(device, pCreateInfo, DE_NULL, &object));
-       return Move<VkFence>(check<VkFence>(object), Deleter<VkFence>(vk, device));
+       VK_CHECK(vk.createFence(device, pCreateInfo, pAllocator, &object));
+       return Move<VkFence>(check<VkFence>(object), Deleter<VkFence>(vk, device, pAllocator));
 }
 
-Move<VkSemaphore> createSemaphore (const DeviceInterface& vk, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo)
+Move<VkSemaphore> createSemaphore (const DeviceInterface& vk, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 {
        VkSemaphore object = 0;
-       VK_CHECK(vk.createSemaphore(device, pCreateInfo, DE_NULL, &object));
-       return Move<VkSemaphore>(check<VkSemaphore>(object), Deleter<VkSemaphore>(vk, device));
+       VK_CHECK(vk.createSemaphore(device, pCreateInfo, pAllocator, &object));
+       return Move<VkSemaphore>(check<VkSemaphore>(object), Deleter<VkSemaphore>(vk, device, pAllocator));
 }
 
-Move<VkEvent> createEvent (const DeviceInterface& vk, VkDevice device, const VkEventCreateInfo* pCreateInfo)
+Move<VkEvent> createEvent (const DeviceInterface& vk, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 {
        VkEvent object = 0;
-       VK_CHECK(vk.createEvent(device, pCreateInfo, DE_NULL, &object));
-       return Move<VkEvent>(check<VkEvent>(object), Deleter<VkEvent>(vk, device));
+       VK_CHECK(vk.createEvent(device, pCreateInfo, pAllocator, &object));
+       return Move<VkEvent>(check<VkEvent>(object), Deleter<VkEvent>(vk, device, pAllocator));
 }
 
-Move<VkQueryPool> createQueryPool (const DeviceInterface& vk, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo)
+Move<VkQueryPool> createQueryPool (const DeviceInterface& vk, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 {
        VkQueryPool object = 0;
-       VK_CHECK(vk.createQueryPool(device, pCreateInfo, DE_NULL, &object));
-       return Move<VkQueryPool>(check<VkQueryPool>(object), Deleter<VkQueryPool>(vk, device));
+       VK_CHECK(vk.createQueryPool(device, pCreateInfo, pAllocator, &object));
+       return Move<VkQueryPool>(check<VkQueryPool>(object), Deleter<VkQueryPool>(vk, device, pAllocator));
 }
 
-Move<VkBuffer> createBuffer (const DeviceInterface& vk, VkDevice device, const VkBufferCreateInfo* pCreateInfo)
+Move<VkBuffer> createBuffer (const DeviceInterface& vk, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 {
        VkBuffer object = 0;
-       VK_CHECK(vk.createBuffer(device, pCreateInfo, DE_NULL, &object));
-       return Move<VkBuffer>(check<VkBuffer>(object), Deleter<VkBuffer>(vk, device));
+       VK_CHECK(vk.createBuffer(device, pCreateInfo, pAllocator, &object));
+       return Move<VkBuffer>(check<VkBuffer>(object), Deleter<VkBuffer>(vk, device, pAllocator));
 }
 
-Move<VkBufferView> createBufferView (const DeviceInterface& vk, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo)
+Move<VkBufferView> createBufferView (const DeviceInterface& vk, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 {
        VkBufferView object = 0;
-       VK_CHECK(vk.createBufferView(device, pCreateInfo, DE_NULL, &object));
-       return Move<VkBufferView>(check<VkBufferView>(object), Deleter<VkBufferView>(vk, device));
+       VK_CHECK(vk.createBufferView(device, pCreateInfo, pAllocator, &object));
+       return Move<VkBufferView>(check<VkBufferView>(object), Deleter<VkBufferView>(vk, device, pAllocator));
 }
 
-Move<VkImage> createImage (const DeviceInterface& vk, VkDevice device, const VkImageCreateInfo* pCreateInfo)
+Move<VkImage> createImage (const DeviceInterface& vk, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 {
        VkImage object = 0;
-       VK_CHECK(vk.createImage(device, pCreateInfo, DE_NULL, &object));
-       return Move<VkImage>(check<VkImage>(object), Deleter<VkImage>(vk, device));
+       VK_CHECK(vk.createImage(device, pCreateInfo, pAllocator, &object));
+       return Move<VkImage>(check<VkImage>(object), Deleter<VkImage>(vk, device, pAllocator));
 }
 
-Move<VkImageView> createImageView (const DeviceInterface& vk, VkDevice device, const VkImageViewCreateInfo* pCreateInfo)
+Move<VkImageView> createImageView (const DeviceInterface& vk, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 {
        VkImageView object = 0;
-       VK_CHECK(vk.createImageView(device, pCreateInfo, DE_NULL, &object));
-       return Move<VkImageView>(check<VkImageView>(object), Deleter<VkImageView>(vk, device));
+       VK_CHECK(vk.createImageView(device, pCreateInfo, pAllocator, &object));
+       return Move<VkImageView>(check<VkImageView>(object), Deleter<VkImageView>(vk, device, pAllocator));
 }
 
-Move<VkShaderModule> createShaderModule (const DeviceInterface& vk, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo)
+Move<VkShaderModule> createShaderModule (const DeviceInterface& vk, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 {
        VkShaderModule object = 0;
-       VK_CHECK(vk.createShaderModule(device, pCreateInfo, DE_NULL, &object));
-       return Move<VkShaderModule>(check<VkShaderModule>(object), Deleter<VkShaderModule>(vk, device));
+       VK_CHECK(vk.createShaderModule(device, pCreateInfo, pAllocator, &object));
+       return Move<VkShaderModule>(check<VkShaderModule>(object), Deleter<VkShaderModule>(vk, device, pAllocator));
 }
 
-Move<VkPipelineCache> createPipelineCache (const DeviceInterface& vk, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo)
+Move<VkPipelineCache> createPipelineCache (const DeviceInterface& vk, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 {
        VkPipelineCache object = 0;
-       VK_CHECK(vk.createPipelineCache(device, pCreateInfo, DE_NULL, &object));
-       return Move<VkPipelineCache>(check<VkPipelineCache>(object), Deleter<VkPipelineCache>(vk, device));
+       VK_CHECK(vk.createPipelineCache(device, pCreateInfo, pAllocator, &object));
+       return Move<VkPipelineCache>(check<VkPipelineCache>(object), Deleter<VkPipelineCache>(vk, device, pAllocator));
 }
 
-Move<VkPipeline> createGraphicsPipelines (const DeviceInterface& vk, VkDevice device, VkPipelineCache pipelineCache, deUint32 createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos)
+Move<VkPipeline> createGraphicsPipelines (const DeviceInterface& vk, VkDevice device, VkPipelineCache pipelineCache, deUint32 createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator)
 {
        VkPipeline object = 0;
-       VK_CHECK(vk.createGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, DE_NULL, &object));
-       return Move<VkPipeline>(check<VkPipeline>(object), Deleter<VkPipeline>(vk, device));
+       VK_CHECK(vk.createGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, &object));
+       return Move<VkPipeline>(check<VkPipeline>(object), Deleter<VkPipeline>(vk, device, pAllocator));
 }
 
-Move<VkPipeline> createComputePipelines (const DeviceInterface& vk, VkDevice device, VkPipelineCache pipelineCache, deUint32 createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos)
+Move<VkPipeline> createComputePipelines (const DeviceInterface& vk, VkDevice device, VkPipelineCache pipelineCache, deUint32 createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator)
 {
        VkPipeline object = 0;
-       VK_CHECK(vk.createComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, DE_NULL, &object));
-       return Move<VkPipeline>(check<VkPipeline>(object), Deleter<VkPipeline>(vk, device));
+       VK_CHECK(vk.createComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, &object));
+       return Move<VkPipeline>(check<VkPipeline>(object), Deleter<VkPipeline>(vk, device, pAllocator));
 }
 
-Move<VkPipelineLayout> createPipelineLayout (const DeviceInterface& vk, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo)
+Move<VkPipelineLayout> createPipelineLayout (const DeviceInterface& vk, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 {
        VkPipelineLayout object = 0;
-       VK_CHECK(vk.createPipelineLayout(device, pCreateInfo, DE_NULL, &object));
-       return Move<VkPipelineLayout>(check<VkPipelineLayout>(object), Deleter<VkPipelineLayout>(vk, device));
+       VK_CHECK(vk.createPipelineLayout(device, pCreateInfo, pAllocator, &object));
+       return Move<VkPipelineLayout>(check<VkPipelineLayout>(object), Deleter<VkPipelineLayout>(vk, device, pAllocator));
 }
 
-Move<VkSampler> createSampler (const DeviceInterface& vk, VkDevice device, const VkSamplerCreateInfo* pCreateInfo)
+Move<VkSampler> createSampler (const DeviceInterface& vk, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 {
        VkSampler object = 0;
-       VK_CHECK(vk.createSampler(device, pCreateInfo, DE_NULL, &object));
-       return Move<VkSampler>(check<VkSampler>(object), Deleter<VkSampler>(vk, device));
+       VK_CHECK(vk.createSampler(device, pCreateInfo, pAllocator, &object));
+       return Move<VkSampler>(check<VkSampler>(object), Deleter<VkSampler>(vk, device, pAllocator));
 }
 
-Move<VkDescriptorSetLayout> createDescriptorSetLayout (const DeviceInterface& vk, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo)
+Move<VkDescriptorSetLayout> createDescriptorSetLayout (const DeviceInterface& vk, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 {
        VkDescriptorSetLayout object = 0;
-       VK_CHECK(vk.createDescriptorSetLayout(device, pCreateInfo, DE_NULL, &object));
-       return Move<VkDescriptorSetLayout>(check<VkDescriptorSetLayout>(object), Deleter<VkDescriptorSetLayout>(vk, device));
+       VK_CHECK(vk.createDescriptorSetLayout(device, pCreateInfo, pAllocator, &object));
+       return Move<VkDescriptorSetLayout>(check<VkDescriptorSetLayout>(object), Deleter<VkDescriptorSetLayout>(vk, device, pAllocator));
 }
 
-Move<VkDescriptorPool> createDescriptorPool (const DeviceInterface& vk, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo)
+Move<VkDescriptorPool> createDescriptorPool (const DeviceInterface& vk, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 {
        VkDescriptorPool object = 0;
-       VK_CHECK(vk.createDescriptorPool(device, pCreateInfo, DE_NULL, &object));
-       return Move<VkDescriptorPool>(check<VkDescriptorPool>(object), Deleter<VkDescriptorPool>(vk, device));
+       VK_CHECK(vk.createDescriptorPool(device, pCreateInfo, pAllocator, &object));
+       return Move<VkDescriptorPool>(check<VkDescriptorPool>(object), Deleter<VkDescriptorPool>(vk, device, pAllocator));
 }
 
-Move<VkFramebuffer> createFramebuffer (const DeviceInterface& vk, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo)
+Move<VkFramebuffer> createFramebuffer (const DeviceInterface& vk, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 {
        VkFramebuffer object = 0;
-       VK_CHECK(vk.createFramebuffer(device, pCreateInfo, DE_NULL, &object));
-       return Move<VkFramebuffer>(check<VkFramebuffer>(object), Deleter<VkFramebuffer>(vk, device));
+       VK_CHECK(vk.createFramebuffer(device, pCreateInfo, pAllocator, &object));
+       return Move<VkFramebuffer>(check<VkFramebuffer>(object), Deleter<VkFramebuffer>(vk, device, pAllocator));
 }
 
-Move<VkRenderPass> createRenderPass (const DeviceInterface& vk, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo)
+Move<VkRenderPass> createRenderPass (const DeviceInterface& vk, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 {
        VkRenderPass object = 0;
-       VK_CHECK(vk.createRenderPass(device, pCreateInfo, DE_NULL, &object));
-       return Move<VkRenderPass>(check<VkRenderPass>(object), Deleter<VkRenderPass>(vk, device));
+       VK_CHECK(vk.createRenderPass(device, pCreateInfo, pAllocator, &object));
+       return Move<VkRenderPass>(check<VkRenderPass>(object), Deleter<VkRenderPass>(vk, device, pAllocator));
 }
 
-Move<VkCommandPool> createCommandPool (const DeviceInterface& vk, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo)
+Move<VkCommandPool> createCommandPool (const DeviceInterface& vk, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
 {
        VkCommandPool object = 0;
-       VK_CHECK(vk.createCommandPool(device, pCreateInfo, DE_NULL, &object));
-       return Move<VkCommandPool>(check<VkCommandPool>(object), Deleter<VkCommandPool>(vk, device));
+       VK_CHECK(vk.createCommandPool(device, pCreateInfo, pAllocator, &object));
+       return Move<VkCommandPool>(check<VkCommandPool>(object), Deleter<VkCommandPool>(vk, device, pAllocator));
 }
 

diff --git a/external/vulkancts/gen_framework.py b/external/vulkancts/gen_framework.py
index e27b26b..1c6a708 100644 (file)
--- a/external/vulkancts/gen_framework.py
+++ b/external/vulkancts/gen_framework.py
@@ -590,16 +590,16 @@ def getConstructorFunctions (api):
                        assert function.arguments[-2].type == "const VkAllocationCallbacks*"
 
                        objectType      = function.arguments[-1].type.replace("*", "").strip()
-                       arguments       = function.arguments[:-2]
+                       arguments       = function.arguments[:-1]
                        funcs.append(ConstructorFunction(function.getType(), getInterfaceName(function), objectType, iface, arguments))
        return funcs
 
 def writeRefUtilProto (api, filename):
-       functions = getConstructorFunctions(api)
+       functions       = getConstructorFunctions(api)
 
        def makeRefUtilProto ():
                unindented = []
-               for line in indentLines(["Move<%s>\t%s\t(%s);" % (function.objectType, function.name, argListToStr([function.iface] + function.arguments)) for function in functions]):
+               for line in indentLines(["Move<%s>\t%s\t(%s = DE_NULL);" % (function.objectType, function.name, argListToStr([function.iface] + function.arguments)) for function in functions]):
                        yield line
 
        writeInlFile(filename, INL_HEADER, makeRefUtilProto())
@@ -620,7 +620,7 @@ def writeRefUtilImpl (api, filename):
                                yield "template<>"
                                yield "void Deleter<%s>::operator() (%s obj) const" % (objectType, objectType)
                                yield "{"
-                               yield "\tm_deviceIface->%s(m_device, obj, DE_NULL);" % (getInterfaceName(function))
+                               yield "\tm_deviceIface->%s(m_device, obj, m_allocator);" % (getInterfaceName(function))
                                yield "}"
                                yield ""
 
@@ -633,8 +633,8 @@ def writeRefUtilImpl (api, filename):
                        yield "Move<%s> %s (%s)" % (function.objectType, function.name, argListToStr([function.iface] + function.arguments))
                        yield "{"
                        yield "\t%s object = 0;" % function.objectType
-                       yield "\tVK_CHECK(vk.%s(%s));" % (function.name, ", ".join([a.name for a in function.arguments] + ["DE_NULL", "&object"]))
-                       yield "\treturn Move<%s>(check<%s>(object), Deleter<%s>(vk, %s));" % (function.objectType, function.objectType, function.objectType, dtorObj)
+                       yield "\tVK_CHECK(vk.%s(%s));" % (function.name, ", ".join([a.name for a in function.arguments] + ["&object"]))
+                       yield "\treturn Move<%s>(check<%s>(object), Deleter<%s>(%s));" % (function.objectType, function.objectType, function.objectType, ", ".join(["vk", dtorObj, function.arguments[-1].name]))
                        yield "}"
                        yield ""
 

diff --git a/external/vulkancts/modules/vulkan/memory/vktMemoryMappingTests.cpp b/external/vulkancts/modules/vulkan/memory/vktMemoryMappingTests.cpp
index 8e821f6..22e8fa2 100644 (file)
--- a/external/vulkancts/modules/vulkan/memory/vktMemoryMappingTests.cpp
+++ b/external/vulkancts/modules/vulkan/memory/vktMemoryMappingTests.cpp
@@ -81,7 +81,7 @@ Move<VkDeviceMemory> allocMemory (const DeviceInterface& vk, VkDevice device, Vk
                pAllocInfo_memoryTypeIndex,
        };
        VK_CHECK(vk.allocateMemory(device, &pAllocInfo, (const VkAllocationCallbacks*)DE_NULL, &object));
-       return Move<VkDeviceMemory>(check<VkDeviceMemory>(object), Deleter<VkDeviceMemory>(vk, device));
+       return Move<VkDeviceMemory>(check<VkDeviceMemory>(object), Deleter<VkDeviceMemory>(vk, device, (const VkAllocationCallbacks*)DE_NULL));
 }
 
 struct MemoryRange

diff --git a/external/vulkancts/modules/vulkan/vktRenderPassTests.cpp b/external/vulkancts/modules/vulkan/vktRenderPassTests.cpp
index 9ecaa00..007b85d 100644 (file)
--- a/external/vulkancts/modules/vulkan/vktRenderPassTests.cpp
+++ b/external/vulkancts/modules/vulkan/vktRenderPassTests.cpp
@@ -99,7 +99,6 @@ enum
 // Utility functions using flattened structs
 Move<VkFence> createFence (const DeviceInterface& vk, VkDevice device, VkFenceCreateFlags flags)
 {
-       VkFence object = 0;
        const VkFenceCreateInfo pCreateInfo =
        {
                VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
@@ -107,8 +106,7 @@ Move<VkFence> createFence (const DeviceInterface& vk, VkDevice device, VkFenceCr
 
                flags
        };
-       VK_CHECK(vk.createFence(device, &pCreateInfo, DE_NULL, &object));
-       return Move<VkFence>(check<VkFence>(object), Deleter<VkFence>(vk, device));
+       return createFence(vk, device, &pCreateInfo);
 }
 
 Move<VkFramebuffer> createFramebuffer (const DeviceInterface&  vk,
@@ -121,7 +119,6 @@ Move<VkFramebuffer> createFramebuffer (const DeviceInterface&       vk,
                                                                           deUint32                                     pCreateInfo_height,
                                                                           deUint32                                     pCreateInfo_layers)
 {
-       VkFramebuffer object = 0;
        const VkFramebufferCreateInfo pCreateInfo =
        {
                VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
@@ -134,8 +131,7 @@ Move<VkFramebuffer> createFramebuffer (const DeviceInterface&       vk,
                pCreateInfo_height,
                pCreateInfo_layers,
        };
-       VK_CHECK(vk.createFramebuffer(device, &pCreateInfo, DE_NULL, &object));
-       return Move<VkFramebuffer>(check<VkFramebuffer>(object), Deleter<VkFramebuffer>(vk, device));
+       return createFramebuffer(vk, device, &pCreateInfo);
 }
 
 Move<VkImage> createImage (const DeviceInterface&      vk,
@@ -154,7 +150,6 @@ Move<VkImage> createImage (const DeviceInterface&   vk,
                                                   const deUint32*                      pCreateInfo_pQueueFamilyIndices,
                                                   VkImageLayout                        pCreateInfo_initialLayout)
 {
-       VkImage object = 0;
        const VkImageCreateInfo pCreateInfo =
        {
                VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
@@ -173,8 +168,7 @@ Move<VkImage> createImage (const DeviceInterface&   vk,
                pCreateInfo_pQueueFamilyIndices,
                pCreateInfo_initialLayout
        };
-       VK_CHECK(vk.createImage(device, &pCreateInfo, DE_NULL, &object));
-       return Move<VkImage>(check<VkImage>(object), Deleter<VkImage>(vk, device));
+       return createImage(vk, device, &pCreateInfo);
 }
 
 void bindBufferMemory (const DeviceInterface& vk, VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset)
@@ -196,7 +190,6 @@ Move<VkImageView> createImageView (const DeviceInterface&   vk,
                                                                        VkComponentMapping              pCreateInfo_components,
                                                                        VkImageSubresourceRange pCreateInfo_subresourceRange)
 {
-       VkImageView object = 0;
        const VkImageViewCreateInfo pCreateInfo =
        {
                VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
@@ -208,8 +201,7 @@ Move<VkImageView> createImageView (const DeviceInterface&   vk,
                pCreateInfo_components,
                pCreateInfo_subresourceRange,
        };
-       VK_CHECK(vk.createImageView(device, &pCreateInfo, DE_NULL, &object));
-       return Move<VkImageView>(check<VkImageView>(object), Deleter<VkImageView>(vk, device));
+       return createImageView(vk, device, &pCreateInfo);
 }
 
 Move<VkBuffer> createBuffer (const DeviceInterface&    vk,
@@ -221,7 +213,6 @@ Move<VkBuffer> createBuffer (const DeviceInterface& vk,
                                                         deUint32                               pCreateInfo_queueFamilyCount,
                                                         const deUint32*                pCreateInfo_pQueueFamilyIndices)
 {
-       VkBuffer object = 0;
        const VkBufferCreateInfo pCreateInfo =
        {
                VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
@@ -233,8 +224,7 @@ Move<VkBuffer> createBuffer (const DeviceInterface& vk,
                pCreateInfo_queueFamilyCount,
                pCreateInfo_pQueueFamilyIndices,
        };
-       VK_CHECK(vk.createBuffer(device, &pCreateInfo, DE_NULL, &object));
-       return Move<VkBuffer>(check<VkBuffer>(object), Deleter<VkBuffer>(vk, device));
+       return createBuffer(vk, device, &pCreateInfo);
 }
 
 Move<VkCommandPool> createCommandPool (const DeviceInterface&  vk,
@@ -242,7 +232,6 @@ Move<VkCommandPool> createCommandPool (const DeviceInterface&       vk,
                                                                           VkCommandPoolCreateFlags     pCreateInfo_flags,
                                                                           deUint32                                     pCreateInfo_queueFamilyIndex)
 {
-       VkCommandPool object = 0;
        const VkCommandPoolCreateInfo pCreateInfo =
        {
                VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
@@ -250,8 +239,7 @@ Move<VkCommandPool> createCommandPool (const DeviceInterface&       vk,
                pCreateInfo_flags,
                pCreateInfo_queueFamilyIndex,
        };
-       VK_CHECK(vk.createCommandPool(device, &pCreateInfo, DE_NULL, &object));
-       return Move<VkCommandPool>(check<VkCommandPool>(object), Deleter<VkCommandPool>(vk, device));
+       return createCommandPool(vk, device, &pCreateInfo);
 }
 
 void cmdBeginRenderPass (const DeviceInterface&        vk,
@@ -281,8 +269,7 @@ Move<VkCommandBuffer> allocateCommandBuffer (const DeviceInterface& vk,
                                                                                         VkCommandPool                  pCreateInfo_commandPool,
                                                                                         VkCommandBufferLevel   pCreateInfo_level)
 {
-       VkCommandBuffer object = 0;
-       const VkCommandBufferAllocateInfo pCreateInfo =
+       const VkCommandBufferAllocateInfo pAllocateInfo =
        {
                VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
                DE_NULL,
@@ -290,8 +277,7 @@ Move<VkCommandBuffer> allocateCommandBuffer (const DeviceInterface& vk,
                pCreateInfo_level,
                1u,                                                                                             // bufferCount
        };
-       VK_CHECK(vk.allocateCommandBuffers(device, &pCreateInfo, &object));
-       return Move<VkCommandBuffer>(check<VkCommandBuffer>(object), Deleter<VkCommandBuffer>(vk, device, pCreateInfo_commandPool));
+       return allocateCommandBuffer(vk, device, &pAllocateInfo);
 }
 
 void beginCommandBuffer (const DeviceInterface&                        vk,