[SYCL][Docs] Add sycl_ext_oneapi_inter_process_communication

llvm/include/llvm/SYCLLowerIR/DeviceConfigFile.td

@@ -98,6 +98,7 @@ def Aspectext_oneapi_clock_sub_group : Aspect<"ext_oneapi_clock_sub_group">;
 def Aspectext_oneapi_clock_work_group : Aspect<"ext_oneapi_clock_work_group">;
 def Aspectext_oneapi_clock_device : Aspect<"ext_oneapi_clock_device">;
 def Aspectext_oneapi_is_integrated_gpu : Aspect<"ext_oneapi_is_integrated_gpu">;
+def Aspectext_oneapi_ipc_memory : Aspect<"ext_oneapi_ipc_memory">;
 
 // Deprecated aspects
 def AspectInt64_base_atomics : Aspect<"int64_base_atomics">;
@@ -176,7 +177,8 @@ def : TargetInfo<"__TestAspectList",
     Aspectext_oneapi_clock_sub_group,
     Aspectext_oneapi_clock_work_group,
     Aspectext_oneapi_clock_device,
-    Aspectext_oneapi_is_integrated_gpu],
+    Aspectext_oneapi_is_integrated_gpu,
+    Aspectext_oneapi_ipc_memory],
     []>;
 // This definition serves the only purpose of testing whether the deprecated aspect list defined in here and in SYCL RT
 // match.

sycl/doc/extensions/experimental/sycl_ext_oneapi_inter_process_communication.asciidoc

