[Mesa-dev] [PATCH 08/15] anv/android: support import/export of AHardwareBuffer objects

Lionel Landwerlin lionel.g.landwerlin at intel.com
Tue Dec 11 13:05:24 UTC 2018


On 27/11/2018 10:53, Tapani Pälli wrote:
> v2: add support for non-image buffers (AHARDWAREBUFFER_FORMAT_BLOB)
> v3: properly handle usage bits when creating from image
> v4: refactor, code cleanup (Jason)
> v5: rebase to b43f955037c changes,
>      initialize bo flags as ANV_BO_EXTERNAL (Lionel)
>
> Signed-off-by: Tapani Pälli <tapani.palli at intel.com>


Just a couple of suggestions below, otherwise :


Reviewed-by: Lionel Landwerlin <lionel.g.landwerlin at intel.com>


> ---
>   src/intel/vulkan/anv_android.c       | 123 +++++++++++++++++++++++++++
>   src/intel/vulkan/anv_android.h       |  10 +++
>   src/intel/vulkan/anv_android_stubs.c |  16 ++++
>   src/intel/vulkan/anv_device.c        |  45 +++++++++-
>   src/intel/vulkan/anv_private.h       |   5 ++
>   5 files changed, 197 insertions(+), 2 deletions(-)
>
> diff --git a/src/intel/vulkan/anv_android.c b/src/intel/vulkan/anv_android.c
> index f2dd16212c1..bdc720214c4 100644
> --- a/src/intel/vulkan/anv_android.c
> +++ b/src/intel/vulkan/anv_android.c
> @@ -233,6 +233,129 @@ anv_ahw_usage_from_vk_usage(const VkImageCreateFlags vk_create,
>      return ahw_usage;
>   }
>   
> +VkResult
> +anv_GetMemoryAndroidHardwareBufferANDROID(
> +   VkDevice device_h,
> +   const VkMemoryGetAndroidHardwareBufferInfoANDROID *pInfo,
> +   struct AHardwareBuffer **pBuffer)
> +{
> +   ANV_FROM_HANDLE(anv_device_memory, mem, pInfo->memory);
> +
> +   /* Some quotes from Vulkan spec:
> +    *
> +    * "If the device memory was created by importing an Android hardware
> +    * buffer, vkGetMemoryAndroidHardwareBufferANDROID must return that same
> +    * Android hardware buffer object."
> +    *
> +    * "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID must
> +    * have been included in VkExportMemoryAllocateInfoKHR::handleTypes when
> +    * memory was created."
> +    */
> +   if (mem->ahw) {
> +      *pBuffer = mem->ahw;
> +      /* Increase refcount. */
> +      AHardwareBuffer_acquire(mem->ahw);
> +      return VK_SUCCESS;
> +   }
> +
> +   return VK_ERROR_OUT_OF_HOST_MEMORY;
> +}
> +
> +/*
> + * Called from anv_AllocateMemory when import AHardwareBuffer.
> + */
> +VkResult
> +anv_import_ahw_memory(VkDevice device_h,
> +                      struct anv_device_memory *mem,
> +                      const VkImportAndroidHardwareBufferInfoANDROID *info)
> +{
> +   ANV_FROM_HANDLE(anv_device, device, device_h);
> +
> +   /* Import from AHardwareBuffer to anv_device_memory. */
> +   const native_handle_t *handle =
> +      AHardwareBuffer_getNativeHandle(info->buffer);
> +
> +   int dma_buf = (handle && handle->numFds) ? handle->data[0] : -1;


Maybe assert(handle->numFds == 1) so we don't forget to update this when 
we add support for multiple BOs later.


> +   if (dma_buf < 0)
> +      return VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR;
> +
> +   uint64_t bo_flags = ANV_BO_EXTERNAL;
> +   if (device->instance->physicalDevice.supports_48bit_addresses)
> +      bo_flags |= EXEC_OBJECT_SUPPORTS_48B_ADDRESS;
> +   if (device->instance->physicalDevice.use_softpin)
> +      bo_flags |= EXEC_OBJECT_PINNED;
> +
> +   VkResult result = anv_bo_cache_import(device, &device->bo_cache,
> +                                dma_buf, bo_flags, &mem->bo);
> +   if (result != VK_SUCCESS)
> +      return result;
> +
> +   /* "If the vkAllocateMemory command succeeds, the implementation must
> +    * acquire a reference to the imported hardware buffer, which it must
> +    * release when the device memory object is freed. If the command fails,
> +    * the implementation must not retain a reference."
> +    */
> +   AHardwareBuffer_acquire(info->buffer);
> +   mem->ahw = info->buffer;
> +
> +   return VK_SUCCESS;
> +}
> +
> +VkResult
> +anv_create_ahw_memory(VkDevice device_h,
> +                      struct anv_device_memory *mem,
> +                      const VkMemoryAllocateInfo *pAllocateInfo)
> +{
> +   ANV_FROM_HANDLE(anv_device, dev, device_h);
> +
> +   const VkMemoryDedicatedAllocateInfo *dedicated_info =
> +      vk_find_struct_const(pAllocateInfo->pNext,
> +                           MEMORY_DEDICATED_ALLOCATE_INFO);
> +
> +   uint32_t w = 0;
> +   uint32_t h = 1;
> +   uint32_t layers = 1;
> +   uint32_t format = 0;
> +   uint64_t usage = 0;
> +
> +   /* If caller passed dedicated information. */
> +   if (dedicated_info && dedicated_info->image) {
> +      ANV_FROM_HANDLE(anv_image, image, dedicated_info->image);
> +      w = image->extent.width;
> +      h = image->extent.height;
> +      layers = image->array_size;
> +      format = android_format_from_vk(image->vk_format);
> +      usage = anv_ahw_usage_from_vk_usage(image->create_flags, image->usage);
> +   } else if (dedicated_info && dedicated_info->buffer) {
> +      ANV_FROM_HANDLE(anv_buffer, buffer, dedicated_info->buffer);
> +      w = buffer->size;
> +      format = AHARDWAREBUFFER_FORMAT_BLOB;
> +      usage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN |
> +              AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN;
> +   } else {
> +      w = pAllocateInfo->allocationSize;
> +      format = AHARDWAREBUFFER_FORMAT_BLOB;
> +      usage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN |
> +              AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN;
> +   }
> +
> +   struct AHardwareBuffer *ahw = NULL;
> +   struct AHardwareBuffer_Desc desc = {
> +      .width = w,
> +      .height = h,
> +      .layers = layers,
> +      .format = format,
> +      .usage = usage,
> +    };
> +
> +   if (AHardwareBuffer_allocate(&desc, &ahw) != 0)
> +      return VK_ERROR_OUT_OF_HOST_MEMORY;
> +
> +   mem->ahw = ahw;
> +
> +   return VK_SUCCESS;
> +}
> +
>   VkResult
>   anv_image_from_gralloc(VkDevice device_h,
>                          const VkImageCreateInfo *base_info,
> diff --git a/src/intel/vulkan/anv_android.h b/src/intel/vulkan/anv_android.h
> index 8d748cecc39..01f0e856291 100644
> --- a/src/intel/vulkan/anv_android.h
> +++ b/src/intel/vulkan/anv_android.h
> @@ -28,6 +28,8 @@
>   #include <vulkan/vulkan_android.h>
>   #include <vulkan/vk_android_native_buffer.h>
>   
> +struct anv_device_memory;
> +
>   VkResult anv_image_from_gralloc(VkDevice device_h,
>                                   const VkImageCreateInfo *base_info,
>                                   const VkNativeBufferANDROID *gralloc_info,
> @@ -36,4 +38,12 @@ VkResult anv_image_from_gralloc(VkDevice device_h,
>   
>   uint64_t anv_ahw_usage_from_vk_usage(const VkImageCreateFlags vk_create,
>                                        const VkImageUsageFlags vk_usage);
> +
> +VkResult anv_import_ahw_memory(VkDevice device_h,
> +                               struct anv_device_memory *mem,
> +                               const VkImportAndroidHardwareBufferInfoANDROID *info);
> +
> +VkResult anv_create_ahw_memory(VkDevice device_h,
> +                               struct anv_device_memory *mem,
> +                               const VkMemoryAllocateInfo *pAllocateInfo);
>   #endif /* ANV_ANDROID_H */
> diff --git a/src/intel/vulkan/anv_android_stubs.c b/src/intel/vulkan/anv_android_stubs.c
> index 0671d5635ee..ccc16500494 100644
> --- a/src/intel/vulkan/anv_android_stubs.c
> +++ b/src/intel/vulkan/anv_android_stubs.c
> @@ -39,3 +39,19 @@ anv_ahw_usage_from_vk_usage(const VkImageCreateFlags vk_create,
>   {
>      return 0;
>   }
> +
> +VkResult
> +anv_import_ahw_memory(VkDevice device_h,
> +                      struct anv_device_memory *mem,
> +                      const VkImportAndroidHardwareBufferInfoANDROID *info)
> +{
> +   return VK_ERROR_EXTENSION_NOT_PRESENT;
> +}
> +
> +VkResult
> +anv_create_ahw_memory(VkDevice device_h,
> +                      struct anv_device_memory *mem,
> +                      const VkMemoryAllocateInfo *pAllocateInfo)
> +{
> +   return VK_ERROR_EXTENSION_NOT_PRESENT;
> +}
> diff --git a/src/intel/vulkan/anv_device.c b/src/intel/vulkan/anv_device.c
> index 0cbbaeca3b3..a1ee9315956 100644
> --- a/src/intel/vulkan/anv_device.c
> +++ b/src/intel/vulkan/anv_device.c
> @@ -2268,6 +2268,7 @@ VkResult anv_AllocateMemory(
>      mem->type = &pdevice->memory.types[pAllocateInfo->memoryTypeIndex];
>      mem->map = NULL;
>      mem->map_size = 0;
> +   mem->ahw = NULL;
>   
>      uint64_t bo_flags = 0;
>   
> @@ -2290,6 +2291,43 @@ VkResult anv_AllocateMemory(
>      if (pdevice->use_softpin)
>         bo_flags |= EXEC_OBJECT_PINNED;
>   
> +   const VkExportMemoryAllocateInfo *export_info =
> +      vk_find_struct_const(pAllocateInfo->pNext, EXPORT_MEMORY_ALLOCATE_INFO);
> +
> +   /* Check if we need to support Android HW buffer export. If so,
> +    * create AHardwareBuffer and import memory from it.
> +    */
> +   bool android_export = false;
> +   if (export_info && export_info->handleTypes &
> +       VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID)
> +      android_export = true;
> +
> +   /* Android memory import. */
> +   const struct VkImportAndroidHardwareBufferInfoANDROID *ahw_import_info =
> +      vk_find_struct_const(pAllocateInfo->pNext,
> +                           IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID);
> +
> +   if (ahw_import_info) {
> +      result = anv_import_ahw_memory(_device, mem, ahw_import_info);
> +      if (result != VK_SUCCESS)
> +         goto fail;
> +
> +      goto success;
> +   } else if (android_export) {
> +      result = anv_create_ahw_memory(_device, mem, pAllocateInfo);
> +      if (result != VK_SUCCESS)
> +         goto fail;
> +
> +      const struct VkImportAndroidHardwareBufferInfoANDROID import_info = {
> +         .buffer = mem->ahw,
> +      };
> +      result = anv_import_ahw_memory(_device, mem, &import_info);
> +      if (result != VK_SUCCESS)
> +         goto fail;


I wonder if we can ever fail importing the buffer we've just allocated.

If we do, then we might need to free the buffer before exiting, 
otherwise just assert(result == VK_SUCCESS); ?


> +
> +      goto success;
> +   }
> +
>      const VkImportMemoryFdInfoKHR *fd_info =
>         vk_find_struct_const(pAllocateInfo->pNext, IMPORT_MEMORY_FD_INFO_KHR);
>   
> @@ -2345,8 +2383,6 @@ VkResult anv_AllocateMemory(
>   
>      /* Regular allocate (not importing memory). */
>   
> -   const VkExportMemoryAllocateInfoKHR *export_info =
> -      vk_find_struct_const(pAllocateInfo->pNext, EXPORT_MEMORY_ALLOCATE_INFO_KHR);
>      if (export_info && export_info->handleTypes)
>         bo_flags |= ANV_BO_EXTERNAL;
>   
> @@ -2450,6 +2486,11 @@ void anv_FreeMemory(
>   
>      anv_bo_cache_release(device, &device->bo_cache, mem->bo);
>   
> +#ifdef ANDROID
> +   if (mem->ahw)
> +      AHardwareBuffer_release(mem->ahw);
> +#endif
> +
>      vk_free2(&device->alloc, pAllocator, mem);
>   }
>   
> diff --git a/src/intel/vulkan/anv_private.h b/src/intel/vulkan/anv_private.h
> index c855f9e4b0d..bd899dcb828 100644
> --- a/src/intel/vulkan/anv_private.h
> +++ b/src/intel/vulkan/anv_private.h
> @@ -1413,6 +1413,11 @@ struct anv_device_memory {
>      struct anv_memory_type *                     type;
>      VkDeviceSize                                 map_size;
>      void *                                       map;
> +
> +   /* If set, we are holding reference to AHardwareBuffer
> +    * which we must release when memory is freed.
> +    */
> +   struct AHardwareBuffer *                     ahw;
>   };
>   
>   /**




More information about the mesa-dev mailing list