diff --git a/sycl/plugins/unified_runtime/pi2ur.hpp b/sycl/plugins/unified_runtime/pi2ur.hpp
index 34b443fd228f6..494c235450a2f 100644
--- a/sycl/plugins/unified_runtime/pi2ur.hpp
+++ b/sycl/plugins/unified_runtime/pi2ur.hpp
@@ -7,37 +7,47 @@
 //===------------------------------------------------------------------===//
 #pragma once
 
-#include <unordered_map>
-
 #include "ur_api.h"
 #include <sycl/detail/pi.h>
 #include <ur/ur.hpp>
 
 // Map of UR error codes to PI error codes
 static pi_result ur2piResult(ur_result_t urResult) {
-  std::unordered_map<ur_result_t, pi_result> ErrorMapping = {
-      {UR_RESULT_SUCCESS, PI_SUCCESS},
-      {UR_RESULT_ERROR_UNKNOWN, PI_ERROR_UNKNOWN},
-      {UR_RESULT_ERROR_DEVICE_LOST, PI_ERROR_DEVICE_NOT_FOUND},
-      {UR_RESULT_ERROR_INVALID_OPERATION, PI_ERROR_INVALID_OPERATION},
-      {UR_RESULT_ERROR_INVALID_PLATFORM, PI_ERROR_INVALID_PLATFORM},
-      {UR_RESULT_ERROR_INVALID_ARGUMENT, PI_ERROR_INVALID_ARG_VALUE},
-      {UR_RESULT_ERROR_INVALID_VALUE, PI_ERROR_INVALID_VALUE},
-      {UR_RESULT_ERROR_INVALID_EVENT, PI_ERROR_INVALID_EVENT},
-      {UR_RESULT_ERROR_INVALID_BINARY, PI_ERROR_INVALID_BINARY},
-      {UR_RESULT_ERROR_INVALID_KERNEL_NAME, PI_ERROR_INVALID_KERNEL_NAME},
-      {UR_RESULT_ERROR_INVALID_FUNCTION_NAME, PI_ERROR_BUILD_PROGRAM_FAILURE},
-      {UR_RESULT_ERROR_INVALID_WORK_GROUP_SIZE,
-       PI_ERROR_INVALID_WORK_GROUP_SIZE},
-      {UR_RESULT_ERROR_PROGRAM_BUILD_FAILURE, PI_ERROR_BUILD_PROGRAM_FAILURE},
-      {UR_RESULT_ERROR_OUT_OF_DEVICE_MEMORY, PI_ERROR_OUT_OF_RESOURCES},
-      {UR_RESULT_ERROR_OUT_OF_HOST_MEMORY, PI_ERROR_OUT_OF_HOST_MEMORY}};
-
-  auto It = ErrorMapping.find(urResult);
-  if (It == ErrorMapping.end()) {
+  if (urResult == UR_RESULT_SUCCESS)
+    return PI_SUCCESS;
+
+  switch (urResult) {
+  case UR_RESULT_ERROR_UNKNOWN:
     return PI_ERROR_UNKNOWN;
-  }
-  return It->second;
+  case UR_RESULT_ERROR_DEVICE_LOST:
+    return PI_ERROR_DEVICE_NOT_FOUND;
+  case UR_RESULT_ERROR_INVALID_OPERATION:
+    return PI_ERROR_INVALID_OPERATION;
+  case UR_RESULT_ERROR_INVALID_PLATFORM:
+    return PI_ERROR_INVALID_PLATFORM;
+  case UR_RESULT_ERROR_INVALID_ARGUMENT:
+    return PI_ERROR_INVALID_ARG_VALUE;
+  case UR_RESULT_ERROR_INVALID_VALUE:
+    return PI_ERROR_INVALID_VALUE;
+  case UR_RESULT_ERROR_INVALID_EVENT:
+    return PI_ERROR_INVALID_EVENT;
+  case UR_RESULT_ERROR_INVALID_BINARY:
+    return PI_ERROR_INVALID_BINARY;
+  case UR_RESULT_ERROR_INVALID_KERNEL_NAME:
+    return PI_ERROR_INVALID_KERNEL_NAME;
+  case UR_RESULT_ERROR_INVALID_FUNCTION_NAME:
+    return PI_ERROR_BUILD_PROGRAM_FAILURE;
+  case UR_RESULT_ERROR_INVALID_WORK_GROUP_SIZE:
+    return PI_ERROR_INVALID_WORK_GROUP_SIZE;
+  case UR_RESULT_ERROR_OUT_OF_DEVICE_MEMORY:
+    return PI_ERROR_OUT_OF_RESOURCES;
+  case UR_RESULT_ERROR_OUT_OF_HOST_MEMORY:
+    return PI_ERROR_OUT_OF_HOST_MEMORY;
+  case UR_RESULT_ERROR_PROGRAM_BUILD_FAILURE:
+    return PI_ERROR_BUILD_PROGRAM_FAILURE;
+  default:
+    return PI_ERROR_UNKNOWN;
+  };
 }
 
 // Early exits on any error
