[SYCL] Implement new env var SYCL_DEVICE_FILTER

sycl/include/CL/sycl/backend_types.hpp

@@ -18,7 +18,7 @@
 __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {
 
-enum class backend : char { host, opencl, level_zero, cuda };
+enum class backend : char { host, opencl, level_zero, cuda, all };
 
 template <backend name, typename SYCLObjectT> struct interop;
 
@@ -35,6 +35,9 @@ inline std::ostream &operator<<(std::ostream &Out, backend be) {
     break;
   case backend::cuda:
     Out << std::string("cuda");
+    break;
+  case backend::all:
+    Out << std::string("all");
   }
   return Out;
 }

sycl/include/CL/sycl/device_triple.hpp

@@ -0,0 +1,91 @@
+//==-------------- triple.hpp - SYCL device triple descripter --------------==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include <CL/sycl/backend_types.hpp>
+#include <CL/sycl/detail/defines.hpp>
+#include <CL/sycl/info/info_desc.hpp>
+
+#include <iostream>
+#include <string>
+
+__SYCL_INLINE_NAMESPACE(cl) {
+namespace sycl {
+
+class device_triple {
+  backend Backend;
+  info::device_type DeviceType;
+  int32_t DeviceNum;
+  const int DEVICE_NUM_UNSPECIFIED = -1;
+
+public:
+  device_triple(std::string &TripleString);
+  backend getBackend() const { return Backend; }
+  info::device_type getDeviceType() const { return DeviceType; }
+  int32_t getDeviceNum() const { return DeviceNum; }
+  friend std::ostream &operator<<(std::ostream &Out, const device_triple &Trp);
+};
+
+class device_triple_list {
+  std::vector<device_triple> TripleList;
+
+public:
+  device_triple_list(std::string &TripleString);
+  device_triple_list(device_triple &Trp);
+  std::vector<device_triple> &get() { return TripleList; }
+  friend std::ostream &operator<<(std::ostream &Out,
+                                  const device_triple_list &List);
+};
+
+inline std::ostream &operator<<(std::ostream &Out, const device_triple &Trp) {
+  switch (Trp.Backend) {
+  case backend::host:
+    Out << std::string("host");
+    break;
+  case backend::opencl:
+    Out << std::string("opencl");
+    break;
+  case backend::level_zero:
+    Out << std::string("level-zero");
+    break;
+  case backend::cuda:
+    Out << std::string("cuda");
+    break;
+  case backend::all:
+    Out << std::string("*");
+  }
+  Out << std::string(":");
+  if (Trp.DeviceType == info::device_type::host) {
+    Out << std::string("host");
+  } else if (Trp.DeviceType == info::device_type::cpu) {
+    Out << std::string("cpu");
+  } else if (Trp.DeviceType == info::device_type::gpu) {
+    Out << std::string("gpu");
+  } else if (Trp.DeviceType == info::device_type::accelerator) {
+    Out << std::string("acceclerator");
+  } else if (Trp.DeviceType == info::device_type::all) {
+    Out << std::string("*");
+  }
+  if (Trp.DeviceNum != Trp.DEVICE_NUM_UNSPECIFIED) {
+    Out << std::string(":") << Trp.DeviceNum;
+  }
+  return Out;
+}
+
+inline std::ostream &operator<<(std::ostream &Out,
+                                const device_triple_list &List) {
+  for (const device_triple &Trp : List.TripleList) {
+    Out << Trp;
+    Out << ",";
+  }
+  return Out;
+}
+
+} // namespace sycl
+} // __SYCL_INLINE_NAMESPACE(cl)

sycl/source/CMakeLists.txt

