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 enum map function - no point maintaining both a switch case and a separate mapping function
- Update some spec wording for consistency
- Add missing 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

include/ur_print.hpp

@@ -2366,8 +2366,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";
@@ -2612,8 +2612,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";
@@ -2648,8 +2648,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";
@@ -2699,41 +2699,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";
@@ -3108,7 +3108,7 @@ inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_device_info
 
         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 << ", expected: >=" << sizeof(ur_bool_t) << ")";
@@ -4048,7 +4048,7 @@ inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_device_info
 
         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 << ", expected: >=" << sizeof(ur_bool_t) << ")";
@@ -4197,7 +4197,7 @@ inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_device_info
 
         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 << ", expected: >=" << sizeof(ur_bool_t) << ")";
@@ -4401,7 +4401,7 @@ inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_device_info
 
         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 << ", expected: >=" << sizeof(ur_bool_t) << ")";
@@ -4413,7 +4413,7 @@ inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_device_info
 
         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 << ", expected: >=" << sizeof(ur_bool_t) << ")";
@@ -4425,7 +4425,7 @@ inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_device_info
 
         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 << ", expected: >=" << sizeof(ur_bool_t) << ")";
@@ -4437,7 +4437,7 @@ inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_device_info
 
         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 << ", expected: >=" << sizeof(ur_bool_t) << ")";
@@ -4449,7 +4449,7 @@ inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_device_info
 
         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 << ", expected: >=" << sizeof(ur_bool_t) << ")";
@@ -4485,7 +4485,7 @@ inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_device_info
 
         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 << ", expected: >=" << sizeof(ur_bool_t) << ")";
@@ -4497,7 +4497,7 @@ inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_device_info
 
         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 << ", expected: >=" << sizeof(ur_bool_t) << ")";
@@ -4509,7 +4509,7 @@ inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_device_info
 
         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 << ", expected: >=" << sizeof(ur_bool_t) << ")";
@@ -4533,7 +4533,7 @@ inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_device_info
 
         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 << ", expected: >=" << sizeof(ur_bool_t) << ")";
@@ -10649,11 +10649,11 @@ inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_launch_pro
 ///     std::ostream &
 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";
@@ -10671,7 +10671,7 @@ inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_exp_peer_in
     }
 
     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) << ")";
@@ -10683,7 +10683,7 @@ inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_exp_peer_in
 
         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) << ")";

scripts/core/EXP-BINDLESS-IMAGES.rst

@@ -90,15 +90,15 @@ Enums
     * ${X}_DEVICE_INFO_EXTERNAL_SEMAPHORE_IMPORT_SUPPORT_EXP
     * ${X}_DEVICE_INFO_CUBEMAP_SUPPORT_EXP
     * ${X}_DEVICE_INFO_CUBEMAP_SEAMLESS_FILTERING_SUPPORT_EXP
-    * ${X}_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_USM_EXP
-    * ${X}_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_EXP
-    * ${X}_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_USM_EXP
-    * ${X}_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_EXP
-    * ${X}_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_3D_EXP
+    * ${X}_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_USM_SUPPORT_EXP
+    * ${X}_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_1D_SUPPORT_EXP
+    * ${X}_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_USM_SUPPORT_EXP
+    * ${X}_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_2D_SUPPORT_EXP
+    * ${X}_DEVICE_INFO_BINDLESS_SAMPLED_IMAGE_FETCH_3D_SUPPORT_EXP
     * ${X}_DEVICE_INFO_IMAGE_ARRAY_SUPPORT_EXP
-    * ${X}_DEVICE_INFO_BINDLESS_UNIQUE_ADDRESSING_PER_DIM_EXP
-    * ${X}_DEVICE_INFO_BINDLESS_SAMPLE_1D_USM_EXP
-    * ${X}_DEVICE_INFO_BINDLESS_SAMPLE_2D_USM_EXP
+    * ${X}_DEVICE_INFO_BINDLESS_UNIQUE_ADDRESSING_PER_DIM_SUPPORT_EXP
+    * ${X}_DEVICE_INFO_BINDLESS_SAMPLE_1D_USM_SUPPORT_EXP
+    * ${X}_DEVICE_INFO_BINDLESS_SAMPLE_2D_USM_SUPPORT_EXP
 
 * ${x}_command_t
     * ${X}_COMMAND_EXTERNAL_SEMAPHORE_WAIT_EXP

