vulkan.h: V136 -- Vulkan Sparse Resource Issues

Totally reworked sparse resources.  This commit also incorporates the
changes for bug 14237.

12 files changed, 307 insertions, 104 deletions

diff --git a/icd/nulldrv/nulldrv.c b/icd/nulldrv/nulldrv.c
index 317a0c6c..f8ded2e0 100644
--- a/icd/nulldrv/nulldrv.c
+++ b/icd/nulldrv/nulldrv.c
@@ -1682,24 +1682,55 @@ ICD_EXPORT VkResult VKAPI vkBindObjectMemory(
     return VK_SUCCESS;
 }
 
+ICD_EXPORT VkResult VKAPI vkGetImageSparseMemoryRequirements(
+    VkDevice                                    device,
+    VkImage                                     image,
+    uint32_t*                                   pNumRequirements,
+    VkSparseImageMemoryRequirements*            pSparseMemoryRequirements)
+{
+    NULLDRV_LOG_FUNC;
+    return VK_SUCCESS;
+}
+
+ICD_EXPORT VkResult VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(
+    VkPhysicalDevice                            physicalDevice,
+    VkFormat                                    format,
+    VkImageType                                 type,
+    uint32_t                                    samples,
+    VkImageUsageFlags                           usage,
+    VkImageTiling                               tiling,
+    uint32_t*                                   pNumProperties,
+    VkSparseImageFormatProperties*              pProperties)
+{
+    NULLDRV_LOG_FUNC;
+    return VK_SUCCESS;
+}
+
 ICD_EXPORT VkResult VKAPI vkQueueBindSparseBufferMemory(
     VkQueue                                     queue,
     VkBuffer                                    buffer,
-    VkDeviceSize                                rangeOffset,
-    VkDeviceSize                                rangeSize,
-    VkDeviceMemory                              mem,
-    VkDeviceSize                                memOffset)
+    uint32_t                                    numBindings,
+    const VkSparseMemoryBindInfo*               pBindInfo)
+{
+    NULLDRV_LOG_FUNC;
+    return VK_SUCCESS;
+}
+
+ICD_EXPORT VkResult VKAPI vkQueueBindSparseImageOpaqueMemory(
+    VkQueue                                     queue,
+    VkImage                                     image,
+    uint32_t                                    numBindings,
+    const VkSparseMemoryBindInfo*               pBindInfo)
 {
     NULLDRV_LOG_FUNC;
     return VK_SUCCESS;
 }
 
 ICD_EXPORT VkResult VKAPI vkQueueBindSparseImageMemory(
-    VkQueue                                   queue,
-    VkImage                                   image,
-    const VkImageMemoryBindInfo*              pBindInfo,
-    VkDeviceMemory                            mem,
-    VkDeviceSize                              memOffset)
+    VkQueue                                     queue,
+    VkImage                                     image,
+    uint32_t                                    numBindings,
+    const VkSparseImageMemoryBindInfo*          pBindInfo)
 {
     NULLDRV_LOG_FUNC;
     return VK_SUCCESS;
diff --git a/include/vk_layer.h b/include/vk_layer.h
index 98a636bc..c2c54658 100644
--- a/include/vk_layer.h
+++ b/include/vk_layer.h
@@ -43,7 +43,9 @@ typedef struct VkLayerDispatchTable_
     PFN_vkDestroyObject DestroyObject;
     PFN_vkGetObjectMemoryRequirements GetObjectMemoryRequirements;
     PFN_vkBindObjectMemory BindObjectMemory;
+    PFN_vkGetImageSparseMemoryRequirements GetImageSparseMemoryRequirements;
     PFN_vkQueueBindSparseBufferMemory QueueBindSparseBufferMemory;
+    PFN_vkQueueBindSparseImageOpaqueMemory QueueBindSparseImageOpaqueMemory;
     PFN_vkQueueBindSparseImageMemory QueueBindSparseImageMemory;
     PFN_vkCreateFence CreateFence;
     PFN_vkGetFenceStatus GetFenceStatus;
@@ -145,6 +147,7 @@ typedef struct VkLayerInstanceDispatchTable_
     PFN_vkGetPhysicalDeviceFeatures GetPhysicalDeviceFeatures;
     PFN_vkGetPhysicalDeviceFormatInfo GetPhysicalDeviceFormatInfo;
     PFN_vkGetPhysicalDeviceLimits GetPhysicalDeviceLimits;
+    PFN_vkGetPhysicalDeviceSparseImageFormatProperties GetPhysicalDeviceSparseImageFormatProperties;
     PFN_vkGetPhysicalDeviceProperties GetPhysicalDeviceProperties;
     PFN_vkGetPhysicalDevicePerformance GetPhysicalDevicePerformance;
     PFN_vkGetPhysicalDeviceQueueCount GetPhysicalDeviceQueueCount;
diff --git a/include/vulkan.h b/include/vulkan.h
index 38567929..9f3a8c44 100644
--- a/include/vulkan.h
+++ b/include/vulkan.h
@@ -33,7 +33,7 @@
 #include "vk_platform.h"
 
 // Vulkan API version supported by this file
-#define VK_API_VERSION VK_MAKE_VERSION(0, 121, 0)
+#define VK_API_VERSION VK_MAKE_VERSION(0, 136, 0)
 
 #ifdef __cplusplus
 extern "C"
@@ -205,8 +205,9 @@ typedef enum VkImageAspect_
     VK_IMAGE_ASPECT_COLOR                                   = 0x00000000,
     VK_IMAGE_ASPECT_DEPTH                                   = 0x00000001,
     VK_IMAGE_ASPECT_STENCIL                                 = 0x00000002,
+    VK_IMAGE_ASPECT_METADATA                                = 0x00000003,
 
-    VK_ENUM_RANGE(IMAGE_ASPECT, COLOR, STENCIL)
+    VK_ENUM_RANGE(IMAGE_ASPECT, COLOR, METADATA)
 } VkImageAspect;
 
 typedef enum VkBufferViewType_