@@ -0,0 +1,221 @@
+= sycl_ext_oneapi_inter_process_communication
+
+:source-highlighter: coderay
+:coderay-linenums-mode: table
+
+// This section needs to be after the document title.
+:doctype: book
+:toc2:
+:toc: left
+:encoding: utf-8
+:lang: en
+:dpcpp: pass:[DPC++]
+:endnote: —{nbsp}end{nbsp}note
+
+// Set the default source code type in this document to C++,
+// for syntax highlighting purposes.  This is needed because
+// docbook uses c++ and html5 uses cpp.
+:language: {basebackend@docbook:c++:cpp}
+
+
+== Notice
+
+[%hardbreaks]
+Copyright (C) 2025 Intel Corporation.  All rights reserved.
+
+Khronos(R) is a registered trademark and SYCL(TM) and SPIR(TM) are trademarks
+of The Khronos Group Inc.  OpenCL(TM) is a trademark of Apple Inc. used by
+permission by Khronos.
+
+
+== Contact
+
+To report problems with this extension, please open a new issue at:
+
+https://github.com/intel/llvm/issues
+
+
+== Dependencies
+
+This extension is written against the SYCL 2020 revision 10 specification.  All
+references below to the "core SYCL specification" or to section numbers in the
+SYCL specification refer to that revision.
+
+
+== Status
+
+This is an experimental extension specification, intended to provide early
+access to features and gather community feedback.  Interfaces defined in this
+specification are implemented in {dpcpp}, but they are not finalized and may
+change incompatibly in future versions of {dpcpp} without prior notice.
+*Shipping software products should not rely on APIs defined in this
+specification.*
+
+
+== Overview
+
+This extension adds the ability for SYCL programs to share device USM memory
+allocations between processes. This is done by the allocating process creating
+a new IPC memory handle through the new free frunctions and transferring the
+returned handle data to the other processes. The other processes can use the
+handle data to retrieve the corresponding device USM memory.
+
+
+== Specification
+
+=== Feature test macro
+
+This extension provides a feature-test macro as described in the core SYCL
+specification.  An implementation supporting this extension must predefine the
+macro `SYCL_EXT_ONEAPI_INTER_PROCESS_COMMUNICATION` to one of the values defined
+in the table below.  Applications can test for the existence of this macro to
+determine if the implementation supports this feature, or applications can test
+the macro's value to determine which of the extension's features the
+implementation supports.
+
+[%header,cols="1,5"]
+|===
+|Value
+|Description
+
+|1
+|The APIs of this experimental extension are not versioned, so the
+ feature-test macro always has this value.
+|===
+
+=== Extension to `enum class aspect`
+
+[source]
+----
+namespace sycl {
+enum class aspect {
+  ...
+  ext_oneapi_ipc_memory
+}
+}
+----
+
+If a SYCL device has this aspect, that device supports `ipc_memory::get()` free
+function specified in the following section.
+
+
+=== Inter-process communicable memory
+
+
+This extension adds new free functions under the `ipc_memory` experimental
+namespace.
+
+```
+namespace sycl::ext::oneapi::experimental::ipc_memory {
+
+using handle_data_t = std::vector<char>;
+
+handle_data_t get(void *ptr, const sycl::context &ctx);
+
+void put(handle_data_t &handle_data, const sycl::context &ctx);
+
+static void *open(handle_data_t handle_data, const sycl::context &ctx,
+                  const sycl::device &dev);
+
+static void close(void *ptr, const sycl::context &ctx);
+
+}
+```
+
+|====
+a|
+[frame=all,grid=none]
+!====
+a!
+[source]
+----
+handle_data_t get(void *ptr, const sycl::context &ctx)
+----
+!====
+
+_Preconditions:_ `ptr` is a pointer to USM device memory on some device _D_ in
+context `ctx` and device _D_ returns `true` for
+`device::has(aspect::ext_oneapi_ipc_memory)`.
+
+_Returns:_ An IPC "handle" to this USM memory allocation. The bytes of this
+handle can be transferred to another process on the same system, and the other
+process can use the handle to get a pointer to the same USM allocation through a
+call to the `open()` function.
+
+!====
+a!
+[source]
+----
+void put(handle_data_t &handle_data, const sycl::context &ctx)
+----
+!====
+
+_Preconditions:_ `handle_data` is the IPC "handle" to USM device memory that was
+returned from a call to get either in this process or in some other process on
+the same system. The USM device memory has not yet been freed in this process.
+
+_Effects:_ Deallocates resources associated with the handle. These resources are
+automatically deallocated when the USM device memory is freed, so it is not
+strictly necessary to call the `put` function.
+
+!====
+a!
+[source]
+----
+static void *open(handle_data_t &handle_data, const sycl::context &ctx,
+                  const sycl::device &dev)
+----
+!====
+
+_Preconditions:_ `handle_data` is the IPC "handle" to USM device memory that was
+returned from a call to the `get` function either in this process or in some
+other process on the same system. That USM device memory is accessible on device
+`dev`.
+
+_Returns:_ A pointer to the same USM device memory represented by `handle_data`.
+This pointer can be used in any API taking a USM device memory pointer, except
+it cannot be passed to `sycl::free`. Instead, use the `close` function to free
+this memory pointer.
+
+_Throws:_
+ * An exception with the `errc::feature_not_supported` error code if device
+   `dev` does not have `aspect::ext_oneapi_ipc_memory`.
+ * An exception with the `errc::invalid` error code if the handle data
+   `handle_data` has an unexpected number of bytes.
+
+!====
+a!
+[source]
+----
+static void close(void *ptr, const sycl::context &ctx)
+----
+!====
+
+_Effects:_ Closes a device USM pointer previously returned by a call to
+`open()`.
+
+|====
+
+
+== Issues
+
+=== Level Zero file descriptor duplication dependency
+
+The IPC memory APIs in Level Zero on Linux currently requires the ability to
+duplicate file descriptors between processes. For security this is not allowed
+by default on Linux-based systems, so in order for the IPC memory APIs to work
+with Level Zero on Linux the user must either call `prctl(PR_SET_PTRACER, ...)`
+in the IPC handle owner process or enable the functionality globally using
+
+```bash
+sudo bash -c "echo 0 > /proc/sys/kernel/yama/ptrace_scope"
+```
+
+See also https://github.com/oneapi-src/unified-memory-framework/tree/main?tab=readme-ov-file#level-zero-memory-provider.
+
+
+=== Level Zero IPC memory Windows support
+
+The new IPC memory APIs are not currently supported on the Level Zero backend on
+Windows systems.
+

sycl/include/sycl/ext/oneapi/experimental/ipc_memory.hpp