scripts/core/EXP-LOW-POWER-EVENTS.rst

@@ -47,7 +47,7 @@ Enums
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 * ${x}_device_info_t
-    * ${X}_DEVICE_INFO_LOW_POWER_EVENTS_EXP
+    * ${X}_DEVICE_INFO_LOW_POWER_EVENTS_SUPPORT_EXP
 * ${x}_queue_flags_t
     * ${X}_QUEUE_FLAG_LOW_POWER_EVENTS_EXP
 * ${x}_exp_enqueue_ext_flags_t
@@ -78,7 +78,7 @@ Support
 --------------------------------------------------------------------------------
 
 Adapters which support this experimental feature *must* return true for the new
-``${X}_DEVICE_INFO_LOW_POWER_EVENTS_EXP`` device info query.
+``${X}_DEVICE_INFO_LOW_POWER_EVENTS_SUPPORT_EXP`` device info query.
 
 
 Contributors

scripts/core/device.yml

@@ -253,7 +253,7 @@ etors:
       desc: "[uint32_t] address bits"
     - name: MAX_MEM_ALLOC_SIZE
       desc: "[uint64_t] max memory allocation size"
-    - name: IMAGE_SUPPORTED
+    - name: IMAGE_SUPPORT
       desc: "[$x_bool_t] images are supported"
     - name: MAX_READ_IMAGE_ARGS
       desc: "[uint32_t] max number of image objects arguments of a kernel declared with the read_only qualifier"
@@ -359,7 +359,7 @@ etors:
             [$x_device_affinity_domain_flags_t] Returns a bit-field of the supported affinity domains for partitioning.
             If the device does not support any affinity domains, then 0 will be returned.
     - name: PARTITION_TYPE
-      desc: "[$x_device_partition_property_t[]] return an array of $x_device_partition_property_t for properties specified in $xDevicePartition"
+      desc: "[$x_device_partition_property_t[]] returns an array of properties specified in $xDevicePartition"
     - name: MAX_NUM_SUB_GROUPS
       desc: "[uint32_t] max number of sub groups"
     - name: SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS
@@ -425,7 +425,7 @@ etors:
       desc: "[$x_bool_t] return true if Async Barrier is supported"
     - name: MEM_CHANNEL_SUPPORT
       desc: "[$x_bool_t] return true if specifying memory channels is supported"
-    - name: HOST_PIPE_READ_WRITE_SUPPORTED
+    - name: HOST_PIPE_READ_WRITE_SUPPORT
       desc: "[$x_bool_t] Return true if the device supports enqueueing commands to read and write pipes from the host."
     - name: MAX_REGISTERS_PER_WORK_GROUP
       desc: "[uint32_t][optional-query] The maximum number of registers available per block."

scripts/core/exp-bindless-images.yml

@@ -86,33 +86,33 @@ etors:
     - name: CUBEMAP_SEAMLESS_FILTERING_SUPPORT_EXP
       value: "0x2011"
       desc: "[$x_bool_t] returns true if the device supports sampling cubemapped images across face boundaries"
-    - name: BINDLESS_SAMPLED_IMAGE_FETCH_1D_USM_EXP
+    - name: BINDLESS_SAMPLED_IMAGE_FETCH_1D_USM_SUPPORT_EXP
       value: "0x2012"
-      desc: "[$x_bool_t] returns true if the device is capable of fetching USM backed 1D sampled image data."
-    - name: BINDLESS_SAMPLED_IMAGE_FETCH_1D_EXP
+      desc: "[$x_bool_t] returns true if the device supports fetching USM backed 1D sampled image data."
+    - name: BINDLESS_SAMPLED_IMAGE_FETCH_1D_SUPPORT_EXP
       value: "0x2013"
-      desc: "[$x_bool_t] returns true if the device is capable of fetching non-USM backed 1D sampled image data."
-    - name: BINDLESS_SAMPLED_IMAGE_FETCH_2D_USM_EXP
+      desc: "[$x_bool_t] returns true if the device supports fetching non-USM backed 1D sampled image data."
+    - name: BINDLESS_SAMPLED_IMAGE_FETCH_2D_USM_SUPPORT_EXP
       value: "0x2014"