@@ -960,6 +961,8 @@ typedef VkFlags VkBufferCreateFlags;
 typedef enum VkBufferCreateFlagBits_
 {
     VK_BUFFER_CREATE_SPARSE_BIT                             = VK_BIT(0),    // Buffer should support sparse backing
+    VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT                   = VK_BIT(1),    // Buffer should support sparse backing with partial residency
+    VK_BUFFER_CREATE_SPARSE_ALIASED_BIT                     = VK_BIT(2),    // Buffer should support consistent data access to physical memoryblocks mapped into multiple locations of sparse buffers
 } VkBufferCreateFlagBits;
 
 // Shader stage flags
@@ -994,10 +997,12 @@ typedef enum VkImageUsageFlagBits_
 typedef VkFlags VkImageCreateFlags;
 typedef enum VkImageCreateFlagBits_
 {
-    VK_IMAGE_CREATE_INVARIANT_DATA_BIT                      = VK_BIT(0),
-    VK_IMAGE_CREATE_SPARSE_BIT                              = VK_BIT(1),    // Image should support sparse backing
-    VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT                      = VK_BIT(2),    // Allows image views to have different format than the base image
-    VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT                     = VK_BIT(3),    // Allows creating image views with cube type from the created image
+    VK_IMAGE_CREATE_SPARSE_BIT                              = VK_BIT(0),    // Image should support sparse backing
+    VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT                    = VK_BIT(1),    // Image should support sparse backing with partial residency
+    VK_IMAGE_CREATE_SPARSE_ALIASED_BIT                      = VK_BIT(2),    // Image should support constant data access to physical memoryblocks mapped into multiple locations fo sparse images
+    VK_IMAGE_CREATE_INVARIANT_DATA_BIT                      = VK_BIT(3),
+    VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT                      = VK_BIT(4),    // Allows image views to have different format than the base image
+    VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT                     = VK_BIT(5),    // Allows creating image views with cube type from the created image
 } VkImageCreateFlagBits;
 
 // Depth-stencil view creation flags
@@ -1033,6 +1038,22 @@ typedef enum VkFenceCreateFlagBits_
     VK_FENCE_CREATE_SIGNALED_BIT                            = VK_BIT(0),
 } VkFenceCreateFlagBits;
 
+// Sparse image format flags
+typedef VkFlags VkSparseImageFormatFlags;
+typedef enum VkSparseImageFormatFlagBits_
+{
+    VK_SPARSE_IMAGE_FMT_SINGLE_MIPTAIL_BIT                  = VK_BIT(0),
+    VK_SPARSE_IMAGE_FMT_ALIGNED_MIP_SIZE_BIT                = VK_BIT(1),
+    VK_SPARSE_IMAGE_FMT_NONSTD_BLOCK_SIZE_BIT               = VK_BIT(2),
+} VkSparseImageFormatFlagBits;
+
+// Sparse memory bind flags
+typedef VkFlags VkSparseMemoryBindFlags;
+typedef enum VkSparseMemoryBindFlagBits_
+{
+    VK_SPARSE_MEMORY_BIND_REPLICATE_64KIB_BLOCK_BIT         = VK_BIT(0),
+} VkSparseMemoryBindFlagBits;
+
 // Semaphore creation flags
 typedef VkFlags VkSemaphoreCreateFlags;
 
@@ -1263,6 +1284,23 @@ typedef struct VkPhysicalDeviceFeatures_
     bool32_t                                    shaderInt64;
     bool32_t                                    shaderFloat16;
     bool32_t                                    shaderInt16;
+    bool32_t                                    shaderResourceResidency;
+    bool32_t                                    shaderResourceMinLOD;
+    bool32_t                                    sparse;
+    bool32_t                                    sparseResidencyBuffer;
+    bool32_t                                    sparseResidencyImage2D;
+    bool32_t                                    sparseResidencyImage3D;
+    bool32_t                                    sparseResidency2Samples;
+    bool32_t                                    sparseResidency4Samples;
+    bool32_t                                    sparseResidency8Samples;
+    bool32_t                                    sparseResidency16Samples;
+    bool32_t                                    sparseResidencyStandard2DBlockShape;
+    bool32_t                                    sparseResidencyStandard2DMSBlockShape;
+    bool32_t                                    sparseResidencyStandard3DBlockShape;
+    bool32_t                                    sparseResidencyAlignedMipSize;
+    bool32_t                                    sparseResidencyNonResident;
+    bool32_t                                    sparseResidencyNonResidentStrict;
+    bool32_t                                    sparseResidencyAliased;
 } VkPhysicalDeviceFeatures;
 
 typedef struct VkPhysicalDeviceLimits_
