[SYCL][Bindless] Add DX11 memory interop (#19217)

In DX11 Texture1D and Texture3D cannot be shared between process or
devices, so only Texture2D is used but its layout is adapted (height =
1 for 1D and ArraySlices = depth for 3D) for the interop purposes and
testing 1D and 3D image operations on it in the SYCL kernel.
The new DXGI adapter selection fixes issues with non-matching devices
between DX and SYCL which also failed the DX12 tests when more than 1
potential adapter is visible to DirectX. Ideally the introduction of
LUIDs to SYCL will resolve that completely when they are properly
matched. The future flow should change to - 1) create SYCL device (so
the device selection itself can be manipulated via
`ONEAPI_DEVICE_SELECTOR`) , 2) get DXGI adapter for creating a DX
logical device (D3D11 or D3D12) by matching adapter LUIDs (this is going
to depend on a LUID device info query extension for SYCL).

Some notes on synchronisation:

- IKeyedMutex is required for synchronising the access to the shared
resource (texture) between devices or processes.
- Currently the SYCL queue calls wait after submission to execute
immediately and block until completion, but we can use ID3D11Fence
imported in SYCL to signal the completion of the work to D3D11 via SYCL
in the future when this kind of interop is considered.

Author: GeorgeWeb

sycl/doc/extensions/experimental/sycl_ext_oneapi_bindless_images.asciidoc

@@ -2075,6 +2075,7 @@ enum class external_mem_handle_type {
   win32_nt_handle = 1,
   win32_nt_dx12_resource = 2,
   dma_buf = 3,
+  win32_nt_dx11_resource = 4,
 };
 
 // Descriptor templated on specific resource type
@@ -2739,3 +2740,6 @@ This query should be added in a later revision of the proposal.
                   - Clarify how and when external memory should be unmapped.
 |6.11|2025-06-16| - Add `external_mem_handle_type::dma_buf`
                   - Add `supports_importing_handle_type`
+|6.12|2025-07-03| - Add `win32_nt_dx11_resource` enum entry to
+                    `external_mem_handle_type` for Direct3D 11 memory interop.
+|======================

sycl/include/sycl/ext/oneapi/bindless_images_interop.hpp

@@ -22,6 +22,7 @@ enum class external_mem_handle_type {
   win32_nt_handle = 1,
   win32_nt_dx12_resource = 2,
   dma_buf = 3,
+  win32_nt_dx11_resource = 4,
 };
 
 // Types of external semaphore handles

sycl/source/detail/bindless_images.cpp

@@ -406,6 +406,8 @@ to_ur_type(external_mem_handle_type externalMemHandleType) {
     return UR_EXP_EXTERNAL_MEM_TYPE_DMA_BUF;
   case external_mem_handle_type::win32_nt_handle:
     return UR_EXP_EXTERNAL_MEM_TYPE_WIN32_NT;
+  case external_mem_handle_type::win32_nt_dx11_resource:
+    return UR_EXP_EXTERNAL_MEM_TYPE_WIN32_NT_DX11_RESOURCE;
   case external_mem_handle_type::win32_nt_dx12_resource:
     return UR_EXP_EXTERNAL_MEM_TYPE_WIN32_NT_DX12_RESOURCE;
   default:
@@ -471,6 +473,7 @@ __SYCL_EXPORT external_mem import_external_memory<resource_win32_handle>(
 
   const auto urHandleType = detail::to_ur_type(externalMemDesc.handle_type);
   if ((urHandleType != UR_EXP_EXTERNAL_MEM_TYPE_WIN32_NT) &&
+      (urHandleType != UR_EXP_EXTERNAL_MEM_TYPE_WIN32_NT_DX11_RESOURCE) &&
       (urHandleType != UR_EXP_EXTERNAL_MEM_TYPE_WIN32_NT_DX12_RESOURCE)) {
     throw sycl::exception(sycl::make_error_code(sycl::errc::invalid),
                           "Invalid memory handle type");

sycl/test-e2e/bindless_images/dx11_interop/dx11_interop.h

@@ -0,0 +1,76 @@
+#ifndef DX11_INTEROP_H
+#define DX11_INTEROP_H
+
+#pragma clang diagnostic ignored "-Waddress-of-temporary"
+
+#include "../helpers/common.hpp"
+#include "../helpers/dx_interop_common.hpp"
+
+#include <sycl/detail/core.hpp>
+#include <sycl/device.hpp>
+
+#include <atomic>
+#include <string_view>
+
+using namespace dx_helpers;
+
+namespace dx11_interop {
+
+/// @brief
+struct D3D11ProgramState {
+  // device management
+  ID3D11Device *device{nullptr};
+  ID3D11DeviceContext *deviceContext{nullptr};
+
+  // Temporary, this is to be replaced by LUID.
+  // Can also store a DXGI_ADAPTER_DESC if more state is needed.
+  std::string deviceName;
+
+  // Keyed mutex ID for synchronizing access to the shared resource.
+  std::atomic<UINT64> key;
+
+  D3D11ProgramState(const sycl::device &syclDevice);
+  ~D3D11ProgramState();
+};
+
+D3D11ProgramState::D3D11ProgramState(const sycl::device &syclDevice) {
+  UINT dxgiFactoryFlags = 0;
+#if WITH_DX_DEBUG
+  dxgiFactoryFlags |= DXGI_CREATE_FACTORY_DEBUG;
+#endif
+  ComPtr<IDXGIFactory3> factory;
+  ThrowIfFailed(CreateDXGIFactory2(dxgiFactoryFlags, IID_PPV_ARGS(&factory)));
+
+  auto hardwareAdapter = getDXGIHardwareAdapter<dx_version::DX11>(
+      factory.Get(), syclDevice.get_info<sycl::info::device::name>());
+  assert(hardwareAdapter && "Invalid DirectX hardware adapter.");
+
+  // Creating the D3D11 device.
+  UINT deviceFlags = 0;
+#if defined(D3D_DEVICE_DEBUG)
+  deviceFlags |= D3D11_CREATE_DEVICE_DEBUG;
+#endif
+  constexpr D3D_FEATURE_LEVEL requestedFeatureLevel = D3D_FEATURE_LEVEL_11_0;
+  D3D_FEATURE_LEVEL featureLevel;
+  ThrowIfFailed(D3D11CreateDevice(hardwareAdapter.Get(),
+                                  D3D_DRIVER_TYPE_UNKNOWN, nullptr, deviceFlags,
+                                  &requestedFeatureLevel, 1, D3D11_SDK_VERSION,
+                                  &device, &featureLevel, &deviceContext));
+
+  // Get the description of the adapter which contains the LUID, etc.
+  DXGI_ADAPTER_DESC1 adapterDesc;
+  ThrowIfFailed(hardwareAdapter->GetDesc1(&adapterDesc));
+
+  deviceName = getD3DDeviceName(adapterDesc);
+}
+
+D3D11ProgramState::~D3D11ProgramState() {
+  if (device)
+    device->Release();
+  if (deviceContext)
+    deviceContext->Release();
+}
+
+} // namespace dx11_interop
+
+#endif // DX11_INTEROP_H