[SYCL] Remove SYCL_BE and SYCL_DEVICE_TYPE env vars from code (#7214)

This PR aims to remove the usage of the SYCL_BE and SYCL_DEVICE_TYPE
environment variables( which can be found here :
https://github.com/intel/llvm/blob/sycl/sycl/doc/EnvironmentVariables.md
) from code and documentation since they have already been deprecated
for some time and warning messages have been shown to discourage their
use.

Author: lbushi25

sycl/doc/EnvironmentVariables.md

@@ -8,8 +8,6 @@ compiler and runtime.
 | Environment variable | Values | Description |
 | -------------------- | ------ | ----------- |
 | `ONEAPI_DEVICE_SELECTOR` | [See below.](#oneapi_device_selector)  | This device selection environment variable can be used to limit the choice of devices available when the SYCL-using application is run.  Useful for limiting devices to a certain type (like GPUs or accelerators) or backends (like Level Zero or OpenCL).  This device selection mechanism is replacing `SYCL_DEVICE_FILTER` .  The `ONEAPI_DEVICE_SELECTOR` syntax is shared with OpenMP and also allows sub-devices to be chosen. [See below.](#oneapi_device_selector) for a full description.   |
-| `SYCL_BE` (deprecated) | `PI_OPENCL`, `PI_LEVEL_ZERO`, `PI_CUDA` | Force SYCL RT to consider only devices of the specified backend during the device selection.  The `SYCL_BE` environment variable is deprecated and will be removed soon. Please use the new env var `ONEAPI_DEVICE_SELECTOR` instead. |
-| `SYCL_DEVICE_TYPE` (deprecated) | CPU, GPU, ACC, HOST | Force SYCL to use the specified device type. If unset, default selection rules are applied. If set to any unlisted value, this control has no effect. If the requested device type is not found, a `sycl::runtime_error` exception is thrown. If a non-default device selector is used, a device must satisfy both the selector and this control to be chosen. This control only has effect on devices created with a selector. The `SYCL_DEVICE_TYPE` environment variable is deprecated and will be removed soon. Please use the new env var `ONEAPI_DEVICE_SELECTOR` instead. |
 | `SYCL_DEVICE_FILTER` (deprecated) | `backend:device_type:device_num` | Please use `ONEAPI_DEVICE_SELECTOR` environment variable instead. See section [`SYCL_DEVICE_FILTER`](#sycl_device_filter) below for `SYCL_DEVICE_FILTER` description. |
 | `SYCL_DEVICE_ALLOWLIST` | See [below](#sycl_device_allowlist) | Filter out devices that do not match the pattern specified. `BackendName` accepts `host`, `opencl`, `level_zero` or `cuda`. `DeviceType` accepts `host`, `cpu`, `gpu` or `acc`. `DeviceVendorId` accepts uint32_t in hex form (`0xXYZW`). `DriverVersion`, `PlatformVersion`, `DeviceName` and `PlatformName` accept regular expression. Special characters, such as parenthesis, must be escaped. DPC++ runtime will select only those devices which satisfy provided values above and regex. More than one device can be specified using the piping symbol "\|".|
 | `SYCL_DISABLE_PARALLEL_FOR_RANGE_ROUNDING` | Any(\*) | Disables automatic rounding-up of `parallel_for` invocation ranges. |

sycl/doc/GetStartedGuide.md

@@ -687,13 +687,13 @@ The `simple-sycl-app.exe` application doesn't specify SYCL device for
 execution, so SYCL runtime will use `default_selector` logic to select one
 of accelerators available in the system.
 In this case, the behavior of the `default_selector` can be altered
-using the `SYCL_BE` environment variable, setting `PI_CUDA` forces
-the usage of the CUDA backend (if available), `PI_HIP` forces
-the usage of the HIP backend (if available), `PI_OPENCL` will
+using the `ONEAPI_DEVICE_SELECTOR` environment variable, setting `cuda:*` forces
+the usage of the CUDA backend (if available), `hip:*` forces
+the usage of the HIP backend (if available), `opencl:*` will
 force the usage of the OpenCL backend.
 
 ```bash
-SYCL_BE=PI_CUDA ./simple-sycl-app-cuda.exe
+ONEAPI_DEVICE_SELECTOR=cuda:* ./simple-sycl-app-cuda.exe
 ```
 
 The default is the OpenCL backend if available.
@@ -709,11 +709,11 @@ The results are correct!
 ```
 
 **NOTE**: Currently, when the application has been built with the CUDA target,
-the CUDA backend must be selected at runtime using the `SYCL_BE` environment
+the CUDA backend must be selected at runtime using the `ONEAPI_DEVICE_SELECTOR` environment
 variable.
 
 ```bash
-SYCL_BE=PI_CUDA ./simple-sycl-app-cuda.exe
+ONEAPI_DEVICE_SELECTOR=cuda:* ./simple-sycl-app-cuda.exe
 ```
 
 **NOTE**: DPC++/SYCL developers can specify SYCL device for execution using

sycl/doc/design/PluginInterface.md

@@ -97,10 +97,10 @@ 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 SYCL_BE. The correspondence between
-a plugin and a SYCL_BE value is currently hardcoded in the runtime.
+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: SYCL_BE=PI_OPENCL corresponds to OpenCL Plugin.
+Eg: ONEAPI_DEVICE_SELECTOR=opencl:* corresponds to OpenCL Plugin.
 
 #### OpenCL plugin
 

sycl/include/sycl/detail/pi.hpp

@@ -159,6 +159,7 @@ template <class To, class From> To cast(From value);
 // Holds the PluginInformation for the plugin that is bound.
 // Currently a global variable is used to store OpenCL plugin information to be
 // used with SYCL Interoperability Constructors.
+// TODO: GlobalPlugin does not seem to be needed anymore. Consider removing it!
 extern std::shared_ptr<plugin> GlobalPlugin;
 
 // Performs PI one-time initialization.

sycl/source/CMakeLists.txt

@@ -132,7 +132,6 @@ set(SYCL_SOURCES
     "detail/error_handling/enqueue_kernel.cpp"
     "detail/event_impl.cpp"
     "detail/filter_selector_impl.cpp"
-    "detail/force_device.cpp"
     "detail/global_handler.cpp"
     "detail/helpers.cpp"
     "detail/handler_proxy.cpp"

sycl/source/detail/config.def

@@ -14,7 +14,6 @@ CONFIG(SYCL_PRINT_EXECUTION_GRAPH, 32, __SYCL_PRINT_EXECUTION_GRAPH)
 CONFIG(SYCL_DISABLE_EXECUTION_GRAPH_CLEANUP, 1, __SYCL_DISABLE_EXECUTION_GRAPH_CLEANUP)
 CONFIG(SYCL_DISABLE_POST_ENQUEUE_CLEANUP, 1, __SYCL_DISABLE_POST_ENQUEUE_CLEANUP)
 CONFIG(SYCL_DEVICE_ALLOWLIST, 1024, __SYCL_DEVICE_ALLOWLIST)
-CONFIG(SYCL_BE, 16, __SYCL_BE)
 CONFIG(SYCL_PI_TRACE, 16, __SYCL_PI_TRACE)
 CONFIG(SYCL_PARALLEL_FOR_RANGE_ROUNDING_TRACE, 16, __SYCL_PARALLEL_FOR_RANGE_ROUNDING_TRACE)
 CONFIG(SYCL_DISABLE_PARALLEL_FOR_RANGE_ROUNDING, 16, __SYCL_DISABLE_PARALLEL_FOR_RANGE_ROUNDING)

sycl/source/detail/config.hpp

@@ -126,46 +126,6 @@ template <ConfigID Config> class SYCLConfig {
   }
 };
 
-template <> class SYCLConfig<SYCL_BE> {
-  using BaseT = SYCLConfigBase<SYCL_BE>;
-
-public:
-  static backend *get() {
-    static bool Initialized = false;
-    static backend *BackendPtr = nullptr;
-
-    // Configuration parameters are processed only once, like reading a string
-    // from environment and converting it into a typed object.
-    if (Initialized)
-      return BackendPtr;
-
-    const char *ValStr = BaseT::getRawValue();
-    const std::array<std::pair<std::string, backend>, 6> SyclBeMap = {
-        {{"PI_OPENCL", backend::opencl},
-         {"PI_LEVEL_ZERO", backend::ext_oneapi_level_zero},
-         {"PI_LEVEL0", backend::ext_oneapi_level_zero}, // for backward
-                                                        // compatibility
-         {"PI_CUDA", backend::ext_oneapi_cuda},
-         {"PI_ESIMD_EMULATOR", backend::ext_intel_esimd_emulator},
-         {"PI_HIP", backend::ext_oneapi_hip}}};
-    if (ValStr) {
-      auto It = std::find_if(
-          std::begin(SyclBeMap), std::end(SyclBeMap),
-          [&ValStr](const std::pair<std::string, backend> &element) {
-            return element.first == ValStr;
-          });
-      if (It == SyclBeMap.end())
-        pi::die("Invalid backend. "
-                "Valid values are "
-                "PI_OPENCL/PI_LEVEL_ZERO/PI_CUDA/PI_ESIMD_EMULATOR/PI_HIP");
-      static backend Backend = It->second;
-      BackendPtr = &Backend;
-    }
-    Initialized = true;
-    return BackendPtr;
-  }
-};
-
 template <> class SYCLConfig<SYCL_PI_TRACE> {
   using BaseT = SYCLConfigBase<SYCL_PI_TRACE>;
 
@@ -336,18 +296,6 @@ class __SYCL2020_DEPRECATED("Use SYCLConfig<ONEAPI_DEVICE_SELECTOR> instead")
       FilterList = &GlobalHandler::instance().getDeviceFilterList(ValStr);
     }
 
-    // TODO: remove the following code when we remove the support for legacy
-    // env vars.
-    // Emit the deprecation warning message if SYCL_BE or SYCL_DEVICE_TYPE is
-    // set.
-    if (SYCLConfig<SYCL_BE>::get() || getenv("SYCL_DEVICE_TYPE")) {
-      std::cerr << "\nWARNING: The legacy environment variables SYCL_BE and "
-                   "SYCL_DEVICE_TYPE are deprecated. Please use "
-                   "SYCL_DEVICE_FILTER instead. For details, please refer to "
-                   "https://github.com/intel/llvm/blob/sycl/sycl/doc/"
-                   "EnvironmentVariables.md\n\n";
-    }
-
     // As mentioned above, configuration parameters are processed only once.
     // If multiple threads are checking this env var at the same time,
     // they will end up setting the configration to the same value.

sycl/source/detail/force_device.cpp

@@ -265,6 +265,7 @@ std::string memFlagsToString(pi_mem_flags Flags) {
 
 // GlobalPlugin is a global Plugin used with Interoperability constructors that
 // use OpenCL objects to construct SYCL class objects.
+// TODO: GlobalPlugin does not seem to be needed anymore. Consider removing it!
 std::shared_ptr<plugin> GlobalPlugin;
 
 // Find the plugin at the appropriate location and return the location.
@@ -441,39 +442,6 @@ static void initializePlugins(std::vector<plugin> &Plugins) {
       }
       continue;
     }
-    backend *BE = SYCLConfig<SYCL_BE>::get();
-    // Use OpenCL as the default interoperability plugin.
-    // This will go away when we make backend interoperability selection
-    // explicit in SYCL-2020.
-    backend InteropBE = BE ? *BE : backend::opencl;
-
-    if (InteropBE == backend::opencl &&
-        PluginNames[I].first.find("opencl") != std::string::npos) {
-      // Use the OpenCL plugin as the GlobalPlugin
-      GlobalPlugin =
-          std::make_shared<plugin>(PluginInformation, backend::opencl, Library);
-    } else if (InteropBE == backend::ext_oneapi_cuda &&
-               PluginNames[I].first.find("cuda") != std::string::npos) {
-      // Use the CUDA plugin as the GlobalPlugin
-      GlobalPlugin = std::make_shared<plugin>(
-          PluginInformation, backend::ext_oneapi_cuda, Library);
-    } else if (InteropBE == backend::ext_oneapi_hip &&
-               PluginNames[I].first.find("hip") != std::string::npos) {
-      // Use the HIP plugin as the GlobalPlugin
-      GlobalPlugin = std::make_shared<plugin>(PluginInformation,
-                                              backend::ext_oneapi_hip, Library);
-    } else if (InteropBE == backend::ext_oneapi_level_zero &&
-               PluginNames[I].first.find("level_zero") != std::string::npos) {
-      // Use the LEVEL_ZERO plugin as the GlobalPlugin
-      GlobalPlugin = std::make_shared<plugin>(
-          PluginInformation, backend::ext_oneapi_level_zero, Library);
-    } else if (InteropBE == backend::ext_intel_esimd_emulator &&
-               PluginNames[I].first.find("esimd_emulator") !=
-                   std::string::npos) {
-      // Use the ESIMD_EMULATOR plugin as the GlobalPlugin
-      GlobalPlugin = std::make_shared<plugin>(
-          PluginInformation, backend::ext_intel_esimd_emulator, Library);
-    }
     plugin &NewPlugin = Plugins.emplace_back(
         plugin(PluginInformation, PluginNames[I].second, Library));
     if (trace(TraceLevel::PI_TRACE_BASIC))