@@ -1498,6 +1536,37 @@ typedef struct VkMemoryRequirements_
     uint32_t                                    memoryTypeBits;             // Bitfield of the allowed memory type indices into memoryTypes[] for this object
 } VkMemoryRequirements;
 
+typedef struct VkSparseImageFormatProperties_
+{
+    VkImageAspect                               aspect;
+    VkExtent3D                                  imageGranularity;
+    VkSparseImageFormatFlags                    flags;
+} VkSparseImageFormatProperties;
+
+typedef struct VkSparseImageMemoryRequirements_
+{
+    VkSparseImageFormatProperties               formatProps;
+    uint32_t                                    imageMipTailStartLOD;
+    VkDeviceSize                                imageMipTailSize;
+    VkDeviceSize                                imageMipTailOffset;
+    VkDeviceSize                                imageMipTailStride;
+} VkSparseImageMemoryRequirements;
+
+typedef struct VkImageSubresource_
+{
+    VkImageAspect                               aspect;
+    uint32_t                                    mipLevel;
+    uint32_t                                    arraySlice;
+} VkImageSubresource;
+
+typedef struct VkSparseMemoryBindInfo
+{
+    VkDeviceSize                                offset;
+    VkDeviceSize                                memOffset;
+    VkDeviceMemory                              mem;
+    VkSparseMemoryBindFlags                     flags;
+} VkSparseMemoryBindInfo;
+
 typedef struct VkFormatProperties_
 {
     VkFormatFeatureFlags                        linearTilingFeatures;       // Format features in case of linear tiling
@@ -1563,13 +1632,6 @@ typedef struct VkBufferViewCreateInfo_
     VkDeviceSize                                range;                      // View size specified in bytes
 } VkBufferViewCreateInfo;
 
-typedef struct VkImageSubresource_
-{
-    VkImageAspect                               aspect;
-    uint32_t                                    mipLevel;
-    uint32_t                                    arraySlice;
-} VkImageSubresource;
-
 typedef struct VkImageSubresourceRange_
 {
     VkImageAspect                               aspect;
@@ -1695,12 +1757,15 @@ typedef struct VkBufferCopy_
     VkDeviceSize                                copySize;               // Specified in bytes
 } VkBufferCopy;
 
-typedef struct VkImageMemoryBindInfo_
+typedef struct VkSparseImageMemoryBindInfo_
 {
     VkImageSubresource                          subresource;
     VkOffset3D                                  offset;
     VkExtent3D                                  extent;
-} VkImageMemoryBindInfo;
+    VkDeviceSize                                memOffset;
+    VkDeviceMemory                              mem;
+    VkSparseMemoryBindFlags                     flags;
+} VkSparseImageMemoryBindInfo;
 
 typedef struct VkImageCopy_
 {
@@ -2180,7 +2245,7 @@ typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice phy
 typedef VkResult (VKAPI *PFN_vkGetPhysicalDevicePerformance)(VkPhysicalDevice physicalDevice, VkPhysicalDevicePerformance* pPerformance);
 typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceQueueCount)(VkPhysicalDevice physicalDevice, uint32_t* pCount);
 typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceQueueProperties)(VkPhysicalDevice physicalDevice, uint32_t count, VkPhysicalDeviceQueueProperties* pQueueProperties);
-typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperies);
+typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
 typedef VkResult (VKAPI *PFN_vkGetGlobalExtensionProperties)(const char * pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);
 typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t *pCount, VkExtensionProperties* pProperties);
 typedef VkResult (VKAPI *PFN_vkGetGlobalLayerProperties)(uint32_t* pCount, VkLayerProperties* pProperties);
