src/virtio/vulkan/vn_device_memory.c

@@ -105,204 +105,6 @@ vn_device_memory_bo_fini(struct vn_device *dev, struct vn_device_memory *mem)
    }
 }
 
-static VkResult
-vn_device_memory_pool_grow_alloc(struct vn_device *dev,
-                                 uint32_t mem_type_index,
-                                 VkDeviceSize size,
-                                 struct vn_device_memory **out_mem)
-{
-   const VkMemoryAllocateInfo alloc_info = {
-      .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
-      .allocationSize = size,
-      .memoryTypeIndex = mem_type_index,
-   };
-   struct vn_device_memory *mem = vk_device_memory_create(
-      &dev->base.base, &alloc_info, NULL, sizeof(*mem));
-   if (!mem)
-      return VK_ERROR_OUT_OF_HOST_MEMORY;
-
-   vn_object_set_id(mem, vn_get_next_obj_id(), VK_OBJECT_TYPE_DEVICE_MEMORY);
-
-   VkResult result = vn_device_memory_alloc_simple(dev, mem, &alloc_info);
-   if (result != VK_SUCCESS)
-      goto obj_fini;
-
-   result = vn_device_memory_bo_init(dev, mem);
-   if (result != VK_SUCCESS)
-      goto mem_free;
-
-   result =
-      vn_ring_submit_roundtrip(dev->primary_ring, &mem->bo_roundtrip_seqno);
-   if (result != VK_SUCCESS)
-      goto bo_unref;
-
-   mem->bo_roundtrip_seqno_valid = true;
-   *out_mem = mem;
-
-   return VK_SUCCESS;
-
-bo_unref:
-   vn_renderer_bo_unref(dev->renderer, mem->base_bo);
-mem_free:
-   vn_device_memory_free_simple(dev, mem);
-obj_fini:
-   vk_device_memory_destroy(&dev->base.base, NULL, &mem->base.base);
-   return result;
-}
-
-static struct vn_device_memory *
-vn_device_memory_pool_ref(struct vn_device *dev,
-                          struct vn_device_memory *pool_mem)
-{
-   assert(pool_mem->base_bo);
-
-   vn_renderer_bo_ref(dev->renderer, pool_mem->base_bo);
-
-   return pool_mem;
-}
-
-static void
-vn_device_memory_pool_unref(struct vn_device *dev,
-                            struct vn_device_memory *pool_mem)
-{
-   assert(pool_mem->base_bo);
-
-   if (!vn_renderer_bo_unref(dev->renderer, pool_mem->base_bo))
-      return;
-
-   /* wait on valid bo_roundtrip_seqno before vkFreeMemory */
-   if (pool_mem->bo_roundtrip_seqno_valid)
-      vn_ring_wait_roundtrip(dev->primary_ring, pool_mem->bo_roundtrip_seqno);
-
-   vn_device_memory_free_simple(dev, pool_mem);
-   vk_device_memory_destroy(&dev->base.base, NULL, &pool_mem->base.base);
-}
-
-void
-vn_device_memory_pool_fini(struct vn_device *dev, uint32_t mem_type_index)
-{
-   struct vn_device_memory_pool *pool = &dev->memory_pools[mem_type_index];
-   if (pool->memory)
-      vn_device_memory_pool_unref(dev, pool->memory);
-   mtx_destroy(&pool->mutex);
-}
-
-static VkResult
-vn_device_memory_pool_grow_locked(struct vn_device *dev,
-                                  uint32_t mem_type_index,
-                                  VkDeviceSize size)
-{
-   struct vn_device_memory *mem;
-   VkResult result =
-      vn_device_memory_pool_grow_alloc(dev, mem_type_index, size, &mem);
-   if (result != VK_SUCCESS)
-      return result;
-
-   struct vn_device_memory_pool *pool = &dev->memory_pools[mem_type_index];
-   if (pool->memory)
-      vn_device_memory_pool_unref(dev, pool->memory);
-
-   pool->memory = mem;
-   pool->used = 0;
-
-   return VK_SUCCESS;
-}
-
-static VkResult
-vn_device_memory_pool_suballocate(struct vn_device *dev,
-                                  struct vn_device_memory *mem)
-{
-   static const VkDeviceSize pool_size = 16 * 1024 * 1024;
-   /* TODO fix https://gitlab.freedesktop.org/mesa/mesa/-/issues/9351
-    * Before that, we use 64K default alignment because some GPUs have 64K
-    * pages. It is also required by newer Intel GPUs. Meanwhile, use prior 4K
-    * align on implementations known to fit.
-    */
-   const bool is_renderer_mali = dev->physical_device->renderer_driver_id ==
-                                 VK_DRIVER_ID_ARM_PROPRIETARY;
-   const VkDeviceSize pool_align = is_renderer_mali ? 4096 : 64 * 1024;
-   const struct vk_device_memory *mem_vk = &mem->base.base;
-   struct vn_device_memory_pool *pool =
-      &dev->memory_pools[mem_vk->memory_type_index];
-
-   assert(mem_vk->size <= pool_size);
-
-   mtx_lock(&pool->mutex);
-
-   if (!pool->memory || pool->used + mem_vk->size > pool_size) {
-      VkResult result = vn_device_memory_pool_grow_locked(
-         dev, mem_vk->memory_type_index, pool_size);
-      if (result != VK_SUCCESS) {
-         mtx_unlock(&pool->mutex);
-         return result;
-      }
-   }
-
-   mem->base_memory = vn_device_memory_pool_ref(dev, pool->memory);
-
-   /* point mem->base_bo at pool base_bo and assign base_offset accordingly */
-   mem->base_bo = pool->memory->base_bo;
-   mem->base_offset = pool->used;
-   pool->used += align64(mem_vk->size, pool_align);
-
-   mtx_unlock(&pool->mutex);
-
-   return VK_SUCCESS;
-}
-
-static bool
-vn_device_memory_should_suballocate(const struct vn_device *dev,
-                                    const VkMemoryAllocateInfo *alloc_info)
-{
-   if (VN_PERF(NO_MEMORY_SUBALLOC))
-      return false;
-
-   if (dev->renderer->info.has_guest_vram)
-      return false;
-
-   /* We should not support suballocations because apps can do better.  But
-    * each BO takes up a KVM memslot currently and some CTS tests exhausts
-    * them.  This might not be needed on newer (host) kernels where there are
-    * many more KVM memslots.
-    */
-
-   /* consider host-visible memory only */
-   const VkMemoryType *mem_type =
-      &dev->physical_device->memory_properties
-          .memoryTypes[alloc_info->memoryTypeIndex];
-   if (!(mem_type->propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT))
-      return false;
-
-   /* reject larger allocations */
-   if (alloc_info->allocationSize > 64 * 1024)
-      return false;
-
-   /* reject if there is any pnext struct other than
-    * VkMemoryDedicatedAllocateInfo, or if dedicated allocation is required
-    */
-   if (alloc_info->pNext) {
-      const VkMemoryDedicatedAllocateInfo *dedicated = alloc_info->pNext;
-      if (dedicated->sType !=
-             VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO ||
-          dedicated->pNext)
-         return false;
-
-      const struct vn_image *img = vn_image_from_handle(dedicated->image);
-      if (img) {
-         for (uint32_t i = 0; i < ARRAY_SIZE(img->requirements); i++) {
-            if (img->requirements[i].dedicated.requiresDedicatedAllocation)
-               return false;
-         }
-      }
-
-      const struct vn_buffer *buf = vn_buffer_from_handle(dedicated->buffer);
-      if (buf && buf->requirements.dedicated.requiresDedicatedAllocation)
-         return false;
-   }
-
-   return true;
-}
-
 VkResult
 vn_device_memory_import_dma_buf(struct vn_device *dev,
                                 struct vn_device_memory *mem,
@@ -593,8 +395,6 @@ vn_AllocateMemory(VkDevice device,
    } else if (import_fd_info) {
       result = vn_device_memory_import_dma_buf(dev, mem, pAllocateInfo, false,
                                                import_fd_info->fd);
-   } else if (vn_device_memory_should_suballocate(dev, pAllocateInfo)) {
-      result = vn_device_memory_pool_suballocate(dev, mem);
    } else {
       result = vn_device_memory_alloc(dev, mem, pAllocateInfo);
    }
@@ -623,18 +423,13 @@ vn_FreeMemory(VkDevice device,
 
    vn_device_memory_emit_report(dev, mem, /* is_alloc */ false, VK_SUCCESS);
 
-   if (mem->base_memory) {
-      vn_device_memory_pool_unref(dev, mem->base_memory);
-   } else {
-      /* ensure renderer side import still sees the resource */
-      vn_device_memory_bo_fini(dev, mem);
+   /* ensure renderer side import still sees the resource */
+   vn_device_memory_bo_fini(dev, mem);
 
-      if (mem->bo_roundtrip_seqno_valid)
-         vn_ring_wait_roundtrip(dev->primary_ring, mem->bo_roundtrip_seqno);
-
-      vn_device_memory_free_simple(dev, mem);
-   }
+   if (mem->bo_roundtrip_seqno_valid)
+      vn_ring_wait_roundtrip(dev->primary_ring, mem->bo_roundtrip_seqno);
 
+   vn_device_memory_free_simple(dev, mem);
    vk_device_memory_destroy(&dev->base.base, pAllocator, &mem->base.base);
 }
 
@@ -643,10 +438,6 @@ vn_GetDeviceMemoryOpaqueCaptureAddress(
    VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
 {
    struct vn_device *dev = vn_device_from_handle(device);
-   ASSERTED struct vn_device_memory *mem =
-      vn_device_memory_from_handle(pInfo->memory);
-
-   assert(!mem->base_memory);
    return vn_call_vkGetDeviceMemoryOpaqueCaptureAddress(dev->primary_ring,
                                                         device, pInfo);
 }
@@ -702,7 +493,7 @@ vn_MapMemory(VkDevice device,
 
    mem->map_end = size == VK_WHOLE_SIZE ? mem_vk->size : offset + size;
 
-   *ppData = ptr + mem->base_offset + offset;
+   *ppData = ptr + offset;
 
    return VK_SUCCESS;
 }
@@ -727,8 +518,7 @@ vn_FlushMappedMemoryRanges(VkDevice device,
       const VkDeviceSize size = range->size == VK_WHOLE_SIZE
                                    ? mem->map_end - range->offset
                                    : range->size;
-      vn_renderer_bo_flush(dev->renderer, mem->base_bo,
-                           mem->base_offset + range->offset, size);
+      vn_renderer_bo_flush(dev->renderer, mem->base_bo, range->offset, size);
    }
 
    return VK_SUCCESS;
@@ -749,8 +539,8 @@ vn_InvalidateMappedMemoryRanges(VkDevice device,
       const VkDeviceSize size = range->size == VK_WHOLE_SIZE
                                    ? mem->map_end - range->offset
                                    : range->size;
-      vn_renderer_bo_invalidate(dev->renderer, mem->base_bo,
-                                mem->base_offset + range->offset, size);
+      vn_renderer_bo_invalidate(dev->renderer, mem->base_bo, range->offset,
+                                size);
    }
 
    return VK_SUCCESS;
@@ -762,10 +552,6 @@ vn_GetDeviceMemoryCommitment(VkDevice device,
                              VkDeviceSize *pCommittedMemoryInBytes)
 {
    struct vn_device *dev = vn_device_from_handle(device);
-   ASSERTED struct vn_device_memory *mem =
-      vn_device_memory_from_handle(memory);
-
-   assert(!mem->base_memory);
    vn_call_vkGetDeviceMemoryCommitment(dev->primary_ring, device, memory,
                                        pCommittedMemoryInBytes);
 }
@@ -784,7 +570,7 @@ vn_GetMemoryFdKHR(VkDevice device,
    assert(pGetFdInfo->handleType &
           (VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT |
            VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT));
-   assert(!mem->base_memory && mem->base_bo);
+   assert(mem->base_bo);
    *pFd = vn_renderer_bo_export_dma_buf(dev->renderer, mem->base_bo);
    if (*pFd < 0)
       return vn_error(dev->instance, VK_ERROR_TOO_MANY_OBJECTS);

src/virtio/vulkan/vn_device_memory.h

@@ -13,17 +13,9 @@
 
 #include "vn_common.h"
 
-struct vn_device_memory_pool {
-   mtx_t mutex;
-   struct vn_device_memory *memory;
-   VkDeviceSize used;
-};
-
 struct vn_device_memory {
    struct vn_device_memory_base base;
 
-   /* non-NULL when suballocated */
-   struct vn_device_memory *base_memory;
    /* non-NULL when mappable or external */
    struct vn_renderer_bo *base_bo;
 
@@ -55,8 +47,6 @@ struct vn_device_memory {
    bool bo_roundtrip_seqno_valid;
    uint64_t bo_roundtrip_seqno;
 
-   VkDeviceSize base_offset;
-
    VkDeviceSize map_end;
 };
 VK_DEFINE_NONDISP_HANDLE_CASTS(vn_device_memory,
@@ -64,9 +54,6 @@ VK_DEFINE_NONDISP_HANDLE_CASTS(vn_device_memory,
                                VkDeviceMemory,
                                VK_OBJECT_TYPE_DEVICE_MEMORY)
 
-void
-vn_device_memory_pool_fini(struct vn_device *dev, uint32_t mem_type_index);
-
 VkResult
 vn_device_memory_import_dma_buf(struct vn_device *dev,
                                 struct vn_device_memory *mem,

src/virtio/vulkan/vn_image.c

@@ -765,23 +765,16 @@ vn_GetImageSparseMemoryRequirements2(
       pSparseMemoryRequirements);
 }
 
-static void
-vn_image_bind_wsi_memory(struct vn_image *img, struct vn_device_memory *mem)
-{
-   assert(img->wsi.is_wsi && !img->wsi.memory);
-   img->wsi.memory = mem;
-}
-
-VkResult
-vn_BindImageMemory2(VkDevice device,
-                    uint32_t bindInfoCount,
-                    const VkBindImageMemoryInfo *pBindInfos)
+static VkResult
+vn_image_bind_wsi_memory(struct vn_device *dev,
+                         uint32_t count,
+                         const VkBindImageMemoryInfo *infos)
 {
-   STACK_ARRAY(VkBindImageMemoryInfo, bind_infos, bindInfoCount);
-   typed_memcpy(bind_infos, pBindInfos, bindInfoCount);
+   STACK_ARRAY(VkBindImageMemoryInfo, local_infos, count);
+   typed_memcpy(local_infos, infos, count);
 
-   for (uint32_t i = 0; i < bindInfoCount; i++) {
-      VkBindImageMemoryInfo *info = &bind_infos[i];
+   for (uint32_t i = 0; i < count; i++) {
+      VkBindImageMemoryInfo *info = &local_infos[i];
       struct vn_image *img = vn_image_from_handle(info->image);
       struct vn_device_memory *mem =
          vn_device_memory_from_handle(info->memory);
@@ -808,24 +801,31 @@ vn_BindImageMemory2(VkDevice device,
       assert(mem && info->memory != VK_NULL_HANDLE);
 
       if (img->wsi.is_wsi)
-         vn_image_bind_wsi_memory(img, mem);
-
-      /* If mem is suballocated, mem->base_memory is non-NULL and we must
-       * patch it in.  If VkBindImageMemorySwapchainInfoKHR is given, we've
-       * looked mem up above and also need to patch it in.
-       */
-      if (mem->base_memory) {
-         info->memory = vn_device_memory_to_handle(mem->base_memory);
-         info->memoryOffset += mem->base_offset;
-      }
+         img->wsi.memory = mem;
    }
 
+   vn_async_vkBindImageMemory2(dev->primary_ring, vn_device_to_handle(dev),
+                               count, local_infos);
+
+   STACK_ARRAY_FINISH(local_infos);
+
+   return VK_SUCCESS;
+}
+
+VkResult
+vn_BindImageMemory2(VkDevice device,
+                    uint32_t bindInfoCount,
+                    const VkBindImageMemoryInfo *pBindInfos)
+{
    struct vn_device *dev = vn_device_from_handle(device);
-   vn_async_vkBindImageMemory2(dev->primary_ring, device, bindInfoCount,
-                               bind_infos);
 
-   STACK_ARRAY_FINISH(bind_infos);
+   for (uint32_t i = 0; i < bindInfoCount; i++) {
+      if (pBindInfos[i].memory == VK_NULL_HANDLE)
+         return vn_image_bind_wsi_memory(dev, bindInfoCount, pBindInfos);
+   }
 
+   vn_async_vkBindImageMemory2(dev->primary_ring, device, bindInfoCount,
+                               pBindInfos);
    return VK_SUCCESS;
 }
 

src/virtio/vulkan/vn_queue.c

@@ -516,7 +516,7 @@ vn_queue_submission_prepare(struct vn_queue_submission *submit)
          submit->submit_batches[0].pNext, WSI_MEMORY_SIGNAL_SUBMIT_INFO_MESA);
       if (info) {
          submit->wsi_mem = vn_device_memory_from_handle(info->memory);
-         assert(!submit->wsi_mem->base_memory && submit->wsi_mem->base_bo);
+         assert(submit->wsi_mem->base_bo);
       }
    }
 

src/vulkan/runtime/vk_android.c

@@ -662,6 +662,8 @@ get_ahb_buffer_format_properties2(
          VK_CHROMA_LOCATION_MIDPOINT : VK_CHROMA_LOCATION_COSITED_EVEN;
       p->suggestedYChromaOffset = (color_info.vertical_siting == __DRI_YUV_CHROMA_SITING_0_5) ?
          VK_CHROMA_LOCATION_MIDPOINT : VK_CHROMA_LOCATION_COSITED_EVEN;
+   } else {
+      p->suggestedYcbcrModel = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601;
    }
 
 finish:

src/vulkan/runtime/vk_pipeline.c

@@ -56,6 +56,15 @@ vk_pipeline_shader_stage_is_null(const VkPipelineShaderStageCreateInfo *info)
    return true;
 }
 
+bool
+vk_pipeline_shader_stage_has_identifier(const VkPipelineShaderStageCreateInfo *info)
+{
+   const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *id_info =
+      vk_find_struct_const(info->pNext, PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT);
+
+   return id_info && id_info->identifierSize != 0;
+}
+
 static nir_shader *
 get_builtin_nir(const VkPipelineShaderStageCreateInfo *info)
 {

src/vulkan/runtime/vk_pipeline.h

@@ -54,6 +54,9 @@ typedef struct VkPipelineShaderStageNirCreateInfoMESA {
 bool
 vk_pipeline_shader_stage_is_null(const VkPipelineShaderStageCreateInfo *info);
 
+bool
+vk_pipeline_shader_stage_has_identifier(const VkPipelineShaderStageCreateInfo *info);
+
 VkResult
 vk_pipeline_shader_stage_to_nir(struct vk_device *device,
                                 const VkPipelineShaderStageCreateInfo *info,

src/vulkan/wsi/wsi_common_drm.c

@@ -908,7 +908,6 @@ wsi_drm_wait_for_explicit_sync_release(struct wsi_swapchain *chain,
                                        uint64_t rel_timeout_ns,
                                        uint32_t *image_index)
 {
-#ifdef HAVE_LIBDRM
    STACK_ARRAY(uint32_t, handles, image_count);
    STACK_ARRAY(uint64_t, points, image_count);
    STACK_ARRAY(uint32_t, indices, image_count);
@@ -989,7 +988,4 @@ done:
       return rel_timeout_ns ? VK_TIMEOUT : VK_NOT_READY;
    else
       return VK_ERROR_OUT_OF_DATE_KHR;
-#else
-   return VK_ERROR_FEATURE_NOT_PRESENT;
-#endif
 }

src/vulkan/wsi/wsi_common_wayland.c

@@ -1893,11 +1893,16 @@ wsi_wl_swapchain_acquire_next_image_explicit(struct wsi_swapchain *wsi_chain,
    for (uint32_t i = 0; i < chain->base.image_count; i++)
       images[i] = &chain->images[i].base;
 
-   VkResult result = wsi_drm_wait_for_explicit_sync_release(wsi_chain,
-                                                            wsi_chain->image_count,
-                                                            images,
-                                                            info->timeout,
-                                                            image_index);
+   VkResult result;
+#ifdef HAVE_LIBDRM
+   result = wsi_drm_wait_for_explicit_sync_release(wsi_chain,
+                                                   wsi_chain->image_count,
+                                                   images,
+                                                   info->timeout,
+                                                   image_index);
+#else
+   result = VK_ERROR_FEATURE_NOT_PRESENT;
+#endif
    STACK_ARRAY_FINISH(images);
 
    if (result == VK_SUCCESS)

src/vulkan/wsi/wsi_common_x11.c

@@ -1240,12 +1240,16 @@ x11_wait_for_explicit_sync_release_submission(struct x11_swapchain *chain,
    for (uint32_t i = 0; i < chain->base.image_count; i++)
       images[i] = &chain->images[i].base;
 
-   VkResult result =
-      wsi_drm_wait_for_explicit_sync_release(&chain->base,
-                                             chain->base.image_count,
-                                             images,
-                                             rel_timeout_ns,
-                                             image_index);
+   VkResult result;
+#ifdef HAVE_LIBDRM
+   result = wsi_drm_wait_for_explicit_sync_release(&chain->base,
+                                                   chain->base.image_count,
+                                                   images,
+                                                   rel_timeout_ns,
+                                                   image_index);
+#else
+   result = VK_ERROR_FEATURE_NOT_PRESENT;
+#endif
    STACK_ARRAY_FINISH(images);
    return result;
 }