@@ -140,6 +140,7 @@ set(SYCL_SOURCES
     "context.cpp"
     "device.cpp"
     "device_selector.cpp"
+    "device_triple.cpp"
     "event.cpp"
     "exception.cpp"
     "exception_list.cpp"

sycl/source/detail/config.def

@@ -16,3 +16,4 @@ CONFIG(SYCL_DEVICE_ALLOWLIST, 1024, __SYCL_DEVICE_ALLOWLIST)
 CONFIG(SYCL_BE, 16, __SYCL_BE)
 CONFIG(SYCL_PI_TRACE, 16, __SYCL_PI_TRACE)
 CONFIG(SYCL_DEVICELIB_NO_FALLBACK, 1, __SYCL_DEVICELIB_NO_FALLBACK)
+CONFIG(SYCL_DEVICE_TRIPLES, 1024, __SYCL_DEVICE_TRIPLES)

sycl/source/detail/config.hpp

@@ -11,6 +11,8 @@
 #include <CL/sycl/backend_types.hpp>
 #include <CL/sycl/detail/defines.hpp>
 #include <CL/sycl/detail/pi.hpp>
+#include <CL/sycl/device_triple.hpp>
+#include <CL/sycl/info/info_desc.hpp>
 
 #include <algorithm>
 #include <array>
@@ -163,6 +165,32 @@ template <> class SYCLConfig<SYCL_PI_TRACE> {
   }
 };
 
+template <> class SYCLConfig<SYCL_DEVICE_TRIPLES> {
+  using BaseT = SYCLConfigBase<SYCL_DEVICE_TRIPLES>;
+
+public:
+  static device_triple_list *get() {
+    static bool Initialized = false;
+    static device_triple_list *TripleList = nullptr;
+
+    // Configuration parameters are processed only once, like reading a string
+    // from environment and converting it into a typed object.
+    if (Initialized) {
+      return TripleList;
+    }
+
+    Initialized = true;
+    const char *ValStr = BaseT::getRawValue();
+    if (ValStr) {
+      std::string TripleString = ValStr;
+      std::transform(TripleString.begin(), TripleString.end(),
+                     TripleString.begin(), ::tolower);
+      TripleList = new device_triple_list(TripleString);
+    }
+    return TripleList;
+  }
+};
+
 } // namespace detail
 } // namespace sycl
 } // __SYCL_INLINE_NAMESPACE(cl)

sycl/source/detail/pi.cpp

@@ -15,6 +15,7 @@
 #include <CL/sycl/context.hpp>
 #include <CL/sycl/detail/common.hpp>
 #include <CL/sycl/detail/pi.hpp>
+#include <CL/sycl/device_triple.hpp>
 #include <detail/config.hpp>
 #include <detail/plugin.hpp>
 
@@ -214,9 +215,33 @@ bool findPlugins(vector_class<std::pair<std::string, backend>> &PluginNames) {
   // search is done for libpi_opencl.so/pi_opencl.dll file in LD_LIBRARY_PATH
   // env only.
   //
-  PluginNames.emplace_back(OPENCL_PLUGIN_NAME, backend::opencl);
-  PluginNames.emplace_back(LEVEL_ZERO_PLUGIN_NAME, backend::level_zero);
-  PluginNames.emplace_back(CUDA_PLUGIN_NAME, backend::cuda);
+  device_triple_list *TripleList = SYCLConfig<SYCL_DEVICE_TRIPLES>::get();
+  if (!TripleList) {
+    PluginNames.emplace_back(OPENCL_PLUGIN_NAME, backend::opencl);
+    PluginNames.emplace_back(LEVEL_ZERO_PLUGIN_NAME, backend::level_zero);
+    PluginNames.emplace_back(CUDA_PLUGIN_NAME, backend::cuda);
+  } else {
+    std::vector<device_triple> Triples = TripleList->get();
+    bool OpenCLFound = false;
+    bool LevelZeroFound = false;
+    bool CudaFound = false;
+    for (const device_triple &Trp : Triples) {
+      backend Backend = Trp.getBackend();
+      if (!OpenCLFound &&
+          (Backend == backend::opencl || Backend == backend::all)) {
+        PluginNames.emplace_back(OPENCL_PLUGIN_NAME, backend::opencl);
+        OpenCLFound = true;
+      } else if (!LevelZeroFound &&
+                 (Backend == backend::level_zero || Backend == backend::all)) {
+        PluginNames.emplace_back(LEVEL_ZERO_PLUGIN_NAME, backend::level_zero);
+        LevelZeroFound = true;
+      } else if (!CudaFound &&
+                 (Backend == backend::cuda || Backend == backend::all)) {
+        PluginNames.emplace_back(CUDA_PLUGIN_NAME, backend::cuda);
+        CudaFound = true;
+      }
+    }
+  }
   return true;
 }
 

sycl/source/device_triple.cpp