@@ -2198,8 +2263,11 @@ typedef VkResult (VKAPI *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, ui
 typedef VkResult (VKAPI *PFN_vkDestroyObject)(VkDevice device, VkObjectType objType, VkObject object);
 typedef VkResult (VKAPI *PFN_vkGetObjectMemoryRequirements)(VkDevice device, VkObjectType objType, VkObject object, VkMemoryRequirements* pMemoryRequirements);
 typedef VkResult (VKAPI *PFN_vkBindObjectMemory)(VkDevice device, VkObjectType objType, VkObject object, VkDeviceMemory mem, VkDeviceSize offset);
-typedef VkResult (VKAPI *PFN_vkQueueBindSparseBufferMemory)(VkQueue queue, VkBuffer buffer, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset);
-typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageMemory)(VkQueue queue, VkImage image, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset);
+typedef VkResult (VKAPI *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties);
+typedef VkResult (VKAPI *PFN_vkQueueBindSparseBufferMemory)(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo);
+typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageOpaqueMemory)(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo);
+typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageMemory)(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseImageMemoryBindInfo* pBindInfo);
 typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence);
 typedef VkResult (VKAPI *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
 typedef VkResult (VKAPI *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
@@ -2445,20 +2513,39 @@ VkResult VKAPI vkGetObjectMemoryRequirements(
     VkObject                                    object,
     VkMemoryRequirements*                       pMemoryRequirements);
 
+VkResult VKAPI vkGetImageSparseMemoryRequirements(
+    VkDevice                                    device,
+    VkImage                                     image,
+    uint32_t*                                   pNumRequirements,
+    VkSparseImageMemoryRequirements*            pSparseMemoryRequirements);
+
+VkResult VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(
+    VkPhysicalDevice                            physicalDevice,
+    VkFormat                                    format,
+    VkImageType                                 type,
+    uint32_t                                    samples,
+    VkImageUsageFlags                           usage,
+    VkImageTiling                               tiling,
+    uint32_t*                                   pNumProperties,
+    VkSparseImageFormatProperties*              pProperties);
+
 VkResult VKAPI vkQueueBindSparseBufferMemory(
     VkQueue                                     queue,
     VkBuffer                                    buffer,
-    VkDeviceSize                                rangeOffset,
-    VkDeviceSize                                rangeSize,
-    VkDeviceMemory                              mem,
-    VkDeviceSize                                memOffset);
+    uint32_t                                    numBindings,
+    const VkSparseMemoryBindInfo*               pBindInfo);
+
+VkResult VKAPI vkQueueBindSparseImageOpaqueMemory(
+    VkQueue                                     queue,
+    VkImage                                     image,
+    uint32_t                                    numBindings,
+    const VkSparseMemoryBindInfo*               pBindInfo);
 
 VkResult VKAPI vkQueueBindSparseImageMemory(
     VkQueue                                     queue,
     VkImage                                     image,
-    const VkImageMemoryBindInfo*                pBindInfo,
-    VkDeviceMemory                              mem,
-    VkDeviceSize                                memOffset);
+    uint32_t                                    numBindings,
+    const VkSparseImageMemoryBindInfo*          pBindInfo);
 
 // Fence functions
 
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index f873a822..e7a55000 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -1191,20 +1191,18 @@ VK_LAYER_EXPORT VkResult VKAPI vkBindObjectMemory(
 }
 
 VK_LAYER_EXPORT VkResult VKAPI vkQueueBindSparseBufferMemory(
-    VkQueue        queue,
-    VkBuffer       buffer,
-    VkDeviceSize   rangeOffset,
-    VkDeviceSize   rangeSize,
-    VkDeviceMemory mem,
-    VkDeviceSize   memOffset)
+    VkQueue                       queue,
+    VkBuffer                      buffer,
+    uint32_t                      numBindings,
+    const VkSparseMemoryBindInfo* pBindInfo)
 {
     VkResult result = get_dispatch_table(mem_tracker_device_table_map, queue)->QueueBindSparseBufferMemory(
-        queue, buffer, rangeOffset, rangeSize, mem, memOffset);
+        queue, buffer, numBindings, pBindInfo);
     loader_platform_thread_lock_mutex(&globalLock);
     // Track objects tied to memory
-    if (VK_FALSE == set_sparse_buffer_binding(buffer, mem)) {
+    if (VK_FALSE == set_sparse_buffer_binding(buffer, pBindInfo->mem)) {
         log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_BUFFER, buffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM",
-                "Unable to set object %p binding to mem obj %p", (void*)buffer, (void*)mem);
+                "Unable to set object %p binding to mem obj %p", (void*)buffer, (void*)pBindInfo->mem);
     }
     print_object_list(queue);
     print_mem_list(queue);
diff --git a/layers/object_track.h b/layers/object_track.h
index 8dcffcf0..cc751872 100644
--- a/layers/object_track.h
+++ b/layers/object_track.h
@@ -688,38 +688,49 @@ explicit_GetObjectMemoryRequirements(
 
 VkResult
 explicit_QueueBindSparseBufferMemory(
-    VkQueue        queue,
-    VkBuffer       buffer,
-    VkDeviceSize   rangeOffset,
-    VkDeviceSize   rangeSize,
-    VkDeviceMemory mem,
-    VkDeviceSize   memOffset)
+    VkQueue                       queue,
+    VkBuffer                      buffer,
+    uint32_t                      numBindings,
+    const VkSparseMemoryBindInfo* pBindInfo)
 {
     loader_platform_thread_lock_mutex(&objLock);
     validateQueueFlags(queue, "QueueBindSparseBufferMemory");
     validate_object(queue, buffer);
     loader_platform_thread_unlock_mutex(&objLock);
 
-    VkResult result = get_dispatch_table(ObjectTracker_device_table_map, queue)->QueueBindSparseBufferMemory(queue, buffer, rangeOffset, rangeSize, mem, memOffset);
+    VkResult result = get_dispatch_table(ObjectTracker_device_table_map, queue)->QueueBindSparseBufferMemory(queue, buffer, numBindings, pBindInfo);
     return result;
 }
 
 VkResult
 explicit_QueueBindSparseImageMemory(
-    VkQueue                      queue,
-    VkImage                      image,
-    const VkImageMemoryBindInfo *pBindInfo,
-    VkDeviceMemory               mem,
-    VkDeviceSize                 memOffset)
+    VkQueue                            queue,
+    VkImage                            image,
+    uint32_t                           numBindings,
+    const VkSparseImageMemoryBindInfo* pBindInfo)
 {
     loader_platform_thread_lock_mutex(&objLock);
     validateQueueFlags(queue, "QueueBindSparseImageMemory");
     loader_platform_thread_unlock_mutex(&objLock);
 
-    VkResult result = get_dispatch_table(ObjectTracker_device_table_map, queue)->QueueBindSparseImageMemory(queue, image, pBindInfo, mem, memOffset);
+    VkResult result = get_dispatch_table(ObjectTracker_device_table_map, queue)->QueueBindSparseImageMemory(queue, image, numBindings, pBindInfo);
     return result;
 }
 
