Update generated files from new script.

Signed-off-by: JackAKirk <[email protected]>

Author: JackAKirk

include/ur_api.h

@@ -8938,63 +8938,65 @@ urEnqueueTimestampRecordingExp(
 #if !defined(__GNUC__)
 #pragma endregion
 #endif
-// Intel 'oneAPI' Unified Runtime Experimental APIs for (kernel) Launch Attributes
+// Intel 'oneAPI' Unified Runtime Experimental APIs for (kernel) Launch Properties
 #if !defined(__GNUC__)
 #pragma region launch attributes(experimental)
 #endif
 ///////////////////////////////////////////////////////////////////////////////
-#ifndef UR_LAUNCH_ATTRIBUTES_EXTENSION_STRING_EXP
-/// @brief The extension string that defines support for the Launch Attributes
+#ifndef UR_LAUNCH_PROPERTIES_EXTENSION_STRING_EXP
+/// @brief The extension string that defines support for the Launch Properties
 ///        extension, which is returned when querying device extensions.
-#define UR_LAUNCH_ATTRIBUTES_EXTENSION_STRING_EXP "ur_exp_launch_attributes"
-#endif // UR_LAUNCH_ATTRIBUTES_EXTENSION_STRING_EXP
+#define UR_LAUNCH_PROPERTIES_EXTENSION_STRING_EXP "ur_exp_launch_properties"
+#endif // UR_LAUNCH_PROPERTIES_EXTENSION_STRING_EXP
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Specifies a launch attribute id
+/// @brief Specifies a launch property id
 ///
 /// @remarks
 ///   _Analogues_
 ///     - **CUlaunchAttributeID**
-typedef enum ur_exp_launch_attribute_id_t {
-    UR_EXP_LAUNCH_ATTRIBUTE_ID_IGNORE = 0,            ///< the attribute has no effect
-    UR_EXP_LAUNCH_ATTRIBUTE_ID_COOPERATIVE = 1,       ///< whether to launch a cooperative kernel
-    UR_EXP_LAUNCH_ATTRIBUTE_ID_CLUSTER_DIMENSION = 2, ///< cluster dimensions
+typedef enum ur_exp_launch_property_id_t {
+    UR_EXP_LAUNCH_PROPERTY_ID_IGNORE = 0,            ///< The property has no effect
+    UR_EXP_LAUNCH_PROPERTY_ID_COOPERATIVE = 1,       ///< Whether to launch a cooperative kernel
+    UR_EXP_LAUNCH_PROPERTY_ID_CLUSTER_DIMENSION = 2, ///< work-group cluster dimensions
     /// @cond
-    UR_EXP_LAUNCH_ATTRIBUTE_ID_FORCE_UINT32 = 0x7fffffff
+    UR_EXP_LAUNCH_PROPERTY_ID_FORCE_UINT32 = 0x7fffffff
     /// @endcond
 
-} ur_exp_launch_attribute_id_t;
+} ur_exp_launch_property_id_t;
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Specifies a launch attribute value
+/// @brief Specifies a launch property value
 ///
 /// @remarks
 ///   _Analogues_
 ///     - **CUlaunchAttributeValue**
-typedef union ur_exp_launch_attribute_value_t {
-    uint32_t clusterDim[3]; ///< [in] cluster dimensions (x, y, z)
+typedef union ur_exp_launch_property_value_t {
+    uint32_t clusterDim[3]; ///< [in] dimensions of the cluster (units of work-group) (x, y, z). Each
+                            ///< value must be a divisor of the corresponding global work-size
+                            ///< dimension (in units of work-group).
     int cooperative;        ///< [in] non-zero value indicates a cooperative kernel
 
-} ur_exp_launch_attribute_value_t;
+} ur_exp_launch_property_value_t;
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Kernel launch attribute
+/// @brief Kernel launch property
 ///
 /// @remarks
 ///   _Analogues_
 ///     - **cuLaunchAttribute**
-typedef struct ur_exp_launch_attribute_t {
-    ur_exp_launch_attribute_id_t id;       ///< [in] Launch attribute id
-    ur_exp_launch_attribute_value_t value; ///< [in][tagged_by(id)] Launch attribute value
+typedef struct ur_exp_launch_property_t {
+    ur_exp_launch_property_id_t id;       ///< [in] launch property id
+    ur_exp_launch_property_value_t value; ///< [in][tagged_by(id)] launch property value
 
-} ur_exp_launch_attribute_t;
+} ur_exp_launch_property_t;
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Launch kernel with custom Launch attributes
+/// @brief Launch kernel with custom launch properties
 ///
 /// @details
-///     - Launches the kernel using the specified launch attributes
-///     - If numAttrsInLaunchAttrList == 0 then a regular kernel launch is used:
+///     - Launches the kernel using the specified launch properties
+///     - If numPropsInLaunchPropList == 0 then a regular kernel launch is used:
 ///       `urEnqueueKernelLaunch`
 ///     - Consult the appropriate adapter driver documentation for details of
 ///       adapter specific behavior and native error codes that may be returned.
@@ -9015,9 +9017,9 @@ typedef struct ur_exp_launch_attribute_t {
 ///         + NULL == hKernel
 ///     - ::UR_RESULT_ERROR_INVALID_NULL_POINTER
 ///         + `NULL == pGlobalWorkSize`
-///         + `NULL == launchAttrList`
+///         + `NULL == launchPropList`
 ///         + NULL == pGlobalWorkSize
-///         + numAttrsInLaunchAttrList != 0 && launchAttrList == NULL
+///         + numPropsInLaunchpropList != 0 && launchPropList == NULL
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_UNINITIALIZED
 ///     - ::UR_RESULT_ERROR_DEVICE_LOST
@@ -9038,26 +9040,26 @@ typedef struct ur_exp_launch_attribute_t {
 ///     - ::UR_RESULT_ERROR_OUT_OF_RESOURCES
 UR_APIEXPORT ur_result_t UR_APICALL
 urEnqueueKernelLaunchCustomExp(
-    ur_queue_handle_t hQueue,                        ///< [in] handle of the queue object
-    ur_kernel_handle_t hKernel,                      ///< [in] handle of the kernel object
-    uint32_t workDim,                                ///< [in] number of dimensions, from 1 to 3, to specify the global and
-                                                     ///< work-group work-items
-    const size_t *pGlobalWorkSize,                   ///< [in] pointer to an array of workDim unsigned values that specify the
-                                                     ///< number of global work-items in workDim that will execute the kernel
-                                                     ///< function
-    const size_t *pLocalWorkSize,                    ///< [in][optional] pointer to an array of workDim unsigned values that
-                                                     ///< specify the number of local work-items forming a work-group that will
-                                                     ///< execute the kernel function. If nullptr, the runtime implementation
-                                                     ///< will choose the work-group size.
-    uint32_t numAttrsInLaunchAttrList,               ///< [in] size of the launch attr list
-    const ur_exp_launch_attribute_t *launchAttrList, ///< [in][range(0, numAttrsInLaunchAttrList)] pointer to a list of launch
-                                                     ///< attributes
-    uint32_t numEventsInWaitList,                    ///< [in] size of the event wait list
-    const ur_event_handle_t *phEventWaitList,        ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
-                                                     ///< events that must be complete before the kernel execution. If nullptr,
-                                                     ///< the numEventsInWaitList must be 0, indicating that no wait event.
-    ur_event_handle_t *phEvent                       ///< [out][optional] return an event object that identifies this particular
-                                                     ///< kernel execution instance.
+    ur_queue_handle_t hQueue,                       ///< [in] handle of the queue object
+    ur_kernel_handle_t hKernel,                     ///< [in] handle of the kernel object
+    uint32_t workDim,                               ///< [in] number of dimensions, from 1 to 3, to specify the global and
+                                                    ///< work-group work-items
+    const size_t *pGlobalWorkSize,                  ///< [in] pointer to an array of workDim unsigned values that specify the
+                                                    ///< number of global work-items in workDim that will execute the kernel
+                                                    ///< function
+    const size_t *pLocalWorkSize,                   ///< [in][optional] pointer to an array of workDim unsigned values that
+                                                    ///< specify the number of local work-items forming a work-group that will
+                                                    ///< execute the kernel function. If nullptr, the runtime implementation
+                                                    ///< will choose the work-group size.
+    uint32_t numPropsInLaunchPropList,              ///< [in] size of the launch prop list
+    const ur_exp_launch_property_t *launchPropList, ///< [in][range(0, numPropsInLaunchPropList)] pointer to a list of launch
+                                                    ///< properties
+    uint32_t numEventsInWaitList,                   ///< [in] size of the event wait list
+    const ur_event_handle_t *phEventWaitList,       ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
+                                                    ///< events that must be complete before the kernel execution. If nullptr,
+                                                    ///< the numEventsInWaitList must be 0, indicating that no wait event.
+    ur_event_handle_t *phEvent                      ///< [out][optional] return an event object that identifies this particular
+                                                    ///< kernel execution instance.
 );
 
 #if !defined(__GNUC__)
@@ -10764,8 +10766,8 @@ typedef struct ur_enqueue_kernel_launch_custom_exp_params_t {
     uint32_t *pworkDim;
     const size_t **ppGlobalWorkSize;
     const size_t **ppLocalWorkSize;
-    uint32_t *pnumAttrsInLaunchAttrList;
-    const ur_exp_launch_attribute_t **plaunchAttrList;
+    uint32_t *pnumPropsInLaunchPropList;
+    const ur_exp_launch_property_t **plaunchPropList;
     uint32_t *pnumEventsInWaitList;
     const ur_event_handle_t **pphEventWaitList;
     ur_event_handle_t **pphEvent;

include/ur_ddi.h

@@ -1444,7 +1444,7 @@ typedef ur_result_t(UR_APICALL *ur_pfnEnqueueKernelLaunchCustomExp_t)(
     const size_t *,
     const size_t *,
     uint32_t,
-    const ur_exp_launch_attribute_t *,
+    const ur_exp_launch_property_t *,
     uint32_t,
     const ur_event_handle_t *,
     ur_event_handle_t *);

include/ur_print.h

@@ -1003,20 +1003,20 @@ UR_APIEXPORT ur_result_t UR_APICALL urPrintExpCommandBufferUpdateValueArgDesc(co
 UR_APIEXPORT ur_result_t UR_APICALL urPrintExpCommandBufferUpdateKernelLaunchDesc(const struct ur_exp_command_buffer_update_kernel_launch_desc_t params, char *buffer, const size_t buff_size, size_t *out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_exp_launch_attribute_id_t enum
+/// @brief Print ur_exp_launch_property_id_t enum
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintExpLaunchAttributeId(enum ur_exp_launch_attribute_id_t value, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintExpLaunchPropertyId(enum ur_exp_launch_property_id_t value, char *buffer, const size_t buff_size, size_t *out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print ur_exp_launch_attribute_t struct
+/// @brief Print ur_exp_launch_property_t struct
 /// @returns
 ///     - ::UR_RESULT_SUCCESS
 ///     - ::UR_RESULT_ERROR_INVALID_SIZE
 ///         - `buff_size < out_size`
-UR_APIEXPORT ur_result_t UR_APICALL urPrintExpLaunchAttribute(const struct ur_exp_launch_attribute_t params, char *buffer, const size_t buff_size, size_t *out_size);
+UR_APIEXPORT ur_result_t UR_APICALL urPrintExpLaunchProperty(const struct ur_exp_launch_property_t params, char *buffer, const size_t buff_size, size_t *out_size);
 
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Print ur_exp_peer_info_t enum

include/ur_print.hpp

@@ -209,8 +209,8 @@ inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_exp_command
 
 inline ur_result_t printUnion(
     std::ostream &os,
-    const union ur_exp_launch_attribute_value_t params,
-    const enum ur_exp_launch_attribute_id_t tag);
+    const union ur_exp_launch_property_value_t params,
+    const enum ur_exp_launch_property_id_t tag);
 
 template <>
 inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_exp_peer_info_t value, size_t size);
@@ -340,8 +340,8 @@ inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_command_buffer_update_pointer_arg_desc_t params);
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_command_buffer_update_value_arg_desc_t params);
 inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_command_buffer_update_kernel_launch_desc_t params);
-inline std::ostream &operator<<(std::ostream &os, enum ur_exp_launch_attribute_id_t value);
-inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_launch_attribute_t params);
+inline std::ostream &operator<<(std::ostream &os, enum ur_exp_launch_property_id_t value);
+inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct ur_exp_launch_property_t params);
 inline std::ostream &operator<<(std::ostream &os, enum ur_exp_peer_info_t value);
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -9848,19 +9848,19 @@ inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_command_bu
     return os;
 }
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_exp_launch_attribute_id_t type
+/// @brief Print operator for the ur_exp_launch_property_id_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, enum ur_exp_launch_attribute_id_t value) {
+inline std::ostream &operator<<(std::ostream &os, enum ur_exp_launch_property_id_t value) {
     switch (value) {
-    case UR_EXP_LAUNCH_ATTRIBUTE_ID_IGNORE:
-        os << "UR_EXP_LAUNCH_ATTRIBUTE_ID_IGNORE";
+    case UR_EXP_LAUNCH_PROPERTY_ID_IGNORE:
+        os << "UR_EXP_LAUNCH_PROPERTY_ID_IGNORE";
         break;
-    case UR_EXP_LAUNCH_ATTRIBUTE_ID_COOPERATIVE:
-        os << "UR_EXP_LAUNCH_ATTRIBUTE_ID_COOPERATIVE";
+    case UR_EXP_LAUNCH_PROPERTY_ID_COOPERATIVE:
+        os << "UR_EXP_LAUNCH_PROPERTY_ID_COOPERATIVE";
         break;
-    case UR_EXP_LAUNCH_ATTRIBUTE_ID_CLUSTER_DIMENSION:
-        os << "UR_EXP_LAUNCH_ATTRIBUTE_ID_CLUSTER_DIMENSION";
+    case UR_EXP_LAUNCH_PROPERTY_ID_CLUSTER_DIMENSION:
+        os << "UR_EXP_LAUNCH_PROPERTY_ID_CLUSTER_DIMENSION";
         break;
     default:
         os << "unknown enumerator";
@@ -9871,15 +9871,15 @@ inline std::ostream &operator<<(std::ostream &os, enum ur_exp_launch_attribute_i
 namespace ur::details {
 
 ///////////////////////////////////////////////////////////////////////////////
-// @brief Print ur_exp_launch_attribute_value_t union
+// @brief Print ur_exp_launch_property_value_t union
 inline ur_result_t printUnion(
     std::ostream &os,
-    const union ur_exp_launch_attribute_value_t params,
-    const enum ur_exp_launch_attribute_id_t tag) {
-    os << "(union ur_exp_launch_attribute_value_t){";
+    const union ur_exp_launch_property_value_t params,
+    const enum ur_exp_launch_property_id_t tag) {
+    os << "(union ur_exp_launch_property_value_t){";
 
     switch (tag) {
-    case UR_EXP_LAUNCH_ATTRIBUTE_ID_CLUSTER_DIMENSION:
+    case UR_EXP_LAUNCH_PROPERTY_ID_CLUSTER_DIMENSION:
 
         os << ".clusterDim = {";
         for (auto i = 0; i < 3; i++) {
@@ -9892,7 +9892,7 @@ inline ur_result_t printUnion(
         os << "}";
 
         break;
-    case UR_EXP_LAUNCH_ATTRIBUTE_ID_COOPERATIVE:
+    case UR_EXP_LAUNCH_PROPERTY_ID_COOPERATIVE:
 
         os << ".cooperative = ";
 
@@ -9908,11 +9908,11 @@ inline ur_result_t printUnion(
 }
 } // namespace ur::details
 ///////////////////////////////////////////////////////////////////////////////
-/// @brief Print operator for the ur_exp_launch_attribute_t type
+/// @brief Print operator for the ur_exp_launch_property_t type
 /// @returns
 ///     std::ostream &
-inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_launch_attribute_t params) {
-    os << "(struct ur_exp_launch_attribute_t){";
+inline std::ostream &operator<<(std::ostream &os, const struct ur_exp_launch_property_t params) {
+    os << "(struct ur_exp_launch_property_t){";
 
     os << ".id = ";
 
@@ -14182,18 +14182,18 @@ inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const struct
                           *(params->ppLocalWorkSize));
 
     os << ", ";
-    os << ".numAttrsInLaunchAttrList = ";
+    os << ".numPropsInLaunchPropList = ";
 
-    os << *(params->pnumAttrsInLaunchAttrList);
+    os << *(params->pnumPropsInLaunchPropList);
 
     os << ", ";
-    os << ".launchAttrList = {";
-    for (size_t i = 0; *(params->plaunchAttrList) != NULL && i < *params->pnumAttrsInLaunchAttrList; ++i) {
+    os << ".launchPropList = {";
+    for (size_t i = 0; *(params->plaunchPropList) != NULL && i < *params->pnumPropsInLaunchPropList; ++i) {
         if (i != 0) {
             os << ", ";
         }
 
-        os << (*(params->plaunchAttrList))[i];
+        os << (*(params->plaunchPropList))[i];
     }
     os << "}";
 

source/adapters/null/ur_nullddi.cpp

@@ -5571,10 +5571,10 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueKernelLaunchCustomExp(
     ///< specify the number of local work-items forming a work-group that will
     ///< execute the kernel function. If nullptr, the runtime implementation
     ///< will choose the work-group size.
-    uint32_t numAttrsInLaunchAttrList, ///< [in] size of the launch attr list
-    const ur_exp_launch_attribute_t *
-        launchAttrList, ///< [in][range(0, numAttrsInLaunchAttrList)] pointer to a list of launch
-                        ///< attributes
+    uint32_t numPropsInLaunchPropList, ///< [in] size of the launch prop list
+    const ur_exp_launch_property_t *
+        launchPropList, ///< [in][range(0, numPropsInLaunchPropList)] pointer to a list of launch
+                        ///< properties
     uint32_t numEventsInWaitList, ///< [in] size of the event wait list
     const ur_event_handle_t *
         phEventWaitList, ///< [in][optional][range(0, numEventsInWaitList)] pointer to a list of
@@ -5592,7 +5592,7 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueKernelLaunchCustomExp(
     if (nullptr != pfnKernelLaunchCustomExp) {
         result = pfnKernelLaunchCustomExp(
             hQueue, hKernel, workDim, pGlobalWorkSize, pLocalWorkSize,
-            numAttrsInLaunchAttrList, launchAttrList, numEventsInWaitList,
+            numPropsInLaunchPropList, launchPropList, numEventsInWaitList,
             phEventWaitList, phEvent);
     } else {
         // generic implementation