@@ -70,7 +80,7 @@ class ConvertHelper : public ReturnHelper {
 public:
   // Convert the value using a conversion map
   template <typename TypeUR, typename TypePI>
-  pi_result convert(const std::unordered_map<TypeUR, TypePI> &Map) {
+  pi_result convert(std::function<TypePI(TypeUR)> Func) {
     *param_value_size_ret = sizeof(TypePI);
 
     // There is no value to convert.
@@ -83,18 +93,13 @@ class ConvertHelper : public ReturnHelper {
     // Cannot convert to a smaller storage type
     PI_ASSERT(sizeof(TypePI) >= sizeof(TypeUR), PI_ERROR_UNKNOWN);
 
-    auto It = Map.find(*pValueUR);
-    if (It == Map.end()) {
-      die("ConvertHelper: unhandled value");
-    }
-
-    *pValuePI = It->second;
+    *pValuePI = Func(*pValueUR);
     return PI_SUCCESS;
   }
 
   // Convert the array (0-terminated) using a conversion map
   template <typename TypeUR, typename TypePI>
-  pi_result convertArray(const std::unordered_map<TypeUR, TypePI> &Map) {
+  pi_result convertArray(std::function<TypePI(TypeUR)> Func) {
     // Cannot convert to a smaller element storage type
     PI_ASSERT(sizeof(TypePI) >= sizeof(TypeUR), PI_ERROR_UNKNOWN);
     *param_value_size_ret *= sizeof(TypePI) / sizeof(TypeUR);
@@ -105,8 +110,8 @@ class ConvertHelper : public ReturnHelper {
 
     PI_ASSERT(*param_value_size_ret % sizeof(TypePI) == 0, PI_ERROR_UNKNOWN);
 
-    // Make a copy of the input UR array as we may possibly overwrite following
-    // elements while converting previous ones (if extending).
+    // Make a copy of the input UR array as we may possibly overwrite
+    // following elements while converting previous ones (if extending).
     auto ValueUR = new char[*param_value_size_ret];
     auto pValueUR = reinterpret_cast<TypeUR *>(ValueUR);
     auto pValuePI = static_cast<TypePI *>(param_value);
@@ -118,11 +123,7 @@ class ConvertHelper : public ReturnHelper {
         break;
       }
 
-      auto It = Map.find(*pValueUR);
-      if (It == Map.end()) {
-        die("ConvertHelper: unhandled value");
-      }
-      *pValuePI = It->second;
+      *pValuePI = Func(*pValueUR);
       ++pValuePI;
       ++pValueUR;
     }
@@ -133,7 +134,7 @@ class ConvertHelper : public ReturnHelper {
 
   // Convert the bitset using a conversion map
   template <typename TypeUR, typename TypePI>
-  pi_result convertBitSet(const std::unordered_map<TypeUR, TypePI> &Map) {
+  pi_result convertBitSet(std::function<TypePI(TypeUR)> Func) {
     // There is no value to convert.
     if (!param_value)
       return PI_SUCCESS;
@@ -152,7 +153,7 @@ class ConvertHelper : public ReturnHelper {
 
       // Convert the Val alone and merge it into Out
       *pValueUR = TypeUR(Val);
-      if (auto Res = convert(Map))
+      if (auto Res = convert(Func))
         return Res;
       Out |= *pValuePI;
     }
@@ -169,100 +170,148 @@ inline pi_result ur2piInfoValue(ur_device_info_t ParamName,
   ConvertHelper Value(ParamValueSizePI, ParamValue, ParamValueSizeUR);
 
   if (ParamName == UR_DEVICE_INFO_TYPE) {
-    static std::unordered_map<ur_device_type_t, pi_device_type> Map = {
-        {UR_DEVICE_TYPE_CPU, PI_DEVICE_TYPE_CPU},
-        {UR_DEVICE_TYPE_GPU, PI_DEVICE_TYPE_GPU},
-        {UR_DEVICE_TYPE_FPGA, PI_DEVICE_TYPE_ACC},
+    auto ConvertFunc = [](ur_device_type_t UrValue) {
+      switch (UrValue) {
+      case UR_DEVICE_TYPE_CPU:
+        return PI_DEVICE_TYPE_CPU;
+      case UR_DEVICE_TYPE_GPU:
+        return PI_DEVICE_TYPE_GPU;
+      case UR_DEVICE_TYPE_FPGA:
+        return PI_DEVICE_TYPE_ACC;
+      default:
+        die("UR_DEVICE_INFO_TYPE: unhandled value");
+      }
     };
-    return Value.convert(Map);
+    return Value.convert<ur_device_type_t, pi_device_type>(ConvertFunc);
   } else if (ParamName == UR_DEVICE_INFO_QUEUE_PROPERTIES) {
-    static std::unordered_map<ur_queue_flag_t, pi_queue_properties> Map = {
-        {UR_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE,
-         PI_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE},
-        {UR_QUEUE_FLAG_PROFILING_ENABLE, PI_QUEUE_FLAG_PROFILING_ENABLE},
-        {UR_QUEUE_FLAG_ON_DEVICE, PI_QUEUE_FLAG_ON_DEVICE},
-        {UR_QUEUE_FLAG_ON_DEVICE_DEFAULT, PI_QUEUE_FLAG_ON_DEVICE_DEFAULT},
+    auto ConvertFunc = [](ur_queue_flag_t UrValue) {
+      switch (UrValue) {
+      case UR_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE:
+        return PI_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE;
+      case UR_QUEUE_FLAG_PROFILING_ENABLE:
+        return PI_QUEUE_FLAG_PROFILING_ENABLE;
+      case UR_QUEUE_FLAG_ON_DEVICE:
+        return PI_QUEUE_FLAG_ON_DEVICE;
+      case UR_QUEUE_FLAG_ON_DEVICE_DEFAULT:
+        return PI_QUEUE_FLAG_ON_DEVICE_DEFAULT;
+      default:
+        die("UR_DEVICE_INFO_QUEUE_PROPERTIES: unhandled value");
+      }
     };
-    return Value.convertBitSet(Map);
+    return Value.convertBitSet<ur_queue_flag_t, pi_queue_properties>(
+        ConvertFunc);
   } else if (ParamName == UR_DEVICE_INFO_EXECUTION_CAPABILITIES) {
-    static std::unordered_map<ur_device_exec_capability_flag_t,
-                              pi_queue_properties>
-        Map = {
-            {UR_DEVICE_EXEC_CAPABILITY_FLAG_KERNEL,
-             PI_DEVICE_EXEC_CAPABILITIES_KERNEL},
-            {UR_DEVICE_EXEC_CAPABILITY_FLAG_NATIVE_KERNEL,
-             PI_DEVICE_EXEC_CAPABILITIES_NATIVE_KERNEL},
-        };
-    return Value.convertBitSet(Map);
+    auto ConvertFunc = [](ur_device_exec_capability_flag_t UrValue) {
+      switch (UrValue) {
+      case UR_DEVICE_EXEC_CAPABILITY_FLAG_KERNEL:
+        return PI_DEVICE_EXEC_CAPABILITIES_KERNEL;
+      case UR_DEVICE_EXEC_CAPABILITY_FLAG_NATIVE_KERNEL:
+        return PI_DEVICE_EXEC_CAPABILITIES_NATIVE_KERNEL;
+      default:
+        die("UR_DEVICE_INFO_EXECUTION_CAPABILITIES: unhandled value");
+      }
+    };
+    return Value
+        .convertBitSet<ur_device_exec_capability_flag_t, pi_queue_properties>(
+            ConvertFunc);
   } else if (ParamName == UR_DEVICE_INFO_PARTITION_AFFINITY_DOMAIN) {
-    static std::unordered_map<ur_device_affinity_domain_flag_t,
-                              pi_device_affinity_domain>
-        Map = {
-            {UR_DEVICE_AFFINITY_DOMAIN_FLAG_NUMA,
-             PI_DEVICE_AFFINITY_DOMAIN_NUMA},
-            {UR_DEVICE_AFFINITY_DOMAIN_FLAG_NEXT_PARTITIONABLE,
-             PI_DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE},
-        };
-    return Value.convertBitSet(Map);
+    auto ConvertFunc = [](ur_device_affinity_domain_flag_t UrValue) {
+      switch (UrValue) {
+      case UR_DEVICE_AFFINITY_DOMAIN_FLAG_NUMA:
+        return PI_DEVICE_AFFINITY_DOMAIN_NUMA;
+      case UR_DEVICE_AFFINITY_DOMAIN_FLAG_NEXT_PARTITIONABLE:
+        return PI_DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE;
+      default:
+        die("UR_DEVICE_INFO_PARTITION_AFFINITY_DOMAIN: unhandled value");
+      }
+    };
+    return Value.convertBitSet<ur_device_affinity_domain_flag_t,
+                               pi_device_affinity_domain>(ConvertFunc);
   } else if (ParamName == UR_DEVICE_INFO_PARTITION_TYPE) {
-    static std::unordered_map<ur_device_partition_property_t,
-                              pi_device_partition_property>
-        Map = {
-            {UR_DEVICE_PARTITION_BY_AFFINITY_DOMAIN,
-             PI_DEVICE_PARTITION_BY_AFFINITY_DOMAIN},
-            {UR_DEVICE_PARTITION_BY_CSLICE,
-             PI_EXT_INTEL_DEVICE_PARTITION_BY_CSLICE},
-            {(ur_device_partition_property_t)
-                 UR_DEVICE_AFFINITY_DOMAIN_FLAG_NEXT_PARTITIONABLE,
-             (pi_device_partition_property)
-                 PI_DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE},
-        };
-    return Value.convertArray(Map);
+    auto ConvertFunc = [](ur_device_partition_property_t UrValue) {
+      switch (UrValue) {
+      case UR_DEVICE_PARTITION_BY_AFFINITY_DOMAIN:
+        return PI_DEVICE_PARTITION_BY_AFFINITY_DOMAIN;
+      case UR_DEVICE_PARTITION_BY_CSLICE:
+        return PI_EXT_INTEL_DEVICE_PARTITION_BY_CSLICE;
+      case (ur_device_partition_property_t)
+          UR_DEVICE_AFFINITY_DOMAIN_FLAG_NEXT_PARTITIONABLE:
+        return (pi_device_partition_property)
+            PI_DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE;
+      default:
+        die("UR_DEVICE_INFO_PARTITION_TYPE: unhandled value");
+      }
+    };
+    return Value.convertArray<ur_device_partition_property_t,
+                              pi_device_partition_property>(ConvertFunc);
   } else if (ParamName == UR_DEVICE_INFO_PARTITION_PROPERTIES) {
-    static std::unordered_map<ur_device_partition_property_t,
-                              pi_device_partition_property>
-        Map = {
-            {UR_DEVICE_PARTITION_BY_AFFINITY_DOMAIN,
-             PI_DEVICE_PARTITION_BY_AFFINITY_DOMAIN},
-            {UR_DEVICE_PARTITION_BY_CSLICE,
-             PI_EXT_INTEL_DEVICE_PARTITION_BY_CSLICE},
-        };
-    return Value.convertArray(Map);
+    auto ConvertFunc = [](ur_device_partition_property_t UrValue) {
+      switch (UrValue) {
+      case UR_DEVICE_PARTITION_BY_AFFINITY_DOMAIN:
+        return PI_DEVICE_PARTITION_BY_AFFINITY_DOMAIN;
+      case UR_DEVICE_PARTITION_BY_CSLICE:
+        return PI_EXT_INTEL_DEVICE_PARTITION_BY_CSLICE;
+      default:
+        die("UR_DEVICE_INFO_PARTITION_PROPERTIES: unhandled value");
+      }
+    };
+    return Value.convertArray<ur_device_partition_property_t,
+                              pi_device_partition_property>(ConvertFunc);
   } else if (ParamName == UR_DEVICE_INFO_LOCAL_MEM_TYPE) {
-    static std::unordered_map<ur_device_local_mem_type_t,
-                              pi_device_local_mem_type>
-        Map = {
-            {UR_DEVICE_LOCAL_MEM_TYPE_LOCAL, PI_DEVICE_LOCAL_MEM_TYPE_LOCAL},
-            {UR_DEVICE_LOCAL_MEM_TYPE_GLOBAL, PI_DEVICE_LOCAL_MEM_TYPE_GLOBAL},
-        };
-    return Value.convert(Map);
+    auto ConvertFunc = [](ur_device_local_mem_type_t UrValue) {
+      switch (UrValue) {
+      case UR_DEVICE_LOCAL_MEM_TYPE_LOCAL:
+        return PI_DEVICE_LOCAL_MEM_TYPE_LOCAL;
+      case UR_DEVICE_LOCAL_MEM_TYPE_GLOBAL:
+        return PI_DEVICE_LOCAL_MEM_TYPE_GLOBAL;
+      default:
+        die("UR_DEVICE_INFO_LOCAL_MEM_TYPE: unhandled value");
+      }
+    };
+    return Value.convert<ur_device_local_mem_type_t, pi_device_local_mem_type>(
+        ConvertFunc);
   } else if (ParamName == UR_DEVICE_INFO_ATOMIC_MEMORY_ORDER_CAPABILITIES ||
              ParamName == UR_DEVICE_INFO_ATOMIC_FENCE_ORDER_CAPABILITIES) {
-    static std::unordered_map<ur_memory_order_capability_flag_t,
-                              pi_memory_order_capabilities>
-        Map = {
-            {UR_MEMORY_ORDER_CAPABILITY_FLAG_RELAXED, PI_MEMORY_ORDER_RELAXED},
-            {UR_MEMORY_ORDER_CAPABILITY_FLAG_ACQUIRE, PI_MEMORY_ORDER_ACQUIRE},
-            {UR_MEMORY_ORDER_CAPABILITY_FLAG_RELEASE, PI_MEMORY_ORDER_RELEASE},
-            {UR_MEMORY_ORDER_CAPABILITY_FLAG_ACQ_REL, PI_MEMORY_ORDER_ACQ_REL},
-            {UR_MEMORY_ORDER_CAPABILITY_FLAG_SEQ_CST, PI_MEMORY_ORDER_SEQ_CST},
-        };
-    return Value.convertBitSet(Map);
+    auto ConvertFunc = [](ur_memory_order_capability_flag_t UrValue) {
+      switch (UrValue) {
+      case UR_MEMORY_ORDER_CAPABILITY_FLAG_RELAXED:
+        return PI_MEMORY_ORDER_RELAXED;
+      case UR_MEMORY_ORDER_CAPABILITY_FLAG_ACQUIRE:
+        return PI_MEMORY_ORDER_ACQUIRE;
+      case UR_MEMORY_ORDER_CAPABILITY_FLAG_RELEASE:
+        return PI_MEMORY_ORDER_RELEASE;
+      case UR_MEMORY_ORDER_CAPABILITY_FLAG_ACQ_REL:
+        return PI_MEMORY_ORDER_ACQ_REL;
+      case UR_MEMORY_ORDER_CAPABILITY_FLAG_SEQ_CST:
+        return PI_MEMORY_ORDER_SEQ_CST;
+      default:
+        die("UR_DEVICE_INFO_ATOMIC_MEMORY_ORDER_CAPABILITIES: unhandled "
+            "value");
+      }
+    };
+    return Value.convertBitSet<ur_memory_order_capability_flag_t,
+                               pi_memory_order_capabilities>(ConvertFunc);
   } else if (ParamName == UR_DEVICE_INFO_ATOMIC_MEMORY_SCOPE_CAPABILITIES ||
              ParamName == UR_DEVICE_INFO_ATOMIC_FENCE_SCOPE_CAPABILITIES) {
-    static std::unordered_map<ur_memory_scope_capability_flag_t,
-                              pi_memory_scope_capabilities>
-        Map = {
-            {UR_MEMORY_SCOPE_CAPABILITY_FLAG_WORK_ITEM,
-             PI_MEMORY_SCOPE_WORK_ITEM},
-            {UR_MEMORY_SCOPE_CAPABILITY_FLAG_SUB_GROUP,
-             PI_MEMORY_SCOPE_SUB_GROUP},
-            {UR_MEMORY_SCOPE_CAPABILITY_FLAG_WORK_GROUP,
-             PI_MEMORY_SCOPE_WORK_GROUP},
-            {UR_MEMORY_SCOPE_CAPABILITY_FLAG_DEVICE, PI_MEMORY_SCOPE_DEVICE},
-            {UR_MEMORY_SCOPE_CAPABILITY_FLAG_SYSTEM, PI_MEMORY_SCOPE_SYSTEM},
-        };
-    return Value.convertBitSet(Map);
+    auto ConvertFunc = [](ur_memory_scope_capability_flag_t UrValue) {
+      switch (UrValue) {
+      case UR_MEMORY_SCOPE_CAPABILITY_FLAG_WORK_ITEM:
+        return PI_MEMORY_SCOPE_WORK_ITEM;
+      case UR_MEMORY_SCOPE_CAPABILITY_FLAG_SUB_GROUP:
+        return PI_MEMORY_SCOPE_SUB_GROUP;
+      case UR_MEMORY_SCOPE_CAPABILITY_FLAG_WORK_GROUP:
+        return PI_MEMORY_SCOPE_WORK_GROUP;
+      case UR_MEMORY_SCOPE_CAPABILITY_FLAG_DEVICE:
+        return PI_MEMORY_SCOPE_DEVICE;
+      case UR_MEMORY_SCOPE_CAPABILITY_FLAG_SYSTEM:
+        return PI_MEMORY_SCOPE_SYSTEM;
+      default:
+        die("UR_DEVICE_INFO_ATOMIC_MEMORY_SCOPE_CAPABILITIES: unhandled "
+            "value");
+      }
+    };
+    return Value.convertBitSet<ur_memory_scope_capability_flag_t,
+                               pi_memory_scope_capabilities>(ConvertFunc);
   } else {
     // TODO: what else needs a UR-PI translation?
   }
@@ -290,49 +339,59 @@ inline pi_result piPlatformGetInfo(pi_platform platform,
                                    pi_platform_info ParamName,
                                    size_t ParamValueSize, void *ParamValue,
                                    size_t *ParamValueSizeRet) {
-
-  static std::unordered_map<pi_platform_info, ur_platform_info_t> InfoMapping =
-      {
-          {PI_PLATFORM_INFO_EXTENSIONS, UR_PLATFORM_INFO_NAME},
-          {PI_PLATFORM_INFO_NAME, UR_PLATFORM_INFO_NAME},
-          {PI_PLATFORM_INFO_PROFILE, UR_PLATFORM_INFO_PROFILE},
-          {PI_PLATFORM_INFO_VENDOR, UR_PLATFORM_INFO_VENDOR_NAME},
-          {PI_PLATFORM_INFO_VERSION, UR_PLATFORM_INFO_VERSION},
-      };
-
-  auto InfoType = InfoMapping.find(ParamName);
-  if (InfoType == InfoMapping.end()) {
+  ur_platform_info_t InfoType;
+  switch (ParamName) {
+  case PI_PLATFORM_INFO_EXTENSIONS:
+    InfoType = UR_PLATFORM_INFO_NAME;
+    break;
+  case PI_PLATFORM_INFO_NAME:
+    InfoType = UR_PLATFORM_INFO_NAME;
+    break;
+  case PI_PLATFORM_INFO_PROFILE:
+    InfoType = UR_PLATFORM_INFO_PROFILE;
+    break;
+  case PI_PLATFORM_INFO_VENDOR:
+    InfoType = UR_PLATFORM_INFO_VENDOR_NAME;
+    break;
+  case PI_PLATFORM_INFO_VERSION:
+    InfoType = UR_PLATFORM_INFO_VERSION;
+    break;
+  default:
     return PI_ERROR_UNKNOWN;
   }
 
   size_t SizeInOut = ParamValueSize;
   auto hPlatform = reinterpret_cast<ur_platform_handle_t>(platform);
-  HANDLE_ERRORS(urPlatformGetInfo(hPlatform, InfoType->second, SizeInOut,
-                                  ParamValue, ParamValueSizeRet));
+  HANDLE_ERRORS(urPlatformGetInfo(hPlatform, InfoType, SizeInOut, ParamValue,
+                                  ParamValueSizeRet));
   return PI_SUCCESS;
 }
 
 inline pi_result piDevicesGet(pi_platform Platform, pi_device_type DeviceType,
                               pi_uint32 NumEntries, pi_device *Devices,
                               pi_uint32 *NumDevices) {
-
-  static std::unordered_map<pi_device_type, ur_device_type_t> TypeMapping = {
-      {PI_DEVICE_TYPE_ALL, UR_DEVICE_TYPE_ALL},
-      {PI_DEVICE_TYPE_GPU, UR_DEVICE_TYPE_GPU},
-      {PI_DEVICE_TYPE_CPU, UR_DEVICE_TYPE_CPU},
-      {PI_DEVICE_TYPE_ACC, UR_DEVICE_TYPE_FPGA},
-  };
-
-  auto Type = TypeMapping.find(DeviceType);
-  if (Type == TypeMapping.end()) {
+  ur_device_type_t Type;
+  switch (DeviceType) {
+  case PI_DEVICE_TYPE_ALL:
+    Type = UR_DEVICE_TYPE_ALL;
+    break;
+  case PI_DEVICE_TYPE_GPU:
+    Type = UR_DEVICE_TYPE_GPU;
+    break;
+  case PI_DEVICE_TYPE_CPU:
+    Type = UR_DEVICE_TYPE_CPU;
+    break;
+  case PI_DEVICE_TYPE_ACC:
+    Type = UR_DEVICE_TYPE_FPGA;
+    break;
+  default:
     return PI_ERROR_UNKNOWN;
   }
 
   uint32_t Count = NumEntries;
   auto hPlatform = reinterpret_cast<ur_platform_handle_t>(Platform);
   auto phDevices = reinterpret_cast<ur_device_handle_t *>(Devices);
-  HANDLE_ERRORS(
-      urDeviceGet(hPlatform, Type->second, Count, phDevices, NumDevices));
+  HANDLE_ERRORS(urDeviceGet(hPlatform, Type, Count, phDevices, NumDevices));
   return PI_SUCCESS;
 }
 
@@ -354,184 +413,332 @@ inline pi_result piDeviceGetInfo(pi_device Device, pi_device_info ParamName,
                                  size_t ParamValueSize, void *ParamValue,
                                  size_t *ParamValueSizeRet) {
 
-  static std::unordered_map<pi_device_info, ur_device_info_t> InfoMapping = {
-      {PI_DEVICE_INFO_TYPE, UR_DEVICE_INFO_TYPE},
-      {PI_DEVICE_INFO_PARENT_DEVICE, UR_DEVICE_INFO_PARENT_DEVICE},
-      {PI_DEVICE_INFO_PLATFORM, UR_DEVICE_INFO_PLATFORM},
-      {PI_DEVICE_INFO_VENDOR_ID, UR_DEVICE_INFO_VENDOR_ID},
-      {PI_DEVICE_INFO_UUID, UR_DEVICE_INFO_UUID},
-      {PI_DEVICE_INFO_ATOMIC_64, UR_DEVICE_INFO_ATOMIC_64},
-      {PI_DEVICE_INFO_EXTENSIONS, UR_DEVICE_INFO_EXTENSIONS},
-      {PI_DEVICE_INFO_NAME, UR_DEVICE_INFO_NAME},
-      {PI_DEVICE_INFO_COMPILER_AVAILABLE, UR_DEVICE_INFO_COMPILER_AVAILABLE},
-      {PI_DEVICE_INFO_LINKER_AVAILABLE, UR_DEVICE_INFO_LINKER_AVAILABLE},
-      {PI_DEVICE_INFO_MAX_COMPUTE_UNITS, UR_DEVICE_INFO_MAX_COMPUTE_UNITS},
-      {PI_DEVICE_INFO_MAX_WORK_ITEM_DIMENSIONS,
-       UR_DEVICE_INFO_MAX_WORK_ITEM_DIMENSIONS},
-      {PI_DEVICE_INFO_MAX_WORK_GROUP_SIZE, UR_DEVICE_INFO_MAX_WORK_GROUP_SIZE},
-      {PI_DEVICE_INFO_MAX_WORK_ITEM_SIZES, UR_DEVICE_INFO_MAX_WORK_ITEM_SIZES},
-      {PI_DEVICE_INFO_MAX_CLOCK_FREQUENCY, UR_DEVICE_INFO_MAX_CLOCK_FREQUENCY},
-      {PI_DEVICE_INFO_ADDRESS_BITS, UR_DEVICE_INFO_ADDRESS_BITS},
-      {PI_DEVICE_INFO_MAX_MEM_ALLOC_SIZE, UR_DEVICE_INFO_MAX_MEM_ALLOC_SIZE},
-      {PI_DEVICE_INFO_GLOBAL_MEM_SIZE, UR_DEVICE_INFO_GLOBAL_MEM_SIZE},
-      {PI_DEVICE_INFO_LOCAL_MEM_SIZE, UR_DEVICE_INFO_LOCAL_MEM_SIZE},
-      {PI_DEVICE_INFO_IMAGE_SUPPORT, UR_DEVICE_INFO_IMAGE_SUPPORTED},
-      {PI_DEVICE_INFO_HOST_UNIFIED_MEMORY, UR_DEVICE_INFO_HOST_UNIFIED_MEMORY},
-      {PI_DEVICE_INFO_AVAILABLE, UR_DEVICE_INFO_AVAILABLE},
-      {PI_DEVICE_INFO_VENDOR, UR_DEVICE_INFO_VENDOR},
-      {PI_DEVICE_INFO_DRIVER_VERSION, UR_DEVICE_INFO_DRIVER_VERSION},
-      {PI_DEVICE_INFO_VERSION, UR_DEVICE_INFO_VERSION},
-      {PI_DEVICE_INFO_PARTITION_MAX_SUB_DEVICES,
-       UR_DEVICE_INFO_PARTITION_MAX_SUB_DEVICES},
-      {PI_DEVICE_INFO_REFERENCE_COUNT, UR_DEVICE_INFO_REFERENCE_COUNT},
-      {PI_DEVICE_INFO_PARTITION_PROPERTIES,
-       UR_DEVICE_INFO_PARTITION_PROPERTIES},
-      {PI_DEVICE_INFO_PARTITION_AFFINITY_DOMAIN,
-       UR_DEVICE_INFO_PARTITION_AFFINITY_DOMAIN},
-      {PI_DEVICE_INFO_PARTITION_TYPE, UR_DEVICE_INFO_PARTITION_TYPE},
-      {PI_DEVICE_INFO_OPENCL_C_VERSION, UR_EXT_DEVICE_INFO_OPENCL_C_VERSION},
-      {PI_DEVICE_INFO_PREFERRED_INTEROP_USER_SYNC,
-       UR_DEVICE_INFO_PREFERRED_INTEROP_USER_SYNC},
-      {PI_DEVICE_INFO_PRINTF_BUFFER_SIZE, UR_DEVICE_INFO_PRINTF_BUFFER_SIZE},
-      {PI_DEVICE_INFO_PROFILE, UR_DEVICE_INFO_PROFILE},
-      {PI_DEVICE_INFO_BUILT_IN_KERNELS, UR_DEVICE_INFO_BUILT_IN_KERNELS},
-      {PI_DEVICE_INFO_QUEUE_PROPERTIES, UR_DEVICE_INFO_QUEUE_PROPERTIES},
-      {PI_DEVICE_INFO_EXECUTION_CAPABILITIES,
-       UR_DEVICE_INFO_EXECUTION_CAPABILITIES},
-      {PI_DEVICE_INFO_ENDIAN_LITTLE, UR_DEVICE_INFO_ENDIAN_LITTLE},
-      {PI_DEVICE_INFO_ERROR_CORRECTION_SUPPORT,
-       UR_DEVICE_INFO_ERROR_CORRECTION_SUPPORT},
-      {PI_DEVICE_INFO_PROFILING_TIMER_RESOLUTION,
-       UR_DEVICE_INFO_PROFILING_TIMER_RESOLUTION},
-      {PI_DEVICE_INFO_LOCAL_MEM_TYPE, UR_DEVICE_INFO_LOCAL_MEM_TYPE},
-      {PI_DEVICE_INFO_MAX_CONSTANT_ARGS, UR_DEVICE_INFO_MAX_CONSTANT_ARGS},
-      {PI_DEVICE_INFO_MAX_CONSTANT_BUFFER_SIZE,
-       UR_DEVICE_INFO_MAX_CONSTANT_BUFFER_SIZE},
-      {PI_DEVICE_INFO_GLOBAL_MEM_CACHE_TYPE,
-       UR_DEVICE_INFO_GLOBAL_MEM_CACHE_TYPE},
-      {PI_DEVICE_INFO_GLOBAL_MEM_CACHELINE_SIZE,
-       UR_DEVICE_INFO_GLOBAL_MEM_CACHELINE_SIZE},
-      {PI_DEVICE_INFO_GLOBAL_MEM_CACHE_SIZE,
-       UR_DEVICE_INFO_GLOBAL_MEM_CACHE_SIZE},
-      {PI_DEVICE_INFO_MAX_PARAMETER_SIZE, UR_DEVICE_INFO_MAX_PARAMETER_SIZE},
-      {PI_DEVICE_INFO_MEM_BASE_ADDR_ALIGN, UR_DEVICE_INFO_MEM_BASE_ADDR_ALIGN},
-      {PI_DEVICE_INFO_MAX_SAMPLERS, UR_DEVICE_INFO_MAX_SAMPLERS},
-      {PI_DEVICE_INFO_MAX_READ_IMAGE_ARGS, UR_DEVICE_INFO_MAX_READ_IMAGE_ARGS},
-      {PI_DEVICE_INFO_MAX_WRITE_IMAGE_ARGS,
-       UR_DEVICE_INFO_MAX_WRITE_IMAGE_ARGS},
-      {PI_DEVICE_INFO_SINGLE_FP_CONFIG, UR_DEVICE_INFO_SINGLE_FP_CONFIG},
-      {PI_DEVICE_INFO_HALF_FP_CONFIG, UR_DEVICE_INFO_HALF_FP_CONFIG},
-      {PI_DEVICE_INFO_DOUBLE_FP_CONFIG, UR_DEVICE_INFO_DOUBLE_FP_CONFIG},
-      {PI_DEVICE_INFO_IMAGE2D_MAX_WIDTH, UR_DEVICE_INFO_IMAGE2D_MAX_WIDTH},
-      {PI_DEVICE_INFO_IMAGE2D_MAX_HEIGHT, UR_DEVICE_INFO_IMAGE2D_MAX_HEIGHT},
-      {PI_DEVICE_INFO_IMAGE3D_MAX_WIDTH, UR_DEVICE_INFO_IMAGE3D_MAX_WIDTH},
-      {PI_DEVICE_INFO_IMAGE3D_MAX_HEIGHT, UR_DEVICE_INFO_IMAGE3D_MAX_HEIGHT},
-      {PI_DEVICE_INFO_IMAGE3D_MAX_DEPTH, UR_DEVICE_INFO_IMAGE3D_MAX_DEPTH},
-      {PI_DEVICE_INFO_IMAGE_MAX_BUFFER_SIZE,
-       UR_DEVICE_INFO_IMAGE_MAX_BUFFER_SIZE},
-      {PI_DEVICE_INFO_IMAGE_MAX_ARRAY_SIZE,
-       (ur_device_info_t)UR_DEVICE_INFO_IMAGE_MAX_ARRAY_SIZE},
-      {PI_DEVICE_INFO_NATIVE_VECTOR_WIDTH_CHAR,
-       UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_CHAR},
-      {PI_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_CHAR,
-       UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_CHAR},
-      {PI_DEVICE_INFO_NATIVE_VECTOR_WIDTH_SHORT,
-       UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_SHORT},
-      {PI_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_SHORT,
-       UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_SHORT},
-      {PI_DEVICE_INFO_NATIVE_VECTOR_WIDTH_INT,
-       UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_INT},
-      {PI_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_INT,
-       UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_INT},
-      {PI_DEVICE_INFO_NATIVE_VECTOR_WIDTH_LONG,
-       UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_LONG},
-      {PI_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_LONG,
-       UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_LONG},
-      {PI_DEVICE_INFO_NATIVE_VECTOR_WIDTH_FLOAT,
-       UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_FLOAT},
-      {PI_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_FLOAT,
-       UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_FLOAT},
-      {PI_DEVICE_INFO_NATIVE_VECTOR_WIDTH_DOUBLE,
-       UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_DOUBLE},
-      {PI_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_DOUBLE,
-       UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_DOUBLE},
-      {PI_DEVICE_INFO_NATIVE_VECTOR_WIDTH_HALF,
-       UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_HALF},
-      {PI_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_HALF,
-       UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_HALF},
-      {PI_DEVICE_INFO_MAX_NUM_SUB_GROUPS, UR_DEVICE_INFO_MAX_NUM_SUB_GROUPS},
-      {PI_DEVICE_INFO_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS,
-       UR_DEVICE_INFO_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS},
-      {PI_DEVICE_INFO_SUB_GROUP_SIZES_INTEL,
-       UR_DEVICE_INFO_SUB_GROUP_SIZES_INTEL},
-      {PI_DEVICE_INFO_IL_VERSION, UR_DEVICE_INFO_IL_VERSION},
-      {PI_DEVICE_INFO_USM_HOST_SUPPORT, UR_DEVICE_INFO_USM_HOST_SUPPORT},
-      {PI_DEVICE_INFO_USM_DEVICE_SUPPORT, UR_DEVICE_INFO_USM_DEVICE_SUPPORT},
-      {PI_DEVICE_INFO_USM_SINGLE_SHARED_SUPPORT,
-       UR_DEVICE_INFO_USM_SINGLE_SHARED_SUPPORT},
-      {PI_DEVICE_INFO_USM_CROSS_SHARED_SUPPORT,
-       UR_DEVICE_INFO_USM_CROSS_SHARED_SUPPORT},
-      {PI_DEVICE_INFO_USM_SYSTEM_SHARED_SUPPORT,
-       UR_DEVICE_INFO_USM_SYSTEM_SHARED_SUPPORT},
-      {PI_DEVICE_INFO_USM_HOST_SUPPORT, UR_DEVICE_INFO_USM_HOST_SUPPORT},
-      {PI_DEVICE_INFO_USM_DEVICE_SUPPORT, UR_DEVICE_INFO_USM_DEVICE_SUPPORT},
-      {PI_DEVICE_INFO_USM_SINGLE_SHARED_SUPPORT,
-       UR_DEVICE_INFO_USM_SINGLE_SHARED_SUPPORT},
-      {PI_DEVICE_INFO_USM_CROSS_SHARED_SUPPORT,
-       UR_DEVICE_INFO_USM_CROSS_SHARED_SUPPORT},
-      {PI_DEVICE_INFO_USM_SYSTEM_SHARED_SUPPORT,
-       UR_DEVICE_INFO_USM_SYSTEM_SHARED_SUPPORT},
-      {PI_DEVICE_INFO_PCI_ADDRESS, UR_DEVICE_INFO_PCI_ADDRESS},
-      {PI_DEVICE_INFO_GPU_EU_COUNT, UR_DEVICE_INFO_GPU_EU_COUNT},
-      {PI_DEVICE_INFO_GPU_EU_SIMD_WIDTH, UR_DEVICE_INFO_GPU_EU_SIMD_WIDTH},
-      {PI_DEVICE_INFO_GPU_SUBSLICES_PER_SLICE,
-       UR_DEVICE_INFO_GPU_SUBSLICES_PER_SLICE},
-      {PI_DEVICE_INFO_BUILD_ON_SUBDEVICE,
-       (ur_device_info_t)UR_EXT_DEVICE_INFO_BUILD_ON_SUBDEVICE},
-      {PI_EXT_ONEAPI_DEVICE_INFO_MAX_WORK_GROUPS_3D,
-       (ur_device_info_t)UR_EXT_DEVICE_INFO_MAX_WORK_GROUPS_3D},
-      {PI_DEVICE_INFO_IMAGE_MAX_ARRAY_SIZE,
-       (ur_device_info_t)UR_DEVICE_INFO_IMAGE_MAX_ARRAY_SIZE},
-      {PI_DEVICE_INFO_DEVICE_ID, (ur_device_info_t)UR_DEVICE_INFO_DEVICE_ID},
-      {PI_EXT_INTEL_DEVICE_INFO_FREE_MEMORY,
-       (ur_device_info_t)UR_EXT_DEVICE_INFO_FREE_MEMORY},
-      {PI_EXT_INTEL_DEVICE_INFO_MEMORY_CLOCK_RATE,
-       (ur_device_info_t)UR_DEVICE_INFO_MEMORY_CLOCK_RATE},
-      {PI_EXT_INTEL_DEVICE_INFO_MEMORY_BUS_WIDTH,
-       (ur_device_info_t)UR_EXT_DEVICE_INFO_MEMORY_BUS_WIDTH},
-      {PI_EXT_INTEL_DEVICE_INFO_MAX_COMPUTE_QUEUE_INDICES,
-       (ur_device_info_t)UR_DEVICE_INFO_MAX_COMPUTE_QUEUE_INDICES},
-      {PI_DEVICE_INFO_GPU_SLICES,
-       (ur_device_info_t)UR_EXT_DEVICE_INFO_GPU_SLICES},
-      {PI_DEVICE_INFO_GPU_EU_COUNT_PER_SUBSLICE,
-       (ur_device_info_t)UR_EXT_DEVICE_INFO_GPU_EU_COUNT_PER_SUBSLICE},
-      {PI_DEVICE_INFO_GPU_HW_THREADS_PER_EU,
-       (ur_device_info_t)UR_EXT_DEVICE_INFO_GPU_HW_THREADS_PER_EU},
-      {PI_DEVICE_INFO_MAX_MEM_BANDWIDTH,
-       (ur_device_info_t)UR_EXT_DEVICE_INFO_MAX_MEM_BANDWIDTH},
-      {PI_EXT_ONEAPI_DEVICE_INFO_BFLOAT16_MATH_FUNCTIONS,
-       (ur_device_info_t)UR_DEVICE_INFO_BFLOAT16},
-      {PI_EXT_DEVICE_INFO_ATOMIC_MEMORY_ORDER_CAPABILITIES,
-       (ur_device_info_t)UR_DEVICE_INFO_ATOMIC_MEMORY_ORDER_CAPABILITIES},
-      {PI_EXT_DEVICE_INFO_ATOMIC_MEMORY_SCOPE_CAPABILITIES,
-       (ur_device_info_t)UR_DEVICE_INFO_ATOMIC_MEMORY_SCOPE_CAPABILITIES},
-      {PI_EXT_DEVICE_INFO_ATOMIC_FENCE_ORDER_CAPABILITIES,
-       (ur_device_info_t)UR_DEVICE_INFO_ATOMIC_FENCE_ORDER_CAPABILITIES},
-      {PI_EXT_DEVICE_INFO_ATOMIC_FENCE_SCOPE_CAPABILITIES,
-       (ur_device_info_t)UR_DEVICE_INFO_ATOMIC_FENCE_SCOPE_CAPABILITIES},
-  };
-
-  auto InfoType = InfoMapping.find(ParamName);
-  if (InfoType == InfoMapping.end()) {
+  ur_device_info_t InfoType;
+  switch (ParamName) {
+  case PI_DEVICE_INFO_TYPE:
+    InfoType = UR_DEVICE_INFO_TYPE;
+    break;
+  case PI_DEVICE_INFO_PARENT_DEVICE:
+    InfoType = UR_DEVICE_INFO_PARENT_DEVICE;
+    break;
+  case PI_DEVICE_INFO_PLATFORM:
+    InfoType = UR_DEVICE_INFO_PLATFORM;
+    break;
+  case PI_DEVICE_INFO_VENDOR_ID:
+    InfoType = UR_DEVICE_INFO_VENDOR_ID;
+    break;
+  case PI_DEVICE_INFO_UUID:
+    InfoType = UR_DEVICE_INFO_UUID;
+    break;
+  case PI_DEVICE_INFO_ATOMIC_64:
+    InfoType = UR_DEVICE_INFO_ATOMIC_64;
+    break;
+  case PI_DEVICE_INFO_EXTENSIONS:
+    InfoType = UR_DEVICE_INFO_EXTENSIONS;
+    break;
+  case PI_DEVICE_INFO_NAME:
+    InfoType = UR_DEVICE_INFO_NAME;
+    break;
+  case PI_DEVICE_INFO_COMPILER_AVAILABLE:
+    InfoType = UR_DEVICE_INFO_COMPILER_AVAILABLE;
+    break;
+  case PI_DEVICE_INFO_LINKER_AVAILABLE:
+    InfoType = UR_DEVICE_INFO_LINKER_AVAILABLE;
+    break;
+  case PI_DEVICE_INFO_MAX_COMPUTE_UNITS:
+    InfoType = UR_DEVICE_INFO_MAX_COMPUTE_UNITS;
+    break;
+  case PI_DEVICE_INFO_MAX_WORK_ITEM_DIMENSIONS:
+    InfoType = UR_DEVICE_INFO_MAX_WORK_ITEM_DIMENSIONS;
+    break;
+  case PI_DEVICE_INFO_MAX_WORK_GROUP_SIZE:
+    InfoType = UR_DEVICE_INFO_MAX_WORK_GROUP_SIZE;
+    break;
+  case PI_DEVICE_INFO_MAX_WORK_ITEM_SIZES:
+    InfoType = UR_DEVICE_INFO_MAX_WORK_ITEM_SIZES;
+    break;
+  case PI_DEVICE_INFO_MAX_CLOCK_FREQUENCY:
+    InfoType = UR_DEVICE_INFO_MAX_CLOCK_FREQUENCY;
+    break;
+  case PI_DEVICE_INFO_ADDRESS_BITS:
+    InfoType = UR_DEVICE_INFO_ADDRESS_BITS;
+    break;
+  case PI_DEVICE_INFO_MAX_MEM_ALLOC_SIZE:
+    InfoType = UR_DEVICE_INFO_MAX_MEM_ALLOC_SIZE;
+    break;
+  case PI_DEVICE_INFO_GLOBAL_MEM_SIZE:
+    InfoType = UR_DEVICE_INFO_GLOBAL_MEM_SIZE;
+    break;
+  case PI_DEVICE_INFO_LOCAL_MEM_SIZE:
+    InfoType = UR_DEVICE_INFO_LOCAL_MEM_SIZE;
+    break;
+  case PI_DEVICE_INFO_IMAGE_SUPPORT:
+    InfoType = UR_DEVICE_INFO_IMAGE_SUPPORTED;
+    break;
+  case PI_DEVICE_INFO_HOST_UNIFIED_MEMORY:
+    InfoType = UR_DEVICE_INFO_HOST_UNIFIED_MEMORY;
+    break;
+  case PI_DEVICE_INFO_AVAILABLE:
+    InfoType = UR_DEVICE_INFO_AVAILABLE;
+    break;
+  case PI_DEVICE_INFO_VENDOR:
+    InfoType = UR_DEVICE_INFO_VENDOR;
+    break;
+  case PI_DEVICE_INFO_DRIVER_VERSION:
+    InfoType = UR_DEVICE_INFO_DRIVER_VERSION;
+    break;
+  case PI_DEVICE_INFO_VERSION:
+    InfoType = UR_DEVICE_INFO_VERSION;
+    break;
+  case PI_DEVICE_INFO_PARTITION_MAX_SUB_DEVICES:
+    InfoType = UR_DEVICE_INFO_PARTITION_MAX_SUB_DEVICES;
+    break;
+  case PI_DEVICE_INFO_REFERENCE_COUNT:
+    InfoType = UR_DEVICE_INFO_REFERENCE_COUNT;
+    break;
+  case PI_DEVICE_INFO_PARTITION_PROPERTIES:
+    InfoType = UR_DEVICE_INFO_PARTITION_PROPERTIES;
+    break;
+  case PI_DEVICE_INFO_PARTITION_AFFINITY_DOMAIN:
+    InfoType = UR_DEVICE_INFO_PARTITION_AFFINITY_DOMAIN;
+    break;
+  case PI_DEVICE_INFO_PARTITION_TYPE:
+    InfoType = UR_DEVICE_INFO_PARTITION_TYPE;
+    break;
+  case PI_DEVICE_INFO_OPENCL_C_VERSION:
+    InfoType = UR_EXT_DEVICE_INFO_OPENCL_C_VERSION;
+    break;
+  case PI_DEVICE_INFO_PREFERRED_INTEROP_USER_SYNC:
+    InfoType = UR_DEVICE_INFO_PREFERRED_INTEROP_USER_SYNC;
+    break;
+  case PI_DEVICE_INFO_PRINTF_BUFFER_SIZE:
+    InfoType = UR_DEVICE_INFO_PRINTF_BUFFER_SIZE;
+    break;
+  case PI_DEVICE_INFO_PROFILE:
+    InfoType = UR_DEVICE_INFO_PROFILE;
+    break;
+  case PI_DEVICE_INFO_BUILT_IN_KERNELS:
+    InfoType = UR_DEVICE_INFO_BUILT_IN_KERNELS;
+    break;
+  case PI_DEVICE_INFO_QUEUE_PROPERTIES:
+    InfoType = UR_DEVICE_INFO_QUEUE_PROPERTIES;
+    break;
+  case PI_DEVICE_INFO_EXECUTION_CAPABILITIES:
+    InfoType = UR_DEVICE_INFO_EXECUTION_CAPABILITIES;
+    break;
+  case PI_DEVICE_INFO_ENDIAN_LITTLE:
+    InfoType = UR_DEVICE_INFO_ENDIAN_LITTLE;
+    break;
+  case PI_DEVICE_INFO_ERROR_CORRECTION_SUPPORT:
+    InfoType = UR_DEVICE_INFO_ERROR_CORRECTION_SUPPORT;
+    break;
+  case PI_DEVICE_INFO_PROFILING_TIMER_RESOLUTION:
+    InfoType = UR_DEVICE_INFO_PROFILING_TIMER_RESOLUTION;
+    break;
+  case PI_DEVICE_INFO_LOCAL_MEM_TYPE:
+    InfoType = UR_DEVICE_INFO_LOCAL_MEM_TYPE;
+    break;
+  case PI_DEVICE_INFO_MAX_CONSTANT_ARGS:
+    InfoType = UR_DEVICE_INFO_MAX_CONSTANT_ARGS;
+    break;
+  case PI_DEVICE_INFO_MAX_CONSTANT_BUFFER_SIZE:
+    InfoType = UR_DEVICE_INFO_MAX_CONSTANT_BUFFER_SIZE;
+    break;
+  case PI_DEVICE_INFO_GLOBAL_MEM_CACHE_TYPE:
+    InfoType = UR_DEVICE_INFO_GLOBAL_MEM_CACHE_TYPE;
+    break;
+  case PI_DEVICE_INFO_GLOBAL_MEM_CACHELINE_SIZE:
+    InfoType = UR_DEVICE_INFO_GLOBAL_MEM_CACHELINE_SIZE;
+    break;
+  case PI_DEVICE_INFO_GLOBAL_MEM_CACHE_SIZE:
+    InfoType = UR_DEVICE_INFO_GLOBAL_MEM_CACHE_SIZE;
+    break;
+  case PI_DEVICE_INFO_MAX_PARAMETER_SIZE:
+    InfoType = UR_DEVICE_INFO_MAX_PARAMETER_SIZE;
+    break;
+  case PI_DEVICE_INFO_MEM_BASE_ADDR_ALIGN:
+    InfoType = UR_DEVICE_INFO_MEM_BASE_ADDR_ALIGN;
+    break;
+  case PI_DEVICE_INFO_MAX_SAMPLERS:
+    InfoType = UR_DEVICE_INFO_MAX_SAMPLERS;
+    break;
+  case PI_DEVICE_INFO_MAX_READ_IMAGE_ARGS:
+    InfoType = UR_DEVICE_INFO_MAX_READ_IMAGE_ARGS;
+    break;
+  case PI_DEVICE_INFO_MAX_WRITE_IMAGE_ARGS:
+    InfoType = UR_DEVICE_INFO_MAX_WRITE_IMAGE_ARGS;
+    break;
+  case PI_DEVICE_INFO_SINGLE_FP_CONFIG:
+    InfoType = UR_DEVICE_INFO_SINGLE_FP_CONFIG;
+    break;
+  case PI_DEVICE_INFO_HALF_FP_CONFIG:
+    InfoType = UR_DEVICE_INFO_HALF_FP_CONFIG;
+    break;
+  case PI_DEVICE_INFO_DOUBLE_FP_CONFIG:
+    InfoType = UR_DEVICE_INFO_DOUBLE_FP_CONFIG;
+    break;
+  case PI_DEVICE_INFO_IMAGE2D_MAX_WIDTH:
+    InfoType = UR_DEVICE_INFO_IMAGE2D_MAX_WIDTH;
+    break;
+  case PI_DEVICE_INFO_IMAGE2D_MAX_HEIGHT:
+    InfoType = UR_DEVICE_INFO_IMAGE2D_MAX_HEIGHT;
+    break;
+  case PI_DEVICE_INFO_IMAGE3D_MAX_WIDTH:
+    InfoType = UR_DEVICE_INFO_IMAGE3D_MAX_WIDTH;
+    break;
+  case PI_DEVICE_INFO_IMAGE3D_MAX_HEIGHT:
+    InfoType = UR_DEVICE_INFO_IMAGE3D_MAX_HEIGHT;
+    break;
+  case PI_DEVICE_INFO_IMAGE3D_MAX_DEPTH:
+    InfoType = UR_DEVICE_INFO_IMAGE3D_MAX_DEPTH;
+    break;
+  case PI_DEVICE_INFO_IMAGE_MAX_BUFFER_SIZE:
+    InfoType = UR_DEVICE_INFO_IMAGE_MAX_BUFFER_SIZE;
+    break;
+  case PI_DEVICE_INFO_NATIVE_VECTOR_WIDTH_CHAR:
+    InfoType = UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_CHAR;
+    break;
+  case PI_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_CHAR:
+    InfoType = UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_CHAR;
+    break;
+  case PI_DEVICE_INFO_NATIVE_VECTOR_WIDTH_SHORT:
+    InfoType = UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_SHORT;
+    break;
+  case PI_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_SHORT:
+    InfoType = UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_SHORT;
+    break;
+  case PI_DEVICE_INFO_NATIVE_VECTOR_WIDTH_INT:
+    InfoType = UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_INT;
+    break;
+  case PI_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_INT:
+    InfoType = UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_INT;
+    break;
+  case PI_DEVICE_INFO_NATIVE_VECTOR_WIDTH_LONG:
+    InfoType = UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_LONG;
+    break;
+  case PI_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_LONG:
+    InfoType = UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_LONG;
+    break;
+  case PI_DEVICE_INFO_NATIVE_VECTOR_WIDTH_FLOAT:
+    InfoType = UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_FLOAT;
+    break;
+  case PI_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_FLOAT:
+    InfoType = UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_FLOAT;
+    break;
+  case PI_DEVICE_INFO_NATIVE_VECTOR_WIDTH_DOUBLE:
+    InfoType = UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_DOUBLE;
+    break;
+  case PI_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_DOUBLE:
+    InfoType = UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_DOUBLE;
+    break;
+  case PI_DEVICE_INFO_NATIVE_VECTOR_WIDTH_HALF:
+    InfoType = UR_DEVICE_INFO_NATIVE_VECTOR_WIDTH_HALF;
+    break;
+  case PI_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_HALF:
+    InfoType = UR_DEVICE_INFO_PREFERRED_VECTOR_WIDTH_HALF;
+    break;
+  case PI_DEVICE_INFO_MAX_NUM_SUB_GROUPS:
+    InfoType = UR_DEVICE_INFO_MAX_NUM_SUB_GROUPS;
+    break;
+  case PI_DEVICE_INFO_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS:
+    InfoType = UR_DEVICE_INFO_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS;
+    break;
+  case PI_DEVICE_INFO_SUB_GROUP_SIZES_INTEL:
+    InfoType = UR_DEVICE_INFO_SUB_GROUP_SIZES_INTEL;
+    break;
+  case PI_DEVICE_INFO_IL_VERSION:
+    InfoType = UR_DEVICE_INFO_IL_VERSION;
+    break;
+  case PI_DEVICE_INFO_USM_HOST_SUPPORT:
+    InfoType = UR_DEVICE_INFO_USM_HOST_SUPPORT;
+    break;
+  case PI_DEVICE_INFO_USM_DEVICE_SUPPORT:
+    InfoType = UR_DEVICE_INFO_USM_DEVICE_SUPPORT;
+    break;
+  case PI_DEVICE_INFO_USM_SINGLE_SHARED_SUPPORT:
+    InfoType = UR_DEVICE_INFO_USM_SINGLE_SHARED_SUPPORT;
+    break;
+  case PI_DEVICE_INFO_USM_CROSS_SHARED_SUPPORT:
+    InfoType = UR_DEVICE_INFO_USM_CROSS_SHARED_SUPPORT;
+    break;
+  case PI_DEVICE_INFO_USM_SYSTEM_SHARED_SUPPORT:
+    InfoType = UR_DEVICE_INFO_USM_SYSTEM_SHARED_SUPPORT;
+    break;
+  case PI_DEVICE_INFO_PCI_ADDRESS:
+    InfoType = UR_DEVICE_INFO_PCI_ADDRESS;
+    break;
+  case PI_DEVICE_INFO_GPU_EU_COUNT:
+    InfoType = UR_DEVICE_INFO_GPU_EU_COUNT;
+    break;
+  case PI_DEVICE_INFO_GPU_EU_SIMD_WIDTH:
+    InfoType = UR_DEVICE_INFO_GPU_EU_SIMD_WIDTH;
+    break;
+  case PI_DEVICE_INFO_GPU_SUBSLICES_PER_SLICE:
+    InfoType = UR_DEVICE_INFO_GPU_SUBSLICES_PER_SLICE;
+    break;
+  case PI_DEVICE_INFO_BUILD_ON_SUBDEVICE:
+    InfoType = (ur_device_info_t)UR_EXT_DEVICE_INFO_BUILD_ON_SUBDEVICE;
+    break;
+  case PI_EXT_ONEAPI_DEVICE_INFO_MAX_WORK_GROUPS_3D:
+    InfoType = (ur_device_info_t)UR_EXT_DEVICE_INFO_MAX_WORK_GROUPS_3D;
+    break;
+  case PI_DEVICE_INFO_IMAGE_MAX_ARRAY_SIZE:
+    InfoType = (ur_device_info_t)UR_DEVICE_INFO_IMAGE_MAX_ARRAY_SIZE;
+    break;
+  case PI_DEVICE_INFO_DEVICE_ID:
+    InfoType = (ur_device_info_t)UR_DEVICE_INFO_DEVICE_ID;
+    break;
+  case PI_EXT_INTEL_DEVICE_INFO_FREE_MEMORY:
+    InfoType = (ur_device_info_t)UR_EXT_DEVICE_INFO_FREE_MEMORY;
+    break;
+  case PI_EXT_INTEL_DEVICE_INFO_MEMORY_CLOCK_RATE:
+    InfoType = (ur_device_info_t)UR_DEVICE_INFO_MEMORY_CLOCK_RATE;
+    break;
+  case PI_EXT_INTEL_DEVICE_INFO_MEMORY_BUS_WIDTH:
+    InfoType = (ur_device_info_t)UR_EXT_DEVICE_INFO_MEMORY_BUS_WIDTH;
+    break;
+  case PI_EXT_INTEL_DEVICE_INFO_MAX_COMPUTE_QUEUE_INDICES:
+    InfoType = (ur_device_info_t)UR_DEVICE_INFO_MAX_COMPUTE_QUEUE_INDICES;
+    break;
+  case PI_DEVICE_INFO_GPU_SLICES:
+    InfoType = (ur_device_info_t)UR_EXT_DEVICE_INFO_GPU_SLICES;
+    break;
+  case PI_DEVICE_INFO_GPU_EU_COUNT_PER_SUBSLICE:
+    InfoType = (ur_device_info_t)UR_EXT_DEVICE_INFO_GPU_EU_COUNT_PER_SUBSLICE;
+    break;
+  case PI_DEVICE_INFO_GPU_HW_THREADS_PER_EU:
+    InfoType = (ur_device_info_t)UR_EXT_DEVICE_INFO_GPU_HW_THREADS_PER_EU;
+    break;
+  case PI_DEVICE_INFO_MAX_MEM_BANDWIDTH:
+    InfoType = (ur_device_info_t)UR_EXT_DEVICE_INFO_MAX_MEM_BANDWIDTH;
+    break;
+  case PI_EXT_ONEAPI_DEVICE_INFO_BFLOAT16_MATH_FUNCTIONS:
+    InfoType = (ur_device_info_t)UR_DEVICE_INFO_BFLOAT16;
+    break;
+  case PI_EXT_DEVICE_INFO_ATOMIC_MEMORY_ORDER_CAPABILITIES:
+    InfoType =
+        (ur_device_info_t)UR_DEVICE_INFO_ATOMIC_MEMORY_ORDER_CAPABILITIES;
+    break;
+  case PI_EXT_DEVICE_INFO_ATOMIC_MEMORY_SCOPE_CAPABILITIES:
+    InfoType =
+        (ur_device_info_t)UR_DEVICE_INFO_ATOMIC_MEMORY_SCOPE_CAPABILITIES;
+    break;
+  case PI_EXT_DEVICE_INFO_ATOMIC_FENCE_ORDER_CAPABILITIES:
+    InfoType = (ur_device_info_t)UR_DEVICE_INFO_ATOMIC_FENCE_ORDER_CAPABILITIES;
+    break;
+  case PI_EXT_DEVICE_INFO_ATOMIC_FENCE_SCOPE_CAPABILITIES:
+    InfoType = (ur_device_info_t)UR_DEVICE_INFO_ATOMIC_FENCE_SCOPE_CAPABILITIES;
+    break;
+  default:
     return PI_ERROR_UNKNOWN;
-  }
+  };
 
   size_t SizeInOut = ParamValueSize;
   auto hDevice = reinterpret_cast<ur_device_handle_t>(Device);
-  HANDLE_ERRORS(urDeviceGetInfo(hDevice, InfoType->second, SizeInOut,
-                                ParamValue, ParamValueSizeRet));
+  HANDLE_ERRORS(urDeviceGetInfo(hDevice, InfoType, SizeInOut, ParamValue,
+                                ParamValueSizeRet));
 
-  ur2piInfoValue(InfoType->second, ParamValueSize, &SizeInOut, ParamValue);
+  ur2piInfoValue(InfoType, ParamValueSize, &SizeInOut, ParamValue);
 
   return PI_SUCCESS;
 }
@@ -543,38 +750,37 @@ inline pi_result piDevicePartition(
   if (!Properties || !Properties[0])
     return PI_ERROR_INVALID_VALUE;
 
-  static std::unordered_map<pi_device_partition_property,
-                            ur_device_partition_property_t>
-      PropertyMap = {
-          {PI_DEVICE_PARTITION_EQUALLY, UR_DEVICE_PARTITION_EQUALLY},
-          {PI_DEVICE_PARTITION_BY_COUNTS, UR_DEVICE_PARTITION_BY_COUNTS},
-          {PI_DEVICE_PARTITION_BY_AFFINITY_DOMAIN,
-           UR_DEVICE_PARTITION_BY_AFFINITY_DOMAIN},
-          {PI_EXT_INTEL_DEVICE_PARTITION_BY_CSLICE,
-           UR_DEVICE_PARTITION_BY_CSLICE},
-      };
-
-  auto PropertyIt = PropertyMap.find(Properties[0]);
-  if (PropertyIt == PropertyMap.end()) {
+  ur_device_partition_property_t Property;
+  switch (Properties[0]) {
+  case PI_DEVICE_PARTITION_EQUALLY:
+    Property = UR_DEVICE_PARTITION_EQUALLY;
+    break;
+  case PI_DEVICE_PARTITION_BY_COUNTS:
+    Property = UR_DEVICE_PARTITION_BY_COUNTS;
+    break;
+  case PI_DEVICE_PARTITION_BY_AFFINITY_DOMAIN:
+    Property = UR_DEVICE_PARTITION_BY_AFFINITY_DOMAIN;
+    break;
+  case PI_EXT_INTEL_DEVICE_PARTITION_BY_CSLICE:
+    Property = UR_DEVICE_PARTITION_BY_CSLICE;
+    break;
+  default:
     return PI_ERROR_UNKNOWN;
   }
 
   // Some partitioning types require a value
   auto Value = uint32_t(Properties[1]);
-  if (PropertyIt->second == UR_DEVICE_PARTITION_BY_AFFINITY_DOMAIN) {
-    static std::unordered_map<pi_device_affinity_domain,
-                              ur_device_affinity_domain_flag_t>
-        ValueMap = {
-            {PI_DEVICE_AFFINITY_DOMAIN_NUMA,
-             UR_DEVICE_AFFINITY_DOMAIN_FLAG_NUMA},
-            {PI_DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE,
-             UR_DEVICE_AFFINITY_DOMAIN_FLAG_NEXT_PARTITIONABLE},
-        };
-    auto ValueIt = ValueMap.find(Properties[1]);
-    if (ValueIt == ValueMap.end()) {
+  if (Property == UR_DEVICE_PARTITION_BY_AFFINITY_DOMAIN) {
+    switch (Properties[1]) {
+    case PI_DEVICE_AFFINITY_DOMAIN_NUMA:
+      Value = UR_DEVICE_AFFINITY_DOMAIN_FLAG_NUMA;
+      break;
+    case PI_DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE:
+      Value = UR_DEVICE_AFFINITY_DOMAIN_FLAG_NEXT_PARTITIONABLE;
+      break;
+    default:
       return PI_ERROR_UNKNOWN;
     }
-    Value = ValueIt->second;
   }
 
   // Translate partitioning properties from PI-way
@@ -585,7 +791,7 @@ inline pi_result piDevicePartition(
   // https://github.com/oneapi-src/unified-runtime/issues/183
   //
   ur_device_partition_property_t UrProperties[] = {
-      ur_device_partition_property_t(PropertyIt->second), Value, 0};
+      ur_device_partition_property_t(Property), Value, 0};
 
   auto hDevice = reinterpret_cast<ur_device_handle_t>(Device);
   auto phSubDevices = reinterpret_cast<ur_device_handle_t *>(SubDevices);