[L0] Implement IPC ops for L0 adapter

Author: kswiecicki

source/adapters/level_zero/usm.cpp

@@ -18,6 +18,7 @@
 
 #include "logger/ur_logger.hpp"
 #include "ur_level_zero.hpp"
+#include "ur_util.hpp"
 
 #include <umf_helpers.hpp>
 
@@ -766,6 +767,97 @@ umf_result_t L0MemoryProvider::get_min_page_size(void *Ptr, size_t *PageSize) {
   return UMF_RESULT_SUCCESS;
 }
 
+typedef struct ze_ipc_data_t {
+  int pid;
+  ze_ipc_mem_handle_t zeHandle;
+} ze_ipc_data_t;
+
+umf_result_t L0MemoryProvider::get_ipc_handle_size(size_t *Size) {
+  UR_ASSERT(Size, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+  *Size = sizeof(ze_ipc_data_t);
+
+  return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t L0MemoryProvider::get_ipc_handle(const void *Ptr, size_t Size,
+                                              void *IpcData) {
+  std::ignore = Size;
+
+  UR_ASSERT(Ptr && IpcData, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+  ze_ipc_data_t *zeIpcData = (ze_ipc_data_t *)IpcData;
+  auto Ret = ZE_CALL_NOCHECK(zeMemGetIpcHandle,
+                             (Context->ZeContext, Ptr, &zeIpcData->zeHandle));
+  if (Ret != ZE_RESULT_SUCCESS) {
+    return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+  }
+
+  zeIpcData->pid = ur_getpid();
+
+  return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t L0MemoryProvider::put_ipc_handle(void *IpcData) {
+  UR_ASSERT(IpcData, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+  ze_ipc_data_t *zeIpcData = (ze_ipc_data_t *)IpcData;
+  std::ignore = zeIpcData;
+
+  // zeMemPutIpcHandle was introduced in Level Zero 1.6. Before Level Zero 1.6,
+  // IPC handle was released automatically when corresponding memory buffer
+  // was freed.
+#if (ZE_API_VERSION_CURRENT >= ZE_MAKE_VERSION(1, 6))
+  auto Ret = ZE_CALL_NOCHECK(zeMemPutIpcHandle,
+                             (Context->ZeContext, zeIpcData->zeHandle));
+  if (Ret != ZE_RESULT_SUCCESS) {
+    return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+  }
+#endif
+
+  return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t L0MemoryProvider::open_ipc_handle(void *IpcData, void **Ptr) {
+  UR_ASSERT(IpcData && Ptr, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+  ze_ipc_data_t *zeIpcData = (ze_ipc_data_t *)IpcData;
+
+  int fdLocal = -1;
+  if (zeIpcData->pid != ur_getpid()) {
+    int fdRemote = -1;
+    memcpy(&fdRemote, &zeIpcData->zeHandle, sizeof(fdRemote));
+    fdLocal = ur_duplicate_fd(zeIpcData->pid, fdRemote);
+    if (fdLocal == -1) {
+      logger::error("duplicating file descriptor from IPC handle failed");
+      return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+    }
+
+    memcpy(&zeIpcData->zeHandle, &fdLocal, sizeof(fdLocal));
+  }
+
+  auto Ret =
+      ZE_CALL_NOCHECK(zeMemOpenIpcHandle, (Context->ZeContext, Device->ZeDevice,
+                                           zeIpcData->zeHandle, 0, Ptr));
+  if (fdLocal != -1) {
+    ur_close_fd(fdLocal);
+  }
+
+  if (Ret != ZE_RESULT_SUCCESS) {
+    return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+  }
+
+  return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t L0MemoryProvider::close_ipc_handle(void *Ptr, size_t Size) {
+  std::ignore = Size;
+
+  UR_ASSERT(Ptr, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+  auto Ret = ZE_CALL_NOCHECK(zeMemCloseIpcHandle, (Context->ZeContext, Ptr));
+  if (Ret != ZE_RESULT_SUCCESS) {
+    return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+  }
+
+  return UMF_RESULT_SUCCESS;
+}
+
 ur_result_t L0SharedMemoryProvider::allocateImpl(void **ResultPtr, size_t Size,
                                                  uint32_t Alignment) {
   return USMSharedAllocImpl(ResultPtr, Context, Device, /*host flags*/ 0,

source/adapters/level_zero/usm.hpp

@@ -126,6 +126,11 @@ class L0MemoryProvider : public USMMemoryProviderBase {
   umf_result_t get_min_page_size(void *, size_t *) override;
   // TODO: Different name for each provider (Host/Shared/SharedRO/Device)
   const char *get_name() override { return "L0"; };
+  umf_result_t get_ipc_handle_size(size_t *) override;
+  umf_result_t get_ipc_handle(const void *, size_t, void *) override;
+  umf_result_t put_ipc_handle(void *) override;
+  umf_result_t open_ipc_handle(void *, void **) override;
+  umf_result_t close_ipc_handle(void *, size_t) override;
 };
 
 // Allocation routines for shared memory type