@@ -0,0 +1,114 @@
+//==------------------- device_triple.cpp ----------------------------------==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <CL/sycl/device_triple.hpp>
+#include <CL/sycl/info/info_desc.hpp>
+#include <cstring>
+#include <detail/config.hpp>
+#include <detail/device_impl.hpp>
+
+__SYCL_INLINE_NAMESPACE(cl) {
+namespace sycl {
+
+device_triple::device_triple(std::string &TripleString) {
+  const std::array<std::pair<std::string, info::device_type>, 5>
+      SyclDeviceTypeMap = {{{"host", info::device_type::host},
+                            {"cpu", info::device_type::cpu},
+                            {"gpu", info::device_type::gpu},
+                            {"acc", info::device_type::accelerator},
+                            {"*", info::device_type::all}}};
+  const std::array<std::pair<std::string, backend>, 4> SyclBeMap = {
+      {{"opencl", backend::opencl},
+       {"level_zero", backend::level_zero},
+       {"cuda", backend::cuda},
+       {"*", backend::all}}};
+
+  // handle the optional 1st entry, backend
+  size_t Cursor = 0;
+  size_t ColonPos = TripleString.find(":", Cursor);
+  auto It = std::find_if(
+      std::begin(SyclBeMap), std::end(SyclBeMap),
+      [=, &Cursor](const std::pair<std::string, backend> &Element) {
+        size_t Found = TripleString.find(Element.first, Cursor);
+        if (Found != std::string::npos) {
+          Cursor = Found;
+          return true;
+        }
+        return false;
+      });
+  if (It == SyclBeMap.end()) {
+    Backend = backend::all;
+  } else {
+    Backend = It->second;
+    if (ColonPos != std::string::npos) {
+      Cursor = ColonPos + 1;
+    } else {
+      Cursor = Cursor + It->first.size();
+    }
+  }
+
+  // handle the optional 2nd entry, device type
+  auto Iter = std::find_if(
+      std::begin(SyclDeviceTypeMap), std::end(SyclDeviceTypeMap),
+      [=, &Cursor](const std::pair<std::string, info::device_type> &Element) {
+        size_t Found = TripleString.find(Element.first, Cursor);
+        if (Found != std::string::npos) {
+          Cursor = Found;
+          return true;
+        }
+        return false;
+      });
+  if (Iter == SyclDeviceTypeMap.end()) {
+    DeviceType = info::device_type::all;
+  } else {
+    DeviceType = Iter->second;
+    ColonPos = TripleString.find(":", Cursor);
+    if (ColonPos != std::string::npos) {
+      Cursor = ColonPos + 1;
+    } else {
+      Cursor = Cursor + Iter->first.size();
+    }
+  }
+
+  // handle the optional 3rd entry, device number
+  if (Cursor < TripleString.size()) {
+    try {
+      DeviceNum = stoi(TripleString.substr(ColonPos + 1));
+    } catch (...) {
+      char message[100];
+      strcpy(message, "Invalid device triple: ");
+      std::strcat(message, TripleString.c_str());
+      std::strcat(message,
+                  "\nPossible backend values are {opencl,level_zero,cuda,*}.");
+      std::strcat(message, "\nPossible device types are {host,cpu,gpu,acc,*}.");
+      std::strcat(message,
+                  "\nDevice number should be an non-negative integer.\n");
+      throw cl::sycl::invalid_parameter_error(message, PI_INVALID_VALUE);
+    }
+  } else {
+    DeviceNum = DEVICE_NUM_UNSPECIFIED;
+  }
+}
+
+device_triple_list::device_triple_list(std::string &TripleString) {
+  std::transform(TripleString.begin(), TripleString.end(), TripleString.begin(),
+                 ::tolower);
+  size_t Pos = 0;
+  while (Pos < TripleString.size()) {
+    size_t CommaPos = TripleString.find(",", Pos);
+    if (CommaPos == std::string::npos) {
+      CommaPos = TripleString.size();
+    }
+    std::string SubString = TripleString.substr(Pos, CommaPos - Pos);
+    TripleList.push_back(device_triple(SubString));
+    Pos = CommaPos + 1;
+  }
+}
+
+} // namespace sycl
+} // __SYCL_INLINE_NAMESPACE(cl)