vulkan: Update from version 0.186.0 to 0.188.0
Change-Id: Ida08d51f4e892202b594072d1e765ba5c55444db
(cherry picked from commit 2ca0449bdeecd0257c7473f663896b00d0082def)
diff --git a/vulkan/libvulkan/entry.cpp b/vulkan/libvulkan/entry.cpp
index 255ad97..7622e4d 100644
--- a/vulkan/libvulkan/entry.cpp
+++ b/vulkan/libvulkan/entry.cpp
@@ -42,13 +42,13 @@
} // namespace
__attribute__((visibility("default")))
-VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance) {
- return vulkan::CreateInstance(pCreateInfo, pInstance);
+VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkInstance* pInstance) {
+ return vulkan::CreateInstance(pCreateInfo, pAllocator, pInstance);
}
__attribute__((visibility("default")))
-void vkDestroyInstance(VkInstance instance) {
- GetVtbl(instance).DestroyInstance(instance);
+void vkDestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator) {
+ GetVtbl(instance).DestroyInstance(instance, pAllocator);
}
__attribute__((visibility("default")))
@@ -72,8 +72,8 @@
}
__attribute__((visibility("default")))
-void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties) {
- GetVtbl(physicalDevice).GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pCount, pQueueFamilyProperties);
+void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) {
+ GetVtbl(physicalDevice).GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
}
__attribute__((visibility("default")))
@@ -97,33 +97,33 @@
}
__attribute__((visibility("default")))
-VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice) {
- return GetVtbl(physicalDevice).CreateDevice(physicalDevice, pCreateInfo, pDevice);
+VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice) {
+ return GetVtbl(physicalDevice).CreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
}
__attribute__((visibility("default")))
-void vkDestroyDevice(VkDevice device) {
- vulkan::DestroyDevice(device);
+void vkDestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator) {
+ vulkan::DestroyDevice(device, pAllocator);
}
__attribute__((visibility("default")))
-VkResult vkEnumerateInstanceLayerProperties(uint32_t* pCount, VkLayerProperties* pProperties) {
- return vulkan::EnumerateInstanceLayerProperties(pCount, pProperties);
+VkResult vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties) {
+ return vulkan::EnumerateInstanceLayerProperties(pPropertyCount, pProperties);
}
__attribute__((visibility("default")))
-VkResult vkEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties) {
- return vulkan::EnumerateInstanceExtensionProperties(pLayerName, pCount, pProperties);
+VkResult vkEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {
+ return vulkan::EnumerateInstanceExtensionProperties(pLayerName, pPropertyCount, pProperties);
}
__attribute__((visibility("default")))
-VkResult vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties) {
- return GetVtbl(physicalDevice).EnumerateDeviceLayerProperties(physicalDevice, pCount, pProperties);
+VkResult vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) {
+ return GetVtbl(physicalDevice).EnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties);
}
__attribute__((visibility("default")))
-VkResult vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties) {
- return GetVtbl(physicalDevice).EnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pCount, pProperties);
+VkResult vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {
+ return GetVtbl(physicalDevice).EnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties);
}
__attribute__((visibility("default")))
@@ -147,13 +147,13 @@
}
__attribute__((visibility("default")))
-VkResult vkAllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem) {
- return GetVtbl(device).AllocMemory(device, pAllocInfo, pMem);
+VkResult vkAllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, const VkAllocCallbacks* pAllocator, VkDeviceMemory* pMem) {
+ return GetVtbl(device).AllocMemory(device, pAllocInfo, pAllocator, pMem);
}
__attribute__((visibility("default")))
-void vkFreeMemory(VkDevice device, VkDeviceMemory mem) {
- GetVtbl(device).FreeMemory(device, mem);
+void vkFreeMemory(VkDevice device, VkDeviceMemory mem, const VkAllocCallbacks* pAllocator) {
+ GetVtbl(device).FreeMemory(device, mem, pAllocator);
}
__attribute__((visibility("default")))
@@ -202,38 +202,38 @@
}
__attribute__((visibility("default")))
-void vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
- GetVtbl(device).GetImageSparseMemoryRequirements(device, image, pNumRequirements, pSparseMemoryRequirements);
+void vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
+ GetVtbl(device).GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
}
__attribute__((visibility("default")))
-void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties) {
- GetVtbl(physicalDevice).GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pNumProperties, pProperties);
+void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) {
+ GetVtbl(physicalDevice).GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
}
__attribute__((visibility("default")))
-VkResult vkQueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo) {
- return GetVtbl(queue).QueueBindSparseBufferMemory(queue, buffer, numBindings, pBindInfo);
+VkResult vkQueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, uint32_t bindInfoCount, const VkSparseMemoryBindInfo* pBindInfo) {
+ return GetVtbl(queue).QueueBindSparseBufferMemory(queue, buffer, bindInfoCount, pBindInfo);
}
__attribute__((visibility("default")))
-VkResult vkQueueBindSparseImageOpaqueMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo) {
- return GetVtbl(queue).QueueBindSparseImageOpaqueMemory(queue, image, numBindings, pBindInfo);
+VkResult vkQueueBindSparseImageOpaqueMemory(VkQueue queue, VkImage image, uint32_t bindInfoCount, const VkSparseMemoryBindInfo* pBindInfo) {
+ return GetVtbl(queue).QueueBindSparseImageOpaqueMemory(queue, image, bindInfoCount, pBindInfo);
}
__attribute__((visibility("default")))
-VkResult vkQueueBindSparseImageMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseImageMemoryBindInfo* pBindInfo) {
- return GetVtbl(queue).QueueBindSparseImageMemory(queue, image, numBindings, pBindInfo);
+VkResult vkQueueBindSparseImageMemory(VkQueue queue, VkImage image, uint32_t bindInfoCount, const VkSparseImageMemoryBindInfo* pBindInfo) {
+ return GetVtbl(queue).QueueBindSparseImageMemory(queue, image, bindInfoCount, pBindInfo);
}
__attribute__((visibility("default")))
-VkResult vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence) {
- return GetVtbl(device).CreateFence(device, pCreateInfo, pFence);
+VkResult vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFence* pFence) {
+ return GetVtbl(device).CreateFence(device, pCreateInfo, pAllocator, pFence);
}
__attribute__((visibility("default")))
-void vkDestroyFence(VkDevice device, VkFence fence) {
- GetVtbl(device).DestroyFence(device, fence);
+void vkDestroyFence(VkDevice device, VkFence fence, const VkAllocCallbacks* pAllocator) {
+ GetVtbl(device).DestroyFence(device, fence, pAllocator);
}
__attribute__((visibility("default")))
@@ -252,23 +252,23 @@
}
__attribute__((visibility("default")))
-VkResult vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore) {
- return GetVtbl(device).CreateSemaphore(device, pCreateInfo, pSemaphore);
+VkResult vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSemaphore* pSemaphore) {
+ return GetVtbl(device).CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
}
__attribute__((visibility("default")))
-void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore) {
- GetVtbl(device).DestroySemaphore(device, semaphore);
+void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocCallbacks* pAllocator) {
+ GetVtbl(device).DestroySemaphore(device, semaphore, pAllocator);
}
__attribute__((visibility("default")))
-VkResult vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent) {
- return GetVtbl(device).CreateEvent(device, pCreateInfo, pEvent);
+VkResult vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkEvent* pEvent) {
+ return GetVtbl(device).CreateEvent(device, pCreateInfo, pAllocator, pEvent);
}
__attribute__((visibility("default")))
-void vkDestroyEvent(VkDevice device, VkEvent event) {
- GetVtbl(device).DestroyEvent(device, event);
+void vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocCallbacks* pAllocator) {
+ GetVtbl(device).DestroyEvent(device, event, pAllocator);
}
__attribute__((visibility("default")))
@@ -287,13 +287,13 @@
}
__attribute__((visibility("default")))
-VkResult vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool) {
- return GetVtbl(device).CreateQueryPool(device, pCreateInfo, pQueryPool);
+VkResult vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkQueryPool* pQueryPool) {
+ return GetVtbl(device).CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
}
__attribute__((visibility("default")))
-void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool) {
- GetVtbl(device).DestroyQueryPool(device, queryPool);
+void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocCallbacks* pAllocator) {
+ GetVtbl(device).DestroyQueryPool(device, queryPool, pAllocator);
}
__attribute__((visibility("default")))
@@ -302,33 +302,33 @@
}
__attribute__((visibility("default")))
-VkResult vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer) {
- return GetVtbl(device).CreateBuffer(device, pCreateInfo, pBuffer);
+VkResult vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBuffer* pBuffer) {
+ return GetVtbl(device).CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
}
__attribute__((visibility("default")))
-void vkDestroyBuffer(VkDevice device, VkBuffer buffer) {
- GetVtbl(device).DestroyBuffer(device, buffer);
+void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocCallbacks* pAllocator) {
+ GetVtbl(device).DestroyBuffer(device, buffer, pAllocator);
}
__attribute__((visibility("default")))
-VkResult vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView) {
- return GetVtbl(device).CreateBufferView(device, pCreateInfo, pView);
+VkResult vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBufferView* pView) {
+ return GetVtbl(device).CreateBufferView(device, pCreateInfo, pAllocator, pView);
}
__attribute__((visibility("default")))
-void vkDestroyBufferView(VkDevice device, VkBufferView bufferView) {
- GetVtbl(device).DestroyBufferView(device, bufferView);
+void vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocCallbacks* pAllocator) {
+ GetVtbl(device).DestroyBufferView(device, bufferView, pAllocator);
}
__attribute__((visibility("default")))
-VkResult vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage) {
- return GetVtbl(device).CreateImage(device, pCreateInfo, pImage);
+VkResult vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImage* pImage) {
+ return GetVtbl(device).CreateImage(device, pCreateInfo, pAllocator, pImage);
}
__attribute__((visibility("default")))
-void vkDestroyImage(VkDevice device, VkImage image) {
- GetVtbl(device).DestroyImage(device, image);
+void vkDestroyImage(VkDevice device, VkImage image, const VkAllocCallbacks* pAllocator) {
+ GetVtbl(device).DestroyImage(device, image, pAllocator);
}
__attribute__((visibility("default")))
@@ -337,43 +337,43 @@
}
__attribute__((visibility("default")))
-VkResult vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView) {
- return GetVtbl(device).CreateImageView(device, pCreateInfo, pView);
+VkResult vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImageView* pView) {
+ return GetVtbl(device).CreateImageView(device, pCreateInfo, pAllocator, pView);
}
__attribute__((visibility("default")))
-void vkDestroyImageView(VkDevice device, VkImageView imageView) {
- GetVtbl(device).DestroyImageView(device, imageView);
+void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocCallbacks* pAllocator) {
+ GetVtbl(device).DestroyImageView(device, imageView, pAllocator);
}
__attribute__((visibility("default")))
-VkResult vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule) {
- return GetVtbl(device).CreateShaderModule(device, pCreateInfo, pShaderModule);
+VkResult vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkShaderModule* pShaderModule) {
+ return GetVtbl(device).CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
}
__attribute__((visibility("default")))
-void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule) {
- GetVtbl(device).DestroyShaderModule(device, shaderModule);
+void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocCallbacks* pAllocator) {
+ GetVtbl(device).DestroyShaderModule(device, shaderModule, pAllocator);
}
__attribute__((visibility("default")))
-VkResult vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader) {
- return GetVtbl(device).CreateShader(device, pCreateInfo, pShader);
+VkResult vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkShader* pShader) {
+ return GetVtbl(device).CreateShader(device, pCreateInfo, pAllocator, pShader);
}
__attribute__((visibility("default")))
-void vkDestroyShader(VkDevice device, VkShader shader) {
- GetVtbl(device).DestroyShader(device, shader);
+void vkDestroyShader(VkDevice device, VkShader shader, const VkAllocCallbacks* pAllocator) {
+ GetVtbl(device).DestroyShader(device, shader, pAllocator);
}
__attribute__((visibility("default")))
-VkResult vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache) {
- return GetVtbl(device).CreatePipelineCache(device, pCreateInfo, pPipelineCache);
+VkResult vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineCache* pPipelineCache) {
+ return GetVtbl(device).CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
}
__attribute__((visibility("default")))
-void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache) {
- GetVtbl(device).DestroyPipelineCache(device, pipelineCache);
+void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocCallbacks* pAllocator) {
+ GetVtbl(device).DestroyPipelineCache(device, pipelineCache, pAllocator);
}
__attribute__((visibility("default")))
@@ -387,58 +387,58 @@
}
__attribute__((visibility("default")))
-VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines) {
- return GetVtbl(device).CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pPipelines);
+VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines) {
+ return GetVtbl(device).CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
}
__attribute__((visibility("default")))
-VkResult vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines) {
- return GetVtbl(device).CreateComputePipelines(device, pipelineCache, count, pCreateInfos, pPipelines);
+VkResult vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines) {
+ return GetVtbl(device).CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
}
__attribute__((visibility("default")))
-void vkDestroyPipeline(VkDevice device, VkPipeline pipeline) {
- GetVtbl(device).DestroyPipeline(device, pipeline);
+void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocCallbacks* pAllocator) {
+ GetVtbl(device).DestroyPipeline(device, pipeline, pAllocator);
}
__attribute__((visibility("default")))
-VkResult vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout) {
- return GetVtbl(device).CreatePipelineLayout(device, pCreateInfo, pPipelineLayout);
+VkResult vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) {
+ return GetVtbl(device).CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
}
__attribute__((visibility("default")))
-void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout) {
- GetVtbl(device).DestroyPipelineLayout(device, pipelineLayout);
+void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocCallbacks* pAllocator) {
+ GetVtbl(device).DestroyPipelineLayout(device, pipelineLayout, pAllocator);
}
__attribute__((visibility("default")))
-VkResult vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler) {
- return GetVtbl(device).CreateSampler(device, pCreateInfo, pSampler);
+VkResult vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSampler* pSampler) {
+ return GetVtbl(device).CreateSampler(device, pCreateInfo, pAllocator, pSampler);
}
__attribute__((visibility("default")))
-void vkDestroySampler(VkDevice device, VkSampler sampler) {
- GetVtbl(device).DestroySampler(device, sampler);
+void vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocCallbacks* pAllocator) {
+ GetVtbl(device).DestroySampler(device, sampler, pAllocator);
}
__attribute__((visibility("default")))
-VkResult vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout) {
- return GetVtbl(device).CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
+VkResult vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) {
+ return GetVtbl(device).CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
}
__attribute__((visibility("default")))
-void vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout) {
- GetVtbl(device).DestroyDescriptorSetLayout(device, descriptorSetLayout);
+void vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocCallbacks* pAllocator) {
+ GetVtbl(device).DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
}
__attribute__((visibility("default")))
-VkResult vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool) {
- return GetVtbl(device).CreateDescriptorPool(device, pCreateInfo, pDescriptorPool);
+VkResult vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) {
+ return GetVtbl(device).CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
}
__attribute__((visibility("default")))
-void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool) {
- GetVtbl(device).DestroyDescriptorPool(device, descriptorPool);
+void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocCallbacks* pAllocator) {
+ GetVtbl(device).DestroyDescriptorPool(device, descriptorPool, pAllocator);
}
__attribute__((visibility("default")))
@@ -452,8 +452,8 @@
}
__attribute__((visibility("default")))
-VkResult vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets) {
- return GetVtbl(device).FreeDescriptorSets(device, descriptorPool, count, pDescriptorSets);
+VkResult vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) {
+ return GetVtbl(device).FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
}
__attribute__((visibility("default")))
@@ -462,23 +462,23 @@
}
__attribute__((visibility("default")))
-VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer) {
- return GetVtbl(device).CreateFramebuffer(device, pCreateInfo, pFramebuffer);
+VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFramebuffer* pFramebuffer) {
+ return GetVtbl(device).CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
}
__attribute__((visibility("default")))
-void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer) {
- GetVtbl(device).DestroyFramebuffer(device, framebuffer);
+void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocCallbacks* pAllocator) {
+ GetVtbl(device).DestroyFramebuffer(device, framebuffer, pAllocator);
}
__attribute__((visibility("default")))
-VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass) {
- return GetVtbl(device).CreateRenderPass(device, pCreateInfo, pRenderPass);
+VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkRenderPass* pRenderPass) {
+ return GetVtbl(device).CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
}
__attribute__((visibility("default")))
-void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass) {
- GetVtbl(device).DestroyRenderPass(device, renderPass);
+void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocCallbacks* pAllocator) {
+ GetVtbl(device).DestroyRenderPass(device, renderPass, pAllocator);
}
__attribute__((visibility("default")))
@@ -487,13 +487,13 @@
}
__attribute__((visibility("default")))
-VkResult vkCreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool) {
- return GetVtbl(device).CreateCommandPool(device, pCreateInfo, pCmdPool);
+VkResult vkCreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkCmdPool* pCmdPool) {
+ return GetVtbl(device).CreateCommandPool(device, pCreateInfo, pAllocator, pCmdPool);
}
__attribute__((visibility("default")))
-void vkDestroyCommandPool(VkDevice device, VkCmdPool cmdPool) {
- GetVtbl(device).DestroyCommandPool(device, cmdPool);
+void vkDestroyCommandPool(VkDevice device, VkCmdPool cmdPool, const VkAllocCallbacks* pAllocator) {
+ GetVtbl(device).DestroyCommandPool(device, cmdPool, pAllocator);
}
__attribute__((visibility("default")))
@@ -507,8 +507,8 @@
}
__attribute__((visibility("default")))
-void vkFreeCommandBuffers(VkDevice device, VkCmdPool cmdPool, uint32_t count, const VkCmdBuffer* pCommandBuffers) {
- GetVtbl(device).FreeCommandBuffers(device, cmdPool, count, pCommandBuffers);
+void vkFreeCommandBuffers(VkDevice device, VkCmdPool cmdPool, uint32_t commandBufferCount, const VkCmdBuffer* pCommandBuffers) {
+ GetVtbl(device).FreeCommandBuffers(device, cmdPool, commandBufferCount, pCommandBuffers);
}
__attribute__((visibility("default")))
@@ -577,8 +577,8 @@
}
__attribute__((visibility("default")))
-void vkCmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
- GetVtbl(cmdBuffer).CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+void vkCmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
+ GetVtbl(cmdBuffer).CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
}
__attribute__((visibility("default")))
@@ -602,13 +602,13 @@
}
__attribute__((visibility("default")))
-void vkCmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) {
- GetVtbl(cmdBuffer).CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
+void vkCmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
+ GetVtbl(cmdBuffer).CmdDrawIndirect(cmdBuffer, buffer, offset, drawCount, stride);
}
__attribute__((visibility("default")))
-void vkCmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) {
- GetVtbl(cmdBuffer).CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
+void vkCmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
+ GetVtbl(cmdBuffer).CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, drawCount, stride);
}
__attribute__((visibility("default")))
@@ -722,8 +722,8 @@
}
__attribute__((visibility("default")))
-void vkCmdPushConstants(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values) {
- GetVtbl(cmdBuffer).CmdPushConstants(cmdBuffer, layout, stageFlags, start, length, values);
+void vkCmdPushConstants(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* values) {
+ GetVtbl(cmdBuffer).CmdPushConstants(cmdBuffer, layout, stageFlags, offset, size, values);
}
__attribute__((visibility("default")))
@@ -762,13 +762,13 @@
}
__attribute__((visibility("default")))
-VkResult vkGetSurfaceFormatsKHR(VkDevice device, VkSurfaceKHR surface, uint32_t* pCount, VkSurfaceFormatKHR* pSurfaceFormats) {
- return GetVtbl(device).GetSurfaceFormatsKHR(device, surface, pCount, pSurfaceFormats);
+VkResult vkGetSurfaceFormatsKHR(VkDevice device, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) {
+ return GetVtbl(device).GetSurfaceFormatsKHR(device, surface, pSurfaceFormatCount, pSurfaceFormats);
}
__attribute__((visibility("default")))
-VkResult vkGetSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, uint32_t* pCount, VkPresentModeKHR* pPresentModes) {
- return GetVtbl(device).GetSurfacePresentModesKHR(device, surface, pCount, pPresentModes);
+VkResult vkGetSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) {
+ return GetVtbl(device).GetSurfacePresentModesKHR(device, surface, pPresentModeCount, pPresentModes);
}
__attribute__((visibility("default")))
@@ -782,8 +782,8 @@
}
__attribute__((visibility("default")))
-VkResult vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pCount, VkImage* pSwapchainImages) {
- return GetVtbl(device).GetSwapchainImagesKHR(device, swapchain, pCount, pSwapchainImages);
+VkResult vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) {
+ return GetVtbl(device).GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
}
__attribute__((visibility("default")))
diff --git a/vulkan/libvulkan/loader.cpp b/vulkan/libvulkan/loader.cpp
index a44026f..10877c5 100644
--- a/vulkan/libvulkan/loader.cpp
+++ b/vulkan/libvulkan/loader.cpp
@@ -22,8 +22,8 @@
#include <dirent.h>
#include <dlfcn.h>
#include <inttypes.h>
-#include <malloc.h>
#include <pthread.h>
+#include <stdlib.h>
#include <string.h>
// standard C++ headers
#include <algorithm>
@@ -58,7 +58,13 @@
// Define Handle typedef to be void* as returned from dlopen.
typedef void* SharedLibraryHandle;
-// Custom versions of std classes that use the vulkan alloc callback.
+// Standard-library allocator that delegates to VkAllocCallbacks.
+//
+// TODO(jessehall): This class currently always uses
+// VK_SYSTEM_ALLOC_SCOPE_INSTANCE. The scope to use could be a template
+// parameter or a constructor parameter. The former would help catch bugs
+// where we use the wrong scope, e.g. adding a command-scope string to an
+// instance-scope vector. But that might also be pretty annoying to deal with.
template <class T>
class CallbackAllocator {
public:
@@ -73,7 +79,7 @@
T* allocate(std::size_t n) {
void* mem = alloc->pfnAlloc(alloc->pUserData, n * sizeof(T), alignof(T),
- VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
return static_cast<T*>(mem);
}
@@ -208,8 +214,43 @@
return *reinterpret_cast<DeviceVtbl**>(queue);
}
-void* DefaultAlloc(void*, size_t size, size_t alignment, VkSystemAllocType) {
- return memalign(alignment, size);
+void* DefaultAlloc(void*, size_t size, size_t alignment, VkSystemAllocScope) {
+ void* ptr = nullptr;
+ // Vulkan requires 'alignment' to be a power of two, but posix_memalign
+ // additionally requires that it be at least sizeof(void*).
+ return posix_memalign(&ptr, std::max(alignment, sizeof(void*)), size) == 0
+ ? ptr
+ : nullptr;
+}
+
+void* DefaultRealloc(void*,
+ void* ptr,
+ size_t size,
+ size_t alignment,
+ VkSystemAllocScope) {
+ if (size == 0) {
+ free(ptr);
+ return nullptr;
+ }
+
+ // TODO(jessehall): Right now we never shrink allocations; if the new
+ // request is smaller than the existing chunk, we just continue using it.
+ // Right now the loader never reallocs, so this doesn't matter. If that
+ // changes, or if this code is copied into some other project, this should
+ // probably have a heuristic to allocate-copy-free when doing so will save
+ // "enough" space.
+ size_t old_size = ptr ? malloc_usable_size(ptr) : 0;
+ if (size <= old_size)
+ return ptr;
+
+ void* new_ptr = nullptr;
+ if (posix_memalign(&new_ptr, alignment, size) != 0)
+ return nullptr;
+ if (ptr) {
+ memcpy(new_ptr, ptr, std::min(old_size, size));
+ free(ptr);
+ }
+ return new_ptr;
}
void DefaultFree(void*, void* pMem) {
@@ -219,6 +260,7 @@
const VkAllocCallbacks kDefaultAllocCallbacks = {
.pUserData = nullptr,
.pfnAlloc = DefaultAlloc,
+ .pfnRealloc = DefaultRealloc,
.pfnFree = DefaultFree,
};
@@ -418,7 +460,7 @@
}
}
// Load app layers
- for (uint32_t i = 0; i < create_info->layerCount; ++i) {
+ for (uint32_t i = 0; i < create_info->enabledLayerNameCount; ++i) {
String layer_name(create_info->ppEnabledLayerNames[i],
string_allocator);
auto element = instance->layers.find(layer_name);
@@ -439,17 +481,18 @@
bool AddExtensionToCreateInfo(TCreateInfo& local_create_info,
const char* extension_name,
const VkAllocCallbacks* alloc) {
- for (uint32_t i = 0; i < local_create_info.extensionCount; ++i) {
+ for (uint32_t i = 0; i < local_create_info.enabledExtensionNameCount; ++i) {
if (!strcmp(extension_name,
local_create_info.ppEnabledExtensionNames[i])) {
return false;
}
}
- uint32_t extension_count = local_create_info.extensionCount;
- local_create_info.extensionCount++;
+ uint32_t extension_count = local_create_info.enabledExtensionNameCount;
+ local_create_info.enabledExtensionNameCount++;
void* mem = alloc->pfnAlloc(
- alloc->pUserData, local_create_info.extensionCount * sizeof(char*),
- alignof(char*), VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+ alloc->pUserData,
+ local_create_info.enabledExtensionNameCount * sizeof(char*),
+ alignof(char*), VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
if (mem) {
const char** enabled_extensions = static_cast<const char**>(mem);
for (uint32_t i = 0; i < extension_count; ++i) {
@@ -461,7 +504,7 @@
} else {
ALOGW("%s extension cannot be enabled: memory allocation failed",
extension_name);
- local_create_info.extensionCount--;
+ local_create_info.enabledExtensionNameCount--;
return false;
}
return true;
@@ -537,12 +580,14 @@
// "Bottom" functions. These are called at the end of the instance dispatch
// chain.
-void DestroyInstanceBottom(VkInstance instance) {
+void DestroyInstanceBottom(VkInstance instance,
+ const VkAllocCallbacks* allocator) {
// These checks allow us to call DestroyInstanceBottom from any error path
// in CreateInstanceBottom, before the driver instance is fully initialized.
if (instance->drv.vtbl.instance != VK_NULL_HANDLE &&
instance->drv.vtbl.DestroyInstance) {
- instance->drv.vtbl.DestroyInstance(instance->drv.vtbl.instance);
+ instance->drv.vtbl.DestroyInstance(instance->drv.vtbl.instance,
+ allocator);
}
if (instance->message) {
PFN_vkDbgDestroyMsgCallback DebugDestroyMessageCallback;
@@ -561,21 +606,22 @@
}
VkResult CreateInstanceBottom(const VkInstanceCreateInfo* create_info,
+ const VkAllocCallbacks* allocator,
VkInstance* instance_ptr) {
Instance* instance = *instance_ptr;
VkResult result;
- result =
- g_hwdevice->CreateInstance(create_info, &instance->drv.vtbl.instance);
+ result = g_hwdevice->CreateInstance(create_info, instance->alloc,
+ &instance->drv.vtbl.instance);
if (result != VK_SUCCESS) {
- DestroyInstanceBottom(instance);
+ DestroyInstanceBottom(instance, allocator);
return result;
}
if (!LoadInstanceVtbl(
instance->drv.vtbl.instance, instance->drv.vtbl.instance,
g_hwdevice->GetInstanceProcAddr, instance->drv.vtbl)) {
- DestroyInstanceBottom(instance);
+ DestroyInstanceBottom(instance, allocator);
return VK_ERROR_INITIALIZATION_FAILED;
}
@@ -587,7 +633,7 @@
"vkGetDeviceProcAddr"));
if (!instance->drv.GetDeviceProcAddr) {
ALOGE("missing instance proc: \"%s\"", "vkGetDeviceProcAddr");
- DestroyInstanceBottom(instance);
+ DestroyInstanceBottom(instance, allocator);
return VK_ERROR_INITIALIZATION_FAILED;
}
@@ -600,7 +646,7 @@
} else {
ALOGE("invalid VkInstance dispatch magic: 0x%" PRIxPTR,
dispatch->magic);
- DestroyInstanceBottom(instance);
+ DestroyInstanceBottom(instance, allocator);
return VK_ERROR_INITIALIZATION_FAILED;
}
@@ -608,7 +654,7 @@
result = instance->drv.vtbl.EnumeratePhysicalDevices(
instance->drv.vtbl.instance, &num_physical_devices, nullptr);
if (result != VK_SUCCESS) {
- DestroyInstanceBottom(instance);
+ DestroyInstanceBottom(instance, allocator);
return VK_ERROR_INITIALIZATION_FAILED;
}
num_physical_devices = std::min(num_physical_devices, kMaxPhysicalDevices);
@@ -616,7 +662,7 @@
instance->drv.vtbl.instance, &num_physical_devices,
instance->physical_devices);
if (result != VK_SUCCESS) {
- DestroyInstanceBottom(instance);
+ DestroyInstanceBottom(instance, allocator);
return VK_ERROR_INITIALIZATION_FAILED;
}
for (uint32_t i = 0; i < num_physical_devices; i++) {
@@ -625,7 +671,7 @@
if (dispatch->magic != HWVULKAN_DISPATCH_MAGIC) {
ALOGE("invalid VkPhysicalDevice dispatch magic: 0x%" PRIxPTR,
dispatch->magic);
- DestroyInstanceBottom(instance);
+ DestroyInstanceBottom(instance, allocator);
return VK_ERROR_INITIALIZATION_FAILED;
}
dispatch->vtbl = instance->vtbl;
@@ -696,13 +742,21 @@
VkResult CreateDeviceBottom(VkPhysicalDevice pdev,
const VkDeviceCreateInfo* create_info,
+ const VkAllocCallbacks* allocator,
VkDevice* out_device) {
Instance& instance = *static_cast<Instance*>(GetVtbl(pdev)->instance);
VkResult result;
- void* mem = instance.alloc->pfnAlloc(instance.alloc->pUserData,
- sizeof(Device), alignof(Device),
- VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
+ if (!allocator) {
+ if (instance.alloc)
+ allocator = instance.alloc;
+ else
+ allocator = &kDefaultAllocCallbacks;
+ }
+
+ void* mem =
+ allocator->pfnAlloc(allocator->pUserData, sizeof(Device),
+ alignof(Device), VK_SYSTEM_ALLOC_SCOPE_DEVICE);
if (!mem)
return VK_ERROR_OUT_OF_HOST_MEMORY;
Device* device = new (mem) Device(&instance);
@@ -714,7 +768,8 @@
}
VkDevice drv_device;
- result = instance.drv.vtbl.CreateDevice(pdev, create_info, &drv_device);
+ result = instance.drv.vtbl.CreateDevice(pdev, create_info, allocator,
+ &drv_device);
if (result != VK_SUCCESS) {
DestroyDevice(device);
return result;
@@ -727,7 +782,7 @@
PFN_vkDestroyDevice destroy_device =
reinterpret_cast<PFN_vkDestroyDevice>(
instance.drv.GetDeviceProcAddr(drv_device, "vkDestroyDevice"));
- destroy_device(drv_device);
+ destroy_device(drv_device, allocator);
DestroyDevice(device);
return VK_ERROR_INITIALIZATION_FAILED;
}
@@ -778,7 +833,7 @@
reinterpret_cast<PFN_vkCreateDevice>(
device->vtbl_storage.GetDeviceProcAddr(drv_device,
"vkCreateDevice"));
- layer_createDevice(pdev, create_info, &drv_device);
+ layer_createDevice(pdev, create_info, allocator, &drv_device);
// TODO(mlentine) : This is needed to use WSI layer validation. Remove this
// when new version of layer initialization exits.
@@ -896,23 +951,25 @@
}
VkResult CreateInstance(const VkInstanceCreateInfo* create_info,
+ const VkAllocCallbacks* allocator,
VkInstance* out_instance) {
VkResult result;
if (!EnsureInitialized())
return VK_ERROR_INITIALIZATION_FAILED;
+ if (!allocator)
+ allocator = &kDefaultAllocCallbacks;
+
VkInstanceCreateInfo local_create_info = *create_info;
- if (!local_create_info.pAllocCb)
- local_create_info.pAllocCb = &kDefaultAllocCallbacks;
create_info = &local_create_info;
- void* instance_mem = create_info->pAllocCb->pfnAlloc(
- create_info->pAllocCb->pUserData, sizeof(Instance), alignof(Instance),
- VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
+ void* instance_mem =
+ allocator->pfnAlloc(allocator->pUserData, sizeof(Instance),
+ alignof(Instance), VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
if (!instance_mem)
return VK_ERROR_OUT_OF_HOST_MEMORY;
- Instance* instance = new (instance_mem) Instance(create_info->pAllocCb);
+ Instance* instance = new (instance_mem) Instance(allocator);
instance->vtbl_storage = kBottomInstanceFunctions;
instance->vtbl_storage.instance = instance;
@@ -930,7 +987,7 @@
result = ActivateAllLayers(create_info, instance, instance);
if (result != VK_SUCCESS) {
- DestroyInstanceBottom(instance);
+ DestroyInstanceBottom(instance, allocator);
return result;
}
@@ -973,7 +1030,7 @@
if (!LoadInstanceVtbl(static_cast<VkInstance>(base_object),
static_cast<VkInstance>(next_object),
next_get_proc_addr, instance->vtbl_storage)) {
- DestroyInstanceBottom(instance);
+ DestroyInstanceBottom(instance, allocator);
return VK_ERROR_INITIALIZATION_FAILED;
}
@@ -988,7 +1045,8 @@
}
*out_instance = instance;
- result = instance->vtbl_storage.CreateInstance(create_info, out_instance);
+ result = instance->vtbl_storage.CreateInstance(create_info, allocator,
+ out_instance);
if (enable_callback)
FreeAllocatedCreateInfo(local_create_info, instance->alloc);
if (result <= 0) {
@@ -1079,7 +1137,7 @@
VkResult result = vtbl->AllocCommandBuffers(device, alloc_info, cmdbuffers);
if (result != VK_SUCCESS)
return result;
- for (uint32_t i = 0; i < alloc_info->count; i++) {
+ for (uint32_t i = 0; i < alloc_info->bufferCount; i++) {
hwvulkan_dispatch_t* dispatch =
reinterpret_cast<hwvulkan_dispatch_t*>(cmdbuffers[i]);
ALOGE_IF(dispatch->magic != HWVULKAN_DISPATCH_MAGIC,
@@ -1090,14 +1148,15 @@
return VK_SUCCESS;
}
-VkResult DestroyDevice(VkDevice drv_device) {
+VkResult DestroyDevice(VkDevice drv_device,
+ const VkAllocCallbacks* /*allocator*/) {
const DeviceVtbl* vtbl = GetVtbl(drv_device);
Device* device = static_cast<Device*>(vtbl->device);
for (auto it = device->active_layers.begin();
it != device->active_layers.end(); ++it) {
DeactivateLayer(device->instance, it);
}
- vtbl->DestroyDevice(drv_device);
+ vtbl->DestroyDevice(drv_device, device->instance->alloc);
DestroyDevice(device);
return VK_SUCCESS;
}
@@ -1105,9 +1164,9 @@
void* AllocMem(VkInstance instance,
size_t size,
size_t align,
- VkSystemAllocType type) {
+ VkSystemAllocScope scope) {
const VkAllocCallbacks* alloc_cb = instance->alloc;
- return alloc_cb->pfnAlloc(alloc_cb->pUserData, size, align, type);
+ return alloc_cb->pfnAlloc(alloc_cb->pUserData, size, align, scope);
}
void FreeMem(VkInstance instance, void* ptr) {
@@ -1118,10 +1177,10 @@
void* AllocMem(VkDevice device,
size_t size,
size_t align,
- VkSystemAllocType type) {
+ VkSystemAllocScope scope) {
const VkAllocCallbacks* alloc_cb =
static_cast<Device*>(GetVtbl(device)->device)->instance->alloc;
- return alloc_cb->pfnAlloc(alloc_cb->pUserData, size, align, type);
+ return alloc_cb->pfnAlloc(alloc_cb->pUserData, size, align, scope);
}
void FreeMem(VkDevice device, void* ptr) {
diff --git a/vulkan/libvulkan/loader.h b/vulkan/libvulkan/loader.h
index 15e2779..e166887 100644
--- a/vulkan/libvulkan/loader.h
+++ b/vulkan/libvulkan/loader.h
@@ -216,6 +216,7 @@
VkResult EnumerateInstanceLayerProperties(uint32_t* count,
VkLayerProperties* properties);
VkResult CreateInstance(const VkInstanceCreateInfo* create_info,
+ const VkAllocCallbacks* pAllocator,
VkInstance* instance);
PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* name);
PFN_vkVoidFunction GetDeviceProcAddr(VkDevice drv_device, const char* name);
@@ -226,17 +227,17 @@
VkResult AllocCommandBuffers(VkDevice device,
const VkCmdBufferAllocInfo* alloc_info,
VkCmdBuffer* cmdbuffers);
-VkResult DestroyDevice(VkDevice drv_device);
+VkResult DestroyDevice(VkDevice drv_device, const VkAllocCallbacks* pAllocator);
void* AllocMem(VkInstance instance,
size_t size,
size_t align,
- VkSystemAllocType type);
+ VkSystemAllocScope scope);
void FreeMem(VkInstance instance, void* ptr);
void* AllocMem(VkDevice device,
size_t size,
size_t align,
- VkSystemAllocType type);
+ VkSystemAllocScope scope);
void FreeMem(VkDevice device, void* ptr);
const DeviceVtbl& GetDriverVtbl(VkDevice device);
const DeviceVtbl& GetDriverVtbl(VkQueue queue);
diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp
index 2922465..f6ab081 100644
--- a/vulkan/libvulkan/swapchain.cpp
+++ b/vulkan/libvulkan/swapchain.cpp
@@ -49,6 +49,19 @@
void operator()(T* obj) { obj->common.decRef(&obj->common); }
};
+template <typename Host>
+struct AllocScope {};
+
+template <>
+struct AllocScope<VkInstance> {
+ static const VkSystemAllocScope kScope = VK_SYSTEM_ALLOC_SCOPE_INSTANCE;
+};
+
+template <>
+struct AllocScope<VkDevice> {
+ static const VkSystemAllocScope kScope = VK_SYSTEM_ALLOC_SCOPE_DEVICE;
+};
+
template <typename T, typename Host>
class VulkanAllocator {
public:
@@ -62,7 +75,7 @@
T* allocate(size_t n) const {
return static_cast<T*>(AllocMem(host_, n * sizeof(T), alignof(T),
- VK_SYSTEM_ALLOC_TYPE_INTERNAL));
+ AllocScope<Host>::kScope));
}
void deallocate(T* p, size_t) const { return FreeMem(host_, p); }
@@ -129,7 +142,7 @@
ANativeWindow* window,
VkSurfaceKHR* out_surface) {
void* mem = AllocMem(instance, sizeof(Surface), alignof(Surface),
- VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
+ VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (!mem)
return VK_ERROR_OUT_OF_HOST_MEMORY;
Surface* surface = new (mem) Surface;
@@ -362,7 +375,7 @@
// After this point, we must deallocate the swapchain on error.
void* mem = AllocMem(device, sizeof(Swapchain), alignof(Swapchain),
- VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
+ VK_SYSTEM_ALLOC_SCOPE_OBJECT);
if (!mem)
return VK_ERROR_OUT_OF_HOST_MEMORY;
Swapchain* swapchain = new (mem) Swapchain(surface, num_images);
@@ -391,7 +404,7 @@
.usage = create_info->imageUsageFlags,
.flags = 0,
.sharingMode = create_info->sharingMode,
- .queueFamilyCount = create_info->queueFamilyCount,
+ .queueFamilyIndexCount = create_info->queueFamilyIndexCount,
.pQueueFamilyIndices = create_info->pQueueFamilyIndices,
};
@@ -418,7 +431,8 @@
image_native_buffer.format = img.buffer->format;
image_native_buffer.usage = img.buffer->usage;
- result = driver_vtbl.CreateImage(device, &image_create, &img.image);
+ result =
+ driver_vtbl.CreateImage(device, &image_create, nullptr, &img.image);
if (result != VK_SUCCESS) {
ALOGD("vkCreateImage w/ native buffer failed: %u", result);
break;
@@ -441,7 +455,7 @@
}
if (result != VK_SUCCESS) {
if (img.image)
- driver_vtbl.DestroyImage(device, img.image);
+ driver_vtbl.DestroyImage(device, img.image, nullptr);
}
}
@@ -469,7 +483,7 @@
img.dequeued = false;
}
if (img.image) {
- driver_vtbl.DestroyImage(device, img.image);
+ driver_vtbl.DestroyImage(device, img.image, nullptr);
}
}
@@ -592,7 +606,7 @@
VkResult final_result = VK_SUCCESS;
for (uint32_t sc = 0; sc < present_info->swapchainCount; sc++) {
Swapchain& swapchain =
- *SwapchainFromHandle(present_info->swapchains[sc]);
+ *SwapchainFromHandle(present_info->pSwapchains[sc]);
ANativeWindow* window = swapchain.surface.window.get();
uint32_t image_idx = present_info->imageIndices[sc];
Swapchain::Image& img = swapchain.images[image_idx];