Merge pull request #1696 from nrspruit/l0_windows_interop

[L0] Support for Bindless Image Import

Author: kbenzie

source/adapters/level_zero/device.hpp

@@ -44,6 +44,18 @@ struct ze_global_memsize {
   uint64_t value;
 };
 
+enum ur_ze_external_memory_desc_type {
+  UR_ZE_EXTERNAL_OPAQUE_FD,
+  UR_ZE_EXTERNAL_WIN32,
+};
+
+struct ur_ze_external_memory_data {
+  void *importExtensionDesc;
+  ur_mem_handle_t urMemoryHandle;
+  enum ur_ze_external_memory_desc_type type;
+  size_t size;
+};
+
 struct ur_device_handle_t_ : _ur_object {
   ur_device_handle_t_(ze_device_handle_t Device, ur_platform_handle_t Plt,
                       ur_device_handle_t ParentDevice = nullptr)

source/adapters/level_zero/image.cpp

@@ -964,42 +964,122 @@ UR_APIEXPORT ur_result_t UR_APICALL urBindlessImagesImportExternalMemoryExp(
     ur_exp_external_mem_type_t memHandleType,
     ur_exp_interop_mem_desc_t *pInteropMemDesc,
     ur_exp_interop_mem_handle_t *phInteropMem) {
-  std::ignore = hContext;
-  std::ignore = hDevice;
-  std::ignore = size;
-  std::ignore = memHandleType;
-  std::ignore = pInteropMemDesc;
-  std::ignore = phInteropMem;
-  logger::error(logger::LegacyMessage("[UR][L0] {} function not implemented!"),
-                "{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+
+  UR_ASSERT(hContext && hDevice, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
+  UR_ASSERT(pInteropMemDesc && phInteropMem,
+            UR_RESULT_ERROR_INVALID_NULL_POINTER);
+
+  struct ur_ze_external_memory_data *externalMemoryData =
+      new struct ur_ze_external_memory_data;
+
+  void *pNext = const_cast<void *>(pInteropMemDesc->pNext);
+  while (pNext != nullptr) {
+    const ur_base_desc_t *BaseDesc = static_cast<const ur_base_desc_t *>(pNext);
+    if (BaseDesc->stype == UR_STRUCTURE_TYPE_EXP_FILE_DESCRIPTOR) {
+      ze_external_memory_import_fd_t *importFd =
+          new ze_external_memory_import_fd_t;
+      importFd->stype = ZE_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMPORT_FD;
+      importFd->pNext = nullptr;
+      auto FileDescriptor =
+          static_cast<const ur_exp_file_descriptor_t *>(pNext);
+      importFd->fd = FileDescriptor->fd;
+      importFd->flags = ZE_EXTERNAL_MEMORY_TYPE_FLAG_OPAQUE_FD;
+      externalMemoryData->importExtensionDesc = importFd;
+      externalMemoryData->type = UR_ZE_EXTERNAL_OPAQUE_FD;
+    } else if (BaseDesc->stype == UR_STRUCTURE_TYPE_EXP_WIN32_HANDLE) {
+      ze_external_memory_import_win32_handle_t *importWin32 =
+          new ze_external_memory_import_win32_handle_t;
+      importWin32->stype = ZE_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMPORT_WIN32;
+      importWin32->pNext = nullptr;
+      auto Win32Handle = static_cast<const ur_exp_win32_handle_t *>(pNext);
+
+      switch (memHandleType) {
+      case UR_EXP_EXTERNAL_MEM_TYPE_WIN32_NT:
+        importWin32->flags = ZE_EXTERNAL_MEMORY_TYPE_FLAG_OPAQUE_WIN32;
+        break;
+      case UR_EXP_EXTERNAL_MEM_TYPE_WIN32_NT_DX12_RESOURCE:
+        importWin32->flags = ZE_EXTERNAL_MEMORY_TYPE_FLAG_D3D12_RESOURCE;
+        break;
+      case UR_EXP_EXTERNAL_MEM_TYPE_OPAQUE_FD:
+      default:
+        return UR_RESULT_ERROR_INVALID_VALUE;
+      }
+      importWin32->handle = Win32Handle->handle;
+      externalMemoryData->importExtensionDesc = importWin32;
+      externalMemoryData->type = UR_ZE_EXTERNAL_WIN32;
+    }
+    pNext = const_cast<void *>(BaseDesc->pNext);
+  }
+  externalMemoryData->size = size;
+
+  *phInteropMem =
+      reinterpret_cast<ur_exp_interop_mem_handle_t>(externalMemoryData);
+  return UR_RESULT_SUCCESS;
 }
 
 UR_APIEXPORT ur_result_t UR_APICALL urBindlessImagesMapExternalArrayExp(
     ur_context_handle_t hContext, ur_device_handle_t hDevice,
     const ur_image_format_t *pImageFormat, const ur_image_desc_t *pImageDesc,
     ur_exp_interop_mem_handle_t hInteropMem,
     ur_exp_image_mem_handle_t *phImageMem) {
-  std::ignore = hContext;
-  std::ignore = hDevice;
-  std::ignore = pImageFormat;
-  std::ignore = pImageDesc;
-  std::ignore = hInteropMem;
-  std::ignore = phImageMem;
-  logger::error(logger::LegacyMessage("[UR][L0] {} function not implemented!"),
-                "{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+
+  UR_ASSERT(hContext && hDevice && hInteropMem,
+            UR_RESULT_ERROR_INVALID_NULL_HANDLE);
+  UR_ASSERT(pImageFormat && pImageDesc, UR_RESULT_ERROR_INVALID_NULL_POINTER);
+
+  struct ur_ze_external_memory_data *externalMemoryData =
+      reinterpret_cast<ur_ze_external_memory_data *>(hInteropMem);
+
+  ze_image_bindless_exp_desc_t ZeImageBindlessDesc = {};
+  ZeImageBindlessDesc.stype = ZE_STRUCTURE_TYPE_BINDLESS_IMAGE_EXP_DESC;
+
+  ZeStruct<ze_image_desc_t> ZeImageDesc;
+  UR_CALL(ur2zeImageDesc(pImageFormat, pImageDesc, ZeImageDesc));
+
+  ZeImageBindlessDesc.pNext = externalMemoryData->importExtensionDesc;
+  ZeImageBindlessDesc.flags = ZE_IMAGE_BINDLESS_EXP_FLAG_BINDLESS;
+  ZeImageDesc.pNext = &ZeImageBindlessDesc;
+
+  ze_image_handle_t ZeImage;
+  ZE2UR_CALL(zeImageCreate,
+             (hContext->ZeContext, hDevice->ZeDevice, &ZeImageDesc, &ZeImage));
+  ZE2UR_CALL(zeContextMakeImageResident,
+             (hContext->ZeContext, hDevice->ZeDevice, ZeImage));
+  UR_CALL(createUrMemFromZeImage(hContext, ZeImage, /*OwnZeMemHandle*/ true,
+                                 ZeImageDesc, phImageMem));
+  externalMemoryData->urMemoryHandle =
+      reinterpret_cast<ur_mem_handle_t>(*phImageMem);
+  return UR_RESULT_SUCCESS;
 }
 
 UR_APIEXPORT ur_result_t UR_APICALL urBindlessImagesReleaseInteropExp(
     ur_context_handle_t hContext, ur_device_handle_t hDevice,
     ur_exp_interop_mem_handle_t hInteropMem) {
-  std::ignore = hContext;
-  std::ignore = hDevice;
-  std::ignore = hInteropMem;
-  logger::error(logger::LegacyMessage("[UR][L0] {} function not implemented!"),
-                "{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+
+  UR_ASSERT(hContext && hDevice && hInteropMem,
+            UR_RESULT_ERROR_INVALID_NULL_HANDLE);
+
+  struct ur_ze_external_memory_data *externalMemoryData =
+      reinterpret_cast<ur_ze_external_memory_data *>(hInteropMem);
+
+  UR_CALL(urMemRelease(externalMemoryData->urMemoryHandle));
+
+  switch (externalMemoryData->type) {
+  case UR_ZE_EXTERNAL_OPAQUE_FD:
+    delete (reinterpret_cast<ze_external_memory_import_fd_t *>(
+        externalMemoryData->importExtensionDesc));
+    break;
+  case UR_ZE_EXTERNAL_WIN32:
+    delete (reinterpret_cast<ze_external_memory_import_win32_handle_t *>(
+        externalMemoryData->importExtensionDesc));
+    break;
+  default:
+    return UR_RESULT_ERROR_INVALID_VALUE;
+  }
+
+  delete (externalMemoryData);
+
+  return UR_RESULT_SUCCESS;
 }
 
 UR_APIEXPORT ur_result_t UR_APICALL urBindlessImagesImportExternalSemaphoreExp(