@@ -0,0 +1,39 @@
+//==------- ipc_memory.hpp --- SYCL inter-process communicable memory ------==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include <sycl/detail/defines_elementary.hpp>
+#include <sycl/detail/export.hpp>
+#include <sycl/detail/owner_less_base.hpp>
+#include <sycl/sycl_span.hpp>
+
+#include <memory>
+
+namespace sycl {
+inline namespace _V1 {
+
+class context;
+class device;
+
+namespace ext::oneapi::experimental::ipc_memory {
+
+using handle_data_t = std::vector<char>;
+
+__SYCL_EXPORT handle_data_t get(void *Ptr, const sycl::context &Ctx);
+
+__SYCL_EXPORT void put(handle_data_t &HandleData, const sycl::context &Ctx);
+
+__SYCL_EXPORT void *open(handle_data_t &HandleData, const sycl::context &Ctx,
+                         const sycl::device &Dev);
+
+__SYCL_EXPORT void close(void *Ptr, const sycl::context &Ctx);
+
+} // namespace ext::oneapi::experimental::ipc_memory
+} // namespace _V1
+} // namespace sycl

sycl/include/sycl/info/aspects.def

@@ -84,3 +84,4 @@ __SYCL_ASPECT(ext_oneapi_clock_sub_group, 91)
 __SYCL_ASPECT(ext_oneapi_clock_work_group, 92)
 __SYCL_ASPECT(ext_oneapi_clock_device, 93)
 __SYCL_ASPECT(ext_oneapi_is_integrated_gpu, 94)
+__SYCL_ASPECT(ext_oneapi_ipc_memory, 95)

sycl/include/sycl/sycl.hpp

@@ -128,6 +128,7 @@ can be disabled by setting SYCL_DISABLE_FSYCL_SYCLHPP_WARNING macro.")
 #include <sycl/ext/oneapi/experimental/group_helpers_sorters.hpp>
 #include <sycl/ext/oneapi/experimental/group_load_store.hpp>
 #include <sycl/ext/oneapi/experimental/group_sort.hpp>
+#include <sycl/ext/oneapi/experimental/ipc_memory.hpp>
 #include <sycl/ext/oneapi/experimental/prefetch.hpp>
 #include <sycl/ext/oneapi/experimental/profiling_tag.hpp>
 #include <sycl/ext/oneapi/experimental/raw_kernel_arg.hpp>

sycl/source/CMakeLists.txt