+VkResult
+explicit_QueueBindSparseImageOpaqueMemory(
+    VkQueue                            queue,
+    VkImage                            image,
+    uint32_t                           numBindings,
+    const VkSparseMemoryBindInfo* pBindInfo)
+{
+    loader_platform_thread_lock_mutex(&objLock);
+    validateQueueFlags(queue, "QueueBindSparseImageOpaqueMemory");
+    loader_platform_thread_unlock_mutex(&objLock);
+
+    VkResult result = get_dispatch_table(ObjectTracker_device_table_map, queue)->QueueBindSparseImageOpaqueMemory(queue, image, numBindings, pBindInfo);
+    return result;
+}
 
 VkResult
 explicit_GetFenceStatus(
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index 8d53751e..1f55e38f 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -2888,10 +2888,8 @@ void PreQueueBindSparseBufferMemory(
 void PostQueueBindSparseBufferMemory(
     VkQueue queue,
     VkBuffer buffer,
-    VkDeviceSize rangeOffset,
-    VkDeviceSize rangeSize,
-    VkDeviceMemory mem,
-    VkDeviceSize memOffset,
+    uint32_t numBindings,
+    const VkSparseMemoryBindInfo* pBindInfo,
     VkResult result)
 {
     if(queue == nullptr)
@@ -2908,16 +2906,6 @@ void PostQueueBindSparseBufferMemory(
         return;
     }
 
-
-
-    if(mem == nullptr)
-    {
-        log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkQueueBindSparseBufferMemory parameter, VkDeviceMemory mem, is null pointer");
-        return;
-    }
-
-
     if(result != VK_SUCCESS)
     {
         std::string reason = "vkQueueBindSparseBufferMemory parameter, VkResult result, is " + EnumeratorString(result);
@@ -2927,24 +2915,22 @@ void PostQueueBindSparseBufferMemory(
 }
 
 VK_LAYER_EXPORT VkResult VKAPI vkQueueBindSparseBufferMemory(
-    VkQueue queue,
-    VkBuffer buffer,
-    VkDeviceSize rangeOffset,
-    VkDeviceSize rangeSize,
-    VkDeviceMemory mem,
-    VkDeviceSize memOffset)
+    VkQueue                       queue,
+    VkBuffer                      buffer,
+    uint32_t                      numBindings,
+    const VkSparseMemoryBindInfo* pBindInfo)
 {
     PreQueueBindSparseBufferMemory(queue);
-    VkResult result = get_dispatch_table(pc_device_table_map, queue)->QueueBindSparseBufferMemory(queue, buffer, rangeOffset, rangeSize, mem, memOffset);
+    VkResult result = get_dispatch_table(pc_device_table_map, queue)->QueueBindSparseBufferMemory(queue, buffer, numBindings, pBindInfo);
 
-    PostQueueBindSparseBufferMemory(queue, buffer, rangeOffset, rangeSize, mem, memOffset, result);
+    PostQueueBindSparseBufferMemory(queue, buffer, numBindings, pBindInfo, result);
 
     return result;
 }
 
 void PreQueueBindSparseImageMemory(
     VkQueue queue,
-    const VkImageMemoryBindInfo* pBindInfo)
+    const VkSparseImageMemoryBindInfo* pBindInfo)
 {
     if(queue == nullptr)
     {
@@ -2959,13 +2945,6 @@ void PreQueueBindSparseImageMemory(
         "vkQueueBindSparseImageMemory parameter, const VkImageMemoryBindInfo* pBindInfo, is null pointer");
         return;
     }
-    if(pBindInfo->subresource.aspect < VK_IMAGE_ASPECT_BEGIN_RANGE ||
-        pBindInfo->subresource.aspect > VK_IMAGE_ASPECT_END_RANGE)
-    {
-        log_msg(mdd(queue), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "PARAMCHECK",
-        "vkQueueBindSparseImageMemory parameter, VkImageAspect pBindInfo->subresource.aspect, is unrecognized enumerator");
-        return;
-    }
 }
 
 void PostQueueBindSparseImageMemory(
@@ -3006,16 +2985,15 @@ void PostQueueBindSparseImageMemory(
 }
 
 VK_LAYER_EXPORT VkResult VKAPI vkQueueBindSparseImageMemory(
-    VkQueue queue,
-    VkImage image,
-    const VkImageMemoryBindInfo* pBindInfo,
-    VkDeviceMemory mem,
-    VkDeviceSize memOffset)
+    VkQueue                            queue,
+    VkImage                            image,
+    uint32_t                           numBindings,
+    const VkSparseImageMemoryBindInfo* pBindInfo)
 {
     PreQueueBindSparseImageMemory(queue, pBindInfo);
-    VkResult result = get_dispatch_table(pc_device_table_map, queue)->QueueBindSparseImageMemory(queue, image, pBindInfo, mem, memOffset);
+    VkResult result = get_dispatch_table(pc_device_table_map, queue)->QueueBindSparseImageMemory(queue, image, numBindings, pBindInfo);
 
-    PostQueueBindSparseImageMemory(queue, image, mem, memOffset, result);
+    PostQueueBindSparseImageMemory(queue, image, pBindInfo->mem, pBindInfo->memOffset, result);
 
     return result;
 }
diff --git a/loader/gpa_helper.h b/loader/gpa_helper.h
index 65c52d41..a54f63bb 100644
--- a/loader/gpa_helper.h
+++ b/loader/gpa_helper.h
@@ -69,6 +69,8 @@ static inline void* globalGetProcAddr(const char *name)
         return (void*) vkGetGlobalLayerProperties;
     if (!strcmp(name, "GetPhysicalDeviceLayerProperties"))
         return (void*) vkGetPhysicalDeviceLayerProperties;
+    if (!strcmp(name, "GetPhysicalDeviceSparseImageFormatProperties"))
+        return (void*) vkGetPhysicalDeviceSparseImageFormatProperties;
     if (!strcmp(name, "GetDeviceQueue"))
         return (void*) vkGetDeviceQueue;
     if (!strcmp(name, "QueueSubmit"))
@@ -99,6 +101,10 @@ static inline void* globalGetProcAddr(const char *name)
         return (void*) vkQueueBindSparseBufferMemory;
     if (!strcmp(name, "QueueBindSparseImageMemory"))
         return (void*) vkQueueBindSparseImageMemory;
+    if (!strcmp(name, "QueueBindSparseImageOpaqueMemory"))
+        return (void*) vkQueueBindSparseImageOpaqueMemory;
+    if (!strcmp(name, "GetImageSparseMemoryRequirements"))
+        return (void*) vkGetImageSparseMemoryRequirements;
     if (!strcmp(name, "CreateFence"))
         return (void*) vkCreateFence;
     if (!strcmp(name, "ResetFences"))
@@ -293,6 +299,8 @@ static inline void *loader_non_passthrough_gpa(const char *name)
         return (void*) vkGetPhysicalDeviceMemoryProperties;
     if (!strcmp(name, "GetPhysicalDeviceProperties"))
         return (void*) vkGetPhysicalDeviceProperties;
+    if (!strcmp(name, "GetPhysicalDeviceSparseImageFormatProperties"))
+        return (void*) vkGetPhysicalDeviceSparseImageFormatProperties;
     if (!strcmp(name, "GetInstanceProcAddr"))
         return (void*) vkGetInstanceProcAddr;
     if (!strcmp(name, "GetDeviceProcAddr"))
diff --git a/loader/loader.c b/loader/loader.c
index 9c725024..8dc0af75 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -98,6 +98,7 @@ const VkLayerInstanceDispatchTable instance_disp = {
     .GetPhysicalDeviceMemoryProperties = loader_GetPhysicalDeviceMemoryProperties,
     .GetPhysicalDeviceExtensionProperties = loader_GetPhysicalDeviceExtensionProperties,
     .GetPhysicalDeviceLayerProperties = loader_GetPhysicalDeviceLayerProperties,
+    .GetPhysicalDeviceSparseImageFormatProperties = loader_GetPhysicalDeviceSparseImageFormatProperties,
     .DbgCreateMsgCallback = loader_DbgCreateMsgCallback,
     .DbgDestroyMsgCallback = loader_DbgDestroyMsgCallback,
 };
@@ -1086,6 +1087,7 @@ static void loader_icd_init_entrys(struct loader_icd *icd,
     LOOKUP(GetPhysicalDeviceQueueCount);
     LOOKUP(GetPhysicalDeviceQueueProperties);
     LOOKUP(GetPhysicalDeviceExtensionProperties);
+    LOOKUP(GetPhysicalDeviceSparseImageFormatProperties);
     LOOKUP(DbgCreateMsgCallback);
     LOOKUP(DbgDestroyMsgCallback);
 #undef LOOKUP
@@ -2727,6 +2729,26 @@ VkResult loader_GetPhysicalDeviceLimits(
     return res;
 }
 
+VkResult loader_GetPhysicalDeviceSparseImageFormatProperties(
+        VkPhysicalDevice                        physicalDevice,
+        VkFormat                                format,
+        VkImageType                             type,
+        uint32_t                                samples,
+        VkImageUsageFlags                       usage,
+        VkImageTiling                           tiling,
+        uint32_t*                               pNumProperties,
+        VkSparseImageFormatProperties*          pProperties)
+{
+    uint32_t gpu_index;
+    struct loader_icd *icd = loader_get_icd(physicalDevice, &gpu_index);
+    VkResult res = VK_ERROR_INITIALIZATION_FAILED;
+
+    if (icd->GetPhysicalDeviceSparseImageFormatProperties)
+        res = icd->GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pNumProperties, pProperties);
+
+    return res;
+}
+
 VkResult loader_CreateDevice(
         VkPhysicalDevice                        gpu,
         const VkDeviceCreateInfo*               pCreateInfo,
diff --git a/loader/loader.h b/loader/loader.h
index e240ce8e..24c0d3ba 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -154,6 +154,7 @@ struct loader_icd {
     PFN_vkGetPhysicalDeviceMemoryProperties GetPhysicalDeviceMemoryProperties;
     PFN_vkGetPhysicalDeviceExtensionProperties GetPhysicalDeviceExtensionProperties;
     PFN_vkGetPhysicalDeviceLayerProperties GetPhysicalDeviceLayerProperties;
+    PFN_vkGetPhysicalDeviceSparseImageFormatProperties GetPhysicalDeviceSparseImageFormatProperties;
     PFN_vkDbgCreateMsgCallback DbgCreateMsgCallback;
     PFN_vkDbgDestroyMsgCallback DbgDestroyMsgCallback;
 
@@ -370,6 +371,15 @@ VkResult loader_GetPhysicalDeviceLimits(
         VkPhysicalDevice                        physicalDevice,
         VkPhysicalDeviceLimits*                 pLimits);
 
+VkResult loader_GetPhysicalDeviceSparseImageFormatProperties(
+        VkPhysicalDevice                        physicalDevice,
+        VkFormat                                format,
+        VkImageType                             type,
+        uint32_t                                samples,
+        VkImageUsageFlags                       usage,
+        VkImageTiling                           tiling,
+        uint32_t*                               pNumProperties,
+        VkSparseImageFormatProperties*          pProperties);
 
 VkResult loader_GetPhysicalDeviceProperties (
         VkPhysicalDevice physicalDevice,
diff --git a/loader/table_ops.h b/loader/table_ops.h
index 430d8113..4f3b5012 100644
--- a/loader/table_ops.h
+++ b/loader/table_ops.h
@@ -54,6 +54,8 @@ static inline void loader_init_device_dispatch_table(VkLayerDispatchTable *table
     table->BindObjectMemory = (PFN_vkBindObjectMemory) gpa(dev, "vkBindObjectMemory");
     table->QueueBindSparseBufferMemory = (PFN_vkQueueBindSparseBufferMemory) gpa(dev, "vkQueueBindSparseBufferMemory");
     table->QueueBindSparseImageMemory = (PFN_vkQueueBindSparseImageMemory) gpa(dev, "vkQueueBindSparseImageMemory");
+    table->QueueBindSparseImageOpaqueMemory = (PFN_vkQueueBindSparseImageOpaqueMemory) gpa(dev, "vkQueueBindSparseImageOpaqueMemory");
+    table->GetImageSparseMemoryRequirements = (PFN_vkGetImageSparseMemoryRequirements) gpa(dev, "vkGetImageSparseMemoryRequirements");
     table->CreateFence = (PFN_vkCreateFence) gpa(dev, "vkCreateFence");
     table->ResetFences = (PFN_vkResetFences) gpa(dev, "vkResetFences");
     table->GetFenceStatus = (PFN_vkGetFenceStatus) gpa(dev, "vkGetFenceStatus");
@@ -187,6 +189,10 @@ static inline void *loader_lookup_device_dispatch_table(
         return (void *) table->QueueBindSparseBufferMemory;
     if (!strcmp(name, "QueueBindSparseImageMemory"))
         return (void *) table->QueueBindSparseImageMemory;
+    if (!strcmp(name, "QueueBindSparseImageOpaqueMemory"))
+        return (void *) table->QueueBindSparseImageOpaqueMemory;
+    if (!strcmp(name, "GetImageSparseMemoryRequirements"))
+        return (void *) table->GetImageSparseMemoryRequirements;
     if (!strcmp(name, "CreateFence"))
         return (void *) table->CreateFence;
     if (!strcmp(name, "ResetFences"))
@@ -371,6 +377,7 @@ static inline void loader_init_instance_core_dispatch_table(VkLayerInstanceDispa
     table->GetPhysicalDeviceMemoryProperties = (PFN_vkGetPhysicalDeviceMemoryProperties) gpa(inst, "vkGetPhysicalDeviceMemoryProperties");
     table->GetPhysicalDeviceExtensionProperties = (PFN_vkGetPhysicalDeviceExtensionProperties) gpa(inst, "vkGetPhysicalDeviceExtensionProperties");
     table->GetPhysicalDeviceLayerProperties = (PFN_vkGetPhysicalDeviceLayerProperties) gpa(inst, "vkGetPhysicalDeviceLayerProperties");
+    table->GetPhysicalDeviceSparseImageFormatProperties = (PFN_vkGetPhysicalDeviceSparseImageFormatProperties) gpa(inst, "vkGetPhysicalDeviceSparseImageFormatProperties");
 }
 
 static inline void loader_init_instance_extension_dispatch_table(
@@ -402,6 +409,8 @@ static inline void *loader_lookup_instance_dispatch_table(
         return (void *) table->GetPhysicalDeviceFormatInfo;
     if (!strcmp(name, "GetPhysicalDeviceLimits"))
         return (void *) table->GetPhysicalDeviceLimits;
+    if (!strcmp(name, "GetPhysicalDeviceSparseImageFormatProperties"))
+        return (void *) table->GetPhysicalDeviceSparseImageFormatProperties;
     if (!strcmp(name, "GetPhysicalDeviceProperties"))
         return (void *) table->GetPhysicalDeviceProperties;
     if (!strcmp(name, "GetPhysicalDevicePerformance"))
diff --git a/loader/trampoline.c b/loader/trampoline.c
index 71943da3..19f1cbbc 100644
--- a/loader/trampoline.c
+++ b/loader/trampoline.c
@@ -447,22 +447,49 @@ LOADER_EXPORT VkResult VKAPI vkBindObjectMemory(VkDevice device, VkObjectType ob
     return disp->BindObjectMemory(device, objType, object, mem, offset);
 }
 
-LOADER_EXPORT VkResult VKAPI vkQueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset)
+LOADER_EXPORT VkResult VKAPI vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->GetImageSparseMemoryRequirements(device, image, pNumRequirements, pSparseMemoryRequirements);
+}
+
+LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties)
+{
+    const VkLayerInstanceDispatchTable *disp;
+
+    disp = loader_get_instance_dispatch(physicalDevice);
+
+    return disp->GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pNumProperties, pProperties);
+}
+
+LOADER_EXPORT VkResult VKAPI vkQueueBindSparseImageOpaqueMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(queue);
+
+    return disp->QueueBindSparseImageOpaqueMemory(queue, image, numBindings, pBindInfo);
+}
+
+LOADER_EXPORT VkResult VKAPI vkQueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(queue);
 
-    return disp->QueueBindSparseBufferMemory(queue, buffer, rangeOffset, rangeSize, mem, memOffset);
+    return disp->QueueBindSparseBufferMemory(queue, buffer, numBindings, pBindInfo);
 }
 
-LOADER_EXPORT VkResult VKAPI vkQueueBindSparseImageMemory(VkQueue queue, VkImage image, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset)
+LOADER_EXPORT VkResult VKAPI vkQueueBindSparseImageMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseImageMemoryBindInfo* pBindInfo)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(queue);
 
-    return disp->QueueBindSparseImageMemory(queue, image, pBindInfo, mem, memOffset);
+    return disp->QueueBindSparseImageMemory(queue, image, numBindings, pBindInfo);
 }
 
 LOADER_EXPORT VkResult VKAPI vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence)
