[SYCL] Add support for devices white list (#867)

Add support for SYCL_DEVICE_WHITE_LIST config which allows to specify the white
list of devices and their minimum driver version. This is done by setting
configuration in the following format:

DeviceName:{{XXX}},DriverVersion:{{X.Y.Z.W}}|DeviceName:{{XXX}},DriverVersion:{{X.Y.Z.W}}

Where values in {{ }} can be specified in ECMAScript regular expressions
pattern syntax

Devices that do not satisfy the pattern from the white list are ignored.

Signed-off-by: Vlad Romanov <[email protected]>

Author: romanovvlad

sycl/source/detail/config.cpp

@@ -102,9 +102,11 @@ void readConfig() {
 // Prints configs name with their value
 void dumpConfig() {
 #define CONFIG(Name, MaxSize, CompileTimeDef)                                  \
-  const char *Val = SYCLConfig<Name>::get();                                   \
-  std::cerr << SYCLConfigBase<Name>::MConfigName << " : "                      \
-            << (Val ? Val : "unset") << std::endl;
+  {                                                                            \
+    const char *Val = SYCLConfig<Name>::get();                                 \
+    std::cerr << SYCLConfigBase<Name>::MConfigName << " : "                    \
+              << (Val ? Val : "unset") << std::endl;                           \
+  }
 #include "detail/config.def"
 #undef CONFIG
 }

sycl/source/detail/config.def

@@ -11,4 +11,5 @@
 // underscore(__).
 
 CONFIG(SYCL_PRINT_EXECUTION_GRAPH, 32, __SYCL_PRINT_EXECUTION_GRAPH)
+CONFIG(SYCL_DEVICE_WHITE_LIST, 1024, __SYCL_DEVICE_WHITE_LIST)
 

sycl/source/detail/platform_impl.cpp

@@ -9,8 +9,11 @@
 #include <CL/sycl/detail/device_impl.hpp>
 #include <CL/sycl/detail/platform_impl.hpp>
 #include <CL/sycl/device.hpp>
+#include <detail/config.hpp>
 
 #include <algorithm>
+#include <cstring>
+#include <regex>
 
 namespace cl {
 namespace sycl {
@@ -49,6 +52,113 @@ platform_impl_host::get_devices(info::device_type dev_type) const {
   return res;
 }
 
+struct DevDescT {
+  const char *devName = nullptr;
+  int devNameSize = 0;
+
+  const char *devDriverVer = nullptr;
+  int devDriverVerSize = 0;
+};
+
+static std::vector<DevDescT> getWhiteListDesc() {
+  const char *str = SYCLConfig<SYCL_DEVICE_WHITE_LIST>::get();
+  if (!str)
+    return {};
+
+  std::vector<DevDescT> decDescs;
+  const char devNameStr[] = "DeviceName";
+  const char driverVerStr[] = "DriverVersion";
+  decDescs.emplace_back();
+  while ('\0' != *str) {
+    const char **valuePtr = nullptr;
+    int *size = nullptr;
+
+    // -1 to avoid comparing null terminator
+    if (0 == strncmp(devNameStr, str, sizeof(devNameStr) - 1)) {
+      valuePtr = &decDescs.back().devName;
+      size = &decDescs.back().devNameSize;
+      str += sizeof(devNameStr) - 1;
+    } else if (0 == strncmp(driverVerStr, str, sizeof(driverVerStr) - 1)) {
+      valuePtr = &decDescs.back().devDriverVer;
+      size = &decDescs.back().devDriverVerSize;
+      str += sizeof(driverVerStr) - 1;
+    }
+
+    if (':' != *str)
+      throw sycl::runtime_error("Malformed device white list");
+
+    // Skip ':'
+    str += 1;
+
+    if ('{' != *str || '{' != *(str + 1))
+      throw sycl::runtime_error("Malformed device white list");
+
+    // Skip opening sequence "{{"
+    str += 2;
+
+    *valuePtr = str;
+
+    // Increment until closing sequence is encountered
+    while (('\0' != *str) && ('}' != *str || '}' != *(str + 1)))
+      ++str;
+
+    if ('\0' == *str)
+      throw sycl::runtime_error("Malformed device white list");
+
+    *size = str - *valuePtr;
+
+    // Skip closing sequence "}}"
+    str += 2;
+
+    if ('\0' == *str)
+      break;
+
+    // '|' means that the is another filter
+    if ('|' == *str)
+      decDescs.emplace_back();
+    else if (',' != *str)
+      throw sycl::runtime_error("Malformed device white list");
+
+    ++str;
+  }
+
+  return decDescs;
+}
+
+static void filterWhiteList(vector_class<RT::PiDevice> &pi_devices) {
+  const std::vector<DevDescT> whiteList(getWhiteListDesc());
+  if (whiteList.empty())
+    return;
+
+  int insertIDx = 0;
+  for (RT::PiDevice dev : pi_devices) {
+    const string_class devName =
+        sycl::detail::get_device_info<string_class, info::device::name>::_(dev);
+
+    const string_class devDriverVer =
+        sycl::detail::get_device_info<string_class,
+                                      info::device::driver_version>::_(dev);
+
+    for (const DevDescT &desc : whiteList) {
+      // At least device name is required field to consider the filter so far
+      if (nullptr == desc.devName ||
+          !std::regex_match(
+              devName, std::regex(std::string(desc.devName, desc.devNameSize))))
+        continue;
+
+      if (nullptr != desc.devDriverVer &&
+          !std::regex_match(devDriverVer,
+                            std::regex(std::string(desc.devDriverVer,
+                                                   desc.devDriverVerSize))))
+        continue;
+
+      pi_devices[insertIDx++] = dev;
+      break;
+    }
+  }
+  pi_devices.resize(insertIDx);
+}
+
 vector_class<device>
 platform_impl_pi::get_devices(info::device_type deviceType) const {
   vector_class<device> res;
@@ -67,6 +177,10 @@ platform_impl_pi::get_devices(info::device_type deviceType) const {
   PI_CALL(piDevicesGet)(m_platform, pi::cast<RT::PiDeviceType>(deviceType),
                         num_devices, pi_devices.data(), nullptr);
 
+  // Filter out devices that are not present in the white list
+  if (SYCLConfig<SYCL_DEVICE_WHITE_LIST>::get())
+    filterWhiteList(pi_devices);
+
   std::for_each(pi_devices.begin(), pi_devices.end(),
                 [&res](const RT::PiDevice &a_pi_device) {
                   device sycl_device = detail::createSyclObjFromImpl<device>(

sycl/test/config/white_list.cpp

@@ -0,0 +1,60 @@
+// REQUIRES: cpu
+// RUN: %clangxx -fsycl %s -o %t.out
+// RUN: env PRINT_DEVICE_INFO=1 %t.out > %t.conf
+// RUN: env TEST_DEVICE_AVAILABLE=1 env SYCL_CONFIG_FILE_NAME=%t.conf %t.out
+// RUN: env TEST_DEVICE_IS_NOT_AVAILABLE=1 env SYCL_DEVICE_WHITE_LIST="" %t.out
+
+#include <CL/sycl.hpp>
+#include <iostream>
+#include <cstdlib>
+#include <exception>
+#include <string>
+
+using namespace cl;
+
+int main() {
+
+  // Expected that white list filter is not set
+  if (getenv("PRINT_DEVICE_INFO")) {
+    for (const sycl::platform &Plt : sycl::platform::get_platforms())
+      if (!Plt.is_host()) {
+        const sycl::device Dev = Plt.get_devices().at(0);
+        std::string DevName = Dev.get_info<sycl::info::device::name>();
+        const std::string DevVer =
+            Dev.get_info<sycl::info::device::driver_version>();
+        // As device name string will be used as regexp pattern, we need to
+        // get rid of symbols that can be treated in a special way.
+        // Replace common special symbols with '.' which matches to any sybmol
+        for (char &Sym : DevName) {
+          if (')' == Sym || '(' == Sym)
+            Sym = '.';
+        }
+        std::cout << "SYCL_DEVICE_WHITE_LIST=DeviceName:{{" << DevName
+                  << "}},DriverVersion:{{" << DevVer << "}}";
+        return 0;
+      }
+    throw std::runtime_error("Non host device is not found");
+  }
+
+  // Expected white list to be set with result from "PRINT_DEVICE_INFO" run
+  if (getenv("TEST_DEVICE_AVAILABLE")) {
+    for (const sycl::platform &Plt : sycl::platform::get_platforms())
+      if (!Plt.is_host()) {
+        if (Plt.get_devices().size() != 1)
+          throw std::runtime_error("Expected only one non host device.");
+
+        return 0;
+      }
+    throw std::runtime_error("Non host device is not found");
+  }
+
+  // Expected white list to be set but empty
+  if (getenv("TEST_DEVICE_IS_NOT_AVAILABLE")) {
+    for (const sycl::platform &Plt : sycl::platform::get_platforms())
+      if (!Plt.is_host())
+        throw std::runtime_error("Expected no non host device is available");
+    return 0;
+  }
+
+  throw std::runtime_error("Unhandled situation");
+}