[SYCL] Add support for platform name and platform version in device whitelist

PlatformName and PlatformVersion are now supported keys. Also all fields
are optional now, so SYCL_DEVICE_WHITE_LIST="" matches any device

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

Author: romanovvlad

sycl/source/detail/platform_impl.cpp

@@ -58,16 +58,26 @@ struct DevDescT {
 
   const char *devDriverVer = nullptr;
   int devDriverVerSize = 0;
+
+  const char *pltName = nullptr;
+  int pltNameSize = 0;
+
+  const char *pltVer = nullptr;
+  int pltVerSize = 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";
+  const char pltNameStr[] = "PlatformName";
+  const char platformVerStr[] = "PlatformVersion";
   decDescs.emplace_back();
   while ('\0' != *str) {
     const char **valuePtr = nullptr;
@@ -78,6 +88,14 @@ static std::vector<DevDescT> getWhiteListDesc() {
       valuePtr = &decDescs.back().devName;
       size = &decDescs.back().devNameSize;
       str += sizeof(devNameStr) - 1;
+    } else if (0 == strncmp(pltNameStr, str, sizeof(pltNameStr) - 1)) {
+      valuePtr = &decDescs.back().pltName;
+      size = &decDescs.back().pltNameSize;
+      str += sizeof(pltNameStr) - 1;
+    } else if (0 == strncmp(platformVerStr, str, sizeof(platformVerStr) - 1)) {
+      valuePtr = &decDescs.back().pltVer;
+      size = &decDescs.back().pltVerSize;
+      str += sizeof(platformVerStr) - 1;
     } else if (0 == strncmp(driverVerStr, str, sizeof(driverVerStr) - 1)) {
       valuePtr = &decDescs.back().devDriverVer;
       size = &decDescs.back().devDriverVerSize;
@@ -125,11 +143,19 @@ static std::vector<DevDescT> getWhiteListDesc() {
   return decDescs;
 }
 
-static void filterWhiteList(vector_class<RT::PiDevice> &pi_devices) {
+static void filterWhiteList(vector_class<RT::PiDevice> &pi_devices,
+                            RT::PiPlatform pi_platform) {
   const std::vector<DevDescT> whiteList(getWhiteListDesc());
   if (whiteList.empty())
     return;
 
+  const string_class pltName =
+      sycl::detail::get_platform_info<string_class, info::platform::name>::get(
+          pi_platform);
+
+  const string_class pltVer = sycl::detail::get_platform_info<
+      string_class, info::platform::version>::get(pi_platform);
+
   int insertIDx = 0;
   for (RT::PiDevice dev : pi_devices) {
     const string_class devName =
@@ -140,8 +166,17 @@ static void filterWhiteList(vector_class<RT::PiDevice> &pi_devices) {
                                       info::device::driver_version>::get(dev);
 
     for (const DevDescT &desc : whiteList) {
-      // At least device name is required field to consider the filter so far
-      if (nullptr == desc.devName ||
+      if (nullptr != desc.pltName &&
+          !std::regex_match(
+              pltName, std::regex(std::string(desc.pltName, desc.pltNameSize))))
+        continue;
+
+      if (nullptr != desc.pltVer &&
+          !std::regex_match(
+              pltVer, std::regex(std::string(desc.pltVer, desc.pltVerSize))))
+        continue;
+
+      if (nullptr != desc.devName &&
           !std::regex_match(
               devName, std::regex(std::string(desc.devName, desc.devNameSize))))
         continue;
@@ -179,7 +214,7 @@ platform_impl_pi::get_devices(info::device_type deviceType) const {
 
   // Filter out devices that are not present in the white list
   if (SYCLConfig<SYCL_DEVICE_WHITE_LIST>::get())
-    filterWhiteList(pi_devices);
+    filterWhiteList(pi_devices, m_platform);
 
   std::for_each(pi_devices.begin(), pi_devices.end(),
                 [&res](const RT::PiDevice &a_pi_device) {

sycl/test/config/white_list.cpp

@@ -1,8 +1,13 @@
 // 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
+//
+// RUN: env PRINT_DEVICE_INFO=1 %t.out > %t1.conf
+// RUN: env TEST_DEVICE_AVAILABLE=1 env SYCL_CONFIG_FILE_NAME=%t1.conf %t.out
+//
+// RUN: env PRINT_PLATFORM_INFO=1 %t.out > %t2.conf
+// RUN: env TEST_DEVICE_AVAILABLE=1 env SYCL_CONFIG_FILE_NAME=%t2.conf %t.out
+//
+// RUN: env TEST_DEVICE_IS_NOT_AVAILABLE=1 env SYCL_DEVICE_WHITE_LIST="PlatformName:{{SUCH NAME DOESN'T EXIST}}" %t.out
 
 #include <CL/sycl.hpp>
 #include <iostream>
@@ -12,25 +17,49 @@
 
 using namespace cl;
 
+static void replaceEscapeCharacters(std::string &Str) {
+  // As a stringwill 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 character
+  std::replace_if(Str.begin(), Str.end(),
+                  [](const char Sym) { return '(' == Sym || ')' == Sym; }, '.');
+}
+
 int main() {
 
+  // Expected that white list filter is not set
+  if (getenv("PRINT_PLATFORM_INFO")) {
+    for (const sycl::platform &Plt : sycl::platform::get_platforms())
+      if (!Plt.is_host()) {
+
+        std::string Name = Plt.get_info<sycl::info::platform::name>();
+        const std::string Ver =
+            Plt.get_info<sycl::info::platform::version>();
+
+        replaceEscapeCharacters(Name);
+
+        std::cout << "SYCL_DEVICE_WHITE_LIST=PlatformName:{{" << Name
+                  << "}},PlatformVersion:{{" << Ver << "}}";
+
+        return 0;
+      }
+    throw std::runtime_error("Non host device is not found");
+  }
+
   // 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 =
+        std::string Name = Dev.get_info<sycl::info::device::name>();
+        const std::string Ver =
             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 << "}}";
+
+        replaceEscapeCharacters(Name);
+
+        std::cout << "SYCL_DEVICE_WHITE_LIST=DeviceName:{{" << Name
+                  << "}},DriverVersion:{{" << Ver << "}}";
+
         return 0;
       }
     throw std::runtime_error("Non host device is not found");