diff --git a/vulkan.py b/vulkan.py
index b3b69753..01112c79 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -367,20 +367,39 @@ core = Extension(
              Param("VkDeviceMemory", "mem"),
              Param("VkDeviceSize", "offset")]),
 
+        Proto("VkResult", "GetImageSparseMemoryRequirements",
+            [Param("VkDevice", "device"),
+             Param("VkImage", "image"),
+             Param("uint32_t*", "pNumRequirements"),
+             Param("VkSparseImageMemoryRequirements*", "pSparseMemoryRequirements"),]),
+
+        Proto("VkResult", "GetPhysicalDeviceSparseImageFormatProperties",
+            [Param("VkPhysicalDevice", "physicalDevice"),
+             Param("VkFormat", "format"),
+             Param("VkImageType", "type"),
+             Param("uint32_t", "samples"),
+             Param("VkImageUsageFlags", "usage"),
+             Param("VkImageTiling", "tiling"),
+             Param("uint32_t*", "pNumProperties"),
+             Param("VkSparseImageFormatProperties*", "pProperties"),]),
+
         Proto("VkResult", "QueueBindSparseBufferMemory",
             [Param("VkQueue", "queue"),
              Param("VkBuffer", "buffer"),
-             Param("VkDeviceSize", "rangeOffset"),
-             Param("VkDeviceSize", "rangeSize"),
-             Param("VkDeviceMemory", "mem"),
-             Param("VkDeviceSize", "memOffset")]),
+             Param("uint32_t", "numBindings"),
+             Param("const VkSparseMemoryBindInfo*", "pBindInfo"),]),
+
+        Proto("VkResult", "QueueBindSparseImageOpaqueMemory",
+            [Param("VkQueue", "queue"),
+             Param("VkImage", "image"),
+             Param("uint32_t", "numBindings"),
+             Param("const VkSparseMemoryBindInfo*", "pBindInfo"),]),
 
         Proto("VkResult", "QueueBindSparseImageMemory",
             [Param("VkQueue", "queue"),
              Param("VkImage", "image"),
-             Param("const VkImageMemoryBindInfo*", "pBindInfo"),
-             Param("VkDeviceMemory", "mem"),
-             Param("VkDeviceSize", "memOffset")]),
+             Param("uint32_t", "numBindings"),
+             Param("const VkSparseImageMemoryBindInfo*", "pBindInfo"),]),
 
         Proto("VkResult", "CreateFence",
             [Param("VkDevice", "device"),