diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 5b7f9271ab034..196fffa19c569 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -41,11 +41,11 @@ sycl/include/sycl/detail/ur.hpp @intel/unified-runtime-reviewers
sycl/source/detail/posix_ur.cpp @intel/unified-runtime-reviewers
sycl/source/detail/ur.cpp @intel/unified-runtime-reviewers
sycl/source/detail/windows_ur.cpp @intel/unified-runtime-reviewers
-sycl/test-e2e/Plugin/ @intel/unified-runtime-reviewers
+sycl/test-e2e/Adapters/ @intel/unified-runtime-reviewers
# Win Proxy Loader
-sycl/pi_win_proxy_loader @intel/llvm-reviewers-runtime
-sycl/test-e2e/Plugin/dll-detach-order.cpp @intel/llvm-reviewers-runtime
+sycl/ur_win_proxy_loader @intel/llvm-reviewers-runtime
+sycl/test-e2e/Adapters/dll-detach-order.cpp @intel/llvm-reviewers-runtime
# CUDA specific runtime implementations
sycl/include/sycl/ext/oneapi/experimental/cuda/ @intel/llvm-reviewers-cuda
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 1954d8c8743b4..88207ccdbde96 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -58,7 +58,7 @@ To contribute:
- [The seven rules of a great Git commit message](https://cbea.ms/git-commit)
are recommended read and follow.
- To a reasonable extent, title tags can be used to signify the component
- changed, e.g.: `[PI]`, `[CUDA]`, `[Doc]`.
+ changed, e.g.: `[UR]`, `[CUDA]`, `[Doc]`.
- Create a pull request (PR) for your changes following
[Creating a pull request instructions](https://help.github.com/articles/creating-a-pull-request/).
- Make sure PR has a good description explaining all of the changes made,
diff --git a/buildbot/configure.py b/buildbot/configure.py
index 5a7fdd003a1de..b77a7cb2d4c3e 100644
--- a/buildbot/configure.py
+++ b/buildbot/configure.py
@@ -69,7 +69,7 @@ def do_configure(args):
if sys.platform != "darwin":
sycl_enabled_backends.append("level_zero")
- # lld is needed on Windows or for the HIP plugin on AMD
+ # lld is needed on Windows or for the HIP adapter on AMD
if platform.system() == "Windows" or (args.hip and args.hip_platform == "AMD"):
llvm_enable_projects += ";lld"
@@ -152,8 +152,8 @@ def do_configure(args):
libclc_targets_to_build += libclc_nvidia_target_names
libclc_gen_remangled_variants = "ON"
- if args.enable_plugin:
- sycl_enabled_backends += args.enable_plugin
+ if args.enable_backends:
+ sycl_enabled_backends += args.enable_backends
if args.disable_preview_lib:
sycl_preview_lib = "OFF"
@@ -374,7 +374,9 @@ def main():
parser.add_argument(
"--ci-defaults", action="store_true", help="Enable default CI parameters"
)
- parser.add_argument("--enable-plugin", action="append", help="Enable SYCL plugin")
+ parser.add_argument(
+ "--enable-backends", action="append", help="Enable SYCL backend"
+ )
parser.add_argument(
"--disable-preview-lib",
action="store_true",
diff --git a/sycl/doc/EnvironmentVariables.md b/sycl/doc/EnvironmentVariables.md
index 5ee2c40542ced..f018aac9c261d 100644
--- a/sycl/doc/EnvironmentVariables.md
+++ b/sycl/doc/EnvironmentVariables.md
@@ -23,7 +23,7 @@ compiler and runtime.
| `SYCL_ENABLE_DEFAULT_CONTEXTS` | '1' or '0' | Enable ('1') or disable ('0') creation of default platform contexts in SYCL runtime. The default context for each platform contains all devices in the platform. Refer to [Platform Default Contexts](extensions/supported/sycl_ext_oneapi_default_context.asciidoc) extension to learn more. Enabled by default on Linux and disabled on Windows. |
| `SYCL_RT_WARNING_LEVEL` | Positive integer | The higher warning level is used the more warnings and performance hints the runtime library may print. Default value is '0', which means no warning/hint messages from the runtime library are allowed. The value '1' enables performance warnings from device runtime/codegen. The values greater than 1 are reserved for future use. |
| `SYCL_USM_HOSTPTR_IMPORT` | Integer | Enable by specifying non-zero value. Buffers created with a host pointer will result in host data promotion to USM, improving data transfer performance. To use this feature, also set SYCL_HOST_UNIFIED_MEMORY=1. |
-| `SYCL_EAGER_INIT` | Integer | Enable by specifying non-zero value. Tells the SYCL runtime to do as much as possible initialization at objects construction as opposed to doing lazy initialization on the fly. This may mean doing some redundant work at warmup but ensures fastest possible execution on the following hot and reportable paths. It also instructs PI plugins to do the same. Default is "0". |
+| `SYCL_EAGER_INIT` | Integer | Enable by specifying non-zero value. Tells the SYCL runtime to do as much as possible initialization at objects construction as opposed to doing lazy initialization on the fly. This may mean doing some redundant work at warmup but ensures fastest possible execution on the following hot and reportable paths. It also instructs UR adapters to do the same. Default is "0". |
| `SYCL_REDUCTION_PREFERRED_WORKGROUP_SIZE` | See [below](#sycl_reduction_preferred_workgroup_size) | Controls the preferred work-group size of reductions. |
| `SYCL_ENABLE_FUSION_CACHING` | '1' or '0' | Enable ('1') or disable ('0') caching of JIT compilations for kernel fusion. Caching avoids repeatedly running the JIT compilation pipeline if the same sequence of kernels is fused multiple times. Default value is '1'. |
| `SYCL_JIT_AMDGCN_PTX_KERNELS` | '1' or '0' | Enable ('1') or disable ('0') JIT compilation of kernels. Only supported for Nvidia and AMD backends. Note, that it is required to have a valid binary for the desired backend (AMD or CUDA), that was compiled with `-fsycl-embed-ir` in order to use JIT-ing. When JIT-ing is enabled SYCL runtime will try to cache and reuse JIT-compiled kernels, furthermore if a kernel uses specialization constants the compiler will attempt to materialize the values in place, turning them to de-facto compile time constants. Default is '0'. |
@@ -153,23 +153,23 @@ For a description of parallel for range rounding in DPC++ see
| | | `MinRangeX`: The minimum X dimension of the range such that range rounding is activated (Default 1024) |
-## Controlling DPC++ Level Zero Plugin
+## Controlling DPC++ Level Zero Adapter
| Environment variable | Values | Description |
| -------------------- | ------ | ----------- |
| `SYCL_ENABLE_PCI` (Deprecated) | Integer | When set to 1, enables obtaining the GPU PCI address when using the Level Zero backend. The default is 1. This option is kept for compatibility reasons and is immediately deprecated. |
-| `SYCL_PI_LEVEL_ZERO_DISABLE_USM_ALLOCATOR` | Any(\*) | Disable USM allocator in Level Zero plugin (each memory request will go directly to Level Zero runtime) |
-| `SYCL_PI_LEVEL_ZERO_TRACK_INDIRECT_ACCESS_MEMORY` | Any(\*) | Enable support of the kernels with indirect access and corresponding deferred release of memory allocations in the Level Zero plugin. |
+| `SYCL_PI_LEVEL_ZERO_DISABLE_USM_ALLOCATOR` | Any(\*) | Disable USM allocator in Level Zero adapter (each memory request will go directly to Level Zero runtime) |
+| `SYCL_PI_LEVEL_ZERO_TRACK_INDIRECT_ACCESS_MEMORY` | Any(\*) | Enable support of the kernels with indirect access and corresponding deferred release of memory allocations in the Level Zero adapter. |
`(*) Note: Any means this environment variable is effective when set to any non-null value.`
-## Controlling DPC++ CUDA Plugin
+## Controlling DPC++ CUDA Adapter
| Environment variable | Values | Description |
| -------------------- | ------ | ----------- |
| `SYCL_PI_CUDA_MAX_LOCAL_MEM_SIZE` | Integer | Specifies the maximum size of a local memory allocation in bytes. If the value exceeds the device's capabilities then a `sycl::runtime_error` is thrown. In order for the full error message to be printed, `SYCL_RT_WARNING_LEVEL=2` must be set. The default value for `SYCL_PI_CUDA_MAX_LOCAL_MEM_SIZE` is determined by the hardware. |
-## Controlling DPC++ HIP Plugin
+## Controlling DPC++ HIP Adapter
| Environment variable | Values | Description |
| -------------------- | ------ | ----------- |
@@ -232,7 +232,6 @@ variables in production code.
| after_addHostAcc | print graph after addHostAccessor method |
| always | print graph before and after each of the above methods |
-
### `SYCL_UR_TRACE` Options
`SYCL_UR_TRACE` accepts a bit-mask, so individual tracing types can be enabled.
@@ -258,7 +257,7 @@ Supported tracing levels are in the table below
Any valid combination of the above bit-masks can be used to enable/disable tracing of the corresponding caches. If the input value is not 0 and not a valid number, the disk cache tracing will be enabled (deprecated behavior).
The default value is 0 and no tracing is enabled.
-## Debugging variables for Level Zero Plugin
+## Debugging variables for Level Zero Adapter
:warning: **Warning:** the environment variables
described below are used for development and debugging of DPC++ compiler
@@ -267,15 +266,15 @@ variables in production code.
| Environment variable | Values | Description |
| -------------------- | ------ | ----------- |
-| `SYCL_PI_LEVEL_ZERO_SINGLE_THREAD_MODE` | Integer | A single-threaded app has an opportunity to enable this mode to avoid overhead from mutex locking in the Level Zero plugin. A value greater than 0 enables single thread mode. A value of 0 disables single thread mode. The default is 0. |
+| `SYCL_PI_LEVEL_ZERO_SINGLE_THREAD_MODE` | Integer | A single-threaded app has an opportunity to enable this mode to avoid overhead from mutex locking in the Level Zero adapter. A value greater than 0 enables single thread mode. A value of 0 disables single thread mode. The default is 0. |
| `SYCL_PI_LEVEL_ZERO_USM_ALLOCATOR` | [EnableBuffers][;[MaxPoolSize][;[host\|device\|shared:][MaxPoolableSize][,[Capacity][,SlabMinSize]]]...] | EnableBuffers enables pooling for SYCL buffers, default 1, set to 0 to disable. MaxPoolSize is the maximum size of the pool, by default there is no size limit. MemType is host, device, shared or read_only_shared. Other parameters are values specified as positive integers with optional K, M or G suffix. MaxPoolableSize is the maximum allocation size that may be pooled, default 0 for shared, 2MB for host, 4MB for device and read_only_shared. Capacity is the number of allocations in each size range freed by the program but retained in the pool for reallocation, default 4. Size ranges follow this pattern: 64, 96, 128, 192, and so on, i.e., powers of 2, with one range in between. SlabMinSize is the minimum allocation size, 64KB for host and device, 2MB for shared and read_only_shared. Example: SYCL_PI_LEVEL_ZERO_USM_ALLOCATOR=1;32M;host:1M,4,64K;device:1M,4,64K;shared:0,0,2M|
| `SYCL_PI_LEVEL_ZERO_BATCH_SIZE` | Integer | Sets a preferred number of compute commands to batch into a command list before executing the command list. A value of 0 causes the batch size to be adjusted dynamically. A value greater than 0 specifies fixed size batching, with the batch size set to the specified value. The default is 0. |
| `SYCL_PI_LEVEL_ZERO_COPY_BATCH_SIZE` | Integer | Sets a preferred number of copy commands to batch into a command list before executing the command list. A value of 0 causes the batch size to be adjusted dynamically. A value greater than 0 specifies fixed size batching, with the batch size set to the specified value. The default is 0. |
| `SYCL_PI_LEVEL_ZERO_FILTER_EVENT_WAIT_LIST` | Integer | When set to 0, disables filtering of signaled events from wait lists when using the Level Zero backend. The default is 0. |
-| `SYCL_PI_LEVEL_ZERO_USE_COPY_ENGINE` | Any(\*) | This environment variable enables users to control use of copy engines for copy operations. If the value is an integer, it will allow the use of copy engines, if available in the device, in Level Zero plugin to transfer SYCL buffer or image data between the host and/or device(s) and to fill SYCL buffer or image data in device or shared memory. The value of this environment variable can also be a pair of the form "lower_index:upper_index" where the indices point to copy engines in a list of all available copy engines. The default is 0:0 when immediate command lists are being used on the device and 1 otherwise. (Also see description of SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS). |
+| `SYCL_PI_LEVEL_ZERO_USE_COPY_ENGINE` | Any(\*) | This environment variable enables users to control use of copy engines for copy operations. If the value is an integer, it will allow the use of copy engines, if available in the device, in Level Zero adapter to transfer SYCL buffer or image data between the host and/or device(s) and to fill SYCL buffer or image data in device or shared memory. The value of this environment variable can also be a pair of the form "lower_index:upper_index" where the indices point to copy engines in a list of all available copy engines. The default is 0:0 when immediate command lists are being used on the device and 1 otherwise. (Also see description of SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS). |
| `SYCL_PI_LEVEL_ZERO_USE_COMPUTE_ENGINE` | Integer | It can be set to an integer (>=0) in which case all compute commands will be submitted to the command-queue with the given index in the compute command group. If it is instead set to a negative value then all available compute engines may be used. The default value is "0" |
-| `SYCL_PI_LEVEL_ZERO_USE_COPY_ENGINE_FOR_D2D_COPY` (experimental) | Integer | Allows the use of copy engine, if available in the device, in Level Zero plugin for device to device copy operations. The default is 0. This option is experimental and will be removed once heuristics are added to make a decision about use of copy engine for device to device copy operations. |
-| `SYCL_PI_LEVEL_ZERO_DEVICE_SCOPE_EVENTS` | Any(\*) | Enable support of device-scope events whose state is not visible to the host. If enabled mode is SYCL_PI_LEVEL_ZERO_DEVICE_SCOPE_EVENTS=1 the Level Zero plugin would create all events having device-scope only and create proxy host-visible events for them when their status is needed (wait/query) on the host. If enabled mode is SYCL_PI_LEVEL_ZERO_DEVICE_SCOPE_EVENTS=2 the Level Zero plugin would create all events having device-scope and add proxy host-visible event at the end of each command-list submission. The default is 0, meaning all events have host visibility. SYCL_PI_LEVEL_ZERO_DEVICE_SCOPE_EVENTS is ignored when using immediate command lists (SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS = 1) and all events use default scope of 0. |
+| `SYCL_PI_LEVEL_ZERO_USE_COPY_ENGINE_FOR_D2D_COPY` (experimental) | Integer | Allows the use of copy engine, if available in the device, in Level Zero adapter for device to device copy operations. The default is 0. This option is experimental and will be removed once heuristics are added to make a decision about use of copy engine for device to device copy operations. |
+| `SYCL_PI_LEVEL_ZERO_DEVICE_SCOPE_EVENTS` | Any(\*) | Enable support of device-scope events whose state is not visible to the host. If enabled mode is SYCL_PI_LEVEL_ZERO_DEVICE_SCOPE_EVENTS=1 the Level Zero adapter would create all events having device-scope only and create proxy host-visible events for them when their status is needed (wait/query) on the host. If enabled mode is SYCL_PI_LEVEL_ZERO_DEVICE_SCOPE_EVENTS=2 the Level Zero adapter would create all events having device-scope and add proxy host-visible event at the end of each command-list submission. The default is 0, meaning all events have host visibility. SYCL_PI_LEVEL_ZERO_DEVICE_SCOPE_EVENTS is ignored when using immediate command lists (SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS = 1) and all events use default scope of 0. |
| `SYCL_PI_LEVEL_ZERO_USE_IMMEDIATE_COMMANDLISTS` | Integer | When set to a positive value enables use of Level Zero immediate commandlists, which means there is no batching and all commands are immediately submitted for execution. When set to 1, unique immediate commandlists are created for each SYCL queue. When set to 2, unique immediate commandlists are created per host thread per SYCL queue. Default is 1 on Intel® Data Center GPU Max Series running Linux and 0 elsewhere. |
| `SYCL_PI_LEVEL_ZERO_USE_MULTIPLE_COMMANDLIST_BARRIERS` | Integer | When set to a positive value enables use of multiple Level Zero commandlists when submitting barriers. Default is 1. |
| `SYCL_PI_LEVEL_ZERO_USE_COPY_ENGINE_FOR_FILL` | Integer | When set to a positive value enables use of a copy engine for memory fill operations. Default is 0. |
@@ -287,7 +286,7 @@ variables in production code.
| `SYCL_PI_LEVEL_ZERO_USM_RESIDENT` | Integer | Bit-mask controls if/where to make USM allocations resident at the time of allocation. Input value is of the form 0xHSD, where 4-bits of D control device allocations, 4-bits of S control shared allocations, and 4-bits of H control host allocations. Each 4-bit component is holding one of the following values: "0" - then no special residency is forced, "1" - then allocation is made resident at the device of allocation, or "2" - then allocation is made resident on all devices in the context of allocation that have P2P access to the device of allocation. Default is 0x002, i.e. force full residency for device allocations only. |
| `SYCL_PI_LEVEL_ZERO_USE_NATIVE_USM_MEMCPY2D` | Integer | When set to a positive value enables the use of Level Zero USM 2D memory copy operations. Default is 0. |
-## Debugging variables for CUDA Plugin
+## Debugging variables for CUDA Adapter
:warning: **Warning:** the environment variables
described below are used for development and debugging of DPC++ compiler
diff --git a/sycl/doc/FAQ.md b/sycl/doc/FAQ.md
index 3c80dab3f6699..499314254d99a 100644
--- a/sycl/doc/FAQ.md
+++ b/sycl/doc/FAQ.md
@@ -138,8 +138,9 @@ OpenCL 2.1, so any device, capable of OpenCL 2.1, should be supported.
Otherwise, your OpenCL device must support `cl_khr_il_program` extension.
Furthermore, developers can extend capabilities of the DPC++ Runtime to
-non-OpenCL devices by writing correspondent plugins. To learn more, please
-check out our [Plugin Interface Guide](design/PluginInterface.md).
+non-OpenCL devices by writing correspondent adapters. To learn more, please
+check out the
+[Unified Runtime project](https://github.com/oneapi-src/unified-runtime).
### Q: DPC++ applications hang on Intel GPUs while working well on other devices
**A:** One of the common reasons is Intel GPUs feature called "hang check".
diff --git a/sycl/doc/GetStartedGuide.md b/sycl/doc/GetStartedGuide.md
index 366a9ae49ea35..10359d6fefce3 100644
--- a/sycl/doc/GetStartedGuide.md
+++ b/sycl/doc/GetStartedGuide.md
@@ -256,24 +256,22 @@ instruction on how to install this refer to
The DPC++ build assumes that ROCm is installed in `/opt/rocm`, if it is
installed somewhere else, the directory must be provided through the CMake
-variable `SYCL_BUILD_PI_HIP_ROCM_DIR` which can be passed using the
+variable `UR_HIP_ROCM_DIR` which can be passed using the
`--cmake-opt` option of `configure.py` as follows:
```sh
python $DPCPP_HOME/llvm/buildbot/configure.py --hip \
- --cmake-opt=-DSYCL_BUILD_PI_HIP_ROCM_DIR=/usr/local/rocm
+ --cmake-opt=-DUR_HIP_ROCM_DIR=/usr/local/rocm
```
If further customization is required — for instance when the layout of
-individual directories can not be inferred from `SYCL_BUILD_PI_HIP_ROCM_DIR` —
+individual directories can not be inferred from `UR_HIP_ROCM_DIR` —
it is possible to specify the location of HIP include, HSA include and HIP
library directories, using the following CMake variables:
-* `SYCL_BUILD_PI_HIP_INCLUDE_DIR`,
-* `SYCL_BUILD_PI_HIP_HSA_INCLUDE_DIR`,
-* `SYCL_BUILD_PI_HIP_LIB_DIR`.
-Please note that a similar customization would also be required for Unified
-Runtime, see [the list of options provided by its
-CMake](https://github.com/oneapi-src/unified-runtime#cmake-standard-options)
-for details.
+* `UR_HIP_INCLUDE_DIR`,
+* `UR_HIP_HSA_INCLUDE_DIR`,
+* `UR_HIP_LIB_DIR`.
+These options are all passed through to Unified Runtime, more detail about them
+can be found [here](https://github.com/oneapi-src/unified-runtime#cmake-standard-options).
[LLD](https://llvm.org/docs/AMDGPUUsage.html) is necessary for the AMDGPU
compilation chain. The AMDGPU backend generates a standard ELF relocatable code
@@ -355,7 +353,7 @@ under the hood to provide implementations of various SYCL backends. By default
the source code for the Unified Runtime will be acquired using CMake's
[FetchCotent](https://cmake.org/cmake/help/latest/module/FetchContent.html). The
specific repository URL and revision tag used can be found in the file
-`sycl/plugins/unified_runtime/CMakeLists.txt` searching for the variables
+`sycl/cmake/modules/FetchUnifiedRuntime.cmake` searching for the variables
`UNIFIED_RUNTIME_REPO` and `UNIFIED_RUNTIME_TAG`.
In order to enable developers, a number of CMake variables are available to
@@ -373,7 +371,7 @@ control which revision of Unified Runtime should be used when building DPC++:
* The path specified by variable `SYCL_UR_SOURCE_DIR` will be used with
`add_directory()`. This can be used to point at an adjacent directory
containing a clone of the Unified Runtime repository.
- * The path `sycl/plugins/unified_runtime/unified-runtime` will be used, if it
+ * The path `sycl/unified-runtime` will be used, if it
exists. This can be used as-if an in-tree build.
* `SYCL_UR_SOURCE_DIR` is a variable used to specify the path to the Unified
Runtime repository when `SYCL_UR_USE_FETCH_CONTENT` is set of `OFF`.
diff --git a/sycl/doc/design/Assert.md b/sycl/doc/design/Assert.md
index 67b3da4203496..2105b8644f8ce 100644
--- a/sycl/doc/design/Assert.md
+++ b/sycl/doc/design/Assert.md
@@ -74,8 +74,8 @@ practical cases.
and running on the device.
- Native Device Compiler - compiler which generates device-native binary image
based on input SPIR-V image.
- - Low-level Runtime - the backend/runtime behind DPCPP Runtime attached via the
- Plugin Interface.
+ - Low-level Runtime - the backend/runtime behind DPCPP Runtime accessed via
+ Unified Runtime.
## How it works?
@@ -92,8 +92,8 @@ ID and the local ID of the failing work item.
Implementation of this function is supplied by Native Device Compiler for
safe approach or by DPCPP Compiler for fallback one.
-In order to distinguish which implementation to use, DPCPP Runtime checks for
-`PI_DEVICE_INFO_EXTENSION_DEVICELIB_ASSERT` extension. If the extension isn't
+In order to distinguish which implementation to use, DPCPP Runtime checks the
+backend for the "cl_intel_devicelib_assert" extension. If the extension isn't
available, then fallback implementation is used.
@@ -102,8 +102,7 @@ available, then fallback implementation is used.
This is the preferred approach and implementations should use it when possible.
It guarantees assertion failure notification delivery to the host regardless of
kernel behavior which hit the assertion. If backend suports the safe approach,
-it must report this capability to DPCPP Runtime via the
-`PI_DEVICE_INFO_EXTENSION_DEVICELIB_ASSERT` extension query.
+it must report support for the "cl_intel_devicelib_assert" device extension.
The Native Device Compiler is responsible for providing implementation of
`__devicelib_assert_fail` which completely hides details of communication
@@ -128,10 +127,9 @@ The following sequence of events describes how user code gets notified:
## Fallback approach
If Device-side Runtime doesn't support `__devicelib_assert_fail` (as reported
-via `PI_DEVICE_INFO_EXTENSION_DEVICELIB_ASSERT` extension query) then a fallback
-approach comes in place. The approach doesn't require any support from
-Device-side Runtime and Native Device Compiler. Neither it does from Low-level
-Runtime.
+via "cl_intel_devicelib_assert" extension query) then a fallback approach comes
+in place. The approach doesn't require any support from Device-side Runtime and
+Native Device Compiler. Neither it does from Low-level Runtime.
Within this approach, a mutable program scope variable is introduced. This
variable stores a flag which says if an assert failure was encountered. Fallback
@@ -234,8 +232,8 @@ with `#ifdef`'s. When in DPCPP Runtime Library this knowledge is obtained from
device binary image descriptor's property sets.
Each device image is supplied with an array of property sets. For description
-of property sets see `struct pi_device_binary_struct` in
-[`pi.h`](https://github.com/intel/llvm/blob/sycl/sycl/include/sycl/detail/pi.h#L692)
+of property sets see `struct sycl_device_binary_struct` in
+[`compiler.hpp`](https://github.com/intel/llvm/blob/7fc17d4b58e1b43882570a330afd84fab219aeba/sycl/source/detail/compiler.hpp#L132)
A distinct property set `SYCL/assert used` is added. In this set a property
with the name of the kernel is added whenever the kernel uses assert. The use of
diff --git a/sycl/doc/design/CompilerAndRuntimeDesign.md b/sycl/doc/design/CompilerAndRuntimeDesign.md
index 1935356d0a3a8..d021b2d1915db 100644
--- a/sycl/doc/design/CompilerAndRuntimeDesign.md
+++ b/sycl/doc/design/CompilerAndRuntimeDesign.md
@@ -387,8 +387,8 @@ when the parent fat binary is unloaded. The registration function basically
takes the pointer to the offload descriptor and invokes SYCL runtime library's
registration function passing it as a parameter.
-The offload descriptor type hierarchy is described in the `pi.h` header. The
-top-level structure is `pi_device_binaries_struct`.
+The offload descriptor type hierarchy is described in the `compiler.hpp`
+header. The top-level structure is `sycl_device_binaries_struct`.
#### Device Link
@@ -677,7 +677,7 @@ define void @SYCL_generated_kernel(i32 %local_ptr_offset, i32 %arg, i32 %local_p
}
```
-On the runtime side, when setting local memory arguments, the CUDA PI
+On the runtime side, when setting local memory arguments, the CUDA UR
implementation will internally set the argument as the offset with respect to
the accumulated size of used local memory. This approach preserves the existing
PI interface.
@@ -797,7 +797,7 @@ For the HIP backend, the resulting fused kernel is compiled to an AMDGCN binary
by the kernel fusion JIT compiler at runtime, however this output requires
finalization by `lld`. Rather than adding another dependancy to the fusion jit,
a `Requires finalization` property is added the binary. The HIP
-PI plugin/UR adapter will then use the AMD Compiler Object Manager library
+UR adapter will then use the AMD Compiler Object Manager library
(`comgr`, part of the ROCm package) in order to finalize it into
a loadable format.
diff --git a/sycl/doc/design/DeviceGlobal.md b/sycl/doc/design/DeviceGlobal.md
index f864410e72ba8..3bbcc55b9a289 100644
--- a/sycl/doc/design/DeviceGlobal.md
+++ b/sycl/doc/design/DeviceGlobal.md
@@ -414,7 +414,7 @@ Each device code module that references one or more device global variables
has an associated "SYCL/device globals" property set. The name of each
property in this set is the `sycl-unique-id` string of a `device_global`
variable that is contained by the module. The value of each property has
-property type `PI_PROPERTY_TYPE_BYTE_ARRAY` and contains a structure with the
+property type `SYCL_PROPERTY_TYPE_BYTE_ARRAY` and contains a structure with the
following fields:
```
@@ -467,19 +467,19 @@ Several changes are needed to the DPC++ runtime
#### Initializing the device global variables in device code
When a DPC++ application submits a kernel, the runtime constructs a
-`pi_program` containing this kernel that is compiled for the target device, if
-such a `pi_program` does not yet exist. If the kernel resides in a device code
-module that calls into a shared library, the runtime identifies a set of device
-code modules that need to be online-linked together in order to construct the
-`pi_program`.
+`ur_program_handle_t` containing this kernel that is compiled for the target
+device, if such a handle does not yet exist. If the kernel resides in a device
+code module that calls into a shared library, the runtime identifies a set of
+device code modules that need to be online-linked together in order to
+construct the `ur_program_handle_t`.
-After creating a `pi_program` and before invoking any kernel it contains, the
-runtime does the following:
+After creating a `ur_program_handle_t` and before invoking any kernel it
+contains, the runtime does the following:
* Scan the entries of the "SYCL/device globals" property sets of each device
- code module that contributes to the the `pi_program` to get information about
- each device global variable that is used by the `pi_program`. This
- information is added to device global database.
+ code module that contributes to the the `ur_program_handle_t` to get
+ information about each device global variable that is used by the
+ `ur_program_handle_t`. This information is added to device global database.
* For each device global variable that is not decorated with the
`device_image_scope` property:
@@ -492,12 +492,12 @@ runtime does the following:
- Regardless of whether the USM buffer has already been created for the
variable, the runtime initializes the `usmptr` member in the *device
- instance* of the variable by using a new [PI interface][7] which copies
- data from the host to a global variable in a `pi_program`. It is a
- simple matter to use this interface to overwrite the `usmptr` member with
- the address of the USM buffer.
+ instance* of the variable by using a new [UR interface][7] which copies
+ data from the host to a global variable in a `ur_program_handle_t`. It is
+ a simple matter to use this interface to overwrite the `usmptr` member
+ with the address of the USM buffer.
-[7]: <#new-pi-interface-to-copy-to-or-from-a-module-scope-variable>
+[7]: <#new-ur-interface-to-copy-to-or-from-a-module-scope-variable>
Note that the runtime does not need to initialize the `val` member variable of
device global variables that are decorated with `device_image_scope` because
@@ -535,16 +535,16 @@ member.
If the variable is decorated with the `device_image_scope` property, the
variable's value exists directly in the device code module, not in a USM
buffer. The runtime first uses the variable's unique string identifier to see
-if there is a `pi_program` that contains the variable. If there is more than
-one such `pi_program`, the runtime diagnoses an error by throwing
-`errc::invalid`. If there is no such `pi_program`, the runtime scans all
+if there is a `ur_program_handle_t that contains the variable. If there is
+more than one such program handle, the runtime diagnoses an error by throwing
+`errc::invalid`. If there is no such program handle, the runtime scans all
"SYCL/device globals" property sets to find the device code module that
contains this variable and uses its normal mechanism for creating a
-`pi_program` from this device code module. (The algorithm for creating device
-code modules in the `sycl-post-link` tool ensures that there will be no more
-than one module that contains the variable.) Finally, the runtime uses the
-new [PI interface][7] to copy to or from the contents of the variable in this
-`pi_program`.
+`ur_program_handle_t` from this device code module. (The algorithm for
+creating device code modules in the `sycl-post-link` tool ensures that there
+will be no more than one module that contains the variable.) Finally, the
+runtime uses the new [UR interface][7] to copy to or from the contents of the
+variable in this program.
It is possible that a device global variable with `device_image_scope` is not
referenced by _any_ kernel, in which case the variable's unique string will not
@@ -556,42 +556,44 @@ In all cases, the runtime uses `sizeof(T)` to determine if the copy operation
will read or write beyond the end of the device global variable's storage. If
so, the runtime diagnoses an error by throwing `errc::invalid`.
-#### New PI interface to copy to or from a module scope variable
+#### New UR interface to copy to or from a module scope variable
-As noted above, we need new PI interfaces that can copy data to or from an
-instance of a device global variable in a `pi_program`. This functionality is
-exposed as two new PI interfaces:
+As noted above, we need new UR interfaces that can copy data to or from an
+instance of a device global variable in a `ur_program_handle_t`. This
+functionality is exposed as two new UR interfaces:
```
-pi_result piextEnqueueDeviceGlobalVariableRead(
- pi_queue Queue, pi_program Program, const char *Name, pi_bool BlockingRead,
- size_t Count, size_t Offset, void *Dst, pi_uint32 NumEventsInWaitList,
- const pi_event *EventsWaitList, pi_event *Event);
-
-pi_result piextEnqueueDeviceGlobalVariableWrite(
- pi_queue Queue, pi_program Program, const char *Name, pi_bool BlockingWrite,
- size_t Count, size_t Offset, const void *Src, pi_uint32 NumEventsInWaitList,
- const pi_event *EventsWaitList, pi_event *Event);
+ur_result_t urEnqueueDeviceGlobalVariableRead(
+ ur_queue_handle_t hQueue, ur_program_handle_t hProgram, const char *name,
+ bool blockingRead, size_t count, size_t offset, void *pDst,
+ uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
+ ur_event_handle_t *phEvent);
+
+ur_result_t urEnqueueDeviceGlobalVariableWrite(
+ ur_queue_handle_t hQueue, ur_program_handle_t hProgram, const char *name,
+ bool blockingWrite, size_t count, size_t offset, const void *pSrc,
+ uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
+ ur_event_handle_t *phEvent)
```
-The `piextEnqueueDeviceGlobalVariableRead` function reads `Count` bytes at
-byte-offset `Offset` from a device global variable in `Program` identified by
-the name `Name`. The read data is stored in `Dst`. Likewise, the
-`piextEnqueueDeviceGlobalVariableWrite` function reads `Count` bytes from `Dst`
-and stores them at byte-offset `Offset` in the device global variable in
-`Program` identified by the name `Name`.
+The `urEnqueueDeviceGlobalVariableRead` function reads `count` bytes at
+byte-offset `offset` from a device global variable in `hProgram` identified by
+the name `name`. The read data is stored in `pDst`. Likewise, the
+`urEnqueueDeviceGlobalVariableWrite` function reads `count` bytes from `pSrc`
+and stores them at byte-offset `offset` in the device global variable in
+`hProgram` identified by the name `name`.
-Both functions will enqueue the associated memory command on `Queue` where it
-will first wait for `NumEventsInWaitList` events in `EventsWaitList` to finish.
-`Event` will be populated with the event associated with resulting enqueued
-command. If either `BlockingRead` or `BlockingWrite` is `true` the call will
-block on the host until the enqueued command finishes execution.
+Both functions will enqueue the associated memory command on `hQueue` where it
+will first wait for `numEventsInWaitList` events in `phEventWaitList,` to
+finish. `hEvent` will be populated with the event associated with resulting
+enqueued command. If either `blockingRead` or `blockingWrite` is `true` the
+call will block on the host until the enqueued command finishes execution.
For `device_global` variables the `Name` parameter in calls to these functions
is the same as the associated `sycl-unique-id` string.
-The Level Zero backend has existing APIs that can implement these PI
-interfaces. The plugin first calls [`zeModuleGetGlobalPointer()`][8] to get a
+The Level Zero backend has existing APIs that can implement these UR
+interfaces. The adapter first calls [`zeModuleGetGlobalPointer()`][8] to get a
device pointer for the variable and then calls
[`zeCommandListAppendMemoryCopy()`][9] to copy to or from that pointer.
However, the documentation (and implementation) of `zeModuleGetGlobalPointer()`
@@ -628,13 +630,13 @@ This must be changed to say something along these lines:
The OpenCL backend has a proposed extension
[`cl_intel_global_variable_access`][10] that defines functions
`clEnqueueReadGlobalVariableINTEL()` and `clEnqueueWriteGlobalVariableINTEL()`
-which can be easily used to implement these PI interfaces. This DPC++ design
+which can be easily used to implement these UR interfaces. This DPC++ design
depends upon implementation of that OpenCL extension.
[10]:
The CUDA backend has existing APIs `cuModuleGetGlobal()` and `cuMemcpyAsync()`
-which can be used to implement these PI interfaces.
+which can be used to implement these UR interfaces.
## Design choices
diff --git a/sycl/doc/design/GlobalObjectsInRuntime.md b/sycl/doc/design/GlobalObjectsInRuntime.md
index 96a9b8fdb05e0..b56dd7767d108 100644
--- a/sycl/doc/design/GlobalObjectsInRuntime.md
+++ b/sycl/doc/design/GlobalObjectsInRuntime.md
@@ -89,16 +89,30 @@ are not wrapped with `GlobalHandler`.
`GlobalHandler` or consider using `sycl::detail::SpinLock`, which has trivial
constructor and destructor.
-## Plugins
+## Adapters
-Plugin lifetime is managed by utilizing piPluginInit() and piTearDown().
-GlobalHandler::shutdown() will tear down all registered globals before SYCL RT
-library is unloaded. It will invoke piTearDown() and unload() for each
-plugin. piTearDown() is going to perform any necessary tear-down process at the
-plugin PI level. These two APIs allow on-demand plugin lifetime management. SYCL
-RT can control the beginning and the end of the plugin.
+Adapter lifetime is managed in two ways: on a per-adapter basis with
+`urAdapterGet`/`urAdapterRelease`, and on a global basis with
+`urLoaderInit`/`urLoaderTearDown`. A call to `urAdapterRelease` will make any
+subsequent use of the adapter in question invalid, but it **does not** call the
+`dlclose` equivalent on the adapter library. A call to `urLoaderTearDown` once
+all initialized adapters have been released will unload all the adapter
+libraries at once.
-
+`GlobalHandler::unloadPlugins` calls both of these APIs in sequence in a pattern
+something like this (pseudo code):
+
+```
+for (adapter in initializedAdapters) {
+ urAdapterRelease(adapter);
+}
+urLoaderTearDown();
+```
+
+Which in turn is called by either `shutdown_late()` or `shutdown_win()`
+depending on platform.
+
+
## Low-level runtimes
diff --git a/sycl/doc/design/KernelFusionJIT.md b/sycl/doc/design/KernelFusionJIT.md
index 303f28106cac1..c194c86c48729 100644
--- a/sycl/doc/design/KernelFusionJIT.md
+++ b/sycl/doc/design/KernelFusionJIT.md
@@ -115,7 +115,7 @@ In this case, the individual kernels and the `KernelFusionCommand` could have be
To handle this case, the `KernelFusionCommand` for each queue remains in the fusion map until the next `ext_codeplay_start_fusion` on the same queue and does not undergo the cleanup process until its status has been set to `DELETE` by `ext_codeplay_start_fusion`.
This way, the lifetime of the event associated with the `KernelFusionCommand` is extended such that it is still valid for synchronization when returned from a later call to `ext_codeplay_complete_fusion`.
-Note that even though the `KernelFusionCommand` is associated with a particular queue and context, the associated event does not have an underlying PI event, i.e., it is essentially a host event.
+Note that even though the `KernelFusionCommand` is associated with a particular queue and context, the associated event does not have an underlying UR event, i.e., it is essentially a host event.
## Fusion Process
diff --git a/sycl/doc/design/KernelProgramCache.md b/sycl/doc/design/KernelProgramCache.md
index 3c408cf809ede..fd242e7d9749d 100644
--- a/sycl/doc/design/KernelProgramCache.md
+++ b/sycl/doc/design/KernelProgramCache.md
@@ -439,8 +439,8 @@ The caching isn't done when:
- Employ the same built object for multiple devices of the same ISA,
capabilities and so on. *NOTE:* It's not really known if it's possible to
check if two distinct devices are *exactly* the same. Probably this should be
- an improvement request for plugins. By now it is assumed that two devices with
- the same device id 2 are the same.
+ an improvement request for the UR adapters. By now it is assumed that two
+ devices with the same device id 2 are the same.
- Improve testing: cover real use-cases. See currently covered cases
[here](https://github.com/intel/llvm/blob/sycl/sycl/unittests/kernel-and-program/Cache.cpp).
- Implement tool for exploring cache items (initially it is possible using OS
diff --git a/sycl/doc/design/OptionalDeviceFeatures.md b/sycl/doc/design/OptionalDeviceFeatures.md
index 679ef4dd69eb4..53e88c3d123f2 100644
--- a/sycl/doc/design/OptionalDeviceFeatures.md
+++ b/sycl/doc/design/OptionalDeviceFeatures.md
@@ -867,10 +867,10 @@ types:
Property Name | Property Type
------------- | -------------
-"aspect" | `PI_PROPERTY_TYPE_BYTE_ARRAY`
-"reqd\_sub\_group\_size" | `PI_PROPERTY_TYPE_BYTE_ARRAY`
-"reqd\_work\_group\_size" | `PI_PROPERTY_TYPE_BYTE_ARRAY`
-"fixed\_target" | `PI_PROPERTY_TYPE_BYTE_ARRAY`
+"aspect" | `SYCL_PROPERTY_TYPE_BYTE_ARRAY`
+"reqd\_sub\_group\_size" | `SYCL_PROPERTY_TYPE_BYTE_ARRAY`
+"reqd\_work\_group\_size" | `SYCL_PROPERTY_TYPE_BYTE_ARRAY`
+"fixed\_target" | `SYCL_PROPERTY_TYPE_BYTE_ARRAY`
The "aspect" property tells the set of aspects that a device must have in order
to use the image. The image is only compatible with a device that supports
diff --git a/sycl/doc/design/PluginInterface.md b/sycl/doc/design/PluginInterface.md
deleted file mode 100644
index 7d0d4a262d3a6..0000000000000
--- a/sycl/doc/design/PluginInterface.md
+++ /dev/null
@@ -1,211 +0,0 @@
-# The DPC++ Runtime Plugin Interface.
-
-## Overview
-The DPC++ Runtime Plugin Interface (PI) is an interface layer between the
-device-agnostic part of DPC++ runtime and the device-specific runtime layers
-which control execution on devices. It employs the “plugin” mechanism to bind
-to the device specific runtime layers similar to what is used by libomptarget
-or OpenCL.
-
-The picture below illustrates the placement of PI within the overall DPC++
-runtime stack. Dotted lines show components or paths which are not yet available
-in the runtime, but are likely to be developed.
-
-
-The plugin interface and the discovery process behind it allows to dynamically
-plug in implementations based on OpenCL and “native” runtime for a particular
-device – such as OpenCL for
-FPGA devices or native runtimes for GPUs. Implementations of the PI are
-“plugins” - dynamic libraries or shared objects which expose a number of entry
-points implementing the PI interface. The DPC++ runtime collects those function
-pointers into a PI interface dispatch table - one per plugin - and uses this
-table to dispatch to the device(s) covered by the corresponding plugin.
-
-PI is based on a subset of OpenCL 1.2 runtime specification, it follows OpenCL's
-platform, execution and memory models in all aspects except for those explicitly
-mentioned in this document. Some of PI API types and functions have exact
-matches in OpenCL. Whenever there is such a match, the semantics also fully
-match unless the differences are explicitly specified in this document. While
-PI has roots in OpenCL, it does have many differences, and the gap is likely
-to grow, for example in areas of memory model and management, program
-management.
-
-## Discovery and linkage of PI implementations
-
-
-
-Device discovery phase enumerates all available devices and their features by
-querying underlying plugins found in the system. This process is performed when
-all attached platforms or devices are queried in an application; for example,
-during device selection.
-
-### Plugin discovery
-
-Plugins are physically dynamic libraries or shared objects.
-The process to discover plugins follows the following guidelines.
-
-The DPC++ Runtime reads the names of the plugins from a configuration file
-at a predetermined location (TBD - Add this location). These plugins are
-searched at locations in env LD_LIBRARY_PATH on Linux and env PATH on Windows.
-(TBD - Extend to search the plugins at a path relative to the SYCL Runtime
-installation directory by using DT_RPATH on Linux. Similar functionality can be
-achieved on Windows using SetDllDirectory. This will help avoiding extra setting
-of LD_LIBRARY_PATH.)
-To avoid any issues with read-only access, an environment variable
-SYCL_PI_CONFIG can be set to point to the configuration file which lists the
-Plugin names. The enviroment variable if set overrides the predetermined
-location's config file. These Plugins are then be searched in LD_LIBRARY_PATH
-locations. It is the developer's responsibility to include the plugin names from
-the predetermined location's config file to enable discovery of all plugins.
-(TBD - Extend to support search in DT_RPATH as above.)
-In the current implementation the plugin names are hardcoded in the library.
-Configuration file or env SYCL_PI_CONFIG is currently not being considered.
-
-A trace mechanism is provided using env SYCL_PI_TRACE to log the discovery/
-binding/ device enumeration process. Different levels of tracing can be achieved
-with different values of SYCL_PI_TRACE.
-SYCL_PI_TRACE=0x01 provides basic trace of plugins discovered and bound. It also
-lists the device selector's selected device information.
-SYCL_PI_TRACE=0x02 provides trace of all PI calls made from the DPC++ runtime
-with arguments and returned values.
-SYCL_PI_TRACE=-1 lists all PI Traces above and more debug messages.
-
-#### Plugin binary interface
-Plugins should implement all the Interface APIs required for the PI Version it
-supports. There is pi.def/ pi.h file listing all PI API names that can be
-called by the specific version of Plugin Interface. It exports a function -
-"piPluginInit" that returns the plugin details and function pointer table
-containing the list of pointers to implemented Interface Functions defined in
-pi.h. In the future, this document will list the minimum set of Interface APIs
-to be supported by Plugins. This will also require adding functionality to SYCL
-Runtime to work with such limited functionality plugins.
-
-(TBD - list and describe the symbols that a plugin must implement in order to
-be picked up by the DPC++ runtime for offload.)
-
-#### Binding a Plugin
-The DPC++ Runtime loads all discovered Plugins and tries to bind them by calling
-piPluginInit API for each loaded Plugin. The Plugins return the information of
-supported PI version and the list of implemented PI API Function pointers.
-(TBD - Use the PI API Version information and check for compatibility.
-Extend to support version compatibility checks without loading the library.
-Eg:Changing the plugin name to reflect the supported Plugin Interface version.)
-The information of compatible plugins (with the Function Pointer Table) is
-stored in the associated platforms during platform object construction.
-The PI API calls are later forwarded using this information.
-A plugin is said to "bind" after this process completes with no errors.
-During device selection, the user can prefer selection of a device from a
-specific Plugin or Backend using the env ONEAPI_DEVICE_SELECTOR. The correspondence between
-a plugin and a ONEAPI_DEVICE_SELECTOR value is currently hardcoded in the runtime.
-( TBD: Make this a part of configuration file).
-Eg: ONEAPI_DEVICE_SELECTOR=opencl:* corresponds to OpenCL Plugin.
-
-#### OpenCL plugin
-
-OpenCL plugin is a usual plugin from DPC++ runtime standpoint, but its loading
-and initialization involves a nested discovery process which finds out available
-OpenCL implementations. They can be installed either in the standard Khronos
-ICD-compatible way (e.g. listed in files under /etc/OpenCL/vendors on
-Linux) or not, and the OpenCL plugin can hook up with both.
-
-TBD - implement and describe the nested OpenCL implementation discovery process
-performed by the OpenCL plugin
-
-### Device enumeration by plugins
-Devices from all bound plugins are queried and listed as and when required, eg:
-during device selection in device_selector.
-The trace shows the PI API calls made when using SYCL_PI_TRACE=-1.
-(TBD - Add the trace to list all available devices when plugins are successfully
-bound.)
-
-### Plugin Unloading
-The plugins not chosen to be connected to should be unloaded. piInitializePlugins()
-can be called to load and bound the necessary plugins. In addition, piTearDown()
-can be called when plugins are not needed any more. It notifies each
-plugin to start performing its own tear-down process such as global memory
-deallocation. In the future, piTearDown() can include any other jobs that need to
-be done before the plugin is unloaded from memory. Possibly, a
-notification of the plugin unloading to lower-level plugins can be added so that
-they can clean up their own memory [TBD].
-After piTearDown() is called, the plugin can be safely unloaded by calling unload(),
-which is going to invoke OS-specific system calls to remove the dynamic library
-from memory.
-
-Each plugin should not create global variables that require non-trivial
-destructor. Pointer variables with heap memory allocation is a good example
-to be created at the global scope. A std::vector object is not. piTearDown
-will take care of deallocation of these global variables safely.
-
-## PI API Specification
-
-PI interface is logically divided into few subsets:
-- **Core API** which must be implemented by all plugins for DPC++ runtime to be
-able to operate on the corresponding device. The core API further breaks down
-into
- - **OpenCL-based** APIs which have OpenCL origin and semantics
- - **Extension** APIs which don't have counterparts in the OpenCL
-- **Interoperability API** which allows interoperability with underlying
-runtimes such as OpenCL.
-
-See pi.h header for the full list and descriptions of PI APIs.
-
-### The Core OpenCL-based PI APIs
-
-This subset defines functions representing core functionality,
-such as device memory management, kernel creation and parameter setting,
-enqueuing kernel for execution, etc. Functions in this subset fully match
-semantics of the corresponding OpenCL functions, for example:
-
- piKernelCreate
- piKernelRelease
- piKernelSetArg
-
-### The Extension PI APIs
-
-Those APIs don't have OpenCL counter parts and require full specification. For
-example, the function below selects the most appropriate device binary based
-on runtime information and the binary's characteristics
-```
-pi_result piextDeviceSelectBinary(
- pi_device device,
- pi_device_binary * binaries,
- pi_uint32 num_binaries,
- pi_device_binary * selected_binary);
-```
-
-PI also defines few types and string tags to describe a device binary image.
-Those are used to communicate to plugins information about the images where it
-is needed, currently only in the above function. The main
-type is ```pi_device_binary```, whose detailed description can also be found
-in the header. The layout of this type strictly matches the layout of the
-corresponding device binary descriptor type defined in the
-```clang-offload-wrapper``` tool which wraps device binaries into a host
-object for further linkage. The wrapped binaries reside inside this descriptor
-in a data section.
-
-### The Interoperability PI APIs
-
-These are APIs needed to implement DPC++ runtime interoperability with
-underlying "native" device runtimes such as OpenCL.
-
-Interoperability extension APIs have been added to get native runtime handles
-from the backend-agnostic PI Objects or to create PI Objects using the native
-handles. Eg:
-
-```
-pi_result piextDeviceGetNativeHandle(
- pi_device device,
- pi_native_handle *nativeHandle);
-
-pi_result piextDeviceCreateWithNativeHandle(
- pi_native_handle nativeHandle,
- pi_device *device);
-
-```
-
-### PI Extension mechanism
-
-TBD This section describes a mechanism for DPC++ or other runtimes to detect
-availability of and obtain interfaces beyond those defined by the PI dispatch.
-
-TBD Add API to query PI version supported by plugin at runtime.
diff --git a/sycl/doc/design/PropagateCompilerFlagsToRuntime.md b/sycl/doc/design/PropagateCompilerFlagsToRuntime.md
index c73bd55b357d8..05a6011c89074 100644
--- a/sycl/doc/design/PropagateCompilerFlagsToRuntime.md
+++ b/sycl/doc/design/PropagateCompilerFlagsToRuntime.md
@@ -109,26 +109,26 @@ In the SYCL runtime, the device image properties can be accessed to extract the
associated optimization level. Once the optimization level is available, it is
converted to its equivalent frontend option string
(`-O0`, `-O1`, `-O2`, or `-O3`). This frontend option string is passed into a
-query that is made to the plugin to identify the correct backend option. This
+query that is made to the adapter to identify the correct backend option. This
backend option is added to the existing list of compiler options and is sent to
the backend.
-### Changes to the plugin
+### Changes to the adapter
-A new plugin API has been added. It takes the frontend option string as input in
-string format and returns `pi_result`. A string format is used for sending the
-frontend option so that this API can be used for querying other frontend
-options as well. The signature of this API is as follows:
+A new unified runtime API has been added. It takes the frontend option string
+as input in string format and returns `ur_result_t`. A string format is used
+for sending the frontend option so that this API can be used for querying other
+frontend options as well. The signature of this API is as follows:
```C++
-pi_result piPluginGetBackendOption(pi_platform platform,
- const char *frontend_option,
- const char **backend_option);
+ur_result_t urPlatformGetBackendOption(ur_platform_handle_t hPlatform,
+ const char *pFrontendOption,
+ const char **ppPlatformOption);
```
-In the level-zero and OpenCL plugins, the table provided in the 'Requirements'
+In the level-zero and OpenCL adapters, the table provided in the 'Requirements'
section is used as a guide to identify the appropriate backend option.
-The option is returned in `backend_option`. For other plugins (HIP, cuda),
-empty string is returned. This API returns `PI_SUCCESS` for
+The option is returned in `ppPlatformOption`. For other adapters (HIP, cuda),
+empty string is returned. This API returns `UR_RESULT_SUCCESS` for
valid inputs (frontend_option != ""). For invalid inputs, it returns
-`PI_ERROR_INVALID_VALUE`.
+`UR_RESULT_ERROR_INVALID_VALUE`.
diff --git a/sycl/doc/design/SYCL2020-SpecializationConstants.md b/sycl/doc/design/SYCL2020-SpecializationConstants.md
index e05151794d62d..2e9b91969a313 100644
--- a/sycl/doc/design/SYCL2020-SpecializationConstants.md
+++ b/sycl/doc/design/SYCL2020-SpecializationConstants.md
@@ -225,7 +225,7 @@ ID was assigned to which symbolic ID).
With help of `clang-offload-wrapper` tool, those device image properties are
embedded into the application together with device code and used by DPC++ RT
while handling specialization constants during application execution: it either
-calls corresponding PI API to set a value of a specialization constant or it
+calls corresponding UR API to set a value of a specialization constant or it
fills a special buffer with values of specialization constants and passes it as
kernel argument to emulate support of specialization constants.
@@ -577,13 +577,13 @@ property_set {
property {
Name: "id_int_symbolic_ID",
ValAddr: points to byte array [{0, 0, 4}],
- Type: PI_PROPERTY_TYPE_BYTE_ARRAY,
+ Type: SYCL_PROPERTY_TYPE_BYTE_ARRAY,
Size: sizeof(byte array above)
},
property {
Name: "id_A_symbolic_ID",
ValAddr: points to byte array [{1, 0, 4}, {2, 4, 4}, {3, 8, 4}],
- Type: PI_PROPERTY_TYPE_BYTE_ARRAY,
+ Type: SYCL_PROPERTY_TYPE_BYTE_ARRAY,
Size: sizeof(byte array above)
},
]
@@ -644,7 +644,7 @@ property_set {
1, 3.0, 4.0, // id_A
5.0, 6.0 // id_Nested
],
- Type: PI_PROPERTY_TYPE_BYTE_ARRAY,
+ Type: SYCL_PROPERTY_TYPE_BYTE_ARRAY,
Size: sizeof(byte array above)
}
]
@@ -950,14 +950,24 @@ If native specialization constants are supported by the target device, the
runtime iterates through the value map and invokes
```
-pi_result piextProgramSetSpecializationConstant(pi_program prog,
- pi_uint32 spec_id,
- size_t spec_size,
- const void *spec_value);
+ur_result_t urProgramSetSpecializationConstants(ur_program_handle_t hProgram,
+ uint32_t count,
+ const ur_specialization_constant_info_t *
+ pSpecConstants)
```
-Plugin Interface function for descriptor of each property: `spec_id` and
-`spec_size` are taken from the descriptor, `spec_value` is calculated based on
+Unified Runtime function for descriptor of each property. The definition for
+`ur_specialization_constant_info_t` is as follows:
+
+```
+struct ur_specialization_constant_info_t {
+ uint32_t id;
+ size_t size;
+ const void *pValue;
+};
+```
+
+`id` and `size` are taken from the descriptor, `pValue` is calculated based on
address of the specialization constant provided by user and `offset` field of
the descriptor as `(char*)(SpecConstantValuesMap[SymbolicID]) + offset`.
diff --git a/sycl/doc/design/SYCLInstrumentationUsingXPTI.md b/sycl/doc/design/SYCLInstrumentationUsingXPTI.md
index bac15cd555b91..a019ba515fc4d 100644
--- a/sycl/doc/design/SYCLInstrumentationUsingXPTI.md
+++ b/sycl/doc/design/SYCLInstrumentationUsingXPTI.md
@@ -73,12 +73,11 @@ To model this, we create a global graph for every application instantiation
and all kernel executions in the applications are added as nodes in this
global graph. In the SYCL runtime, there is no obvious location where the
creation of the global graph can be inserted as many objects are
-instantiated statically. Currently, we embed the graph creation in the
-plugin interface (PI) layer `initialize()` call. In this call, we will
-perform two operations:
+instantiated statically. Currently, graph creation happens alongside UR
+initialization in `initializePlugins` ([here](https://github.com/intel/llvm/blob/2137ff0e2ae0b478d341c12466bed0ac4402f516/sycl/source/detail/ur.cpp#L96)).
+In this call, we will perform two operations:
1. Initialize all listeners and create a trace event to represent the graph.
-This is done in `sycl/include/sycl/detail/pi.cpp`.
2. Send a `graph_create` event to all subscribers. This notification
will only be sent once.
diff --git a/sycl/doc/design/SYCLNativeCPU.md b/sycl/doc/design/SYCLNativeCPU.md
index 28d19de097e76..86a78ae74b9a4 100644
--- a/sycl/doc/design/SYCLNativeCPU.md
+++ b/sycl/doc/design/SYCLNativeCPU.md
@@ -238,7 +238,7 @@ peeling loops.
## Kernel registration
-In order to register the SYCL Native CPU kernels to the SYCL runtime, we applied a small change to the `clang-offload-wrapper` tool: normally, the `clang-offload-wrapper` bundles the offload binary in an LLVM-IR module. Instead of bundling the device code, for the SYCL Native CPU target we insert an array of function pointers to the `subhandler`s, and the `pi_device_binary_struct::BinaryStart` and `pi_device_binary_struct::BinaryEnd` fields, which normally point to the begin and end addresses of the offload binary, now point to the begin and end of the array.
+In order to register the SYCL Native CPU kernels to the SYCL runtime, we applied a small change to the `clang-offload-wrapper` tool: normally, the `clang-offload-wrapper` bundles the offload binary in an LLVM-IR module. Instead of bundling the device code, for the SYCL Native CPU target we insert an array of function pointers to the `subhandler`s, and the `sycl_device_binary_struct::BinaryStart` and `sycl_device_binary_struct::BinaryEnd` fields, which normally point to the begin and end addresses of the offload binary, now point to the begin and end of the array.
```
-------------------------------------------------------
diff --git a/sycl/doc/design/SharedLibraries.md b/sycl/doc/design/SharedLibraries.md
index 9bced26b71f67..f85160372cf00 100644
--- a/sycl/doc/design/SharedLibraries.md
+++ b/sycl/doc/design/SharedLibraries.md
@@ -256,11 +256,11 @@ mechanism.
Each device image is supplied with an array of property sets:
```C++
-struct pi_device_binary_struct {
+struct sycl_device_binary_struct {
...
// Array of property sets
- pi_device_binary_property_set PropertySetsBegin;
- pi_device_binary_property_set PropertySetsEnd;
+ sycl_device_binary_property_set PropertySetsBegin;
+ sycl_device_binary_property_set PropertySetsEnd;
};
```
@@ -268,10 +268,10 @@ Each property set is represented by the following struct:
```C++
// Named array of properties.
-struct _pi_device_binary_property_set_struct {
+struct _sycl_device_binary_property_set_struct {
char *Name; // the name
- pi_device_binary_property PropertiesBegin; // array start
- pi_device_binary_property PropertiesEnd; // array end
+ sycl_device_binary_property PropertiesBegin; // array start
+ sycl_device_binary_property PropertiesEnd; // array end
};
```
@@ -279,10 +279,10 @@ It contains name of property set and array of properties. Each property is
represented by the following struct:
```C++
-struct _pi_device_binary_property_struct {
+struct _sycl_device_binary_property_struct {
char *Name; // null-terminated property name
void *ValAddr; // address of property value
- uint32_t Type; // _pi_property_type
+ uint32_t Type; // _sycl_property_type
uint64_t ValSize; // size of property value in bytes
};
```
@@ -298,39 +298,42 @@ corresponding set has the name `SYCL/exported symbols`.
DPC++ RT performs *device images collection* task by grouping all device
images required to execute a kernel based on the list of exports/imports, creates
-programs using collected images and links them together using PI API.
+programs using collected images and links them together using UR API.
Resulting program is then added to the cache to avoid repetition of symbol
resolution, compilation, and linking processes for any future attempts to invoke
kernels defined by this program.
-#### DPC++ runtime plugin interface (PI) changes
+#### DPC++ Unified Runtime changes
During *device images collection* process RT considers modules as available for
linking using information about ability of chosen device backend to compile
and link programs created from particular device image format. The information
about ability to compile and link particular format of device code is provided
-by PI plugin implementation for concrete backend. For this purpose
-`piDeviceGetInfo` API is used. For each device image format supported by DPC++
-RT PI device extension is defined. Each extension is a string that can be
-returned by `piDeviceGetInfo` call with query `PI_DEVICE_INFO_EXTENSIONS`.
-Mapping of extension strings and formats that can be linked:
-| Device image format | Extension string | Meaning |
+by UR adapter implementation for concrete backend. For this purpose the
+`urDeviceSelectBinary` API is used. Each device image format supported by DPC++
+RT has a UR equivalent. To check if a backend is capable of linking a given
+device image, a `ur_device_binary_t` struct is prepared with the appropriate UR
+format string. Passing the struct to `urDeviceSelectBinary` will result in a
+success code if the adapter supports the binary, or
+`UR_RESULT_ERROR_INVALID_BINARY` otherwise. Mapping of extension strings and
+formats that can be linked:
+| Device image format | UR equivalent | Meaning |
|---------------------|------------------|---------|
-| `__SYCL_PI_DEVICE_BINARY_TARGET_SPIRV64` | "pi_ext_spirv64_linking" | Linking of SPIR-V 64-bit programs is supported|
-| `__SYCL_PI_DEVICE_BINARY_TARGET_SPIRV64_X86_64` | "pi_ext_spirv64_x86_64_linking" | Linking of 64-bit programs that were AOT compiled for CPU device is supported|
-| `__SYCL_PI_DEVICE_BINARY_TARGET_SPIRV64_GEN` | "pi_ext_spirv64_gen_linking" | Linking of 64-bit programs that were AOT compiled for GPU device is supported|
-| `__SYCL_PI_DEVICE_BINARY_TARGET_SPIRV64_FPGA` | "pi_ext_spirv64_fpga_linking" | Linking of 64-bit programs that were AOT compiled for FPGA device is supported|
-
-To link several device images together `piProgramLink` API will be used.
-Depending on concrete plugin implementation and set of device image formats that
-can be linked at run-time, `piProgramLink` API may receive programs made from
+| `__SYCL_DEVICE_BINARY_TARGET_SPIRV64` | "UR_DEVICE_BINARY_TARGET_SPIRV64" | Linking of SPIR-V 64-bit programs is supported|
+| `__SYCL_DEVICE_BINARY_TARGET_SPIRV64_X86_64` | "UR_DEVICE_BINARY_TARGET_SPIRV64_X86_64" | Linking of 64-bit programs that were AOT compiled for CPU device is supported|
+| `__SYCL_DEVICE_BINARY_TARGET_SPIRV64_GEN` | "UR_DEVICE_BINARY_TARGET_SPIRV64_GEN" | Linking of 64-bit programs that were AOT compiled for GPU device is supported|
+| `__SYCL_DEVICE_BINARY_TARGET_SPIRV64_FPGA` | "UR_DEVICE_BINARY_TARGET_SPIRV64_FPGA" | Linking of 64-bit programs that were AOT compiled for FPGA device is supported|
+
+To link several device images together `urProgramLink` API will be used.
+Depending on concrete adapter implementation and set of device image formats that
+can be linked at run-time, `urProgramLink` API may receive programs made from
device images in different formats as inputs (including SPIR-V and native code).
##### Support of runtime linking in backends
- The initial implementation will support dynamic linking of device code in SPIR-V
format on OpenCL backend:
- - OpenCL plugin will use the existing OpenCL `clLinkProgram()` API to online
+ - OpenCL adapter will use the existing OpenCL `clLinkProgram()` API to online
link the SPIR-V modules together.
- A new Level Zero API to online link programs on SPIR-V level is required for
better performance.
diff --git a/sycl/doc/design/UnifiedRuntime.md b/sycl/doc/design/UnifiedRuntime.md
new file mode 100644
index 0000000000000..ab796a9d1cf0b
--- /dev/null
+++ b/sycl/doc/design/UnifiedRuntime.md
@@ -0,0 +1,21 @@
+# Unified Runtime
+
+## Overview
+The Unified Runtime project serves as an interface layer between the DPC++
+runtime and the device-specific runtime layers which control execution on
+devices. The parts of it primarily utilized by DPC++ are its C API, loader
+library, and the adapter libraries that implement the API for various backends.
+
+The DPC++ runtime accesses the UR api via the [Plugin](https://github.com/intel/llvm/blob/sycl/sycl/source/detail/plugin.hpp)
+object. Each Plugin object owns a `ur_adapter_handle_t`, which represents a UR
+backend (e.g. OpenCL, Level Zero, etc).
+
+The picture below illustrates the placement of UR within the overall DPC++
+runtime stack. Dotted lines show components or paths which are not yet available
+in the runtime, but are likely to be developed.
+
+
+For detailed information about the UR project including the API specification
+see the
+[Unified Runtime Documentation](https://oneapi-src.github.io/unified-runtime/core/INTRO.html).
+You can find the Unified Runtime repo [here](https://github.com/oneapi-src/unified-runtime).
diff --git a/sycl/doc/design/images/KernelFusionRuntimeWorkflow.svg b/sycl/doc/design/images/KernelFusionRuntimeWorkflow.svg
index 125402fb324a2..d18cee31e58f1 100644
--- a/sycl/doc/design/images/KernelFusionRuntimeWorkflow.svg
+++ b/sycl/doc/design/images/KernelFusionRuntimeWorkflow.svg
@@ -2,14 +2,6 @@
\ No newline at end of file
+ transform="matrix(-4.4e-8,1,1,4.4e-8,448.17,353.15)"
+ style="font-variant:normal;font-weight:normal;font-size:12px;font-family:ArialMT;-inkscape-font-specification:ArialMT;writing-mode:lr-tb;fill:#0c0c0c;fill-opacity:1;fill-rule:nonzero;stroke:none"
+ id="text936"
+ y="0">store
+
diff --git a/sycl/doc/design/images/PluginDiscovery.svg b/sycl/doc/design/images/PluginDiscovery.svg
deleted file mode 100644
index 2a462cd1fdb4e..0000000000000
--- a/sycl/doc/design/images/PluginDiscovery.svg
+++ /dev/null
@@ -1,702 +0,0 @@
-
-
diff --git a/sycl/doc/design/images/RuntimeArchitecture-with-fusion.svg b/sycl/doc/design/images/RuntimeArchitecture-with-fusion.svg
index 2c6b9466e1362..c6e0f2568ba14 100644
--- a/sycl/doc/design/images/RuntimeArchitecture-with-fusion.svg
+++ b/sycl/doc/design/images/RuntimeArchitecture-with-fusion.svg
@@ -1,22 +1,21 @@
diff --git a/sycl/doc/design/images/RuntimeArchitecture.svg b/sycl/doc/design/images/RuntimeArchitecture.svg
index 9c9e6ce472a8e..3cbf96f741e7c 100644
--- a/sycl/doc/design/images/RuntimeArchitecture.svg
+++ b/sycl/doc/design/images/RuntimeArchitecture.svg
@@ -1,21 +1,21 @@
diff --git a/sycl/doc/design/images/adapter-lifetime.jpg b/sycl/doc/design/images/adapter-lifetime.jpg
new file mode 100644
index 0000000000000..1cd4f68e23df1
Binary files /dev/null and b/sycl/doc/design/images/adapter-lifetime.jpg differ
diff --git a/sycl/doc/design/images/plugin-lifetime.jpg b/sycl/doc/design/images/plugin-lifetime.jpg
deleted file mode 100644
index fcd3310f38a64..0000000000000
Binary files a/sycl/doc/design/images/plugin-lifetime.jpg and /dev/null differ
diff --git a/sycl/doc/developer/ContributeToDPCPP.md b/sycl/doc/developer/ContributeToDPCPP.md
index a096d99b33397..a141e69b901ce 100644
--- a/sycl/doc/developer/ContributeToDPCPP.md
+++ b/sycl/doc/developer/ContributeToDPCPP.md
@@ -35,7 +35,7 @@ See [Get Started Guide instructions](../GetStartedGuide.md)
For any DPC++-related commit, the `[SYCL]` tag should be present in the
commit message title. To a reasonable extent, additional tags can be used
-to signify the component changed, e.g.: `[PI]`, `[CUDA]`, `[Doc]`.
+to signify the component changed, e.g.: `[UR]`, `[CUDA]`, `[Doc]`.
## Using \
@@ -112,8 +112,11 @@ end-to-end or SYCL-CTS tests.
unit tests. LIT tests make compile-time checks of DPC++ headers, e.g. device
code IR verification, `static_assert` tests. Unit tests check DPC++ runtime
behavior and do not perform any device code compilation, instead relying on
- redefining plugin API with [PiMock](https://github.com/intel/llvm/blob/sycl/sycl/unittests/helpers/PiMock.hpp) when
- necessary.
+ redefining the UR API with
+ [UrMock](https://github.com/intel/llvm/blob/sycl/sycl/unittests/helpers/UrMock.hpp)
+ and the
+ [Unified Runtime mocking interface](https://oneapi-src.github.io/unified-runtime/core/INTRO.html#mocking)
+ when necessary.
When adding new test to `check-sycl`, please consider the following:
diff --git a/sycl/doc/extensions/supported/sycl_ext_oneapi_discard_queue_events.asciidoc b/sycl/doc/extensions/supported/sycl_ext_oneapi_discard_queue_events.asciidoc
index d56fbf052b7e7..f8e62d21a9a31 100644
--- a/sycl/doc/extensions/supported/sycl_ext_oneapi_discard_queue_events.asciidoc
+++ b/sycl/doc/extensions/supported/sycl_ext_oneapi_discard_queue_events.asciidoc
@@ -193,7 +193,7 @@ the `discard_events` property. But using local accessors does not affect optimiz
=== Using Level Zero backend
-Since Level Zero Plugin support is required to be able to not create a low-level event,
+Since Level Zero adapter support is required to be able to not create a low-level event,
any queue operations using the Level Zero backend temporarily work without optimization.
diff --git a/sycl/doc/index.rst b/sycl/doc/index.rst
index bfe2292e1ddcc..cc4961dd7f438 100644
--- a/sycl/doc/index.rst
+++ b/sycl/doc/index.rst
@@ -28,7 +28,7 @@ Design Documents for the oneAPI DPC++ Compiler
Clang Documentation
design/CompilerAndRuntimeDesign
design/KernelParameterPassing
- design/PluginInterface
+ design/UnifiedRuntime
design/SYCL2020-SpecializationConstants
design/KernelProgramCache
design/GlobalObjectsInRuntime
diff --git a/sycl/source/detail/context_impl.hpp b/sycl/source/detail/context_impl.hpp
index 4fde73c8ba90c..65e1fda0a5a7a 100644
--- a/sycl/source/detail/context_impl.hpp
+++ b/sycl/source/detail/context_impl.hpp
@@ -109,7 +109,7 @@ class context_impl {
/// be safely passed to the underlying native runtime API. Warning. Returned
/// reference will be invalid if context_impl was destroyed.
///
- /// \return an instance of raw plug-in context handle.
+ /// \return an instance of raw UR context handle.
ur_context_handle_t &getHandleRef();
/// Gets the underlying context object (if any) without reference count
@@ -119,7 +119,7 @@ class context_impl {
/// be safely passed to the underlying native runtime API. Warning. Returned
/// reference will be invalid if context_impl was destroyed.
///
- /// \return an instance of raw plug-in context handle.
+ /// \return an instance of raw UR context handle.
const ur_context_handle_t &getHandleRef() const;
/// Unlike `get_info', this function returns a
diff --git a/sycl/source/detail/event_impl.hpp b/sycl/source/detail/event_impl.hpp
index f92d198d259d6..86e9b26b98084 100644
--- a/sycl/source/detail/event_impl.hpp
+++ b/sycl/source/detail/event_impl.hpp
@@ -58,12 +58,12 @@ class event_impl {
SYCLConfig::get();
}
- /// Constructs an event instance from a plug-in event handle.
+ /// Constructs an event instance from a UR event handle.
///
- /// The SyclContext must match the plug-in context associated with the
- /// ClEvent.
+ /// The SyclContext must match the UR context associated with the
+ /// ur_event_handle_t.
///
- /// \param Event is a valid instance of plug-in event.
+ /// \param Event is a valid instance of UR event.
/// \param SyclContext is an instance of SYCL context.
event_impl(ur_event_handle_t Event, const context &SyclContext);
event_impl(const QueueImplPtr &Queue);
diff --git a/sycl/source/detail/kernel_impl.hpp b/sycl/source/detail/kernel_impl.hpp
index 2dee6d9da151e..67fe2b155ea1e 100644
--- a/sycl/source/detail/kernel_impl.hpp
+++ b/sycl/source/detail/kernel_impl.hpp
@@ -34,7 +34,7 @@ class kernel_impl {
public:
/// Constructs a SYCL kernel instance from a UrKernel
///
- /// This constructor is used for plug-in interoperability. It always marks
+ /// This constructor is used for UR adapter interoperability. It always marks
/// kernel as being created from source.
///
/// \param Kernel is a valid UrKernel instance
diff --git a/sycl/source/detail/platform_impl.hpp b/sycl/source/detail/platform_impl.hpp
index e7e76334efaa6..45d38c9c661f6 100644
--- a/sycl/source/detail/platform_impl.hpp
+++ b/sycl/source/detail/platform_impl.hpp
@@ -33,8 +33,7 @@ class device_impl;
// TODO: implement parameters treatment for host device
class platform_impl {
public:
- /// Constructs platform_impl from a plug-in interoperability platform
- /// handle.
+ /// Constructs platform_impl from a UR platform handle.
///
/// \param APlatform is a raw plug-in platform handle.
/// \param AAdapter is a plug-in handle.
@@ -107,7 +106,7 @@ class platform_impl {
return ur::cast(nativeHandle);
}
- /// Returns raw underlying plug-in platform handle.
+ /// Returns raw underlying UR platform handle.
///
/// Unlike get() method, this method does not retain handler. It is caller
/// responsibility to make sure that platform stays alive while raw handle
diff --git a/sycl/test-e2e/Plugin/adapter-release.cpp b/sycl/test-e2e/Adapters/adapter-release.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/adapter-release.cpp
rename to sycl/test-e2e/Adapters/adapter-release.cpp
diff --git a/sycl/test-e2e/Plugin/cuda-max-local-mem-size.cpp b/sycl/test-e2e/Adapters/cuda-max-local-mem-size.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/cuda-max-local-mem-size.cpp
rename to sycl/test-e2e/Adapters/cuda-max-local-mem-size.cpp
diff --git a/sycl/test-e2e/Plugin/cuda_queue_priority.cpp b/sycl/test-e2e/Adapters/cuda_queue_priority.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/cuda_queue_priority.cpp
rename to sycl/test-e2e/Adapters/cuda_queue_priority.cpp
diff --git a/sycl/test-e2e/Plugin/dll-detach-order.cpp b/sycl/test-e2e/Adapters/dll-detach-order.cpp
similarity index 77%
rename from sycl/test-e2e/Plugin/dll-detach-order.cpp
rename to sycl/test-e2e/Adapters/dll-detach-order.cpp
index e6e45f6dc4db5..72d014eb066bb 100644
--- a/sycl/test-e2e/Plugin/dll-detach-order.cpp
+++ b/sycl/test-e2e/Adapters/dll-detach-order.cpp
@@ -2,7 +2,8 @@
// REQUIRES: build-and-run-mode
// RUN: env SYCL_UR_TRACE=-1 sycl-ls | FileCheck %s
-// ensure that the plugins are detached AFTER urLoaderTearDown is done executing
+// ensure that the adapters are detached AFTER urLoaderTearDown is done
+// executing
// CHECK: ---> DLL_PROCESS_DETACH syclx.dll
diff --git a/sycl/test-e2e/Plugin/enqueue-arg-order-buffer.cpp b/sycl/test-e2e/Adapters/enqueue-arg-order-buffer.cpp
similarity index 99%
rename from sycl/test-e2e/Plugin/enqueue-arg-order-buffer.cpp
rename to sycl/test-e2e/Adapters/enqueue-arg-order-buffer.cpp
index ee744efe1bf47..468069e275a29 100644
--- a/sycl/test-e2e/Plugin/enqueue-arg-order-buffer.cpp
+++ b/sycl/test-e2e/Adapters/enqueue-arg-order-buffer.cpp
@@ -415,7 +415,7 @@ int main() {
// CHECK-LABEL: start copyH2D-buffer
// CHECK: <--- urEnqueueMemBufferWrite({{.*}} .size = 64,
-// CHECK: <--- urEnqueueMemBufferWriteRect({{.*}} .region = (struct ur_rect_region_t){.width = 64, .height = 5, .depth = 1}, .bufferRowPitch = 64, .bufferSlicePitch = 0, .hostRowPitch = 64,
+// CHECK: <--- urEnqueueMemBufferWriteRect({{.*}} .region = (struct ur_rect_region_t){.width = 64, .height = 5, .depth = 1}, .bufferRowPitch = 64, .bufferSlicePitch = 0, .hostRowPitch = 64,
// CHECK: <--- urEnqueueMemBufferWriteRect({{.*}} .region = (struct ur_rect_region_t){.width = 64, .height = 5, .depth = 3}, .bufferRowPitch = 64, .bufferSlicePitch = 320, .hostRowPitch = 64, .hostSlicePitch = 320,
// CHECK: end copyH2D-buffer
diff --git a/sycl/test-e2e/Plugin/enqueue-arg-order-image.cpp b/sycl/test-e2e/Adapters/enqueue-arg-order-image.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/enqueue-arg-order-image.cpp
rename to sycl/test-e2e/Adapters/enqueue-arg-order-image.cpp
diff --git a/sycl/test-e2e/Plugin/interop-cuda-experimental.cpp b/sycl/test-e2e/Adapters/interop-cuda-experimental.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/interop-cuda-experimental.cpp
rename to sycl/test-e2e/Adapters/interop-cuda-experimental.cpp
diff --git a/sycl/test-e2e/Plugin/interop-device.cpp b/sycl/test-e2e/Adapters/interop-device.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/interop-device.cpp
rename to sycl/test-e2e/Adapters/interop-device.cpp
diff --git a/sycl/test-e2e/Plugin/interop-experimental-single-TU-SYCL-CUDA-compilation.cpp b/sycl/test-e2e/Adapters/interop-experimental-single-TU-SYCL-CUDA-compilation.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/interop-experimental-single-TU-SYCL-CUDA-compilation.cpp
rename to sycl/test-e2e/Adapters/interop-experimental-single-TU-SYCL-CUDA-compilation.cpp
diff --git a/sycl/test-e2e/Plugin/interop-l0-direct.cpp b/sycl/test-e2e/Adapters/interop-l0-direct.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/interop-l0-direct.cpp
rename to sycl/test-e2e/Adapters/interop-l0-direct.cpp
diff --git a/sycl/test-e2e/Plugin/interop-level-zero-buffer-helpers.hpp b/sycl/test-e2e/Adapters/interop-level-zero-buffer-helpers.hpp
similarity index 100%
rename from sycl/test-e2e/Plugin/interop-level-zero-buffer-helpers.hpp
rename to sycl/test-e2e/Adapters/interop-level-zero-buffer-helpers.hpp
diff --git a/sycl/test-e2e/Plugin/interop-level-zero-buffer-multi-dim.cpp b/sycl/test-e2e/Adapters/interop-level-zero-buffer-multi-dim.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/interop-level-zero-buffer-multi-dim.cpp
rename to sycl/test-e2e/Adapters/interop-level-zero-buffer-multi-dim.cpp
diff --git a/sycl/test-e2e/Plugin/interop-level-zero-buffer-ownership.cpp b/sycl/test-e2e/Adapters/interop-level-zero-buffer-ownership.cpp
similarity index 98%
rename from sycl/test-e2e/Plugin/interop-level-zero-buffer-ownership.cpp
rename to sycl/test-e2e/Adapters/interop-level-zero-buffer-ownership.cpp
index 7fa9c9895a38e..c1e72929ad489 100644
--- a/sycl/test-e2e/Plugin/interop-level-zero-buffer-ownership.cpp
+++ b/sycl/test-e2e/Adapters/interop-level-zero-buffer-ownership.cpp
@@ -1,5 +1,5 @@
// REQUIRES: gpu, level_zero, level_zero_dev_kit
-// L0 plugin incorrectly reports memory leaks because it doesn't take into
+// L0 adapter incorrectly reports memory leaks because it doesn't take into
// account direct calls to L0 API.
// UNSUPPORTED: ze_debug
// RUN: %{build} %level_zero_options -o %t.out
diff --git a/sycl/test-e2e/Plugin/interop-level-zero-buffer.cpp b/sycl/test-e2e/Adapters/interop-level-zero-buffer.cpp
similarity index 99%
rename from sycl/test-e2e/Plugin/interop-level-zero-buffer.cpp
rename to sycl/test-e2e/Adapters/interop-level-zero-buffer.cpp
index 9ec7f00a10819..897e854a25df7 100644
--- a/sycl/test-e2e/Plugin/interop-level-zero-buffer.cpp
+++ b/sycl/test-e2e/Adapters/interop-level-zero-buffer.cpp
@@ -1,5 +1,5 @@
// REQUIRES: level_zero, level_zero_dev_kit
-// L0 plugin incorrectly reports memory leaks because it doesn't take into
+// L0 adapter incorrectly reports memory leaks because it doesn't take into
// account direct calls to L0 API.
// UNSUPPORTED: ze_debug
// RUN: %{build} -Wno-error=deprecated-declarations %level_zero_options -o %t.out
diff --git a/sycl/test-e2e/Plugin/interop-level-zero-device.cpp b/sycl/test-e2e/Adapters/interop-level-zero-device.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/interop-level-zero-device.cpp
rename to sycl/test-e2e/Adapters/interop-level-zero-device.cpp
diff --git a/sycl/test-e2e/Plugin/interop-level-zero-get-native-mem.cpp b/sycl/test-e2e/Adapters/interop-level-zero-get-native-mem.cpp
similarity index 98%
rename from sycl/test-e2e/Plugin/interop-level-zero-get-native-mem.cpp
rename to sycl/test-e2e/Adapters/interop-level-zero-get-native-mem.cpp
index 1f9bfd5b5f239..5a59e7d100306 100644
--- a/sycl/test-e2e/Plugin/interop-level-zero-get-native-mem.cpp
+++ b/sycl/test-e2e/Adapters/interop-level-zero-get-native-mem.cpp
@@ -1,5 +1,5 @@
// REQUIRES: level_zero, level_zero_dev_kit
-// L0 plugin incorrectly reports memory leaks because it doesn't take into
+// L0 adapter incorrectly reports memory leaks because it doesn't take into
// account direct calls to L0 API.
// UNSUPPORTED: ze_debug
// RUN: %{build} %level_zero_options -o %t.out
diff --git a/sycl/test-e2e/Plugin/interop-level-zero-image-get-native-mem.cpp b/sycl/test-e2e/Adapters/interop-level-zero-image-get-native-mem.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/interop-level-zero-image-get-native-mem.cpp
rename to sycl/test-e2e/Adapters/interop-level-zero-image-get-native-mem.cpp
diff --git a/sycl/test-e2e/Plugin/interop-level-zero-image-ownership.cpp b/sycl/test-e2e/Adapters/interop-level-zero-image-ownership.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/interop-level-zero-image-ownership.cpp
rename to sycl/test-e2e/Adapters/interop-level-zero-image-ownership.cpp
diff --git a/sycl/test-e2e/Plugin/interop-level-zero-image.cpp b/sycl/test-e2e/Adapters/interop-level-zero-image.cpp
similarity index 99%
rename from sycl/test-e2e/Plugin/interop-level-zero-image.cpp
rename to sycl/test-e2e/Adapters/interop-level-zero-image.cpp
index 8b1febce40c28..019a63b470538 100644
--- a/sycl/test-e2e/Plugin/interop-level-zero-image.cpp
+++ b/sycl/test-e2e/Adapters/interop-level-zero-image.cpp
@@ -116,7 +116,7 @@ int main() {
}
} // ~image
- } // closure
+ } // closure
{
// ------ 2D ------
@@ -165,7 +165,7 @@ int main() {
}
} // ~image
- } // closure
+ } // closure
{
// ------ 3D ------
@@ -216,7 +216,7 @@ int main() {
}
} // ~image
- } // closure
+ } // closure
#else
std::cout << "Missing Level-Zero backend. Test skipped." << std::endl;
diff --git a/sycl/test-e2e/Plugin/interop-level-zero-keep-ownership.cpp b/sycl/test-e2e/Adapters/interop-level-zero-keep-ownership.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/interop-level-zero-keep-ownership.cpp
rename to sycl/test-e2e/Adapters/interop-level-zero-keep-ownership.cpp
diff --git a/sycl/test-e2e/Plugin/interop-level-zero-thread.cpp b/sycl/test-e2e/Adapters/interop-level-zero-thread.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/interop-level-zero-thread.cpp
rename to sycl/test-e2e/Adapters/interop-level-zero-thread.cpp
diff --git a/sycl/test-e2e/Plugin/interop-level-zero.cpp b/sycl/test-e2e/Adapters/interop-level-zero.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/interop-level-zero.cpp
rename to sycl/test-e2e/Adapters/interop-level-zero.cpp
diff --git a/sycl/test-e2e/Plugin/interop-opencl-make-kernel-bundle.cpp b/sycl/test-e2e/Adapters/interop-opencl-make-kernel-bundle.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/interop-opencl-make-kernel-bundle.cpp
rename to sycl/test-e2e/Adapters/interop-opencl-make-kernel-bundle.cpp
diff --git a/sycl/test-e2e/Plugin/interop-opencl-make-kernel.cpp b/sycl/test-e2e/Adapters/interop-opencl-make-kernel.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/interop-opencl-make-kernel.cpp
rename to sycl/test-e2e/Adapters/interop-opencl-make-kernel.cpp
diff --git a/sycl/test-e2e/Plugin/interop-opencl.cpp b/sycl/test-e2e/Adapters/interop-opencl.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/interop-opencl.cpp
rename to sycl/test-e2e/Adapters/interop-opencl.cpp
diff --git a/sycl/test-e2e/Plugin/level-zero-event-leak.cpp b/sycl/test-e2e/Adapters/level-zero-event-leak.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/level-zero-event-leak.cpp
rename to sycl/test-e2e/Adapters/level-zero-event-leak.cpp
diff --git a/sycl/test-e2e/Plugin/level-zero-usm-capabilities.cpp b/sycl/test-e2e/Adapters/level-zero-usm-capabilities.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/level-zero-usm-capabilities.cpp
rename to sycl/test-e2e/Adapters/level-zero-usm-capabilities.cpp
diff --git a/sycl/test-e2e/Plugin/level_zero_barrier_optimization.cpp b/sycl/test-e2e/Adapters/level_zero_barrier_optimization.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/level_zero_barrier_optimization.cpp
rename to sycl/test-e2e/Adapters/level_zero_barrier_optimization.cpp
diff --git a/sycl/test-e2e/Plugin/level_zero_batch_barrier.cpp b/sycl/test-e2e/Adapters/level_zero_batch_barrier.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/level_zero_batch_barrier.cpp
rename to sycl/test-e2e/Adapters/level_zero_batch_barrier.cpp
diff --git a/sycl/test-e2e/Plugin/level_zero_batch_event_status.cpp b/sycl/test-e2e/Adapters/level_zero_batch_event_status.cpp
similarity index 97%
rename from sycl/test-e2e/Plugin/level_zero_batch_event_status.cpp
rename to sycl/test-e2e/Adapters/level_zero_batch_event_status.cpp
index 57ba0134c88e1..91eefba54793c 100644
--- a/sycl/test-e2e/Plugin/level_zero_batch_event_status.cpp
+++ b/sycl/test-e2e/Adapters/level_zero_batch_event_status.cpp
@@ -8,7 +8,7 @@
// level_zero_batch_test.cpp
//
-// This tests the level zero plugin's kernel batching code. It specifically
+// This tests the level zero adapter's kernel batching code. It specifically
// tests that the current batch is submitted when an Event execution status
// request is made. This test uses explicit SYCL_PI_LEVEL_ZERO_BATCH_SIZE=4
// to make sure that the batching is submitted when the urEventGetInfo is
diff --git a/sycl/test-e2e/Plugin/level_zero_batch_test.cpp b/sycl/test-e2e/Adapters/level_zero_batch_test.cpp
similarity index 99%
rename from sycl/test-e2e/Plugin/level_zero_batch_test.cpp
rename to sycl/test-e2e/Adapters/level_zero_batch_test.cpp
index 792090a35e481..0a45743fd074f 100644
--- a/sycl/test-e2e/Plugin/level_zero_batch_test.cpp
+++ b/sycl/test-e2e/Adapters/level_zero_batch_test.cpp
@@ -73,7 +73,7 @@
// level_zero_batch_test.cpp
//
-// This tests the level zero plugin's kernel batching code. The default
+// This tests the level zero adapter's kernel batching code. The default
// batching is 4, and exact batch size can be controlled with environment
// variable SYCL_PI_LEVEL_ZEOR+BATCH_SIZE=N.
// This test enqueues 8 kernels and then does a wait. And it does this 3 times.
diff --git a/sycl/test-e2e/Plugin/level_zero_batch_test_copy_with_compute.cpp b/sycl/test-e2e/Adapters/level_zero_batch_test_copy_with_compute.cpp
similarity index 99%
rename from sycl/test-e2e/Plugin/level_zero_batch_test_copy_with_compute.cpp
rename to sycl/test-e2e/Adapters/level_zero_batch_test_copy_with_compute.cpp
index 2ebe6aa0c748a..6742000dd2f84 100644
--- a/sycl/test-e2e/Plugin/level_zero_batch_test_copy_with_compute.cpp
+++ b/sycl/test-e2e/Adapters/level_zero_batch_test_copy_with_compute.cpp
@@ -26,7 +26,7 @@
// level_zero_batch_test_copy_with_compute.cpp
//
-// This tests the level zero plugin's kernel batching code. The default
+// This tests the level zero adapter's kernel batching code. The default
// batching is 4, and exact batch size can be controlled with environment
// variable SYCL_PI_LEVEL_ZERO_{COPY_}BATCH_SIZE=N.
// This test enqueues 8 kernels and then does a wait. And it does this 3 times.
diff --git a/sycl/test-e2e/Plugin/level_zero_device_free_mem.cpp b/sycl/test-e2e/Adapters/level_zero_device_free_mem.cpp
similarity index 97%
rename from sycl/test-e2e/Plugin/level_zero_device_free_mem.cpp
rename to sycl/test-e2e/Adapters/level_zero_device_free_mem.cpp
index 62b32c90544b6..d6301bf8b93af 100644
--- a/sycl/test-e2e/Plugin/level_zero_device_free_mem.cpp
+++ b/sycl/test-e2e/Adapters/level_zero_device_free_mem.cpp
@@ -1,6 +1,6 @@
// https://github.com/intel/llvm/issues/14244
-// sycl-ls --verbose shows the "ext_intel_free_memory" aspect if
-// ZES_ENABLE_SYSMAN=1 is set, but also is sysman init is supported,
+// sycl-ls --verbose shows the "ext_intel_free_memory" aspect if
+// ZES_ENABLE_SYSMAN=1 is set, but also is sysman init is supported,
// so this test is missed if it requires aspect-ext_intel_free_memory.
// Since gen9 and get12 don't support this query,
diff --git a/sycl/test-e2e/Plugin/level_zero_device_memory_clock_rate_and_bus_width.cpp b/sycl/test-e2e/Adapters/level_zero_device_memory_clock_rate_and_bus_width.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/level_zero_device_memory_clock_rate_and_bus_width.cpp
rename to sycl/test-e2e/Adapters/level_zero_device_memory_clock_rate_and_bus_width.cpp
diff --git a/sycl/test-e2e/Plugin/level_zero_device_scope_events.cpp b/sycl/test-e2e/Adapters/level_zero_device_scope_events.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/level_zero_device_scope_events.cpp
rename to sycl/test-e2e/Adapters/level_zero_device_scope_events.cpp
diff --git a/sycl/test-e2e/Plugin/level_zero_dynamic_batch_test.cpp b/sycl/test-e2e/Adapters/level_zero_dynamic_batch_test.cpp
similarity index 99%
rename from sycl/test-e2e/Plugin/level_zero_dynamic_batch_test.cpp
rename to sycl/test-e2e/Adapters/level_zero_dynamic_batch_test.cpp
index fbe7d8e27cb55..106043eddc3bf 100644
--- a/sycl/test-e2e/Plugin/level_zero_dynamic_batch_test.cpp
+++ b/sycl/test-e2e/Adapters/level_zero_dynamic_batch_test.cpp
@@ -12,7 +12,7 @@
// level_zero_dynamic_batch_test.cpp
//
-// This tests the level zero plugin's kernel dynamic batch size adjustment
+// This tests the level zero adapter's kernel dynamic batch size adjustment
// code.
// It starts out by enqueing 40 kernels before it does a wait, and it does
// this 5 times. That should cause the dynamic batch size adjustment to
diff --git a/sycl/test-e2e/Plugin/level_zero_eager_init.cpp b/sycl/test-e2e/Adapters/level_zero_eager_init.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/level_zero_eager_init.cpp
rename to sycl/test-e2e/Adapters/level_zero_eager_init.cpp
diff --git a/sycl/test-e2e/Plugin/level_zero_events_caching.cpp b/sycl/test-e2e/Adapters/level_zero_events_caching.cpp
similarity index 95%
rename from sycl/test-e2e/Plugin/level_zero_events_caching.cpp
rename to sycl/test-e2e/Adapters/level_zero_events_caching.cpp
index caa107a2eaf6f..40e0349f5d356 100644
--- a/sycl/test-e2e/Plugin/level_zero_events_caching.cpp
+++ b/sycl/test-e2e/Adapters/level_zero_events_caching.cpp
@@ -13,7 +13,7 @@
// CACHING-ENABLED: zeEventCreate = {{[1-9]}}
// CACHING-DISABLED: zeEventCreate = 256
-// Check event caching modes in the L0 plugin.
+// Check event caching modes in the L0 adapter.
#include
diff --git a/sycl/test-e2e/Plugin/level_zero_events_caching_leak.cpp b/sycl/test-e2e/Adapters/level_zero_events_caching_leak.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/level_zero_events_caching_leak.cpp
rename to sycl/test-e2e/Adapters/level_zero_events_caching_leak.cpp
diff --git a/sycl/test-e2e/Plugin/level_zero_ext_intel_cslice.cpp b/sycl/test-e2e/Adapters/level_zero_ext_intel_cslice.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/level_zero_ext_intel_cslice.cpp
rename to sycl/test-e2e/Adapters/level_zero_ext_intel_cslice.cpp
diff --git a/sycl/test-e2e/Plugin/level_zero_ext_intel_queue_index.cpp b/sycl/test-e2e/Adapters/level_zero_ext_intel_queue_index.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/level_zero_ext_intel_queue_index.cpp
rename to sycl/test-e2e/Adapters/level_zero_ext_intel_queue_index.cpp
diff --git a/sycl/test-e2e/Plugin/level_zero_imm_cmdlist.cpp b/sycl/test-e2e/Adapters/level_zero_imm_cmdlist.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/level_zero_imm_cmdlist.cpp
rename to sycl/test-e2e/Adapters/level_zero_imm_cmdlist.cpp
diff --git a/sycl/test-e2e/Plugin/level_zero_imm_cmdlist_per_thread.cpp b/sycl/test-e2e/Adapters/level_zero_imm_cmdlist_per_thread.cpp
similarity index 93%
rename from sycl/test-e2e/Plugin/level_zero_imm_cmdlist_per_thread.cpp
rename to sycl/test-e2e/Adapters/level_zero_imm_cmdlist_per_thread.cpp
index 153af5c5a1f9d..6fe8d3c98ff64 100644
--- a/sycl/test-e2e/Plugin/level_zero_imm_cmdlist_per_thread.cpp
+++ b/sycl/test-e2e/Adapters/level_zero_imm_cmdlist_per_thread.cpp
@@ -74,10 +74,10 @@ int main() {
// Create one queue
auto D = Queue.get_device();
const char *devType = D.is_cpu() ? "CPU" : "GPU";
- std::string pluginName = D.get_platform().get_info();
+ std::string adapterName = D.get_platform().get_info();
std::cout << "Running on device " << devType << " ("
- << D.get_info() << ") " << pluginName
- << " plugin\n";
+ << D.get_info() << ") " << adapterName
+ << " adapter\n";
// Use queue in multiple threads
std::thread T1(run_sample, Queue, 0);
diff --git a/sycl/test-e2e/Plugin/level_zero_inorder.cpp b/sycl/test-e2e/Adapters/level_zero_inorder.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/level_zero_inorder.cpp
rename to sycl/test-e2e/Adapters/level_zero_inorder.cpp
diff --git a/sycl/test-e2e/Plugin/level_zero_inorder_interleaving_kernel_copy.cpp b/sycl/test-e2e/Adapters/level_zero_inorder_interleaving_kernel_copy.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/level_zero_inorder_interleaving_kernel_copy.cpp
rename to sycl/test-e2e/Adapters/level_zero_inorder_interleaving_kernel_copy.cpp
diff --git a/sycl/test-e2e/Plugin/level_zero_interop_memcpy.cpp b/sycl/test-e2e/Adapters/level_zero_interop_memcpy.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/level_zero_interop_memcpy.cpp
rename to sycl/test-e2e/Adapters/level_zero_interop_memcpy.cpp
diff --git a/sycl/test-e2e/Plugin/level_zero_memory_fill.cpp b/sycl/test-e2e/Adapters/level_zero_memory_fill.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/level_zero_memory_fill.cpp
rename to sycl/test-e2e/Adapters/level_zero_memory_fill.cpp
diff --git a/sycl/test-e2e/Plugin/level_zero_queue_create.cpp b/sycl/test-e2e/Adapters/level_zero_queue_create.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/level_zero_queue_create.cpp
rename to sycl/test-e2e/Adapters/level_zero_queue_create.cpp
diff --git a/sycl/test-e2e/Plugin/level_zero_queue_priority.cpp b/sycl/test-e2e/Adapters/level_zero_queue_priority.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/level_zero_queue_priority.cpp
rename to sycl/test-e2e/Adapters/level_zero_queue_priority.cpp
diff --git a/sycl/test-e2e/Plugin/level_zero_queue_profiling.cpp b/sycl/test-e2e/Adapters/level_zero_queue_profiling.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/level_zero_queue_profiling.cpp
rename to sycl/test-e2e/Adapters/level_zero_queue_profiling.cpp
diff --git a/sycl/test-e2e/Plugin/level_zero_sub_sub_device.cpp b/sycl/test-e2e/Adapters/level_zero_sub_sub_device.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/level_zero_sub_sub_device.cpp
rename to sycl/test-e2e/Adapters/level_zero_sub_sub_device.cpp
diff --git a/sycl/test-e2e/Plugin/level_zero_track_indirect_access_memory.cpp b/sycl/test-e2e/Adapters/level_zero_track_indirect_access_memory.cpp
similarity index 97%
rename from sycl/test-e2e/Plugin/level_zero_track_indirect_access_memory.cpp
rename to sycl/test-e2e/Adapters/level_zero_track_indirect_access_memory.cpp
index 40cfee5b66c0e..12ac686b2f4db 100644
--- a/sycl/test-e2e/Plugin/level_zero_track_indirect_access_memory.cpp
+++ b/sycl/test-e2e/Adapters/level_zero_track_indirect_access_memory.cpp
@@ -9,7 +9,7 @@
// Tracking and deferred release is necessary for memory which can be indirectly
// accessed because such memory can't be released as soon as someone calls free.
// It can be released only after completion of all kernels which can possibly
-// access this memory indirectly. Currently the Level Zero plugin marks all
+// access this memory indirectly. Currently the Level Zero adapter marks all
// kernels with indirect access flag conservatively. This flag means that kernel
// starts to reference all existing memory allocations (even if not explicitly
// used in the kernel) as soon as it is submitted. That's why basically all
diff --git a/sycl/test-e2e/Plugin/level_zero_usm_device_read_only.cpp b/sycl/test-e2e/Adapters/level_zero_usm_device_read_only.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/level_zero_usm_device_read_only.cpp
rename to sycl/test-e2e/Adapters/level_zero_usm_device_read_only.cpp
diff --git a/sycl/test-e2e/Plugin/level_zero_usm_residency.cpp b/sycl/test-e2e/Adapters/level_zero_usm_residency.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/level_zero_usm_residency.cpp
rename to sycl/test-e2e/Adapters/level_zero_usm_residency.cpp
diff --git a/sycl/test-e2e/Plugin/level_zero_uuid.cpp b/sycl/test-e2e/Adapters/level_zero_uuid.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/level_zero_uuid.cpp
rename to sycl/test-e2e/Adapters/level_zero_uuid.cpp
diff --git a/sycl/test-e2e/Plugin/max_malloc.cpp b/sycl/test-e2e/Adapters/max_malloc.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/max_malloc.cpp
rename to sycl/test-e2e/Adapters/max_malloc.cpp
diff --git a/sycl/test-e2e/Plugin/queue_submit_mode.cpp b/sycl/test-e2e/Adapters/queue_submit_mode.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/queue_submit_mode.cpp
rename to sycl/test-e2e/Adapters/queue_submit_mode.cpp
diff --git a/sycl/test-e2e/Plugin/retain_events.cpp b/sycl/test-e2e/Adapters/retain_events.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/retain_events.cpp
rename to sycl/test-e2e/Adapters/retain_events.cpp
diff --git a/sycl/test-e2e/Plugin/sycl-ls-gpu-cuda.cpp b/sycl/test-e2e/Adapters/sycl-ls-gpu-cuda.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/sycl-ls-gpu-cuda.cpp
rename to sycl/test-e2e/Adapters/sycl-ls-gpu-cuda.cpp
diff --git a/sycl/test-e2e/Plugin/sycl-ls-gpu-default-any.cpp b/sycl/test-e2e/Adapters/sycl-ls-gpu-default-any.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/sycl-ls-gpu-default-any.cpp
rename to sycl/test-e2e/Adapters/sycl-ls-gpu-default-any.cpp
diff --git a/sycl/test-e2e/Plugin/sycl-ls-gpu-default-level-zero.cpp b/sycl/test-e2e/Adapters/sycl-ls-gpu-default-level-zero.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/sycl-ls-gpu-default-level-zero.cpp
rename to sycl/test-e2e/Adapters/sycl-ls-gpu-default-level-zero.cpp
diff --git a/sycl/test-e2e/Plugin/sycl-ls-gpu-hip.cpp b/sycl/test-e2e/Adapters/sycl-ls-gpu-hip.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/sycl-ls-gpu-hip.cpp
rename to sycl/test-e2e/Adapters/sycl-ls-gpu-hip.cpp
diff --git a/sycl/test-e2e/Plugin/sycl-ls-gpu-level-zero.cpp b/sycl/test-e2e/Adapters/sycl-ls-gpu-level-zero.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/sycl-ls-gpu-level-zero.cpp
rename to sycl/test-e2e/Adapters/sycl-ls-gpu-level-zero.cpp
diff --git a/sycl/test-e2e/Plugin/sycl-ls-gpu-opencl.cpp b/sycl/test-e2e/Adapters/sycl-ls-gpu-opencl.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/sycl-ls-gpu-opencl.cpp
rename to sycl/test-e2e/Adapters/sycl-ls-gpu-opencl.cpp
diff --git a/sycl/test-e2e/Plugin/sycl-ls-gpu-sycl-be.cpp b/sycl/test-e2e/Adapters/sycl-ls-gpu-sycl-be.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/sycl-ls-gpu-sycl-be.cpp
rename to sycl/test-e2e/Adapters/sycl-ls-gpu-sycl-be.cpp
diff --git a/sycl/test-e2e/Plugin/sycl-ls-uuid-subdevs.cpp b/sycl/test-e2e/Adapters/sycl-ls-uuid-subdevs.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/sycl-ls-uuid-subdevs.cpp
rename to sycl/test-e2e/Adapters/sycl-ls-uuid-subdevs.cpp
diff --git a/sycl/test-e2e/Plugin/sycl-ls.cpp b/sycl/test-e2e/Adapters/sycl-ls.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/sycl-ls.cpp
rename to sycl/test-e2e/Adapters/sycl-ls.cpp
diff --git a/sycl/test-e2e/Plugin/sycl-partition-info.cpp b/sycl/test-e2e/Adapters/sycl-partition-info.cpp
similarity index 89%
rename from sycl/test-e2e/Plugin/sycl-partition-info.cpp
rename to sycl/test-e2e/Adapters/sycl-partition-info.cpp
index e6f911f541d3e..8274c2bb0459f 100644
--- a/sycl/test-e2e/Plugin/sycl-partition-info.cpp
+++ b/sycl/test-e2e/Adapters/sycl-partition-info.cpp
@@ -1,7 +1,7 @@
// RUN: %{build} -o %t.out
// RUN: %{run} %t.out
-// various plugins may return a larger choice of partition properties than SYCL
+// various adapters may return a larger choice of partition properties than SYCL
// supports ensure we are only returning SYCL standard partition properties.
#include
diff --git a/sycl/test-e2e/Plugin/sycl-targets-order.cpp b/sycl/test-e2e/Adapters/sycl-targets-order.cpp
similarity index 100%
rename from sycl/test-e2e/Plugin/sycl-targets-order.cpp
rename to sycl/test-e2e/Adapters/sycl-targets-order.cpp
diff --git a/sycl/test-e2e/Assert/assert_in_simultaneous_kernels.cpp b/sycl/test-e2e/Assert/assert_in_simultaneous_kernels.cpp
index 69b6197921322..15854048d275b 100644
--- a/sycl/test-e2e/Assert/assert_in_simultaneous_kernels.cpp
+++ b/sycl/test-e2e/Assert/assert_in_simultaneous_kernels.cpp
@@ -7,7 +7,7 @@
// XFAIL-TRACKER: https://github.com/intel/llvm/issues/11364
//
// Since this is a multi-threaded application enable memory tracking and
-// deferred release feature in the Level Zero plugin to avoid releasing memory
+// deferred release feature in the Level Zero adapter to avoid releasing memory
// too early. This is necessary because currently SYCL RT sets indirect access
// flag for all kernels and the Level Zero runtime doesn't support deferred
// release yet.
diff --git a/sycl/test-e2e/Assert/assert_in_simultaneous_kernels_win.cpp b/sycl/test-e2e/Assert/assert_in_simultaneous_kernels_win.cpp
index f3b9bd9fc645f..8ca6db17ae348 100644
--- a/sycl/test-e2e/Assert/assert_in_simultaneous_kernels_win.cpp
+++ b/sycl/test-e2e/Assert/assert_in_simultaneous_kernels_win.cpp
@@ -2,7 +2,7 @@
// RUN: %{build} -DSYCL_FALLBACK_ASSERT=1 -o %t.out %threads_lib
//
// Since this is a multi-threaded application enable memory tracking and
-// deferred release feature in the Level Zero plugin to avoid releasing memory
+// deferred release feature in the Level Zero adapter to avoid releasing memory
// too early. This is necessary because currently SYCL RT sets indirect access
// flag for all kernels and the Level Zero runtime doesn't support deferred
// release yet.
diff --git a/sycl/test-e2e/Assert/assert_in_simultaneously_multiple_tus.cpp b/sycl/test-e2e/Assert/assert_in_simultaneously_multiple_tus.cpp
index 0ee0b2f7a4ad0..d43c806952990 100644
--- a/sycl/test-e2e/Assert/assert_in_simultaneously_multiple_tus.cpp
+++ b/sycl/test-e2e/Assert/assert_in_simultaneously_multiple_tus.cpp
@@ -7,7 +7,7 @@
// RUN: %{build} -DSYCL_FALLBACK_ASSERT=1 -I %S/Inputs %S/Inputs/kernels_in_file2.cpp -o %t.out %threads_lib
//
// Since this is a multi-threaded application enable memory tracking and
-// deferred release feature in the Level Zero plugin to avoid releasing memory
+// deferred release feature in the Level Zero adapter to avoid releasing memory
// too early. This is necessary because currently SYCL RT sets indirect access
// flag for all kernels and the Level Zero runtime doesn't support deferred
// release yet.
diff --git a/sycl/test-e2e/Assert/assert_in_simultaneously_multiple_tus_one_ndebug.cpp b/sycl/test-e2e/Assert/assert_in_simultaneously_multiple_tus_one_ndebug.cpp
index 6cc3b6c85d283..731187fe4cdf7 100644
--- a/sycl/test-e2e/Assert/assert_in_simultaneously_multiple_tus_one_ndebug.cpp
+++ b/sycl/test-e2e/Assert/assert_in_simultaneously_multiple_tus_one_ndebug.cpp
@@ -9,7 +9,7 @@
// RUN: %if cpu %{ %{run} %t.out &> %t.cpu.txt ; FileCheck %s --input-file %t.cpu.txt %}
//
// Since this is a multi-threaded application enable memory tracking and
-// deferred release feature in the Level Zero plugin to avoid releasing memory
+// deferred release feature in the Level Zero adapter to avoid releasing memory
// too early. This is necessary because currently SYCL RT sets indirect access
// flag for all kernels and the Level Zero runtime doesn't support deferred
// release yet.
diff --git a/sycl/test-e2e/Basic/image/srgba-aspect-check.cpp b/sycl/test-e2e/Basic/image/srgba-aspect-check.cpp
index 5c892d716fcc5..a93cae1e64d5a 100644
--- a/sycl/test-e2e/Basic/image/srgba-aspect-check.cpp
+++ b/sycl/test-e2e/Basic/image/srgba-aspect-check.cpp
@@ -5,7 +5,7 @@
int main() {
sycl::queue q;
- // Ensure that plugins that don't implement the support can still handle the
+ // Ensure that adapters that don't implement the support can still handle the
// aspect query.
std::ignore = q.get_device().has(sycl::aspect::ext_oneapi_srgb);
return 0;
diff --git a/sycl/test-e2e/Basic/queue/release.cpp b/sycl/test-e2e/Basic/queue/release.cpp
index aef5160123ce4..d241b742a0216 100644
--- a/sycl/test-e2e/Basic/queue/release.cpp
+++ b/sycl/test-e2e/Basic/queue/release.cpp
@@ -14,7 +14,7 @@ int main() {
}
// CHECK: <--- urEnqueueKernelLaunch(
-// FIXME the order of these 2 varies between plugins due to a Level Zero
+// FIXME the order of these 2 varies between adapters due to a Level Zero
// specific queue workaround.
// CHECK-DAG: <--- urEventRelease(
// CHECK-DAG: <--- urQueueRelease(
diff --git a/sycl/test-e2e/Graph/Explicit/interop-level-zero-get-native-mem.cpp b/sycl/test-e2e/Graph/Explicit/interop-level-zero-get-native-mem.cpp
index 1d8fcdf963ab5..adf4b8bc06b2b 100644
--- a/sycl/test-e2e/Graph/Explicit/interop-level-zero-get-native-mem.cpp
+++ b/sycl/test-e2e/Graph/Explicit/interop-level-zero-get-native-mem.cpp
@@ -1,5 +1,5 @@
// REQUIRES: level_zero, level_zero_dev_kit
-// L0 plugin incorrectly reports memory leaks because it doesn't take into
+// L0 adapter incorrectly reports memory leaks because it doesn't take into
// account direct calls to L0 API.
// UNSUPPORTED: ze_debug
// RUN: %{build} %level_zero_options -o %t.out
diff --git a/sycl/test-e2e/Graph/Explicit/interop-level-zero-launch-kernel.cpp b/sycl/test-e2e/Graph/Explicit/interop-level-zero-launch-kernel.cpp
index b283697720201..ce1aac6c121dd 100644
--- a/sycl/test-e2e/Graph/Explicit/interop-level-zero-launch-kernel.cpp
+++ b/sycl/test-e2e/Graph/Explicit/interop-level-zero-launch-kernel.cpp
@@ -1,5 +1,5 @@
// REQUIRES: level_zero, level_zero_dev_kit
-// L0 plugin incorrectly reports memory leaks because it doesn't take into
+// L0 adapter incorrectly reports memory leaks because it doesn't take into
// account direct calls to the L0 API.
// UNSUPPORTED: ze_debug
// RUN: %{build} %level_zero_options -o %t.out
diff --git a/sycl/test-e2e/Graph/Inputs/interop-level-zero-get-native-mem.cpp b/sycl/test-e2e/Graph/Inputs/interop-level-zero-get-native-mem.cpp
index 56ce712b8d410..59ca0390a80ab 100644
--- a/sycl/test-e2e/Graph/Inputs/interop-level-zero-get-native-mem.cpp
+++ b/sycl/test-e2e/Graph/Inputs/interop-level-zero-get-native-mem.cpp
@@ -1,6 +1,6 @@
// Tests interop with host_task in graph
// This test was taken from
-// `sycl/test-e2e/Plugin/interop-level-zero-get-native-mem.cpp` This test has
+// `sycl/test-e2e/Adapter/interop-level-zero-get-native-mem.cpp` This test has
// been simplified to only work with signle device.
#include "../graph_common.hpp"
diff --git a/sycl/test-e2e/Graph/RecordReplay/interop-level-zero-get-native-mem.cpp b/sycl/test-e2e/Graph/RecordReplay/interop-level-zero-get-native-mem.cpp
index 551e463f6d887..a41645599b66e 100644
--- a/sycl/test-e2e/Graph/RecordReplay/interop-level-zero-get-native-mem.cpp
+++ b/sycl/test-e2e/Graph/RecordReplay/interop-level-zero-get-native-mem.cpp
@@ -1,5 +1,5 @@
// REQUIRES: level_zero, level_zero_dev_kit
-// L0 plugin incorrectly reports memory leaks because it doesn't take into
+// L0 adapter incorrectly reports memory leaks because it doesn't take into
// account direct calls to L0 API.
// UNSUPPORTED: ze_debug
// RUN: %{build} %level_zero_options -o %t.out
diff --git a/sycl/test-e2e/Graph/RecordReplay/interop-level-zero-launch-kernel.cpp b/sycl/test-e2e/Graph/RecordReplay/interop-level-zero-launch-kernel.cpp
index 894c35e995152..77bd7ab9fa1b3 100644
--- a/sycl/test-e2e/Graph/RecordReplay/interop-level-zero-launch-kernel.cpp
+++ b/sycl/test-e2e/Graph/RecordReplay/interop-level-zero-launch-kernel.cpp
@@ -1,5 +1,5 @@
// REQUIRES: level_zero, level_zero_dev_kit
-// L0 plugin incorrectly reports memory leaks because it doesn't take into
+// L0 adapter incorrectly reports memory leaks because it doesn't take into
// account direct calls to the L0 API.
// UNSUPPORTED: ze_debug
// RUN: %{build} %level_zero_options -o %t.out
diff --git a/sycl/test-e2e/KernelAndProgram/level-zero-static-link-flow.cpp b/sycl/test-e2e/KernelAndProgram/level-zero-static-link-flow.cpp
index 2360554318092..55402a0f44a5b 100644
--- a/sycl/test-e2e/KernelAndProgram/level-zero-static-link-flow.cpp
+++ b/sycl/test-e2e/KernelAndProgram/level-zero-static-link-flow.cpp
@@ -6,7 +6,7 @@
//==--- level-zero-static-link-flow.cpp.cpp - Check L0 static link flow --==//
//
// Run a simple program that uses online linking and verify that the sequence
-// of calls to the plugin and to the Level Zero driver are consistent with the
+// of calls to the adapter and to the Level Zero driver are consistent with the
// "static linking" implementation.
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
diff --git a/sycl/test-e2e/OneapiDeviceSelector/illegal_input_hang.cpp b/sycl/test-e2e/OneapiDeviceSelector/illegal_input_hang.cpp
index 1c763fef3a8ba..b89b51c3c0266 100644
--- a/sycl/test-e2e/OneapiDeviceSelector/illegal_input_hang.cpp
+++ b/sycl/test-e2e/OneapiDeviceSelector/illegal_input_hang.cpp
@@ -4,7 +4,7 @@
#include
// Check that the application does not hang when we attempt
-// to initialize plugins multiple times with invalid values
+// to initialize adapters multiple times with invalid values
// of ONEAPI_DEVICE_SELECTOR.
int main() {
for (int I = 0; I < 3; ++I) {
diff --git a/sycl/test-e2e/Scheduler/InOrderQueueDeps.cpp b/sycl/test-e2e/Scheduler/InOrderQueueDeps.cpp
index 27365433248a0..e1309ee0edb1a 100644
--- a/sycl/test-e2e/Scheduler/InOrderQueueDeps.cpp
+++ b/sycl/test-e2e/Scheduler/InOrderQueueDeps.cpp
@@ -4,7 +4,7 @@
// XFAIL: hip_nvidia
// The tested functionality is disabled with Level Zero until it is supported by
-// the plugin.
+// the adapter.
// UNSUPPORTED: level_zero
//==----------------------- InOrderQueueDeps.cpp ---------------------------==//
//
diff --git a/sycl/test-e2e/Tracing/buffer_printers.cpp b/sycl/test-e2e/Tracing/buffer_printers.cpp
index f5c8521ce6ec5..4e29cbb02ff6c 100644
--- a/sycl/test-e2e/Tracing/buffer_printers.cpp
+++ b/sycl/test-e2e/Tracing/buffer_printers.cpp
@@ -6,7 +6,7 @@
#include
#include
-// Test image-specific printers of the Plugin Interace
+// Test the buffer-specific printers of UR tracing.
//
//CHECK: <--- urEnqueueMemBufferCopyRect(
//CHECK-SAME: .srcOrigin = (struct ur_rect_offset_t){.x = 64, .y = 5, .z = 0}
diff --git a/sycl/test-e2e/Tracing/image_printers.cpp b/sycl/test-e2e/Tracing/image_printers.cpp
index c176a699d5e1a..3556fa4c0c7b4 100644
--- a/sycl/test-e2e/Tracing/image_printers.cpp
+++ b/sycl/test-e2e/Tracing/image_printers.cpp
@@ -3,7 +3,7 @@
// RUN: %{build} -o %t.out
// RUN: %{run} %t.out
-// Test image-specific printers of the Plugin Interace
+// Test the image-specific printers of UR tracing.
//
// CHECK: <--- urMemImageCreate(
// CHECK-SAME: image_desc w/h/d : 4 / 4 / 1 -- arrSz/row/slice : 0 / 64 / 256 -- num_mip_lvls/num_smpls/image_type : 0 / 0 / 4337
diff --git a/sycl/test-e2e/USM/usm_pooling.cpp b/sycl/test-e2e/USM/usm_pooling.cpp
index 63a083e5d47a3..258d97420a665 100644
--- a/sycl/test-e2e/USM/usm_pooling.cpp
+++ b/sycl/test-e2e/USM/usm_pooling.cpp
@@ -88,11 +88,11 @@ int main(int argc, char *argv[]) {
context C = Q.get_context();
const char *devType = D.is_cpu() ? "CPU" : "GPU";
- std::string pluginName =
+ std::string adapterName =
D.get_platform().get_info();
std::cout << "Running on device " << devType << " ("
- << D.get_info() << ") " << pluginName
- << " plugin\n";
+ << D.get_info() << ") " << adapterName
+ << " adapter\n";
if (*argv[1] == 'h') {
std::cerr << "Test zeMemAllocHost\n";
diff --git a/sycl/test/e2e_test_requirements/no-unsupported-without-info.cpp b/sycl/test/e2e_test_requirements/no-unsupported-without-info.cpp
index 713d1b7ff73d5..ec44b32f182f7 100644
--- a/sycl/test/e2e_test_requirements/no-unsupported-without-info.cpp
+++ b/sycl/test/e2e_test_requirements/no-unsupported-without-info.cpp
@@ -62,6 +62,27 @@
// CHECK: AOT/early_aot.cpp
// CHECK-NEXT: AOT/gpu.cpp
// CHECK-NEXT: AOT/multiple-devices.cpp
+// CHECK-NEXT: Adapters/enqueue-arg-order-buffer.cpp
+// CHECK-NEXT: Adapters/enqueue-arg-order-image.cpp
+// CHECK-NEXT: Adapters/enqueue-arg-order-image.cpp
+// CHECK-NEXT: Adapters/interop-l0-direct.cpp
+// CHECK-NEXT: Adapters/interop-level-zero-buffer-ownership.cpp
+// CHECK-NEXT: Adapters/interop-level-zero-buffer.cpp
+// CHECK-NEXT: Adapters/interop-level-zero-get-native-mem.cpp
+// CHECK-NEXT: Adapters/interop-level-zero-image-get-native-mem.cpp
+// CHECK-NEXT: Adapters/interop-level-zero-image-ownership.cpp
+// CHECK-NEXT: Adapters/interop-level-zero-image-ownership.cpp
+// CHECK-NEXT: Adapters/interop-level-zero-image.cpp
+// CHECK-NEXT: Adapters/interop-level-zero.cpp
+// CHECK-NEXT: Adapters/level_zero_batch_event_status.cpp
+// CHECK-NEXT: Adapters/level_zero_batch_test.cpp
+// CHECK-NEXT: Adapters/level_zero_batch_test_copy_with_compute.cpp
+// CHECK-NEXT: Adapters/level_zero_device_scope_events.cpp
+// CHECK-NEXT: Adapters/level_zero_dynamic_batch_test.cpp
+// CHECK-NEXT: Adapters/level_zero_imm_cmdlist_per_thread.cpp
+// CHECK-NEXT: Adapters/level_zero_queue_profiling.cpp
+// CHECK-NEXT: Adapters/level_zero_usm_device_read_only.cpp
+// CHECK-NEXT: Adapters/max_malloc.cpp
// CHECK-NEXT: AddressCast/dynamic_address_cast.cpp
// CHECK-NEXT: AddressCast/static_address_cast.cpp
// CHECK-NEXT: AmdNvidiaJIT/kernel_and_bundle.cpp
@@ -285,27 +306,6 @@
// CHECK-NEXT: OptionalKernelFeatures/is_compatible/is_compatible_with_aspects.cpp
// CHECK-NEXT: OptionalKernelFeatures/large-reqd-work-group-size.cpp
// CHECK-NEXT: OptionalKernelFeatures/no-fp64-optimization-declared-aspects.cpp
-// CHECK-NEXT: Plugin/enqueue-arg-order-buffer.cpp
-// CHECK-NEXT: Plugin/enqueue-arg-order-image.cpp
-// CHECK-NEXT: Plugin/enqueue-arg-order-image.cpp
-// CHECK-NEXT: Plugin/interop-l0-direct.cpp
-// CHECK-NEXT: Plugin/interop-level-zero-buffer-ownership.cpp
-// CHECK-NEXT: Plugin/interop-level-zero-buffer.cpp
-// CHECK-NEXT: Plugin/interop-level-zero-get-native-mem.cpp
-// CHECK-NEXT: Plugin/interop-level-zero-image-get-native-mem.cpp
-// CHECK-NEXT: Plugin/interop-level-zero-image-ownership.cpp
-// CHECK-NEXT: Plugin/interop-level-zero-image-ownership.cpp
-// CHECK-NEXT: Plugin/interop-level-zero-image.cpp
-// CHECK-NEXT: Plugin/interop-level-zero.cpp
-// CHECK-NEXT: Plugin/level_zero_batch_event_status.cpp
-// CHECK-NEXT: Plugin/level_zero_batch_test.cpp
-// CHECK-NEXT: Plugin/level_zero_batch_test_copy_with_compute.cpp
-// CHECK-NEXT: Plugin/level_zero_device_scope_events.cpp
-// CHECK-NEXT: Plugin/level_zero_dynamic_batch_test.cpp
-// CHECK-NEXT: Plugin/level_zero_imm_cmdlist_per_thread.cpp
-// CHECK-NEXT: Plugin/level_zero_queue_profiling.cpp
-// CHECK-NEXT: Plugin/level_zero_usm_device_read_only.cpp
-// CHECK-NEXT: Plugin/max_malloc.cpp
// CHECK-NEXT: Printf/char.cpp
// CHECK-NEXT: Printf/double.cpp
// CHECK-NEXT: Printf/float.cpp