@@ -322,6 +322,7 @@ set(SYCL_COMMON_SOURCES
     "handler.cpp"
     "image.cpp"
     "interop_handle.cpp"
+    "ipc_memory.cpp"
     "kernel.cpp"
     "kernel_bundle.cpp"
     "physical_mem.cpp"

sycl/source/detail/device_impl.hpp

@@ -1597,6 +1597,10 @@ class device_impl : public std::enable_shared_from_this<device_impl> {
              get_info_impl_nocheck<UR_DEVICE_INFO_IS_INTEGRATED_GPU>().value_or(
                  0);
     }
+    CASE(ext_oneapi_ipc_memory) {
+      return get_info_impl_nocheck<UR_DEVICE_INFO_IPC_MEMORY_SUPPORT_EXP>()
+          .value_or(0);
+    }
     else {
       return false; // This device aspect has not been implemented yet.
     }

sycl/source/detail/ur_device_info_ret_types.inc

@@ -162,6 +162,7 @@ MAP(UR_DEVICE_INFO_NODE_MASK, uint32_t)
 // These aren't present in the specification, extracted from ur_api.h
 // instead.
 MAP(UR_DEVICE_INFO_2D_BLOCK_ARRAY_CAPABILITIES_EXP, ur_exp_device_2d_block_array_capability_flags_t)
+MAP(UR_DEVICE_INFO_IPC_MEMORY_SUPPORT_EXP, ur_bool_t)
 MAP(UR_DEVICE_INFO_ASYNC_USM_ALLOCATIONS_SUPPORT_EXP, ur_bool_t)
 MAP(UR_DEVICE_INFO_BINDLESS_IMAGES_1D_USM_SUPPORT_EXP, ur_bool_t)
 MAP(UR_DEVICE_INFO_BINDLESS_IMAGES_2D_USM_SUPPORT_EXP, ur_bool_t)

sycl/source/feature_test.hpp.in

@@ -127,6 +127,7 @@ inline namespace _V1 {
 #define SYCL_KHR_DEFAULT_CONTEXT 1
 #define SYCL_EXT_INTEL_EVENT_MODE 1
 #define SYCL_EXT_ONEAPI_TANGLE 1
+#define SYCL_EXT_ONEAPI_IPC 1
 
 // Unfinished KHR extensions. These extensions are only available if the
 // __DPCPP_ENABLE_UNFINISHED_KHR_EXTENSIONS macro is defined.

sycl/source/ipc_memory.cpp

@@ -0,0 +1,71 @@
+//==------- ipc_memory.cpp --- SYCL inter-process communicable memory ------==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <detail/adapter_impl.hpp>
+#include <detail/context_impl.hpp>
+#include <sycl/context.hpp>
+#include <sycl/ext/oneapi/experimental/ipc_memory.hpp>
+
+namespace sycl {
+inline namespace _V1 {
+namespace ext::oneapi::experimental::ipc_memory {
+
+__SYCL_EXPORT handle_data_t get(void *Ptr, const sycl::context &Ctx) {
+  auto CtxImpl = sycl::detail::getSyclObjImpl(Ctx);
+  sycl::detail::adapter_impl &Adapter = CtxImpl->getAdapter();
+
+  size_t HandleSize = 0;
+  Adapter.call<sycl::detail::UrApiKind::urIPCGetMemHandleExp>(
+      CtxImpl->getHandleRef(), Ptr, nullptr, &HandleSize);
+
+  handle_data_t Res(HandleSize);
+  Adapter.call<sycl::detail::UrApiKind::urIPCGetMemHandleExp>(
+      CtxImpl->getHandleRef(), Ptr, Res.data(), nullptr);
+  return Res;
+}
+
+__SYCL_EXPORT void put(handle_data_t &HandleData, const sycl::context &Ctx) {
+  auto CtxImpl = sycl::detail::getSyclObjImpl(Ctx);
+  sycl::detail::adapter_impl &Adapter = CtxImpl->getAdapter();
+  Adapter.call<sycl::detail::UrApiKind::urIPCPutMemHandleExp>(
+      CtxImpl->getHandleRef(), HandleData.data());
+}
+
+__SYCL_EXPORT void *open(handle_data_t &HandleData, const sycl::context &Ctx,
+                         const sycl::device &Dev) {
+  if (!Dev.has(aspect::ext_oneapi_ipc_memory))
+    throw sycl::exception(
+        sycl::make_error_code(errc::feature_not_supported),
+        "Device does not support aspect::ext_oneapi_ipc_memory.");
+
+  auto CtxImpl = sycl::detail::getSyclObjImpl(Ctx);
+  sycl::detail::adapter_impl &Adapter = CtxImpl->getAdapter();
+
+  void *Ptr = nullptr;
+  ur_result_t UrRes =
+      Adapter.call_nocheck<sycl::detail::UrApiKind::urIPCOpenMemHandleExp>(
+          CtxImpl->getHandleRef(), getSyclObjImpl(Dev)->getHandleRef(),
+          HandleData.data(), HandleData.size(), &Ptr);
+  if (UrRes == UR_RESULT_ERROR_INVALID_VALUE)
+    throw sycl::exception(sycl::make_error_code(errc::invalid),
+                          "HandleData data size does not correspond "
+                          "to the target platform's IPC memory handle size.");
+  Adapter.checkUrResult(UrRes);
+  return Ptr;
+}
+
+__SYCL_EXPORT void close(void *Ptr, const sycl::context &Ctx) {
+  auto CtxImpl = sycl::detail::getSyclObjImpl(Ctx);
+  sycl::detail::adapter_impl &Adapter = CtxImpl->getAdapter();
+  Adapter.call<sycl::detail::UrApiKind::urIPCCloseMemHandleExp>(
+      CtxImpl->getHandleRef(), Ptr);
+}
+
+} // namespace ext::oneapi::experimental::ipc_memory
+} // namespace _V1
+} // namespace sycl