Improvements to align CTS and Spec for Device:

- Rework urDeviceGetInfoTest to move all enums to their own tests instead of a switch case - #2290
- Remove the UR/OpenCL Device enum map function - no point maintaining both a switch case and a separate mapping function
- Update some spec wording for consistency
- Add missing Device info enums to OpenCL adapater
- Add new urDevicePartition test for checking UR_DEVICE_INFO_PARENT_DEVICE
- Move UUR_RETURN_ON_FATAL_FAILURE and UUR_ASSERT_SUCCESS_OR_UNSUPPORTED to join similar macros in checks.h

Author: martygrant

include/ur_api.h

@@ -1976,7 +1976,7 @@ typedef enum ur_device_info_t {
   /// [uint64_t] max memory allocation size
   UR_DEVICE_INFO_MAX_MEM_ALLOC_SIZE = 28,
   /// [::ur_bool_t] images are supported
-  UR_DEVICE_INFO_IMAGE_SUPPORTED = 29,
+  UR_DEVICE_INFO_IMAGE_SUPPORT = 29,
   /// [uint32_t] max number of image objects arguments of a kernel declared
   /// with the read_only qualifier
   UR_DEVICE_INFO_MAX_READ_IMAGE_ARGS = 30,
@@ -2089,9 +2089,8 @@ typedef enum ur_device_info_t {
   /// If the device does not support any affinity domains, then 0 will be
   /// returned.
   UR_DEVICE_INFO_PARTITION_AFFINITY_DOMAIN = 78,
-  /// [::ur_device_partition_property_t[]] return an array of
-  /// ::ur_device_partition_property_t for properties specified in
-  /// ::urDevicePartition
+  /// [::ur_device_partition_property_t[]] returns an array of properties
+  /// specified in ::urDevicePartition
   UR_DEVICE_INFO_PARTITION_TYPE = 79,
   /// [uint32_t] max number of sub groups
   UR_DEVICE_INFO_MAX_NUM_SUB_GROUPS = 80,
@@ -2172,7 +2171,7 @@ typedef enum ur_device_info_t {
   UR_DEVICE_INFO_MEM_CHANNEL_SUPPORT = 110,
   /// [::ur_bool_t] Return true if the device supports enqueueing commands
   /// to read and write pipes from the host.
-  UR_DEVICE_INFO_HOST_PIPE_READ_WRITE_SUPPORTED = 111,
+  UR_DEVICE_INFO_HOST_PIPE_READ_WRITE_SUPPORT = 111,
   /// [uint32_t][optional-query] The maximum number of registers available
   /// per block.
   UR_DEVICE_INFO_MAX_REGISTERS_PER_WORK_GROUP = 112,
@@ -2211,7 +2210,7 @@ typedef enum ur_device_info_t {
   /// for command synchronization outside of a command-buffer.
   UR_DEVICE_INFO_COMMAND_BUFFER_EVENT_SUPPORT_EXP = 0x1002,
   /// [::ur_bool_t] return true if enqueue Cluster Launch is supported
-  UR_DEVICE_INFO_CLUSTER_LAUNCH_EXP = 0x1111,
+  UR_DEVICE_INFO_CLUSTER_LAUNCH_SUPPORT_EXP = 0x1111,
   /// [::ur_bool_t] returns true if the device supports the creation of
   /// bindless images
   UR_DEVICE_INFO_BINDLESS_IMAGES_SUPPORT_EXP = 0x2000,
@@ -2260,40 +2259,40 @@ typedef enum ur_device_info_t {
   /// [::ur_bool_t] returns true if the device supports sampling cubemapped
   /// images across face boundaries
   UR_DEVICE_INFO_CUBEMAP_SEAMLESS_FILTERING_SUPPORT_EXP = 0x2011,
-  /// [::ur_bool_t] returns true if the device is capable of fetching USM
+  /// [::ur_bool_t] returns true if the device supports fetching USM backed
+  /// 1D sampled image data.
+  UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_USM_SUPPORT_EXP = 0x2012,
+  /// [::ur_bool_t] returns true if the device supports fetching non-USM
   /// backed 1D sampled image data.
-  UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_USM_EXP = 0x2012,
-  /// [::ur_bool_t] returns true if the device is capable of fetching
-  /// non-USM backed 1D sampled image data.
-  UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_EXP = 0x2013,
-  /// [::ur_bool_t] returns true if the device is capable of fetching USM
+  UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_SUPPORT_EXP = 0x2013,
+  /// [::ur_bool_t] returns true if the device supports fetching USM backed
+  /// 2D sampled image data.
+  UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_USM_SUPPORT_EXP = 0x2014,
+  /// [::ur_bool_t] returns true if the device supports fetching non-USM
   /// backed 2D sampled image data.
-  UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_USM_EXP = 0x2014,
-  /// [::ur_bool_t] returns true if the device is capable of fetching
-  /// non-USM backed 2D sampled image data.
-  UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_EXP = 0x2015,
-  /// [::ur_bool_t] returns true if the device is capable of fetching
-  /// non-USM backed 3D sampled image data.
-  UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_3D_EXP = 0x2017,
+  UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_SUPPORT_EXP = 0x2015,
+  /// [::ur_bool_t] returns true if the device supports fetching non-USM
+  /// backed 3D sampled image data.
+  UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_3D_SUPPORT_EXP = 0x2017,
   /// [::ur_bool_t] returns true if the device supports timestamp recording
   UR_DEVICE_INFO_TIMESTAMP_RECORDING_SUPPORT_EXP = 0x2018,
   /// [::ur_bool_t] returns true if the device supports allocating and
   /// accessing image array resources.
   UR_DEVICE_INFO_IMAGE_ARRAY_SUPPORT_EXP = 0x2019,
   /// [::ur_bool_t] returns true if the device supports unique addressing
   /// per dimension.
-  UR_DEVICE_INFO_BINDLESS_UNIQUE_ADDRESSING_PER_DIM_EXP = 0x201A,
-  /// [::ur_bool_t] returns true if the device is capable of sampling USM
-  /// backed 1D sampled image data.
-  UR_DEVICE_INFO_BINDLESS_SAMPLE_1D_USM_EXP = 0x201B,
-  /// [::ur_bool_t] returns true if the device is capable of sampling USM
-  /// backed 2D sampled image data.
-  UR_DEVICE_INFO_BINDLESS_SAMPLE_2D_USM_EXP = 0x201C,
+  UR_DEVICE_INFO_BINDLESS_UNIQUE_ADDRESSING_PER_DIM_SUPPORT_EXP = 0x201A,
+  /// [::ur_bool_t] returns true if the device supports sampling USM backed
+  /// 1D sampled image data.
+  UR_DEVICE_INFO_BINDLESS_SAMPLE_1D_USM_SUPPORT_EXP = 0x201B,
+  /// [::ur_bool_t] returns true if the device supports sampling USM backed
+  /// 2D sampled image data.
+  UR_DEVICE_INFO_BINDLESS_SAMPLE_2D_USM_SUPPORT_EXP = 0x201C,
   /// [::ur_bool_t] returns true if the device supports enqueueing of native
   /// work
   UR_DEVICE_INFO_ENQUEUE_NATIVE_COMMAND_SUPPORT_EXP = 0x2020,
   /// [::ur_bool_t] returns true if the device supports low-power events.
-  UR_DEVICE_INFO_LOW_POWER_EVENTS_EXP = 0x2021,
+  UR_DEVICE_INFO_LOW_POWER_EVENTS_SUPPORT_EXP = 0x2021,
   /// [::ur_exp_device_2d_block_array_capability_flags_t] return a bit-field
   /// of Intel GPU 2D block array capabilities
   UR_DEVICE_INFO_2D_BLOCK_ARRAY_CAPABILITIES_EXP = 0x2022,
@@ -6647,7 +6646,7 @@ typedef enum ur_queue_flag_t {
   /// implementation may use interrupt-driven events. May reduce CPU
   /// utilization at the cost of increased event completion latency. Other
   /// platforms may ignore this flag.
-  UR_QUEUE_FLAG_LOW_POWER_EVENTS_EXP = UR_BIT(11),
+  UR_QUEUE_FLAG_LOW_POWER_EVENTS_SUPPORT_EXP = UR_BIT(11),
   /// @cond
   UR_QUEUE_FLAG_FORCE_UINT32 = 0x7fffffff
   /// @endcond
@@ -11805,10 +11804,10 @@ UR_APIEXPORT ur_result_t UR_APICALL urUSMReleaseExp(
 typedef enum ur_exp_peer_info_t {
   /// [int] 1 if P2P access is supported otherwise P2P access is not
   /// supported.
-  UR_EXP_PEER_INFO_UR_PEER_ACCESS_SUPPORTED = 0,
+  UR_EXP_PEER_INFO_UR_PEER_ACCESS_SUPPORT = 0,
   /// [int] 1 if atomic operations are supported over the P2P link,
   /// otherwise such operations are not supported.
-  UR_EXP_PEER_INFO_UR_PEER_ATOMICS_SUPPORTED = 1,
+  UR_EXP_PEER_INFO_UR_PEER_ATOMICS_SUPPORT = 1,
   /// @cond
   UR_EXP_PEER_INFO_FORCE_UINT32 = 0x7fffffff
   /// @endcond
@@ -11918,7 +11917,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urUsmP2PDisablePeerAccessExp(
 ///         + `NULL == commandDevice`
 ///         + `NULL == peerDevice`
 ///     - ::UR_RESULT_ERROR_INVALID_ENUMERATION
-///         + `::UR_EXP_PEER_INFO_UR_PEER_ATOMICS_SUPPORTED < propName`
+///         + `::UR_EXP_PEER_INFO_UR_PEER_ATOMICS_SUPPORT < propName`
 ///     - ::UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION
 ///         + If `propName` is not supported by the adapter.
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE

include/ur_print.hpp

@@ -2644,8 +2644,8 @@ inline std::ostream &operator<<(std::ostream &os, enum ur_device_info_t value) {
   case UR_DEVICE_INFO_MAX_MEM_ALLOC_SIZE:
     os << "UR_DEVICE_INFO_MAX_MEM_ALLOC_SIZE";
     break;
-  case UR_DEVICE_INFO_IMAGE_SUPPORTED:
-    os << "UR_DEVICE_INFO_IMAGE_SUPPORTED";
+  case UR_DEVICE_INFO_IMAGE_SUPPORT:
+    os << "UR_DEVICE_INFO_IMAGE_SUPPORT";
     break;
   case UR_DEVICE_INFO_MAX_READ_IMAGE_ARGS:
     os << "UR_DEVICE_INFO_MAX_READ_IMAGE_ARGS";
@@ -2890,8 +2890,8 @@ inline std::ostream &operator<<(std::ostream &os, enum ur_device_info_t value) {
   case UR_DEVICE_INFO_MEM_CHANNEL_SUPPORT:
     os << "UR_DEVICE_INFO_MEM_CHANNEL_SUPPORT";
     break;
-  case UR_DEVICE_INFO_HOST_PIPE_READ_WRITE_SUPPORTED:
-    os << "UR_DEVICE_INFO_HOST_PIPE_READ_WRITE_SUPPORTED";
+  case UR_DEVICE_INFO_HOST_PIPE_READ_WRITE_SUPPORT:
+    os << "UR_DEVICE_INFO_HOST_PIPE_READ_WRITE_SUPPORT";
     break;
   case UR_DEVICE_INFO_MAX_REGISTERS_PER_WORK_GROUP:
     os << "UR_DEVICE_INFO_MAX_REGISTERS_PER_WORK_GROUP";
@@ -2929,8 +2929,8 @@ inline std::ostream &operator<<(std::ostream &os, enum ur_device_info_t value) {
   case UR_DEVICE_INFO_COMMAND_BUFFER_EVENT_SUPPORT_EXP:
     os << "UR_DEVICE_INFO_COMMAND_BUFFER_EVENT_SUPPORT_EXP";
     break;
-  case UR_DEVICE_INFO_CLUSTER_LAUNCH_EXP:
-    os << "UR_DEVICE_INFO_CLUSTER_LAUNCH_EXP";
+  case UR_DEVICE_INFO_CLUSTER_LAUNCH_SUPPORT_EXP:
+    os << "UR_DEVICE_INFO_CLUSTER_LAUNCH_SUPPORT_EXP";
     break;
   case UR_DEVICE_INFO_BINDLESS_IMAGES_SUPPORT_EXP:
     os << "UR_DEVICE_INFO_BINDLESS_IMAGES_SUPPORT_EXP";
@@ -2980,41 +2980,41 @@ inline std::ostream &operator<<(std::ostream &os, enum ur_device_info_t value) {
   case UR_DEVICE_INFO_CUBEMAP_SEAMLESS_FILTERING_SUPPORT_EXP:
     os << "UR_DEVICE_INFO_CUBEMAP_SEAMLESS_FILTERING_SUPPORT_EXP";
     break;
-  case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_USM_EXP:
-    os << "UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_USM_EXP";
+  case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_USM_SUPPORT_EXP:
+    os << "UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_USM_SUPPORT_EXP";
     break;
-  case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_EXP:
-    os << "UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_EXP";
+  case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_SUPPORT_EXP:
+    os << "UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_SUPPORT_EXP";
     break;
-  case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_USM_EXP:
-    os << "UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_USM_EXP";
+  case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_USM_SUPPORT_EXP:
+    os << "UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_USM_SUPPORT_EXP";
     break;
-  case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_EXP:
-    os << "UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_EXP";
+  case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_SUPPORT_EXP:
+    os << "UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_SUPPORT_EXP";
     break;
-  case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_3D_EXP:
-    os << "UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_3D_EXP";
+  case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_3D_SUPPORT_EXP:
+    os << "UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_3D_SUPPORT_EXP";
     break;
   case UR_DEVICE_INFO_TIMESTAMP_RECORDING_SUPPORT_EXP:
     os << "UR_DEVICE_INFO_TIMESTAMP_RECORDING_SUPPORT_EXP";
     break;
   case UR_DEVICE_INFO_IMAGE_ARRAY_SUPPORT_EXP:
     os << "UR_DEVICE_INFO_IMAGE_ARRAY_SUPPORT_EXP";
     break;
-  case UR_DEVICE_INFO_BINDLESS_UNIQUE_ADDRESSING_PER_DIM_EXP:
-    os << "UR_DEVICE_INFO_BINDLESS_UNIQUE_ADDRESSING_PER_DIM_EXP";
+  case UR_DEVICE_INFO_BINDLESS_UNIQUE_ADDRESSING_PER_DIM_SUPPORT_EXP:
+    os << "UR_DEVICE_INFO_BINDLESS_UNIQUE_ADDRESSING_PER_DIM_SUPPORT_EXP";
     break;
-  case UR_DEVICE_INFO_BINDLESS_SAMPLE_1D_USM_EXP:
-    os << "UR_DEVICE_INFO_BINDLESS_SAMPLE_1D_USM_EXP";
+  case UR_DEVICE_INFO_BINDLESS_SAMPLE_1D_USM_SUPPORT_EXP:
+    os << "UR_DEVICE_INFO_BINDLESS_SAMPLE_1D_USM_SUPPORT_EXP";
     break;
-  case UR_DEVICE_INFO_BINDLESS_SAMPLE_2D_USM_EXP:
-    os << "UR_DEVICE_INFO_BINDLESS_SAMPLE_2D_USM_EXP";
+  case UR_DEVICE_INFO_BINDLESS_SAMPLE_2D_USM_SUPPORT_EXP:
+    os << "UR_DEVICE_INFO_BINDLESS_SAMPLE_2D_USM_SUPPORT_EXP";
     break;
   case UR_DEVICE_INFO_ENQUEUE_NATIVE_COMMAND_SUPPORT_EXP:
     os << "UR_DEVICE_INFO_ENQUEUE_NATIVE_COMMAND_SUPPORT_EXP";
     break;
-  case UR_DEVICE_INFO_LOW_POWER_EVENTS_EXP:
-    os << "UR_DEVICE_INFO_LOW_POWER_EVENTS_EXP";
+  case UR_DEVICE_INFO_LOW_POWER_EVENTS_SUPPORT_EXP:
+    os << "UR_DEVICE_INFO_LOW_POWER_EVENTS_SUPPORT_EXP";
     break;
   case UR_DEVICE_INFO_2D_BLOCK_ARRAY_CAPABILITIES_EXP:
     os << "UR_DEVICE_INFO_2D_BLOCK_ARRAY_CAPABILITIES_EXP";
@@ -3417,7 +3417,7 @@ inline ur_result_t printTagged(std::ostream &os, const void *ptr,
 
     os << ")";
   } break;
-  case UR_DEVICE_INFO_IMAGE_SUPPORTED: {
+  case UR_DEVICE_INFO_IMAGE_SUPPORT: {
     const ur_bool_t *tptr = (const ur_bool_t *)ptr;
     if (sizeof(ur_bool_t) > size) {
       os << "invalid size (is: " << size
@@ -4433,7 +4433,7 @@ inline ur_result_t printTagged(std::ostream &os, const void *ptr,
 
     os << ")";
   } break;
-  case UR_DEVICE_INFO_HOST_PIPE_READ_WRITE_SUPPORTED: {
+  case UR_DEVICE_INFO_HOST_PIPE_READ_WRITE_SUPPORT: {
     const ur_bool_t *tptr = (const ur_bool_t *)ptr;
     if (sizeof(ur_bool_t) > size) {
       os << "invalid size (is: " << size
@@ -4605,7 +4605,7 @@ inline ur_result_t printTagged(std::ostream &os, const void *ptr,
 
     os << ")";
   } break;
-  case UR_DEVICE_INFO_CLUSTER_LAUNCH_EXP: {
+  case UR_DEVICE_INFO_CLUSTER_LAUNCH_SUPPORT_EXP: {
     const ur_bool_t *tptr = (const ur_bool_t *)ptr;
     if (sizeof(ur_bool_t) > size) {
       os << "invalid size (is: " << size
@@ -4826,7 +4826,7 @@ inline ur_result_t printTagged(std::ostream &os, const void *ptr,
 
     os << ")";
   } break;
-  case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_USM_EXP: {
+  case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_USM_SUPPORT_EXP: {
     const ur_bool_t *tptr = (const ur_bool_t *)ptr;
     if (sizeof(ur_bool_t) > size) {
       os << "invalid size (is: " << size
@@ -4839,7 +4839,7 @@ inline ur_result_t printTagged(std::ostream &os, const void *ptr,
 
     os << ")";
   } break;
-  case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_EXP: {
+  case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_SUPPORT_EXP: {
     const ur_bool_t *tptr = (const ur_bool_t *)ptr;
     if (sizeof(ur_bool_t) > size) {
       os << "invalid size (is: " << size
@@ -4852,7 +4852,7 @@ inline ur_result_t printTagged(std::ostream &os, const void *ptr,
 
     os << ")";
   } break;
-  case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_USM_EXP: {
+  case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_USM_SUPPORT_EXP: {
     const ur_bool_t *tptr = (const ur_bool_t *)ptr;
     if (sizeof(ur_bool_t) > size) {
       os << "invalid size (is: " << size
@@ -4865,7 +4865,7 @@ inline ur_result_t printTagged(std::ostream &os, const void *ptr,
 
     os << ")";
   } break;
-  case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_EXP: {
+  case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_SUPPORT_EXP: {
     const ur_bool_t *tptr = (const ur_bool_t *)ptr;
     if (sizeof(ur_bool_t) > size) {
       os << "invalid size (is: " << size
@@ -4878,7 +4878,7 @@ inline ur_result_t printTagged(std::ostream &os, const void *ptr,
 
     os << ")";
   } break;
-  case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_3D_EXP: {
+  case UR_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_3D_SUPPORT_EXP: {
     const ur_bool_t *tptr = (const ur_bool_t *)ptr;
     if (sizeof(ur_bool_t) > size) {
       os << "invalid size (is: " << size
@@ -4917,7 +4917,7 @@ inline ur_result_t printTagged(std::ostream &os, const void *ptr,
 
     os << ")";
   } break;
-  case UR_DEVICE_INFO_BINDLESS_UNIQUE_ADDRESSING_PER_DIM_EXP: {
+  case UR_DEVICE_INFO_BINDLESS_UNIQUE_ADDRESSING_PER_DIM_SUPPORT_EXP: {
     const ur_bool_t *tptr = (const ur_bool_t *)ptr;
     if (sizeof(ur_bool_t) > size) {
       os << "invalid size (is: " << size
@@ -4930,7 +4930,7 @@ inline ur_result_t printTagged(std::ostream &os, const void *ptr,
 
     os << ")";
   } break;
-  case UR_DEVICE_INFO_BINDLESS_SAMPLE_1D_USM_EXP: {
+  case UR_DEVICE_INFO_BINDLESS_SAMPLE_1D_USM_SUPPORT_EXP: {
     const ur_bool_t *tptr = (const ur_bool_t *)ptr;
     if (sizeof(ur_bool_t) > size) {
       os << "invalid size (is: " << size
@@ -4943,7 +4943,7 @@ inline ur_result_t printTagged(std::ostream &os, const void *ptr,
 
     os << ")";
   } break;
-  case UR_DEVICE_INFO_BINDLESS_SAMPLE_2D_USM_EXP: {
+  case UR_DEVICE_INFO_BINDLESS_SAMPLE_2D_USM_SUPPORT_EXP: {
     const ur_bool_t *tptr = (const ur_bool_t *)ptr;
     if (sizeof(ur_bool_t) > size) {
       os << "invalid size (is: " << size
@@ -4969,7 +4969,7 @@ inline ur_result_t printTagged(std::ostream &os, const void *ptr,
 
     os << ")";
   } break;
-  case UR_DEVICE_INFO_LOW_POWER_EVENTS_EXP: {
+  case UR_DEVICE_INFO_LOW_POWER_EVENTS_SUPPORT_EXP: {
     const ur_bool_t *tptr = (const ur_bool_t *)ptr;
     if (sizeof(ur_bool_t) > size) {
       os << "invalid size (is: " << size
@@ -9524,8 +9524,8 @@ inline std::ostream &operator<<(std::ostream &os, enum ur_queue_flag_t value) {
   case UR_QUEUE_FLAG_SYNC_WITH_DEFAULT_STREAM:
     os << "UR_QUEUE_FLAG_SYNC_WITH_DEFAULT_STREAM";
     break;
-  case UR_QUEUE_FLAG_LOW_POWER_EVENTS_EXP:
-    os << "UR_QUEUE_FLAG_LOW_POWER_EVENTS_EXP";
+  case UR_QUEUE_FLAG_LOW_POWER_EVENTS_SUPPORT_EXP:
+    os << "UR_QUEUE_FLAG_LOW_POWER_EVENTS_SUPPORT_EXP";
     break;
   default:
     os << "unknown enumerator";
@@ -9662,15 +9662,15 @@ inline ur_result_t printFlag<ur_queue_flag_t>(std::ostream &os, uint32_t flag) {
     os << UR_QUEUE_FLAG_SYNC_WITH_DEFAULT_STREAM;
   }
 
-  if ((val & UR_QUEUE_FLAG_LOW_POWER_EVENTS_EXP) ==
-      (uint32_t)UR_QUEUE_FLAG_LOW_POWER_EVENTS_EXP) {
-    val ^= (uint32_t)UR_QUEUE_FLAG_LOW_POWER_EVENTS_EXP;
+  if ((val & UR_QUEUE_FLAG_LOW_POWER_EVENTS_SUPPORT_EXP) ==
+      (uint32_t)UR_QUEUE_FLAG_LOW_POWER_EVENTS_SUPPORT_EXP) {
+    val ^= (uint32_t)UR_QUEUE_FLAG_LOW_POWER_EVENTS_SUPPORT_EXP;
     if (!first) {
       os << " | ";
     } else {
       first = false;
     }
-    os << UR_QUEUE_FLAG_LOW_POWER_EVENTS_EXP;
+    os << UR_QUEUE_FLAG_LOW_POWER_EVENTS_SUPPORT_EXP;
   }
   if (val != 0) {
     std::bitset<32> bits(val);
@@ -11373,11 +11373,11 @@ inline std::ostream &operator<<(std::ostream &os,
 inline std::ostream &operator<<(std::ostream &os,
                                 enum ur_exp_peer_info_t value) {
   switch (value) {
-  case UR_EXP_PEER_INFO_UR_PEER_ACCESS_SUPPORTED:
-    os << "UR_EXP_PEER_INFO_UR_PEER_ACCESS_SUPPORTED";
+  case UR_EXP_PEER_INFO_UR_PEER_ACCESS_SUPPORT:
+    os << "UR_EXP_PEER_INFO_UR_PEER_ACCESS_SUPPORT";
     break;
-  case UR_EXP_PEER_INFO_UR_PEER_ATOMICS_SUPPORTED:
-    os << "UR_EXP_PEER_INFO_UR_PEER_ATOMICS_SUPPORTED";
+  case UR_EXP_PEER_INFO_UR_PEER_ATOMICS_SUPPORT:
+    os << "UR_EXP_PEER_INFO_UR_PEER_ATOMICS_SUPPORT";
     break;
   default:
     os << "unknown enumerator";
@@ -11396,7 +11396,7 @@ inline ur_result_t printTagged(std::ostream &os, const void *ptr,
   }
 
   switch (value) {
-  case UR_EXP_PEER_INFO_UR_PEER_ACCESS_SUPPORTED: {
+  case UR_EXP_PEER_INFO_UR_PEER_ACCESS_SUPPORT: {
     const int *tptr = (const int *)ptr;
     if (sizeof(int) > size) {
       os << "invalid size (is: " << size << ", expected: >=" << sizeof(int)
@@ -11409,7 +11409,7 @@ inline ur_result_t printTagged(std::ostream &os, const void *ptr,
 
     os << ")";
   } break;
-  case UR_EXP_PEER_INFO_UR_PEER_ATOMICS_SUPPORTED: {
+  case UR_EXP_PEER_INFO_UR_PEER_ATOMICS_SUPPORT: {
     const int *tptr = (const int *)ptr;
     if (sizeof(int) > size) {
       os << "invalid size (is: " << size << ", expected: >=" << sizeof(int)