-      desc: "[$x_bool_t] returns true if the device is capable of fetching USM backed 2D sampled image data."
-    - name: BINDLESS_SAMPLED_IMAGE_FETCH_2D_EXP
+      desc: "[$x_bool_t] returns true if the device supports fetching USM backed 2D sampled image data."
+    - name: BINDLESS_SAMPLED_IMAGE_FETCH_2D_SUPPORT_EXP
       value: "0x2015"
-      desc: "[$x_bool_t] returns true if the device is capable of fetching non-USM backed 2D sampled image data."
-    - name: BINDLESS_SAMPLED_IMAGE_FETCH_3D_EXP
+      desc: "[$x_bool_t] returns true if the device supports fetching non-USM backed 2D sampled image data."
+    - name: BINDLESS_SAMPLED_IMAGE_FETCH_3D_SUPPORT_EXP
       value: "0x2017"
-      desc: "[$x_bool_t] returns true if the device is capable of fetching non-USM backed 3D sampled image data."
+      desc: "[$x_bool_t] returns true if the device supports fetching non-USM backed 3D sampled image data."
     - name: IMAGE_ARRAY_SUPPORT_EXP
       value: "0x2019"
       desc: "[$x_bool_t] returns true if the device supports allocating and accessing image array resources."
-    - name: BINDLESS_UNIQUE_ADDRESSING_PER_DIM_EXP
+    - name: BINDLESS_UNIQUE_ADDRESSING_PER_DIM_SUPPORT_EXP
       value: "0x201A"
       desc: "[$x_bool_t] returns true if the device supports unique addressing per dimension."
-    - name: BINDLESS_SAMPLE_1D_USM_EXP
+    - name: BINDLESS_SAMPLE_1D_USM_SUPPORT_EXP
       value: "0x201B"
-      desc: "[$x_bool_t] returns true if the device is capable of sampling USM backed 1D sampled image data."
-    - name: BINDLESS_SAMPLE_2D_USM_EXP
+      desc: "[$x_bool_t] returns true if the device supports sampling USM backed 1D sampled image data."
+    - name: BINDLESS_SAMPLE_2D_USM_SUPPORT_EXP
       value: "0x201C"
-      desc: "[$x_bool_t] returns true if the device is capable of sampling USM backed 2D sampled image data."
+      desc: "[$x_bool_t] returns true if the device supports sampling USM backed 2D sampled image data."
 --- #--------------------------------------------------------------------------
 type: enum
 extend: true

scripts/core/exp-launch-properties.yml

@@ -144,6 +144,6 @@ typed_etors: true
 desc: "Extension enums to $x_device_info_t to support arch specific launch properties."
 name: $x_device_info_t
 etors:
-    - name: CLUSTER_LAUNCH_EXP
+    - name: CLUSTER_LAUNCH_SUPPORT_EXP
       value: "0x1111"
       desc: "[$x_bool_t] return true if enqueue Cluster Launch is supported"

scripts/core/exp-low-power-events.yml

@@ -19,7 +19,7 @@ typed_etors: true
 desc: "Extension enums to $x_device_info_t to support low-power events."
 name: $x_device_info_t
 etors:
-    - name: LOW_POWER_EVENTS_EXP
+    - name: LOW_POWER_EVENTS_SUPPORT_EXP
       value: "0x2021"
       desc: "[$x_bool_t] returns true if the device supports low-power events."
 

scripts/core/exp-usm-p2p.yml

@@ -23,9 +23,9 @@ class: $xUsmP2P
 name: $x_exp_peer_info_t
 typed_etors: True
 etors:
-    - name: UR_PEER_ACCESS_SUPPORTED
+    - name: UR_PEER_ACCESS_SUPPORT
       desc: "[int] 1 if P2P access is supported otherwise P2P access is not supported."
-    - name: UR_PEER_ATOMICS_SUPPORTED
+    - name: UR_PEER_ATOMICS_SUPPORT
       desc: "[int] 1 if atomic operations are supported over the P2P link, otherwise such operations are not supported."
 --- #--------------------------------------------------------------------------
 type: function