[UR] Fix backend parsing in ONEAPI_DEVICE_SELECTOR

`native_cpu` is now accepted as a valid backend, and having a different
backend to the one matching the platform is now valid.
`native_cpu:*;level_zero:*` now works properly.

Author: RossBrunton

unified-runtime/source/common/ur_util.hpp

@@ -209,6 +209,7 @@ using EnvVarMap = std::map<std::string, std::vector<std::string>>;
 /// @param env_var_name name of an environment variable to be parsed
 /// @param reject_empy whether to throw an error on discovering an empty value
 /// @param allow_duplicate whether to allow multiple pairs with the same key
+/// @param lower convert keys to lowercase
 /// @return std::optional with a possible map with parsed parameters as keys and
 ///         vectors of strings containing parsed values as keys.
 ///         Otherwise, optional is set to std::nullopt when the environment
@@ -217,7 +218,8 @@ using EnvVarMap = std::map<std::string, std::vector<std::string>>;
 /// wrong format
 inline std::optional<EnvVarMap> getenv_to_map(const char *env_var_name,
                                               bool reject_empty = true,
-                                              bool allow_duplicate = false) {
+                                              bool allow_duplicate = false,
+                                              bool lower = false) {
   char main_delim = ';';
   char key_value_delim = ':';
   char values_delim = ',';
@@ -254,6 +256,10 @@ inline std::optional<EnvVarMap> getenv_to_map(const char *env_var_name,
       throw_wrong_format_map(env_var_name, *env_var);
     }
 
+    if (lower) {
+      std::transform(key.begin(), key.end(), key.begin(), tolower);
+    }
+
     std::vector<std::string> values_vec;
     std::stringstream values_ss(values);
     std::string value;

unified-runtime/source/loader/ur_lib.cpp

@@ -251,6 +251,13 @@ ur_result_t urDeviceGetSelected(ur_platform_handle_t hPlatform,
                                 uint32_t NumEntries,
                                 ur_device_handle_t *phDevices,
                                 uint32_t *pNumDevices) {
+  constexpr std::pair<const ur_platform_backend_t, const char *> adapters[6] = {
+      {UR_PLATFORM_BACKEND_UNKNOWN, "*"},
+      {UR_PLATFORM_BACKEND_LEVEL_ZERO, "level_zero"},
+      {UR_PLATFORM_BACKEND_OPENCL, "opencl"},
+      {UR_PLATFORM_BACKEND_CUDA, "cuda"},
+      {UR_PLATFORM_BACKEND_HIP, "hip"},
+      {UR_PLATFORM_BACKEND_NATIVE_CPU, "native_cpu"}};
 
   if (!hPlatform) {
     return UR_RESULT_ERROR_INVALID_NULL_HANDLE;
@@ -323,7 +330,8 @@ ur_result_t urDeviceGetSelected(ur_platform_handle_t hPlatform,
   // (If we wished to preserve the ordering of terms, we could replace
   // `std::map` with `std::queue<std::pair<key_type_t, value_type_t>>` or
   // something similar.)
-  auto maybeEnvVarMap = getenv_to_map("ONEAPI_DEVICE_SELECTOR", false);
+  auto maybeEnvVarMap =
+      getenv_to_map("ONEAPI_DEVICE_SELECTOR", false, false, true);
   logger::debug(
       "getenv_to_map parsed env var and {} a map",
       (maybeEnvVarMap.has_value() ? "produced" : "failed to produce"));
@@ -380,35 +388,6 @@ ur_result_t urDeviceGetSelected(ur_platform_handle_t hPlatform,
                         sizeof(ur_platform_backend_t), &platformBackend, 0)) {
     return UR_RESULT_ERROR_INVALID_PLATFORM;
   }
-  const std::string platformBackendName = // hPlatform->get_backend_name();
-      [&platformBackend]() constexpr {
-        switch (platformBackend) {
-        case UR_PLATFORM_BACKEND_UNKNOWN:
-          return "*"; // the only ODS string that matches
-          break;
-        case UR_PLATFORM_BACKEND_LEVEL_ZERO:
-          return "level_zero";
-          break;
-        case UR_PLATFORM_BACKEND_OPENCL:
-          return "opencl";
-          break;
-        case UR_PLATFORM_BACKEND_CUDA:
-          return "cuda";
-          break;
-        case UR_PLATFORM_BACKEND_HIP:
-          return "hip";
-          break;
-        case UR_PLATFORM_BACKEND_NATIVE_CPU:
-          return "*"; // the only ODS string that matches
-          break;
-        case UR_PLATFORM_BACKEND_FORCE_UINT32:
-          return ""; // no ODS string matches this
-          break;
-        default:
-          return ""; // no ODS string matches this
-          break;
-        }
-      }();
 
   using DeviceHardwareType = ur_device_type_t;
 
@@ -482,18 +461,18 @@ ur_result_t urDeviceGetSelected(ur_platform_handle_t hPlatform,
     // Note the hPlatform -> platformBackend -> platformBackendName conversion
     // above guarantees minimal sanity for the comparison with backend from the
     // ODS string
-    if (backend.front() != '*' &&
-        !std::equal(platformBackendName.cbegin(), platformBackendName.cend(),
-                    backend.cbegin(), backend.cend(),
-                    [](const auto &a, const auto &b) {
-                      // case-insensitive comparison by converting both tolower
-                      return std::tolower(static_cast<unsigned char>(a)) ==
-                             std::tolower(static_cast<unsigned char>(b));
-                    })) {
-      // irrelevant term for current request: different backend -- silently
-      // ignore
-      logger::error("unrecognised backend '{}'", backend);
-      return UR_RESULT_ERROR_INVALID_VALUE;
+    if (backend.front() != '*') {
+      auto cend = &adapters[sizeof(adapters) / sizeof(adapters[0])];
+      auto found = std::find_if(adapters, cend,
+                                [&](auto &p) { return p.second == backend; });
+      if (found == cend) {
+        // It's not a legal backend
+        logger::error("unrecognised backend '{}'", backend);
+        return UR_RESULT_ERROR_INVALID_VALUE;
+      } else if (found->first != platformBackend) {
+        // If it's a rule for a different backend, ignore it
+        continue;
+      }
     }
     if (termPair.second.size() == 0) {
       // malformed term: missing filterStrings -- output ERROR

unified-runtime/test/conformance/device/urDeviceGetSelected.cpp

@@ -178,6 +178,13 @@ TEST_P(urDeviceGetSelectedTest, InvalidGarbageBackendString) {
   ASSERT_EQ(count, 0);
 }
 
+TEST_P(urDeviceGetSelectedTest, SuccessCaseSensitive) {
+  setenv("ONEAPI_DEVICE_SELECTOR", "OpEnCl:0", 1);
+  uint32_t count = 0;
+  ASSERT_SUCCESS(
+      urDeviceGetSelected(platform, UR_DEVICE_TYPE_ALL, 0, nullptr, &count));
+}
+
 TEST_P(urDeviceGetSelectedTest, InvalidMissingFilterStrings) {
   setenv("ONEAPI_DEVICE_SELECTOR", "*", 1);
   uint32_t count = 0;