[SYCL] Deprecate SYCL 1.2.1 device selectors (#6599)

Now that we have added the SYCL 2020 callable device selectors, we need
to prepare for the removal of the older SYCL 1.2.1 `device_selector`
class. The first step is to add the deprecation message to the 1.2.1
style device selectors, which this PR does. It also removes the usage of
those from our own codebase so as to not trip on our own messages in the
future.

Signed-off-by: Chris Perkins <[email protected]>
Signed-off-by: Larsen, Steffen <[email protected]>
Co-authored-by: Larsen, Steffen <[email protected]>

Author: cperkinsintel

sycl/doc/GetStartedGuide.md

@@ -705,7 +705,7 @@ SYCL_BE=PI_CUDA ./simple-sycl-app-cuda.exe
 ```
 
 **NOTE**: DPC++/SYCL developers can specify SYCL device for execution using
-device selectors (e.g. `sycl::cpu_selector`, `sycl::gpu_selector`,
+device selectors (e.g. `sycl::cpu_selector_v`, `sycl::gpu_selector_v`,
 [Intel FPGA selector(s)](extensions/supported/sycl_ext_intel_fpga_device_selector.md)) as
 explained in following section [Code the program for a specific
 GPU](#code-the-program-for-a-specific-gpu).
@@ -740,42 +740,38 @@ the CMake.
 
 ### Code the program for a specific GPU
 
-To specify OpenCL device SYCL provides the abstract `sycl::device_selector`
-class which the can be used to define how the runtime should select the best
-device.
-
-The method `sycl::device_selector::operator()` of the SYCL
-`sycl::device_selector` is an abstract member function which takes a
-reference to a SYCL device and returns an integer score. This abstract member
-function can be implemented in a derived class to provide a logic for selecting
-a SYCL device. SYCL runtime uses the device for with the highest score is
-returned. Such object can be passed to `sycl::queue` and `sycl::device`
-constructors.
-
-The example below illustrates how to use `sycl::device_selector` to create
-device and queue objects bound to Intel GPU device:
+To assist in finding a specific SYCL compatible device out of all that may be
+available, a "device selector" may be used. A "device selector" is a ranking
+function (C++ Callable) that will give an integer ranking value to all the
+devices on the system. It can be passed to `sycl::queue`, `sycl::device` and
+`sycl::platform` constructors. The highest ranking device is then selected. SYCL
+has built-in device selectors for selecting a generic GPU, CPU, or accelerator
+device, as well as one for a default device. Additionally, a user can define
+their own as function, lambda, or functor class. Device selectors returning
+negative values will "reject" a device ensuring it is not selected, but values 0
+or higher will be selected by the highest score with ties resolved by an
+internal algorithm (see Section 4.6.1 of the SYCL 2020 specification)
+
+The example below illustrates how to use a device selector to create device and
+queue objects bound to Intel GPU device:
 
 ```c++
 #include <sycl/sycl.hpp>
 
 int main() {
-  class NEOGPUDeviceSelector : public sycl::device_selector {
-  public:
-    int operator()(const sycl::device &Device) const override {
-      using namespace sycl::info;
 
-      const std::string DeviceName = Device.get_info<device::name>();
-      const std::string DeviceVendor = Device.get_info<device::vendor>();
+  auto NEOGPUDeviceSelector = [](const sycl::device &Device){
+    using namespace sycl::info;
 
-      return Device.is_gpu() && (DeviceName.find("HD Graphics NEO") != std::string::npos);
-    }
+    const std::string DeviceName = Device.get_info<device::name>();
+    bool match = Device.is_gpu() && (DeviceName.find("HD Graphics NEO") != std::string::npos);
+    return match ? 1 : -1;
   };
 
-  NEOGPUDeviceSelector Selector;
   try {
-    sycl::queue Queue(Selector);
-    sycl::device Device(Selector);
-  } catch (sycl::invalid_parameter_error &E) {
+    sycl::queue Queue(NEOGPUDeviceSelector);
+    sycl::device Device(NEOGPUDeviceSelector);
+  } catch (sycl::exception &E) {
     std::cout << E.what() << std::endl;
   }
 }
@@ -786,19 +782,18 @@ The device selector below selects an NVIDIA device only, and won't execute if
 there is none.
 
 ```c++
-class CUDASelector : public sycl::device_selector {
-  public:
-    int operator()(const sycl::device &Device) const override {
-      using namespace sycl::info;
-      const std::string DriverVersion = Device.get_info<device::driver_version>();
-
-      if (Device.is_gpu() && (DriverVersion.find("CUDA") != std::string::npos)) {
-        std::cout << " CUDA device found " << std::endl;
-        return 1;
-      };
-      return -1;
-    }
-};
+
+int CUDASelector(const sycl::device &Device) {
+  using namespace sycl::info;
+  const std::string DriverVersion = Device.get_info<device::driver_version>();
+
+  if (Device.is_gpu() && (DriverVersion.find("CUDA") != std::string::npos)) {
+    std::cout << " CUDA device found " << std::endl;
+    return 1;
+  };
+  return -1;
+}
+
 ```
 
 ### Using the DPC++ toolchain on CUDA platforms

sycl/doc/MultiTileCardWithLevelZero.md

@@ -143,8 +143,7 @@ try {
 ``` C++	
 try {
   // The queue is attached to the root-device, driver distributes to sub-devices, if any.
-  auto D = device(gpu_selector{});
-  auto Q = queue(D);
+  auto Q = queue(gpu_selector_v);
   Q.submit([&](handler& cgh) {...});
 }
 ```
@@ -155,7 +154,7 @@ try {
 - Example:
 ``` C++	
 try {
-  auto P = platform(gpu_selector{});
+  auto P = platform(gpu_selector_v);
   auto RootDevices = P.get_devices();
   auto C = context(RootDevices);
   for (auto &D : RootDevices) {

sycl/doc/design/GlobalObjectsInRuntime.md

@@ -22,7 +22,7 @@ like in example below:
 sycl::queue Queue;
 
 int main() {
-  Queue = sycl::queue{sycl::default_selector{}.select_device()};
+  Queue = sycl::queue{sycl::default_selector_v};
 
   return 0;
 }

sycl/doc/extensions/experimental/sycl_ext_intel_esimd/sycl_ext_intel_esimd.md

@@ -660,7 +660,7 @@ int main(void) {
   int err_cnt = 0;
 
   try {
-    queue q(gpu_selector{}, createExceptionHandler());
+    queue q(gpu_selector_v, createExceptionHandler());
     auto dev = q.get_device();
     std::cout << "Running on " << dev.get_info<info::device::name>() << "\n";
 

sycl/doc/extensions/experimental/sycl_ext_oneapi_max_work_group_query.md

@@ -34,7 +34,7 @@ As encouraged by the SYCL specification, a feature-test macro, `SYCL_EXT_ONEAPI_
 ## Examples
 
 ```c++
-sycl::device gpu = sycl::device{sycl::gpu_selector{}};
+sycl::device gpu = sycl::device{sycl::gpu_selector_v};
 std::cout << gpu.get_info<sycl::info::device::name>() << '\n';
 
 #ifdef SYCL_EXT_ONEAPI_MAX_WORK_GROUP_QUERY

sycl/include/sycl/device.hpp

@@ -61,6 +61,8 @@ class __SYCL_EXPORT device {
   /// by the DeviceSelector provided.
   ///
   /// \param DeviceSelector SYCL 1.2.1 device_selector to be used (see 4.6.1.1).
+  __SYCL2020_DEPRECATED("Use Callable device selectors instead of deprecated "
+                        "device_selector subclasses.")
   explicit device(const device_selector &DeviceSelector);
 
 #if __cplusplus >= 201703L

sycl/include/sycl/device_selector.hpp

@@ -31,7 +31,8 @@ class filter_selector;
 /// \sa device
 ///
 /// \ingroup sycl_api_dev_sel
-class __SYCL_EXPORT device_selector {
+class __SYCL_EXPORT __SYCL2020_DEPRECATED(
+    "Use Callable instead to select device.") device_selector {
 
 public:
   virtual ~device_selector() = default;
@@ -46,7 +47,9 @@ class __SYCL_EXPORT device_selector {
 /// \sa device
 ///
 /// \ingroup sycl_api_dev_sel
-class __SYCL_EXPORT default_selector : public device_selector {
+class __SYCL_EXPORT __SYCL2020_DEPRECATED(
+    "Use the callable sycl::default_selector_v instead.") default_selector
+    : public device_selector {
 public:
   int operator()(const device &dev) const override;
 };
@@ -56,7 +59,9 @@ class __SYCL_EXPORT default_selector : public device_selector {
 /// \sa device
 ///
 /// \ingroup sycl_api_dev_sel
-class __SYCL_EXPORT gpu_selector : public device_selector {
+class __SYCL_EXPORT __SYCL2020_DEPRECATED(
+    "Use the callable sycl::gpu_selector_v instead.") gpu_selector
+    : public device_selector {
 public:
   int operator()(const device &dev) const override;
 };
@@ -66,7 +71,9 @@ class __SYCL_EXPORT gpu_selector : public device_selector {
 /// \sa device
 ///
 /// \ingroup sycl_api_dev_sel
-class __SYCL_EXPORT cpu_selector : public device_selector {
+class __SYCL_EXPORT __SYCL2020_DEPRECATED(
+    "Use the callable sycl::cpu_selector_v instead.") cpu_selector
+    : public device_selector {
 public:
   int operator()(const device &dev) const override;
 };
@@ -76,7 +83,9 @@ class __SYCL_EXPORT cpu_selector : public device_selector {
 /// \sa device
 ///
 /// \ingroup sycl_api_dev_sel
-class __SYCL_EXPORT accelerator_selector : public device_selector {
+class __SYCL_EXPORT
+__SYCL2020_DEPRECATED("Use the callable sycl::accelerator_selector_v instead.")
+    accelerator_selector : public device_selector {
 public:
   int operator()(const device &dev) const override;
 };
@@ -86,7 +95,9 @@ class __SYCL_EXPORT accelerator_selector : public device_selector {
 /// \sa device
 ///
 /// \ingroup sycl_api_dev_sel
-class __SYCL_EXPORT host_selector : public device_selector {
+class __SYCL_EXPORT
+__SYCL2020_DEPRECATED("Use a callable function instead.") host_selector
+    : public device_selector {
 public:
   int operator()(const device &dev) const override;
 };

sycl/include/sycl/platform.hpp

@@ -64,6 +64,8 @@ class __SYCL_EXPORT platform {
   /// provided device selector.
   ///
   /// \param DeviceSelector is an instance of a SYCL 1.2.1 device_selector
+  __SYCL2020_DEPRECATED("Use Callable device selectors instead of deprecated "
+                        "device_selector subclasses.")
   explicit platform(const device_selector &DeviceSelector);
 
 #if __cplusplus >= 201703L

sycl/include/sycl/queue.hpp

@@ -163,6 +163,8 @@ class __SYCL_EXPORT queue {
   ///
   /// \param DeviceSelector is an instance of a SYCL 1.2.1 device_selector.
   /// \param PropList is a list of properties for queue construction.
+  __SYCL2020_DEPRECATED("Use Callable device selectors instead of deprecated "
+                        "device_selector subclasses.")
   queue(const device_selector &DeviceSelector,
         const property_list &PropList = {})
       : queue(DeviceSelector.select_device(), async_handler{}, PropList) {}
@@ -173,6 +175,8 @@ class __SYCL_EXPORT queue {
   /// \param DeviceSelector is an instance of SYCL 1.2.1 device_selector.
   /// \param AsyncHandler is a SYCL asynchronous exception handler.
   /// \param PropList is a list of properties for queue construction.
+  __SYCL2020_DEPRECATED("Use Callable device selectors instead of deprecated "
+                        "device_selector subclasses.")
   queue(const device_selector &DeviceSelector,
         const async_handler &AsyncHandler, const property_list &PropList = {})
       : queue(DeviceSelector.select_device(), AsyncHandler, PropList) {}
@@ -199,6 +203,8 @@ class __SYCL_EXPORT queue {
   /// \param SyclContext is an instance of SYCL context.
   /// \param DeviceSelector is an instance of SYCL device selector.
   /// \param PropList is a list of properties for queue construction.
+  __SYCL2020_DEPRECATED("Use Callable device selectors instead of deprecated "
+                        "device_selector subclasses.")
   queue(const context &SyclContext, const device_selector &DeviceSelector,
         const property_list &PropList = {});
 
@@ -210,6 +216,8 @@ class __SYCL_EXPORT queue {
   /// \param DeviceSelector is an instance of SYCL device selector.
   /// \param AsyncHandler is a SYCL asynchronous exception handler.
   /// \param PropList is a list of properties for queue construction.
+  __SYCL2020_DEPRECATED("Use Callable device selectors instead of deprecated "
+                        "device_selector subclasses.")
   queue(const context &SyclContext, const device_selector &DeviceSelector,
         const async_handler &AsyncHandler, const property_list &PropList = {});
 

sycl/test/basic_tests/accessor/atomic_zero_dimension_accessor.cpp

@@ -19,7 +19,7 @@ void store(atomic_t foo, int value) { foo.store(value); }
 
 int main(int argc, char *argv[]) {
 
-  queue q(default_selector{});
+  queue q(default_selector_v);
 
   // Accessor with dimensionality 0.
   {

sycl/test/extensions/inline_asm.cpp

@@ -31,7 +31,7 @@ int main() {
     sycl::buffer<DataType, 1> BufB(DataB, DEFAULT_PROBLEM_SIZE);
     sycl::buffer<DataType, 1> BufC(DataC, DEFAULT_PROBLEM_SIZE);
 
-    sycl::queue deviceQueue(sycl::gpu_selector{}, AsyncHandler);
+    sycl::queue deviceQueue(sycl::gpu_selector_v, AsyncHandler);
 
     deviceQueue.submit([&](sycl::handler &cgh) {
       auto A = BufA.get_access<sycl::access::mode::read>(cgh);

sycl/test/warnings/sycl_2020_deprecations.cpp

@@ -1,4 +1,4 @@
-// RUN: %clangxx %fsycl-host-only -fsyntax-only -sycl-std=2020 -Xclang -verify -Xclang -verify-ignore-unexpected=note %s -o %t.out
+// RUN: %clangxx %fsycl-host-only -fsyntax-only -ferror-limit=100 -sycl-std=2020 -Xclang -verify -Xclang -verify-ignore-unexpected=note %s -o %t.out
 
 #include <CL/sycl.hpp>
 #include <sycl/ext/intel/online_compiler.hpp>
@@ -194,6 +194,17 @@ int main() {
   // expected-warning@+1{{'get_linear_id' is deprecated: use sycl::group::get_group_linear_id() instead}}
   group.get_linear_id();
 
+  // expected-warning@+1{{'default_selector' is deprecated: Use the callable sycl::default_selector_v instead.}}
+  sycl::default_selector ds;
+  // expected-warning@+1{{'cpu_selector' is deprecated: Use the callable sycl::cpu_selector_v instead.}}
+  sycl::cpu_selector cs;
+  // expected-warning@+1{{'gpu_selector' is deprecated: Use the callable sycl::gpu_selector_v instead.}}
+  sycl::gpu_selector gs;
+  // expected-warning@+1{{'accelerator_selector' is deprecated: Use the callable sycl::accelerator_selector_v instead.}}
+  sycl::accelerator_selector as;
+  // expected-warning@+1{{'host_selector' is deprecated: Use a callable function instead.}}
+  sycl::host_selector hs;
+
   // expected-warning@+2{{'local' is deprecated: use `local_accessor` instead}}
   Queue.submit([&](sycl::handler &CGH) {
     sycl::accessor<int, 1, sycl::access::mode::read_write, sycl::target::local>

sycl/unittests/assert/assert.cpp

@@ -438,7 +438,7 @@ void ChildProcess(int StdErrFD) {
     exit(1);
   }
 
-  sycl::platform Plt{sycl::default_selector()};
+  sycl::platform Plt;
 
   sycl::unittest::PiMock Mock{Plt};
 
@@ -516,7 +516,7 @@ void ParentProcess(int ChildPID, int ChildStdErrFD) {
 TEST(Assert, TestPositive) {
   // Preliminary checks
   {
-    sycl::platform Plt{sycl::default_selector()};
+    sycl::platform Plt;
     if (Plt.is_host()) {
       printf("Test is not supported on host, skipping\n");
       return;
@@ -572,7 +572,7 @@ TEST(Assert, TestAssertServiceKernelHidden) {
 }
 
 TEST(Assert, TestInteropKernelNegative) {
-  sycl::platform Plt{sycl::default_selector()};
+  sycl::platform Plt;
 
   if (Plt.is_host()) {
     printf("Test is not supported on host, skipping\n");
@@ -610,7 +610,7 @@ TEST(Assert, TestInteropKernelNegative) {
 }
 
 TEST(Assert, TestInteropKernelFromProgramNegative) {
-  sycl::platform Plt{sycl::default_selector()};
+  sycl::platform Plt;
 
   if (Plt.is_host()) {
     printf("Test is not supported on host, skipping\n");

sycl/unittests/buffer/BufferLocation.cpp

@@ -71,7 +71,7 @@ static pi_result redefinedDeviceGetInfo(pi_device device,
 
 class BufferTest : public ::testing::Test {
 public:
-  BufferTest() : Plt{sycl::default_selector()} {}
+  BufferTest() {}
 
 protected:
   void SetUp() override {