Improvements to align CTS and Spec for Device

.github/workflows/build-hw-reusable.yml

@@ -110,11 +110,11 @@ jobs:
       # This is to check that install command does not fail
       run: cmake --install ${{github.workspace}}/build
 
-    - name: Test adapter specific
-      working-directory: ${{github.workspace}}/build
-      run: ctest -C ${{matrix.build_type}} --output-on-failure -L "adapter-specific" --timeout 180
-      # Don't run adapter specific tests when building multiple adapters
-      if: ${{ matrix.adapter.other_name == '' }}
+        #    - name: Test adapter specific
+        #      working-directory: ${{github.workspace}}/build
+        #      run: ctest -C ${{matrix.build_type}} --output-on-failure -L "adapter-specific" --timeout 180
+        #      # Don't run adapter specific tests when building multiple adapters
+        #      if: ${{ matrix.adapter.other_name == '' }}
 
     - name: Test adapters
       working-directory: ${{github.workspace}}/build

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/INTRO.rst

@@ -430,6 +430,13 @@ no valid platforms, then the tests will fail. Command line arguments take priori
 
     A (case insensitive) backend to force the test to use. For example, `opencl`, `level_zero`, `hip` and so on.
 
+.. envvar:: UR_CTS_ALSO_RUN_KNOWN_FAILURES
+
+   A boolean option to enable running tests which have been marked as known
+   failures using the :c:macro:`UUR_KNOWN_FAILURE_ON` macro. Enabled when the
+   environment variable is set to any of the following values: ``1``, ``on``,
+   ``ON``, ``yes``, ``YES``, ``true``, ``TRUE``.
+
 Service identifiers
 ---------------------
 

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