diff --git a/include/layers/zel_tracing_register_cb.h b/include/layers/zel_tracing_register_cb.h index 2b73c3ce..d70dd3b1 100644 --- a/include/layers/zel_tracing_register_cb.h +++ b/include/layers/zel_tracing_register_cb.h @@ -619,59 +619,6 @@ typedef void (ZE_APICALL *ze_pfnCommandListGetNextCommandIdWithKernelsExpCb_t)( void** ppTracerInstanceUserData ); -/////////////////////////////////////////////////////////////////////////////// -/// @brief Callback function parameters for zeCommandListUpdateMutableCommandsExp -/// @details Each entry is a pointer to the parameter passed to the function; -/// allowing the callback the ability to modify the parameter's value - -typedef struct _ze_command_list_update_mutable_commands_exp_params_t -{ - ze_command_list_handle_t* phCommandList; - const ze_mutable_commands_exp_desc_t** pdesc; -} ze_command_list_update_mutable_commands_exp_params_t; - - -/////////////////////////////////////////////////////////////////////////////// -/// @brief Callback function-pointer for zeCommandListUpdateMutableCommandsExp -/// @param[in] params Parameters passed to this instance -/// @param[in] result Return value -/// @param[in] pTracerUserData Per-Tracer user data -/// @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data - -typedef void (ZE_APICALL *ze_pfnCommandListUpdateMutableCommandsExpCb_t)( - ze_command_list_update_mutable_commands_exp_params_t* params, - ze_result_t result, - void* pTracerUserData, - void** ppTracerInstanceUserData - ); - -/////////////////////////////////////////////////////////////////////////////// -/// @brief Callback function parameters for zeCommandListUpdateMutableCommandSignalEventExp -/// @details Each entry is a pointer to the parameter passed to the function; -/// allowing the callback the ability to modify the parameter's value - -typedef struct _ze_command_list_update_mutable_command_signal_event_exp_params_t -{ - ze_command_list_handle_t* phCommandList; - uint64_t* pcommandId; - ze_event_handle_t* phSignalEvent; -} ze_command_list_update_mutable_command_signal_event_exp_params_t; - - -/////////////////////////////////////////////////////////////////////////////// -/// @brief Callback function-pointer for zeCommandListUpdateMutableCommandSignalEventExp -/// @param[in] params Parameters passed to this instance -/// @param[in] result Return value -/// @param[in] pTracerUserData Per-Tracer user data -/// @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data - -typedef void (ZE_APICALL *ze_pfnCommandListUpdateMutableCommandSignalEventExpCb_t)( - ze_command_list_update_mutable_command_signal_event_exp_params_t* params, - ze_result_t result, - void* pTracerUserData, - void** ppTracerInstanceUserData - ); - /////////////////////////////////////////////////////////////////////////////// /// @brief Callback function parameters for zeCommandListUpdateMutableCommandKernelsExp /// @details Each entry is a pointer to the parameter passed to the function; @@ -948,6 +895,36 @@ typedef void (ZE_APICALL *ze_pfnCommandListIsImmediateCb_t)( void** ppTracerInstanceUserData ); +/////////////////////////////////////////////////////////////////////////////// +/// @brief Callback function parameters for zeCommandListImmediateAppendCommandListsExp +/// @details Each entry is a pointer to the parameter passed to the function; +/// allowing the callback the ability to modify the parameter's value + +typedef struct _ze_command_list_immediate_append_command_lists_exp_params_t +{ + ze_command_list_handle_t* phCommandListImmediate; + uint32_t* pnumCommandLists; + ze_command_list_handle_t** pphCommandLists; + ze_event_handle_t* phSignalEvent; + uint32_t* pnumWaitEvents; + ze_event_handle_t** pphWaitEvents; +} ze_command_list_immediate_append_command_lists_exp_params_t; + + +/////////////////////////////////////////////////////////////////////////////// +/// @brief Callback function-pointer for zeCommandListImmediateAppendCommandListsExp +/// @param[in] params Parameters passed to this instance +/// @param[in] result Return value +/// @param[in] pTracerUserData Per-Tracer user data +/// @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data + +typedef void (ZE_APICALL *ze_pfnCommandListImmediateAppendCommandListsExpCb_t)( + ze_command_list_immediate_append_command_lists_exp_params_t* params, + ze_result_t result, + void* pTracerUserData, + void** ppTracerInstanceUserData + ); + /////////////////////////////////////////////////////////////////////////////// /// @brief Callback function parameters for zeCommandListGetNextCommandIdExp /// @details Each entry is a pointer to the parameter passed to the function; @@ -976,58 +953,81 @@ typedef void (ZE_APICALL *ze_pfnCommandListGetNextCommandIdExpCb_t)( ); /////////////////////////////////////////////////////////////////////////////// -/// @brief Callback function parameters for zeCommandListUpdateMutableCommandWaitEventsExp +/// @brief Callback function parameters for zeCommandListUpdateMutableCommandsExp /// @details Each entry is a pointer to the parameter passed to the function; /// allowing the callback the ability to modify the parameter's value -typedef struct _ze_command_list_update_mutable_command_wait_events_exp_params_t +typedef struct _ze_command_list_update_mutable_commands_exp_params_t { ze_command_list_handle_t* phCommandList; - uint64_t* pcommandId; - uint32_t* pnumWaitEvents; - ze_event_handle_t** pphWaitEvents; -} ze_command_list_update_mutable_command_wait_events_exp_params_t; + const ze_mutable_commands_exp_desc_t** pdesc; +} ze_command_list_update_mutable_commands_exp_params_t; /////////////////////////////////////////////////////////////////////////////// -/// @brief Callback function-pointer for zeCommandListUpdateMutableCommandWaitEventsExp +/// @brief Callback function-pointer for zeCommandListUpdateMutableCommandsExp /// @param[in] params Parameters passed to this instance /// @param[in] result Return value /// @param[in] pTracerUserData Per-Tracer user data /// @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data -typedef void (ZE_APICALL *ze_pfnCommandListUpdateMutableCommandWaitEventsExpCb_t)( - ze_command_list_update_mutable_command_wait_events_exp_params_t* params, +typedef void (ZE_APICALL *ze_pfnCommandListUpdateMutableCommandsExpCb_t)( + ze_command_list_update_mutable_commands_exp_params_t* params, ze_result_t result, void* pTracerUserData, void** ppTracerInstanceUserData ); /////////////////////////////////////////////////////////////////////////////// -/// @brief Callback function parameters for zeCommandListImmediateAppendCommandListsExp +/// @brief Callback function parameters for zeCommandListUpdateMutableCommandSignalEventExp /// @details Each entry is a pointer to the parameter passed to the function; /// allowing the callback the ability to modify the parameter's value -typedef struct _ze_command_list_immediate_append_command_lists_exp_params_t +typedef struct _ze_command_list_update_mutable_command_signal_event_exp_params_t { - ze_command_list_handle_t* phCommandListImmediate; - uint32_t* pnumCommandLists; - ze_command_list_handle_t** pphCommandLists; + ze_command_list_handle_t* phCommandList; + uint64_t* pcommandId; ze_event_handle_t* phSignalEvent; +} ze_command_list_update_mutable_command_signal_event_exp_params_t; + + +/////////////////////////////////////////////////////////////////////////////// +/// @brief Callback function-pointer for zeCommandListUpdateMutableCommandSignalEventExp +/// @param[in] params Parameters passed to this instance +/// @param[in] result Return value +/// @param[in] pTracerUserData Per-Tracer user data +/// @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data + +typedef void (ZE_APICALL *ze_pfnCommandListUpdateMutableCommandSignalEventExpCb_t)( + ze_command_list_update_mutable_command_signal_event_exp_params_t* params, + ze_result_t result, + void* pTracerUserData, + void** ppTracerInstanceUserData + ); + +/////////////////////////////////////////////////////////////////////////////// +/// @brief Callback function parameters for zeCommandListUpdateMutableCommandWaitEventsExp +/// @details Each entry is a pointer to the parameter passed to the function; +/// allowing the callback the ability to modify the parameter's value + +typedef struct _ze_command_list_update_mutable_command_wait_events_exp_params_t +{ + ze_command_list_handle_t* phCommandList; + uint64_t* pcommandId; uint32_t* pnumWaitEvents; ze_event_handle_t** pphWaitEvents; -} ze_command_list_immediate_append_command_lists_exp_params_t; +} ze_command_list_update_mutable_command_wait_events_exp_params_t; /////////////////////////////////////////////////////////////////////////////// -/// @brief Callback function-pointer for zeCommandListImmediateAppendCommandListsExp +/// @brief Callback function-pointer for zeCommandListUpdateMutableCommandWaitEventsExp /// @param[in] params Parameters passed to this instance /// @param[in] result Return value /// @param[in] pTracerUserData Per-Tracer user data /// @param[in,out] ppTracerInstanceUserData Per-Tracer, Per-Instance user data -typedef void (ZE_APICALL *ze_pfnCommandListImmediateAppendCommandListsExpCb_t)( - ze_command_list_immediate_append_command_lists_exp_params_t* params, +typedef void (ZE_APICALL *ze_pfnCommandListUpdateMutableCommandWaitEventsExpCb_t)( + ze_command_list_update_mutable_command_wait_events_exp_params_t* params, ze_result_t result, void* pTracerUserData, void** ppTracerInstanceUserData @@ -3023,54 +3023,6 @@ zelTracerKernelSetGlobalOffsetExpRegisterCallback( ); -ZE_APIEXPORT ze_result_t ZE_APICALL -zelTracerCommandListGetNextCommandIdExpRegisterCallback( - zel_tracer_handle_t hTracer, - zel_tracer_reg_t callback_type, - ze_pfnCommandListGetNextCommandIdExpCb_t pfnGetNextCommandIdExpCb - ); - - -ZE_APIEXPORT ze_result_t ZE_APICALL -zelTracerCommandListGetNextCommandIdWithKernelsExpRegisterCallback( - zel_tracer_handle_t hTracer, - zel_tracer_reg_t callback_type, - ze_pfnCommandListGetNextCommandIdWithKernelsExpCb_t pfnGetNextCommandIdWithKernelsExpCb - ); - - -ZE_APIEXPORT ze_result_t ZE_APICALL -zelTracerCommandListUpdateMutableCommandsExpRegisterCallback( - zel_tracer_handle_t hTracer, - zel_tracer_reg_t callback_type, - ze_pfnCommandListUpdateMutableCommandsExpCb_t pfnUpdateMutableCommandsExpCb - ); - - -ZE_APIEXPORT ze_result_t ZE_APICALL -zelTracerCommandListUpdateMutableCommandSignalEventExpRegisterCallback( - zel_tracer_handle_t hTracer, - zel_tracer_reg_t callback_type, - ze_pfnCommandListUpdateMutableCommandSignalEventExpCb_t pfnUpdateMutableCommandSignalEventExpCb - ); - - -ZE_APIEXPORT ze_result_t ZE_APICALL -zelTracerCommandListUpdateMutableCommandWaitEventsExpRegisterCallback( - zel_tracer_handle_t hTracer, - zel_tracer_reg_t callback_type, - ze_pfnCommandListUpdateMutableCommandWaitEventsExpCb_t pfnUpdateMutableCommandWaitEventsExpCb - ); - - -ZE_APIEXPORT ze_result_t ZE_APICALL -zelTracerCommandListUpdateMutableCommandKernelsExpRegisterCallback( - zel_tracer_handle_t hTracer, - zel_tracer_reg_t callback_type, - ze_pfnCommandListUpdateMutableCommandKernelsExpCb_t pfnUpdateMutableCommandKernelsExpCb - ); - - ZE_APIEXPORT ze_result_t ZE_APICALL zelTracerDeviceReserveCacheExtRegisterCallback( zel_tracer_handle_t hTracer, @@ -3351,6 +3303,54 @@ zelTracerCommandListImmediateAppendCommandListsExpRegisterCallback( ); +ZE_APIEXPORT ze_result_t ZE_APICALL +zelTracerCommandListGetNextCommandIdExpRegisterCallback( + zel_tracer_handle_t hTracer, + zel_tracer_reg_t callback_type, + ze_pfnCommandListGetNextCommandIdExpCb_t pfnGetNextCommandIdExpCb + ); + + +ZE_APIEXPORT ze_result_t ZE_APICALL +zelTracerCommandListGetNextCommandIdWithKernelsExpRegisterCallback( + zel_tracer_handle_t hTracer, + zel_tracer_reg_t callback_type, + ze_pfnCommandListGetNextCommandIdWithKernelsExpCb_t pfnGetNextCommandIdWithKernelsExpCb + ); + + +ZE_APIEXPORT ze_result_t ZE_APICALL +zelTracerCommandListUpdateMutableCommandsExpRegisterCallback( + zel_tracer_handle_t hTracer, + zel_tracer_reg_t callback_type, + ze_pfnCommandListUpdateMutableCommandsExpCb_t pfnUpdateMutableCommandsExpCb + ); + + +ZE_APIEXPORT ze_result_t ZE_APICALL +zelTracerCommandListUpdateMutableCommandSignalEventExpRegisterCallback( + zel_tracer_handle_t hTracer, + zel_tracer_reg_t callback_type, + ze_pfnCommandListUpdateMutableCommandSignalEventExpCb_t pfnUpdateMutableCommandSignalEventExpCb + ); + + +ZE_APIEXPORT ze_result_t ZE_APICALL +zelTracerCommandListUpdateMutableCommandWaitEventsExpRegisterCallback( + zel_tracer_handle_t hTracer, + zel_tracer_reg_t callback_type, + ze_pfnCommandListUpdateMutableCommandWaitEventsExpCb_t pfnUpdateMutableCommandWaitEventsExpCb + ); + + +ZE_APIEXPORT ze_result_t ZE_APICALL +zelTracerCommandListUpdateMutableCommandKernelsExpRegisterCallback( + zel_tracer_handle_t hTracer, + zel_tracer_reg_t callback_type, + ze_pfnCommandListUpdateMutableCommandKernelsExpCb_t pfnUpdateMutableCommandKernelsExpCb + ); + + ZE_APIEXPORT ze_result_t ZE_APICALL zelTracerResetAllCallbacks(zel_tracer_handle_t hTracer); diff --git a/scripts/input.json b/scripts/input.json index dbb3082b..f235bf5a 100644 --- a/scripts/input.json +++ b/scripts/input.json @@ -5,6 +5,7 @@ "namespace": "ze", "tags": { "$OneApi": "'oneAPI'", + "$s": "zes", "$x": "ze" } }, @@ -98,7 +99,10 @@ "EnumRasErrorSets", "EnumSchedulers", "EnumStandbyDomains", - "EnumTemperatureSensors" + "GetSubDevicePropertiesExp", + "EnumTemperatureSensors", + "EnumActiveVFExp", + "EnumEnabledVFExp" ], "handle": [ "$s_device_handle_t" @@ -121,7 +125,8 @@ "$sRas", "$sScheduler", "$sStandby", - "$sTemperature" + "$sTemperature", + "$sVFManagement" ], "struct": [ "$s_device_state_t", @@ -140,7 +145,8 @@ "$s_device_ecc_desc_t", "$s_device_ecc_properties_t", "$s_sched_timeout_properties_t", - "$s_sched_timeslice_properties_t" + "$s_sched_timeslice_properties_t", + "$s_subdevice_exp_properties_t" ] }, "$sDiagnostics": { @@ -172,14 +178,20 @@ ], "function": [ "Get", + "GetExtensionProperties", + "GetExtensionFunctionAddress", "EventListen", - "EventListenEx" + "EventListenEx", + "GetDeviceByUuidExp" ], "handle": [ "$s_driver_handle_t" ], "members": [], - "ordinal": 2 + "ordinal": 2, + "struct": [ + "$s_driver_extension_properties_t" + ] }, "$sEngine": { "enum": [ @@ -274,7 +286,11 @@ "$sFirmware": { "function": [ "GetProperties", - "Flash" + "Flash", + "GetFlashProgress", + "GetConsoleLogs", + "GetSecurityVersionExp", + "SetSecurityVersionExp" ], "handle": [ "$s_firmware_handle_t" @@ -373,10 +389,12 @@ "ordinal": 1000, "owner": "$sDevice", "struct": [ + "$s_mem_page_offline_state_exp_t", "$s_mem_properties_t", "$s_mem_state_t", "$s_mem_bandwidth_t", - "$s_mem_ext_bandwidth_t" + "$s_mem_ext_bandwidth_t", + "$s_mem_bandwidth_counter_bits_exp_properties_t" ] }, "$sOverclock": { @@ -467,6 +485,7 @@ "$s_power_burst_limit_t", "$s_power_peak_limit_t", "$s_energy_threshold_t", + "$s_power_domain_exp_properties_t", "$s_power_limit_ext_desc_t", "$s_power_ext_properties_t" ] @@ -595,6 +614,39 @@ "$s_temp_config_t" ] }, + "$sVFManagement": { + "enum": [ + "$s_vf_info_mem_type_exp_flags_t", + "$s_vf_info_util_exp_flags_t" + ], + "function": [ + "GetVFPropertiesExp", + "GetVFMemoryUtilizationExp", + "GetVFEngineUtilizationExp", + "SetVFTelemetryModeExp", + "SetVFTelemetrySamplingIntervalExp", + "GetVFCapabilitiesExp", + "GetVFMemoryUtilizationExp2", + "GetVFEngineUtilizationExp2" + ], + "handle": [ + "$s_vf_handle_t" + ], + "members": [ + "$s_vf_handle_t", + "$sDevice*" + ], + "ordinal": 1900, + "owner": "$sDevice", + "struct": [ + "$s_vf_exp_properties_t", + "$s_vf_util_mem_exp_t", + "$s_vf_util_engine_exp_t", + "$s_vf_exp_capabilities_t", + "$s_vf_util_mem_exp2_t", + "$s_vf_util_engine_exp2_t" + ] + }, "$tCommandList": { "function": [ "AppendMetricStreamerMarker", @@ -667,7 +719,9 @@ "$t_device_debug_property_flags_t" ], "function": [ - "GetDebugProperties" + "GetConcurrentMetricGroupsExp", + "GetDebugProperties", + "CreateMetricGroupsFromMetricsExp" ], "handle": [ "$t_device_handle_t" @@ -719,7 +773,10 @@ ], "function": [ "Get", - "GetProperties" + "GetProperties", + "CreateFromProgrammableExp2", + "CreateFromProgrammableExp", + "DestroyExp" ], "handle": [ "$t_metric_handle_t" @@ -733,13 +790,26 @@ "struct": [ "$t_metric_global_timestamps_resolution_exp_t", "$t_metric_properties_t", - "$t_metric_calculate_exp_desc_t" + "$t_metric_calculate_exp_desc_t", + "$t_export_dma_buf_exp_properties_t" ] }, + "$tMetricDecoder": { + "function": [ + "CreateExp", + "DestroyExp", + "GetDecodableMetricsExp" + ], + "handle": [ + "$t_metric_decoder_exp_handle_t" + ], + "ordinal": 0 + }, "$tMetricGroup": { "enum": [ "$t_metric_group_sampling_type_flags_t", - "$t_metric_group_calculation_type_t" + "$t_metric_group_calculation_type_t", + "$t_metric_group_type_exp_flags_t" ], "function": [ "GetGlobalTimestampsExp", @@ -748,6 +818,11 @@ "CalculateMetricValues", "GetExportDataExp", "CalculateMetricExportDataExp", + "CreateExp", + "AddMetricExp", + "RemoveMetricExp", + "CloseExp", + "DestroyExp", "CalculateMultipleMetricValuesExp" ], "handle": [ @@ -763,7 +838,29 @@ "$tMetric" ], "struct": [ - "$t_metric_group_properties_t" + "$t_metric_group_properties_t", + "$t_metric_group_type_exp_t" + ] + }, + "$tMetricProgrammable": { + "enum": [ + "$t_metric_programmable_param_type_exp_t" + ], + "function": [ + "GetExp", + "GetPropertiesExp", + "GetParamInfoExp", + "GetParamValueInfoExp" + ], + "handle": [ + "$t_metric_programmable_exp_handle_t" + ], + "ordinal": 0, + "struct": [ + "$t_metric_programmable_exp_properties_t", + "$t_metric_programmable_param_info_exp_t", + "$t_metric_programmable_param_value_info_exp_t", + "$t_metric_programmable_param_value_exp_t" ] }, "$tMetricQuery": { @@ -825,6 +922,23 @@ "$t_metric_streamer_desc_t" ] }, + "$tMetricTracer": { + "function": [ + "CreateExp", + "DestroyExp", + "EnableExp", + "DisableExp", + "ReadDataExp", + "DecodeExp" + ], + "handle": [ + "$t_metric_tracer_exp_handle_t" + ], + "ordinal": 0, + "struct": [ + "$t_metric_tracer_exp_desc_t" + ] + }, "$tModule": { "enum": [ "$t_module_debug_info_format_t" @@ -865,12 +979,17 @@ }, "$x": { "enum": [ - "$x_init_flags_t" + "$x_init_flags_t", + "$x_init_driver_type_flags_t" ], "function": [ - "Init" + "Init", + "InitDrivers" ], - "ordinal": 0 + "ordinal": 0, + "struct": [ + "$x_init_driver_type_desc_t" + ] }, "$xCommandList": { "child": [ @@ -878,7 +997,9 @@ ], "enum": [ "$x_command_list_flags_t", - "$x_memory_advice_t" + "$x_memory_advice_t", + "$x_mutable_command_exp_flags_t", + "$x_mutable_command_list_exp_flags_t" ], "function": [ "AppendBarrier", @@ -890,6 +1011,12 @@ "Reset", "AppendWriteGlobalTimestamp", "HostSynchronize", + "GetDeviceHandle", + "GetContextHandle", + "GetOrdinal", + "ImmediateGetIndex", + "IsImmediate", + "CreateCloneExp", "AppendMemoryCopy", "AppendMemoryFill", "AppendMemoryCopyRegion", @@ -906,10 +1033,17 @@ "AppendQueryKernelTimestamps", "AppendImageCopyToMemoryExt", "AppendImageCopyFromMemoryExt", + "ImmediateAppendCommandListsExp", "AppendLaunchKernel", "AppendLaunchCooperativeKernel", "AppendLaunchKernelIndirect", - "AppendLaunchMultipleKernelsIndirect" + "AppendLaunchMultipleKernelsIndirect", + "GetNextCommandIdExp", + "GetNextCommandIdWithKernelsExp", + "UpdateMutableCommandsExp", + "UpdateMutableCommandSignalEventExp", + "UpdateMutableCommandWaitEventsExp", + "UpdateMutableCommandKernelsExp" ], "handle": [ "$x_command_list_handle_t" @@ -925,7 +1059,16 @@ "$x_command_list_desc_t", "$x_copy_region_t", "$x_image_region_t", - "$x_group_count_t" + "$x_group_count_t", + "$x_mutable_command_id_exp_desc_t", + "$x_mutable_command_list_exp_properties_t", + "$x_mutable_command_list_exp_desc_t", + "$x_mutable_commands_exp_desc_t", + "$x_mutable_kernel_argument_exp_desc_t", + "$x_mutable_group_count_exp_desc_t", + "$x_mutable_group_size_exp_desc_t", + "$x_mutable_global_offset_exp_desc_t", + "$x_mutable_graph_argument_exp_desc_t" ] }, "$xCommandQueue": { @@ -938,7 +1081,9 @@ "Create", "Destroy", "ExecuteCommandLists", - "Synchronize" + "Synchronize", + "GetOrdinal", + "GetIndex" ], "handle": [ "$x_command_queue_handle_t" @@ -1067,6 +1212,7 @@ "$x_pci_ext_properties_t", "$x_rtas_device_exp_properties_t", "$x_device_p2p_bandwidth_exp_properties_t", + "$x_device_pitched_alloc_exp_properties_t", "$x_cache_reservation_ext_desc_t", "$x_device_properties_t", "$x_device_thread_t", @@ -1140,6 +1286,9 @@ "QueryStatus", "HostReset", "QueryKernelTimestamp", + "GetEventPool", + "GetSignalScope", + "GetWaitScope", "QueryKernelTimestampsExt", "QueryTimestampsExp" ], @@ -1163,6 +1312,7 @@ }, "$xEventPool": { "enum": [ + "$x_event_pool_counter_based_exp_flags_t", "$x_event_pool_flags_t" ], "function": [ @@ -1171,7 +1321,9 @@ "GetIpcHandle", "PutIpcHandle", "OpenIpcHandle", - "CloseIpcHandle" + "CloseIpcHandle", + "GetContextHandle", + "GetFlags" ], "handle": [ "$x_event_pool_handle_t" @@ -1187,6 +1339,7 @@ "$xEvent" ], "struct": [ + "$x_event_pool_counter_based_exp_desc_t", "$x_event_pool_desc_t" ] }, @@ -1263,6 +1416,7 @@ }, "$xImage": { "enum": [ + "$x_image_bindless_exp_flags_t", "$x_image_flags_t", "$x_image_type_t", "$x_image_format_layout_t", @@ -1271,6 +1425,7 @@ "$x_image_sampler_filter_flags_t" ], "function": [ + "GetDeviceOffsetExp", "GetProperties", "Create", "Destroy", @@ -1291,6 +1446,8 @@ "owner": "$xDevice", "struct": [ "$x_srgb_ext_desc_t", + "$x_image_bindless_exp_desc_t", + "$x_image_pitched_exp_desc_t", "$x_image_format_t", "$x_image_desc_t", "$x_image_properties_t", @@ -1355,6 +1512,7 @@ "$x_relaxed_allocation_limits_exp_flags_t" ], "function": [ + "GetPitchFor2dImage", "AllocShared", "AllocDevice", "AllocHost", @@ -1649,9 +1807,10 @@ "$S_ENGINE_GROUP_3D_SINGLE", "$S_ENGINE_GROUP_3D_RENDER_COMPUTE_ALL", "$S_ENGINE_GROUP_RENDER_ALL", - "$S_ENGINE_GROUP_3D_ALL" + "$S_ENGINE_GROUP_3D_ALL", + "$S_ENGINE_GROUP_MEDIA_CODEC_SINGLE" ], - "max": "$S_ENGINE_GROUP_3D_ALL" + "max": "$S_ENGINE_GROUP_MEDIA_CODEC_SINGLE" }, "$s_engine_type_flags_t": { "class": "$sDevice", @@ -1682,9 +1841,10 @@ "$S_EVENT_TYPE_FLAG_PCI_LINK_HEALTH", "$S_EVENT_TYPE_FLAG_RAS_CORRECTABLE_ERRORS", "$S_EVENT_TYPE_FLAG_RAS_UNCORRECTABLE_ERRORS", - "$S_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED" + "$S_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED", + "$S_EVENT_TYPE_FLAG_SURVIVABILITY_MODE_DETECTED" ], - "max": "0x7fff" + "max": "0xffff" }, "$s_fabric_port_failure_flags_t": { "class": "$sFabricPort", @@ -1731,6 +1891,14 @@ ], "max": "$S_FAN_SPEED_UNITS_PERCENT" }, + "$s_firmware_security_exp_version_t": { + "class": "", + "etors": [ + "$S_FIRMWARE_SECURITY_EXP_VERSION_1_0", + "$S_FIRMWARE_SECURITY_EXP_VERSION_CURRENT" + ], + "max": "$S_FIRMWARE_SECURITY_EXP_VERSION_CURRENT" + }, "$s_freq_domain_t": { "class": "$sDevice", "etors": [ @@ -1769,6 +1937,14 @@ ], "max": "$S_LIMIT_UNIT_POWER" }, + "$s_mem_bandwidth_counter_bits_exp_version_t": { + "class": "", + "etors": [ + "$S_MEM_BANDWIDTH_COUNTER_BITS_EXP_VERSION_1_0", + "$S_MEM_BANDWIDTH_COUNTER_BITS_EXP_VERSION_CURRENT" + ], + "max": "$S_MEM_BANDWIDTH_COUNTER_BITS_EXP_VERSION_CURRENT" + }, "$s_mem_health_t": { "class": "$sMemory", "etors": [ @@ -1788,6 +1964,14 @@ ], "max": "$S_MEM_LOC_DEVICE" }, + "$s_mem_page_offline_state_exp_version_t": { + "class": "", + "etors": [ + "$S_MEM_PAGE_OFFLINE_STATE_EXP_VERSION_1_0", + "$S_MEM_PAGE_OFFLINE_STATE_EXP_VERSION_CURRENT" + ], + "max": "$S_MEM_PAGE_OFFLINE_STATE_EXP_VERSION_CURRENT" + }, "$s_mem_type_t": { "class": "$sMemory", "etors": [ @@ -1912,15 +2096,25 @@ ], "max": "$S_PENDING_ACTION_PENDING_WARM_RESET" }, + "$s_power_domain_properties_exp_version_t": { + "class": "", + "etors": [ + "$S_POWER_DOMAIN_PROPERTIES_EXP_VERSION_1_0", + "$S_POWER_DOMAIN_PROPERTIES_EXP_VERSION_CURRENT" + ], + "max": "$S_POWER_DOMAIN_PROPERTIES_EXP_VERSION_CURRENT" + }, "$s_power_domain_t": { "class": "$sPower", "etors": [ "$S_POWER_DOMAIN_UNKNOWN", "$S_POWER_DOMAIN_CARD", "$S_POWER_DOMAIN_PACKAGE", - "$S_POWER_DOMAIN_STACK" + "$S_POWER_DOMAIN_STACK", + "$S_POWER_DOMAIN_MEMORY", + "$S_POWER_DOMAIN_GPU" ], - "max": "$S_POWER_DOMAIN_STACK" + "max": "$S_POWER_DOMAIN_GPU" }, "$s_power_level_t": { "class": "$sPower", @@ -2104,9 +2298,27 @@ "$S_STRUCTURE_TYPE_ENGINE_EXT_PROPERTIES", "$S_STRUCTURE_TYPE_RESET_PROPERTIES", "$S_STRUCTURE_TYPE_DEVICE_EXT_PROPERTIES", - "$S_STRUCTURE_TYPE_DEVICE_UUID" + "$S_STRUCTURE_TYPE_DEVICE_UUID", + "$S_STRUCTURE_TYPE_POWER_DOMAIN_EXP_PROPERTIES", + "$S_STRUCTURE_TYPE_MEM_BANDWIDTH_COUNTER_BITS_EXP_PROPERTIES", + "$S_STRUCTURE_TYPE_MEMORY_PAGE_OFFLINE_STATE_EXP", + "$S_STRUCTURE_TYPE_SUBDEVICE_EXP_PROPERTIES", + "$S_STRUCTURE_TYPE_VF_EXP_PROPERTIES", + "$S_STRUCTURE_TYPE_VF_UTIL_MEM_EXP", + "$S_STRUCTURE_TYPE_VF_UTIL_ENGINE_EXP", + "$S_STRUCTURE_TYPE_VF_EXP_CAPABILITIES", + "$S_STRUCTURE_TYPE_VF_UTIL_MEM_EXP2", + "$S_STRUCTURE_TYPE_VF_UTIL_ENGINE_EXP2" + ], + "max": "$S_STRUCTURE_TYPE_VF_UTIL_ENGINE_EXP2" + }, + "$s_sysman_device_mapping_exp_version_t": { + "class": "", + "etors": [ + "$S_SYSMAN_DEVICE_MAPPING_EXP_VERSION_1_0", + "$S_SYSMAN_DEVICE_MAPPING_EXP_VERSION_CURRENT" ], - "max": "$S_STRUCTURE_TYPE_DEVICE_UUID" + "max": "$S_SYSMAN_DEVICE_MAPPING_EXP_VERSION_CURRENT" }, "$s_temp_sensors_t": { "class": "$sTemperature", @@ -2116,9 +2328,12 @@ "$S_TEMP_SENSORS_MEMORY", "$S_TEMP_SENSORS_GLOBAL_MIN", "$S_TEMP_SENSORS_GPU_MIN", - "$S_TEMP_SENSORS_MEMORY_MIN" + "$S_TEMP_SENSORS_MEMORY_MIN", + "$S_TEMP_SENSORS_GPU_BOARD", + "$S_TEMP_SENSORS_GPU_BOARD_MIN", + "$S_TEMP_SENSORS_VOLTAGE_REGULATOR" ], - "max": "$S_TEMP_SENSORS_MEMORY_MIN" + "max": "$S_TEMP_SENSORS_VOLTAGE_REGULATOR" }, "$s_vf_array_type_t": { "class": "$sOverclock", @@ -2129,6 +2344,34 @@ ], "max": "$S_VF_ARRAY_TYPE_LIVE_VF_ARRAY" }, + "$s_vf_info_mem_type_exp_flags_t": { + "class": "$sVFManagement", + "etors": [ + "$S_VF_INFO_MEM_TYPE_EXP_FLAG_MEM_TYPE_SYSTEM", + "$S_VF_INFO_MEM_TYPE_EXP_FLAG_MEM_TYPE_DEVICE" + ], + "max": "0x3" + }, + "$s_vf_info_util_exp_flags_t": { + "class": "$sVFManagement", + "etors": [ + "$S_VF_INFO_UTIL_EXP_FLAG_INFO_NONE", + "$S_VF_INFO_UTIL_EXP_FLAG_INFO_MEM_CPU", + "$S_VF_INFO_UTIL_EXP_FLAG_INFO_MEM_GPU", + "$S_VF_INFO_UTIL_EXP_FLAG_INFO_ENGINE" + ], + "max": "0xf" + }, + "$s_vf_management_exp_version_t": { + "class": "", + "etors": [ + "$S_VF_MANAGEMENT_EXP_VERSION_1_0", + "$S_VF_MANAGEMENT_EXP_VERSION_1_1", + "$S_VF_MANAGEMENT_EXP_VERSION_1_2", + "$S_VF_MANAGEMENT_EXP_VERSION_CURRENT" + ], + "max": "$S_VF_MANAGEMENT_EXP_VERSION_CURRENT" + }, "$s_vf_program_type_t": { "class": "$sOverclock", "etors": [ @@ -2154,6 +2397,14 @@ ], "max": "$T_API_TRACING_EXP_VERSION_CURRENT" }, + "$t_concurrent_metric_groups_exp_version_t": { + "class": "", + "etors": [ + "$T_CONCURRENT_METRIC_GROUPS_EXP_VERSION_1_0", + "$T_CONCURRENT_METRIC_GROUPS_EXP_VERSION_CURRENT" + ], + "max": "$T_CONCURRENT_METRIC_GROUPS_EXP_VERSION_CURRENT" + }, "$t_debug_detach_reason_t": { "class": "$tDebug", "etors": [ @@ -2188,9 +2439,10 @@ "class": "$tDebug", "etors": [ "$T_DEBUG_MEMORY_SPACE_TYPE_DEFAULT", - "$T_DEBUG_MEMORY_SPACE_TYPE_SLM" + "$T_DEBUG_MEMORY_SPACE_TYPE_SLM", + "$T_DEBUG_MEMORY_SPACE_TYPE_ELF" ], - "max": "$T_DEBUG_MEMORY_SPACE_TYPE_SLM" + "max": "$T_DEBUG_MEMORY_SPACE_TYPE_ELF" }, "$t_debug_page_fault_reason_t": { "class": "$tDebug", @@ -2236,9 +2488,39 @@ "class": "$tMetricGroup", "etors": [ "$T_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED", - "$T_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED" + "$T_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED", + "$T_METRIC_GROUP_SAMPLING_TYPE_FLAG_EXP_TRACER_BASED" ], - "max": "0x3" + "max": "0x7" + }, + "$t_metric_group_type_exp_flags_t": { + "class": "$tMetricGroup", + "etors": [ + "$T_METRIC_GROUP_TYPE_EXP_FLAG_EXPORT_DMA_BUF", + "$T_METRIC_GROUP_TYPE_EXP_FLAG_USER_CREATED", + "$T_METRIC_GROUP_TYPE_EXP_FLAG_OTHER" + ], + "max": "0x7" + }, + "$t_metric_programmable_exp_version_t": { + "class": "", + "etors": [ + "$T_METRIC_PROGRAMMABLE_EXP_VERSION_1_1", + "$T_METRIC_PROGRAMMABLE_EXP_VERSION_CURRENT" + ], + "max": "$T_METRIC_PROGRAMMABLE_EXP_VERSION_CURRENT" + }, + "$t_metric_programmable_param_type_exp_t": { + "class": "$tMetricProgrammable", + "etors": [ + "$T_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_DISAGGREGATION", + "$T_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_LATENCY", + "$T_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_NORMALIZATION_UTILIZATION", + "$T_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_NORMALIZATION_AVERAGE", + "$T_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_NORMALIZATION_RATE", + "$T_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_NORMALIZATION_BYTES" + ], + "max": "$T_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_NORMALIZATION_BYTES" }, "$t_metric_query_pool_type_t": { "class": "$tMetricQueryPool", @@ -2248,6 +2530,14 @@ ], "max": "$T_METRIC_QUERY_POOL_TYPE_EXECUTION" }, + "$t_metric_tracer_exp_version_t": { + "class": "", + "etors": [ + "$T_METRIC_TRACER_EXP_VERSION_1_0", + "$T_METRIC_TRACER_EXP_VERSION_CURRENT" + ], + "max": "$T_METRIC_TRACER_EXP_VERSION_CURRENT" + }, "$t_metric_type_t": { "class": "$tMetric", "etors": [ @@ -2260,9 +2550,14 @@ "$T_METRIC_TYPE_RATIO", "$T_METRIC_TYPE_RAW", "$T_METRIC_TYPE_IP_EXP", - "$T_METRIC_TYPE_IP" + "$T_METRIC_TYPE_IP", + "$T_METRIC_TYPE_EVENT_EXP_TIMESTAMP", + "$T_METRIC_TYPE_EVENT_EXP_START", + "$T_METRIC_TYPE_EVENT_EXP_END", + "$T_METRIC_TYPE_EXPORT_DMA_BUF", + "$T_METRIC_TYPE_EVENT_EXP_MONOTONIC_WRAPS_VALUE" ], - "max": "$T_METRIC_TYPE_IP" + "max": "$T_METRIC_TYPE_EVENT_EXP_MONOTONIC_WRAPS_VALUE" }, "$t_module_debug_info_format_t": { "class": "$tModule", @@ -2301,9 +2596,30 @@ "$T_STRUCTURE_TYPE_METRIC_GLOBAL_TIMESTAMPS_RESOLUTION_EXP", "$T_STRUCTURE_TYPE_TRACER_EXP_DESC", "$T_STRUCTURE_TYPE_METRICS_CALCULATE_EXP_DESC", - "$T_STRUCTURE_TYPE_METRIC_CALCULATE_EXP_DESC" + "$T_STRUCTURE_TYPE_METRIC_CALCULATE_EXP_DESC", + "$T_STRUCTURE_TYPE_METRIC_PROGRAMMABLE_EXP_PROPERTIES", + "$T_STRUCTURE_TYPE_METRIC_PROGRAMMABLE_PARAM_INFO_EXP", + "$T_STRUCTURE_TYPE_METRIC_PROGRAMMABLE_PARAM_VALUE_INFO_EXP", + "$T_STRUCTURE_TYPE_METRIC_GROUP_TYPE_EXP", + "$T_STRUCTURE_TYPE_EXPORT_DMA_EXP_PROPERTIES", + "$T_STRUCTURE_TYPE_METRIC_TRACER_EXP_DESC" ], - "max": "$T_STRUCTURE_TYPE_METRIC_CALCULATE_EXP_DESC" + "max": "$T_STRUCTURE_TYPE_METRIC_TRACER_EXP_DESC" + }, + "$t_value_info_type_exp_t": { + "class": "", + "etors": [ + "$T_VALUE_INFO_TYPE_EXP_UINT32", + "$T_VALUE_INFO_TYPE_EXP_UINT64", + "$T_VALUE_INFO_TYPE_EXP_FLOAT32", + "$T_VALUE_INFO_TYPE_EXP_FLOAT64", + "$T_VALUE_INFO_TYPE_EXP_BOOL8", + "$T_VALUE_INFO_TYPE_EXP_UINT8", + "$T_VALUE_INFO_TYPE_EXP_UINT16", + "$T_VALUE_INFO_TYPE_EXP_UINT64_RANGE", + "$T_VALUE_INFO_TYPE_EXP_FLOAT64_RANGE" + ], + "max": "$T_VALUE_INFO_TYPE_EXP_FLOAT64_RANGE" }, "$t_value_type_t": { "class": "", @@ -2330,6 +2646,10 @@ "$X_API_VERSION_1_5", "$X_API_VERSION_1_6", "$X_API_VERSION_1_7", + "$X_API_VERSION_1_8", + "$X_API_VERSION_1_9", + "$X_API_VERSION_1_10", + "$X_API_VERSION_1_11", "$X_API_VERSION_CURRENT" ], "max": "$X_API_VERSION_CURRENT" @@ -2351,6 +2671,14 @@ ], "max": "$X_BFLOAT16_CONVERSIONS_EXT_VERSION_CURRENT" }, + "$x_bindless_image_exp_version_t": { + "class": "", + "etors": [ + "$X_BINDLESS_IMAGE_EXP_VERSION_1_0", + "$X_BINDLESS_IMAGE_EXP_VERSION_CURRENT" + ], + "max": "$X_BINDLESS_IMAGE_EXP_VERSION_CURRENT" + }, "$x_cache_config_flags_t": { "class": "$xKernel", "etors": [ @@ -2387,15 +2715,24 @@ ], "max": "$X_CALCULATE_MULTIPLE_METRICS_EXP_VERSION_CURRENT" }, + "$x_command_list_clone_exp_version_t": { + "class": "", + "etors": [ + "$X_COMMAND_LIST_CLONE_EXP_VERSION_1_0", + "$X_COMMAND_LIST_CLONE_EXP_VERSION_CURRENT" + ], + "max": "$X_COMMAND_LIST_CLONE_EXP_VERSION_CURRENT" + }, "$x_command_list_flags_t": { "class": "$xCommandList", "etors": [ "$X_COMMAND_LIST_FLAG_RELAXED_ORDERING", "$X_COMMAND_LIST_FLAG_MAXIMIZE_THROUGHPUT", "$X_COMMAND_LIST_FLAG_EXPLICIT_ONLY", - "$X_COMMAND_LIST_FLAG_IN_ORDER" + "$X_COMMAND_LIST_FLAG_IN_ORDER", + "$X_COMMAND_LIST_FLAG_EXP_CLONEABLE" ], - "max": "0xf" + "max": "0x1f" }, "$x_command_queue_flags_t": { "class": "$xCommandQueue", @@ -2603,6 +2940,22 @@ ], "max": "$X_EU_COUNT_EXT_VERSION_CURRENT" }, + "$x_event_pool_counter_based_exp_flags_t": { + "class": "$xEventPool", + "etors": [ + "$X_EVENT_POOL_COUNTER_BASED_EXP_FLAG_IMMEDIATE", + "$X_EVENT_POOL_COUNTER_BASED_EXP_FLAG_NON_IMMEDIATE" + ], + "max": "0x3" + }, + "$x_event_pool_counter_based_exp_version_t": { + "class": "", + "etors": [ + "$X_EVENT_POOL_COUNTER_BASED_EXP_VERSION_1_0", + "$X_EVENT_POOL_COUNTER_BASED_EXP_VERSION_CURRENT" + ], + "max": "$X_EVENT_POOL_COUNTER_BASED_EXP_VERSION_CURRENT" + }, "$x_event_pool_flags_t": { "class": "$xEventPool", "etors": [ @@ -2712,6 +3065,14 @@ ], "max": "0xf" }, + "$x_image_bindless_exp_flags_t": { + "class": "$xImage", + "etors": [ + "$X_IMAGE_BINDLESS_EXP_FLAG_BINDLESS", + "$X_IMAGE_BINDLESS_EXP_FLAG_SAMPLED_IMAGE" + ], + "max": "0x3" + }, "$x_image_copy_ext_version_t": { "class": "", "etors": [ @@ -2773,9 +3134,12 @@ "$X_IMAGE_FORMAT_LAYOUT_422V", "$X_IMAGE_FORMAT_LAYOUT_444P", "$X_IMAGE_FORMAT_LAYOUT_RGBP", - "$X_IMAGE_FORMAT_LAYOUT_BRGP" + "$X_IMAGE_FORMAT_LAYOUT_BRGP", + "$X_IMAGE_FORMAT_LAYOUT_8_8_8", + "$X_IMAGE_FORMAT_LAYOUT_16_16_16", + "$X_IMAGE_FORMAT_LAYOUT_32_32_32" ], - "max": "$X_IMAGE_FORMAT_LAYOUT_BRGP" + "max": "$X_IMAGE_FORMAT_LAYOUT_32_32_32" }, "$x_image_format_swizzle_t": { "class": "$xImage", @@ -2869,6 +3233,22 @@ ], "max": "$X_IMAGE_VIEW_PLANAR_EXT_VERSION_CURRENT" }, + "$x_immediate_command_list_append_exp_version_t": { + "class": "", + "etors": [ + "$X_IMMEDIATE_COMMAND_LIST_APPEND_EXP_VERSION_1_0", + "$X_IMMEDIATE_COMMAND_LIST_APPEND_EXP_VERSION_CURRENT" + ], + "max": "$X_IMMEDIATE_COMMAND_LIST_APPEND_EXP_VERSION_CURRENT" + }, + "$x_init_driver_type_flags_t": { + "class": "$x", + "etors": [ + "$X_INIT_DRIVER_TYPE_FLAG_GPU", + "$X_INIT_DRIVER_TYPE_FLAG_NPU" + ], + "max": "0x3" + }, "$x_init_flags_t": { "class": "$x", "etors": [ @@ -3066,6 +3446,36 @@ ], "max": "0x1" }, + "$x_mutable_command_exp_flags_t": { + "class": "$xCommandList", + "etors": [ + "$X_MUTABLE_COMMAND_EXP_FLAG_KERNEL_ARGUMENTS", + "$X_MUTABLE_COMMAND_EXP_FLAG_GROUP_COUNT", + "$X_MUTABLE_COMMAND_EXP_FLAG_GROUP_SIZE", + "$X_MUTABLE_COMMAND_EXP_FLAG_GLOBAL_OFFSET", + "$X_MUTABLE_COMMAND_EXP_FLAG_SIGNAL_EVENT", + "$X_MUTABLE_COMMAND_EXP_FLAG_WAIT_EVENTS", + "$X_MUTABLE_COMMAND_EXP_FLAG_KERNEL_INSTRUCTION", + "$X_MUTABLE_COMMAND_EXP_FLAG_GRAPH_ARGUMENTS" + ], + "max": "0xff" + }, + "$x_mutable_command_list_exp_flags_t": { + "class": "$xCommandList", + "etors": [ + "$X_MUTABLE_COMMAND_LIST_EXP_FLAG_RESERVED" + ], + "max": "0x1" + }, + "$x_mutable_command_list_exp_version_t": { + "class": "", + "etors": [ + "$X_MUTABLE_COMMAND_LIST_EXP_VERSION_1_0", + "$X_MUTABLE_COMMAND_LIST_EXP_VERSION_1_1", + "$X_MUTABLE_COMMAND_LIST_EXP_VERSION_CURRENT" + ], + "max": "$X_MUTABLE_COMMAND_LIST_EXP_VERSION_CURRENT" + }, "$x_pci_properties_ext_version_t": { "class": "", "etors": [ @@ -3077,9 +3487,10 @@ "$x_physical_mem_flags_t": { "class": "$xPhysicalMem", "etors": [ - "$X_PHYSICAL_MEM_FLAG_TBD" + "$X_PHYSICAL_MEM_FLAG_ALLOCATE_ON_DEVICE", + "$X_PHYSICAL_MEM_FLAG_ALLOCATE_ON_HOST" ], - "max": "0x1" + "max": "0x3" }, "$x_power_saving_hint_exp_version_t": { "class": "", @@ -3176,6 +3587,7 @@ "$X_RESULT_ERROR_INVALID_COMMAND_LIST_TYPE", "$X_RESULT_ERROR_OVERLAPPING_REGIONS", "$X_RESULT_WARNING_ACTION_REQUIRED", + "$X_RESULT_ERROR_INVALID_KERNEL_HANDLE", "$X_RESULT_ERROR_UNKNOWN" ], "max": "$X_RESULT_ERROR_UNKNOWN" @@ -3392,9 +3804,23 @@ "$X_STRUCTURE_TYPE_RTAS_BUILDER_EXP_PROPERTIES", "$X_STRUCTURE_TYPE_RTAS_PARALLEL_OPERATION_EXP_PROPERTIES", "$X_STRUCTURE_TYPE_RTAS_DEVICE_EXP_PROPERTIES", - "$X_STRUCTURE_TYPE_RTAS_GEOMETRY_AABBS_EXP_CB_PARAMS" - ], - "max": "$X_STRUCTURE_TYPE_RTAS_GEOMETRY_AABBS_EXP_CB_PARAMS" + "$X_STRUCTURE_TYPE_RTAS_GEOMETRY_AABBS_EXP_CB_PARAMS", + "$X_STRUCTURE_TYPE_COUNTER_BASED_EVENT_POOL_EXP_DESC", + "$X_STRUCTURE_TYPE_MUTABLE_COMMAND_LIST_EXP_PROPERTIES", + "$X_STRUCTURE_TYPE_MUTABLE_COMMAND_LIST_EXP_DESC", + "$X_STRUCTURE_TYPE_MUTABLE_COMMAND_ID_EXP_DESC", + "$X_STRUCTURE_TYPE_MUTABLE_COMMANDS_EXP_DESC", + "$X_STRUCTURE_TYPE_MUTABLE_KERNEL_ARGUMENT_EXP_DESC", + "$X_STRUCTURE_TYPE_MUTABLE_GROUP_COUNT_EXP_DESC", + "$X_STRUCTURE_TYPE_MUTABLE_GROUP_SIZE_EXP_DESC", + "$X_STRUCTURE_TYPE_MUTABLE_GLOBAL_OFFSET_EXP_DESC", + "$X_STRUCTURE_TYPE_PITCHED_ALLOC_DEVICE_EXP_PROPERTIES", + "$X_STRUCTURE_TYPE_BINDLESS_IMAGE_EXP_DESC", + "$X_STRUCTURE_TYPE_PITCHED_IMAGE_EXP_DESC", + "$X_STRUCTURE_TYPE_MUTABLE_GRAPH_ARGUMENT_EXP_DESC", + "$X_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC" + ], + "max": "$X_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC" }, "$x_sub_allocations_exp_version_t": { "class": "", @@ -3459,6 +3885,20 @@ } ] }, + "$sDeviceEnumActiveVFExp": { + "class": "$sDevice", + "params": [ + { + "type": "$s_device_handle_t" + }, + { + "type": "uint32_t*" + }, + { + "type": "$s_vf_handle_t*" + } + ] + }, "$sDeviceEnumDiagnosticTestSuites": { "class": "$sDevice", "params": [ @@ -3473,6 +3913,20 @@ } ] }, + "$sDeviceEnumEnabledVFExp": { + "class": "$sDevice", + "params": [ + { + "type": "$s_device_handle_t" + }, + { + "type": "uint32_t*" + }, + { + "type": "$s_vf_handle_t*" + } + ] + }, "$sDeviceEnumEngineGroups": { "class": "$sDevice", "params": [ @@ -3777,6 +4231,20 @@ } ] }, + "$sDeviceGetSubDevicePropertiesExp": { + "class": "$sDevice", + "params": [ + { + "type": "$s_device_handle_t" + }, + { + "type": "uint32_t*" + }, + { + "type": "$s_subdevice_exp_properties_t*" + } + ] + }, "$sDevicePciGetBars": { "class": "$sDevice", "params": [ @@ -4015,6 +4483,54 @@ } ] }, + "$sDriverGetDeviceByUuidExp": { + "class": "$sDriver", + "params": [ + { + "type": "$s_driver_handle_t" + }, + { + "type": "$s_uuid_t" + }, + { + "type": "$s_device_handle_t*" + }, + { + "type": "$x_bool_t*" + }, + { + "type": "uint32_t*" + } + ] + }, + "$sDriverGetExtensionFunctionAddress": { + "class": "$sDriver", + "params": [ + { + "type": "$s_driver_handle_t" + }, + { + "type": "const char*" + }, + { + "type": "void**" + } + ] + }, + "$sDriverGetExtensionProperties": { + "class": "$sDriver", + "params": [ + { + "type": "$s_driver_handle_t" + }, + { + "type": "uint32_t*" + }, + { + "type": "$s_driver_extension_properties_t*" + } + ] + }, "$sEngineGetActivity": { "class": "$sEngine", "params": [ @@ -4225,6 +4741,31 @@ } ] }, + "$sFirmwareGetConsoleLogs": { + "class": "$sFirmware", + "params": [ + { + "type": "$s_firmware_handle_t" + }, + { + "type": "size_t*" + }, + { + "type": "char*" + } + ] + }, + "$sFirmwareGetFlashProgress": { + "class": "$sFirmware", + "params": [ + { + "type": "$s_firmware_handle_t" + }, + { + "type": "uint32_t*" + } + ] + }, "$sFirmwareGetProperties": { "class": "$sFirmware", "params": [ @@ -4236,6 +4777,25 @@ } ] }, + "$sFirmwareGetSecurityVersionExp": { + "class": "$sFirmware", + "params": [ + { + "type": "$s_firmware_handle_t" + }, + { + "type": "char*" + } + ] + }, + "$sFirmwareSetSecurityVersionExp": { + "class": "$sFirmware", + "params": [ + { + "type": "$s_firmware_handle_t" + } + ] + }, "$sFrequencyGetAvailableClocks": { "class": "$sFrequency", "params": [ @@ -5062,6 +5622,112 @@ } ] }, + "$sVFManagementGetVFCapabilitiesExp": { + "class": "$sVFManagement", + "params": [ + { + "type": "$s_vf_handle_t" + }, + { + "type": "$s_vf_exp_capabilities_t*" + } + ] + }, + "$sVFManagementGetVFEngineUtilizationExp": { + "class": "$sVFManagement", + "params": [ + { + "type": "$s_vf_handle_t" + }, + { + "type": "uint32_t*" + }, + { + "type": "$s_vf_util_engine_exp_t*" + } + ] + }, + "$sVFManagementGetVFEngineUtilizationExp2": { + "class": "$sVFManagement", + "params": [ + { + "type": "$s_vf_handle_t" + }, + { + "type": "uint32_t*" + }, + { + "type": "$s_vf_util_engine_exp2_t*" + } + ] + }, + "$sVFManagementGetVFMemoryUtilizationExp": { + "class": "$sVFManagement", + "params": [ + { + "type": "$s_vf_handle_t" + }, + { + "type": "uint32_t*" + }, + { + "type": "$s_vf_util_mem_exp_t*" + } + ] + }, + "$sVFManagementGetVFMemoryUtilizationExp2": { + "class": "$sVFManagement", + "params": [ + { + "type": "$s_vf_handle_t" + }, + { + "type": "uint32_t*" + }, + { + "type": "$s_vf_util_mem_exp2_t*" + } + ] + }, + "$sVFManagementGetVFPropertiesExp": { + "class": "$sVFManagement", + "params": [ + { + "type": "$s_vf_handle_t" + }, + { + "type": "$s_vf_exp_properties_t*" + } + ] + }, + "$sVFManagementSetVFTelemetryModeExp": { + "class": "$sVFManagement", + "params": [ + { + "type": "$s_vf_handle_t" + }, + { + "type": "$s_vf_info_util_exp_flags_t" + }, + { + "type": "$x_bool_t" + } + ] + }, + "$sVFManagementSetVFTelemetrySamplingIntervalExp": { + "class": "$sVFManagement", + "params": [ + { + "type": "$s_vf_handle_t" + }, + { + "type": "$s_vf_info_util_exp_flags_t" + }, + { + "type": "uint64_t" + } + ] + }, "$tCommandListAppendMetricMemoryBarrier": { "class": "$tCommandList", "params": [ @@ -5318,6 +5984,52 @@ } ] }, + "$tDeviceCreateMetricGroupsFromMetricsExp": { + "class": "$tDevice", + "params": [ + { + "type": "$t_device_handle_t" + }, + { + "type": "uint32_t" + }, + { + "type": "zet_metric_handle_t *" + }, + { + "type": "const char *" + }, + { + "type": "const char *" + }, + { + "type": "uint32_t *" + }, + { + "type": "$t_metric_group_handle_t*" + } + ] + }, + "$tDeviceGetConcurrentMetricGroupsExp": { + "class": "$tDevice", + "params": [ + { + "type": "$t_device_handle_t" + }, + { + "type": "uint32_t" + }, + { + "type": "$t_metric_group_handle_t *" + }, + { + "type": "uint32_t *" + }, + { + "type": "uint32_t *" + } + ] + }, "$tDeviceGetDebugProperties": { "class": "$tDevice", "params": [ @@ -5340,6 +6052,99 @@ } ] }, + "$tMetricCreateFromProgrammableExp": { + "class": "$tMetric", + "params": [ + { + "type": "$t_metric_programmable_exp_handle_t" + }, + { + "type": "$t_metric_programmable_param_value_exp_t*" + }, + { + "type": "uint32_t" + }, + { + "type": "const char*" + }, + { + "type": "const char*" + }, + { + "type": "uint32_t*" + }, + { + "type": "$t_metric_handle_t*" + } + ] + }, + "$tMetricCreateFromProgrammableExp2": { + "class": "$tMetric", + "params": [ + { + "type": "$t_metric_programmable_exp_handle_t" + }, + { + "type": "uint32_t" + }, + { + "type": "$t_metric_programmable_param_value_exp_t*" + }, + { + "type": "const char*" + }, + { + "type": "const char*" + }, + { + "type": "uint32_t*" + }, + { + "type": "$t_metric_handle_t*" + } + ] + }, + "$tMetricDecoderCreateExp": { + "class": "$tMetricDecoder", + "params": [ + { + "type": "$t_metric_tracer_exp_handle_t" + }, + { + "type": "$t_metric_decoder_exp_handle_t*" + } + ] + }, + "$tMetricDecoderDestroyExp": { + "class": "$tMetricDecoder", + "params": [ + { + "type": "$t_metric_decoder_exp_handle_t" + } + ] + }, + "$tMetricDecoderGetDecodableMetricsExp": { + "class": "$tMetricDecoder", + "params": [ + { + "type": "$t_metric_decoder_exp_handle_t" + }, + { + "type": "uint32_t*" + }, + { + "type": "$t_metric_handle_t*" + } + ] + }, + "$tMetricDestroyExp": { + "class": "$tMetric", + "params": [ + { + "type": "$t_metric_handle_t" + } + ] + }, "$tMetricGet": { "class": "$tMetric", "params": [ @@ -5365,6 +6170,23 @@ } ] }, + "$tMetricGroupAddMetricExp": { + "class": "$tMetricGroup", + "params": [ + { + "type": "$t_metric_group_handle_t" + }, + { + "type": "$t_metric_handle_t" + }, + { + "type": "size_t *" + }, + { + "type": "char*" + } + ] + }, "$tMetricGroupCalculateMetricExportDataExp": { "class": "$tMetricGroup", "params": [ @@ -5449,6 +6271,42 @@ } ] }, + "$tMetricGroupCloseExp": { + "class": "$tMetricGroup", + "params": [ + { + "type": "$t_metric_group_handle_t" + } + ] + }, + "$tMetricGroupCreateExp": { + "class": "$tMetricGroup", + "params": [ + { + "type": "$t_device_handle_t" + }, + { + "type": "const char*" + }, + { + "type": "const char*" + }, + { + "type": "$t_metric_group_sampling_type_flags_t" + }, + { + "type": "$t_metric_group_handle_t*" + } + ] + }, + "$tMetricGroupDestroyExp": { + "class": "$tMetricGroup", + "params": [ + { + "type": "$t_metric_group_handle_t" + } + ] + }, "$tMetricGroupGet": { "class": "$tMetricGroup", "params": [ @@ -5511,6 +6369,73 @@ } ] }, + "$tMetricGroupRemoveMetricExp": { + "class": "$tMetricGroup", + "params": [ + { + "type": "$t_metric_group_handle_t" + }, + { + "type": "$t_metric_handle_t" + } + ] + }, + "$tMetricProgrammableGetExp": { + "class": "$tMetricProgrammable", + "params": [ + { + "type": "$t_device_handle_t" + }, + { + "type": "uint32_t*" + }, + { + "type": "$t_metric_programmable_exp_handle_t*" + } + ] + }, + "$tMetricProgrammableGetParamInfoExp": { + "class": "$tMetricProgrammable", + "params": [ + { + "type": "$t_metric_programmable_exp_handle_t" + }, + { + "type": "uint32_t*" + }, + { + "type": "$t_metric_programmable_param_info_exp_t*" + } + ] + }, + "$tMetricProgrammableGetParamValueInfoExp": { + "class": "$tMetricProgrammable", + "params": [ + { + "type": "$t_metric_programmable_exp_handle_t" + }, + { + "type": "uint32_t" + }, + { + "type": "uint32_t*" + }, + { + "type": "$t_metric_programmable_param_value_info_exp_t*" + } + ] + }, + "$tMetricProgrammableGetPropertiesExp": { + "class": "$tMetricProgrammable", + "params": [ + { + "type": "$t_metric_programmable_exp_handle_t" + }, + { + "type": "$t_metric_programmable_exp_properties_t*" + } + ] + }, "$tMetricQueryCreate": { "class": "$tMetricQuery", "params": [ @@ -5631,6 +6556,108 @@ } ] }, + "$tMetricTracerCreateExp": { + "class": "$tMetricTracer", + "params": [ + { + "type": "$t_context_handle_t" + }, + { + "type": "$t_device_handle_t" + }, + { + "type": "uint32_t" + }, + { + "type": "$t_metric_group_handle_t*" + }, + { + "type": "$t_metric_tracer_exp_desc_t*" + }, + { + "type": "$x_event_handle_t" + }, + { + "type": "$t_metric_tracer_exp_handle_t*" + } + ] + }, + "$tMetricTracerDecodeExp": { + "class": "$tMetricTracer", + "params": [ + { + "type": "$t_metric_decoder_exp_handle_t" + }, + { + "type": "size_t*" + }, + { + "type": "uint8_t*" + }, + { + "type": "uint32_t" + }, + { + "type": "$t_metric_handle_t*" + }, + { + "type": "uint32_t*" + }, + { + "type": "uint32_t*" + }, + { + "type": "uint32_t*" + }, + { + "type": "$t_metric_entry_exp_t*" + } + ] + }, + "$tMetricTracerDestroyExp": { + "class": "$tMetricTracer", + "params": [ + { + "type": "$t_metric_tracer_exp_handle_t" + } + ] + }, + "$tMetricTracerDisableExp": { + "class": "$tMetricTracer", + "params": [ + { + "type": "$t_metric_tracer_exp_handle_t" + }, + { + "type": "$x_bool_t" + } + ] + }, + "$tMetricTracerEnableExp": { + "class": "$tMetricTracer", + "params": [ + { + "type": "$t_metric_tracer_exp_handle_t" + }, + { + "type": "$x_bool_t" + } + ] + }, + "$tMetricTracerReadDataExp": { + "class": "$tMetricTracer", + "params": [ + { + "type": "$t_metric_tracer_exp_handle_t" + }, + { + "type": "size_t*" + }, + { + "type": "uint8_t*" + } + ] + }, "$tModuleGetDebugInfo": { "class": "$tModule", "params": [ @@ -6281,6 +7308,17 @@ } ] }, + "$xCommandListCreateCloneExp": { + "class": "$xCommandList", + "params": [ + { + "type": "$x_command_list_handle_t" + }, + { + "type": "$x_command_list_handle_t*" + } + ] + }, "$xCommandListCreateImmediate": { "class": "$xCommandList", "params": [ @@ -6306,6 +7344,73 @@ } ] }, + "$xCommandListGetContextHandle": { + "class": "$xCommandList", + "params": [ + { + "type": "$x_command_list_handle_t" + }, + { + "type": "$x_context_handle_t*" + } + ] + }, + "$xCommandListGetDeviceHandle": { + "class": "$xCommandList", + "params": [ + { + "type": "$x_command_list_handle_t" + }, + { + "type": "$x_device_handle_t*" + } + ] + }, + "$xCommandListGetNextCommandIdExp": { + "class": "$xCommandList", + "params": [ + { + "type": "$x_command_list_handle_t" + }, + { + "type": "const $x_mutable_command_id_exp_desc_t*" + }, + { + "type": "uint64_t*" + } + ] + }, + "$xCommandListGetNextCommandIdWithKernelsExp": { + "class": "$xCommandList", + "params": [ + { + "type": "$x_command_list_handle_t" + }, + { + "type": "const $x_mutable_command_id_exp_desc_t*" + }, + { + "type": "uint32_t" + }, + { + "type": "$x_kernel_handle_t*" + }, + { + "type": "uint64_t*" + } + ] + }, + "$xCommandListGetOrdinal": { + "class": "$xCommandList", + "params": [ + { + "type": "$x_command_list_handle_t" + }, + { + "type": "uint32_t*" + } + ] + }, "$xCommandListHostSynchronize": { "class": "$xCommandList", "params": [ @@ -6317,6 +7422,51 @@ } ] }, + "$xCommandListImmediateAppendCommandListsExp": { + "class": "$xCommandList", + "params": [ + { + "type": "$x_command_list_handle_t" + }, + { + "type": "uint32_t" + }, + { + "type": "$x_command_list_handle_t*" + }, + { + "type": "$x_event_handle_t" + }, + { + "type": "uint32_t" + }, + { + "type": "$x_event_handle_t*" + } + ] + }, + "$xCommandListImmediateGetIndex": { + "class": "$xCommandList", + "params": [ + { + "type": "$x_command_list_handle_t" + }, + { + "type": "uint32_t*" + } + ] + }, + "$xCommandListIsImmediate": { + "class": "$xCommandList", + "params": [ + { + "type": "$x_command_list_handle_t" + }, + { + "type": "$x_bool_t*" + } + ] + }, "$xCommandListReset": { "class": "$xCommandList", "params": [ @@ -6325,6 +7475,65 @@ } ] }, + "$xCommandListUpdateMutableCommandKernelsExp": { + "class": "$xCommandList", + "params": [ + { + "type": "$x_command_list_handle_t" + }, + { + "type": "uint32_t" + }, + { + "type": "uint64_t*" + }, + { + "type": "$x_kernel_handle_t*" + } + ] + }, + "$xCommandListUpdateMutableCommandSignalEventExp": { + "class": "$xCommandList", + "params": [ + { + "type": "$x_command_list_handle_t" + }, + { + "type": "uint64_t" + }, + { + "type": "$x_event_handle_t" + } + ] + }, + "$xCommandListUpdateMutableCommandWaitEventsExp": { + "class": "$xCommandList", + "params": [ + { + "type": "$x_command_list_handle_t" + }, + { + "type": "uint64_t" + }, + { + "type": "uint32_t" + }, + { + "type": "$x_event_handle_t*" + } + ] + }, + "$xCommandListUpdateMutableCommandsExp": { + "class": "$xCommandList", + "params": [ + { + "type": "$x_command_list_handle_t" + }, + { + "type": "const $x_mutable_commands_exp_desc_t*" + } + ] + }, "$xCommandQueueCreate": { "class": "$xCommandQueue", "params": [ @@ -6367,6 +7576,28 @@ } ] }, + "$xCommandQueueGetIndex": { + "class": "$xCommandQueue", + "params": [ + { + "type": "$x_command_queue_handle_t" + }, + { + "type": "uint32_t*" + } + ] + }, + "$xCommandQueueGetOrdinal": { + "class": "$xCommandQueue", + "params": [ + { + "type": "$x_command_queue_handle_t" + }, + { + "type": "uint32_t*" + } + ] + }, "$xCommandQueueSynchronize": { "class": "$xCommandQueue", "params": [ @@ -6870,6 +8101,39 @@ } ] }, + "$xEventGetEventPool": { + "class": "$xEvent", + "params": [ + { + "type": "$x_event_handle_t" + }, + { + "type": "$x_event_pool_handle_t*" + } + ] + }, + "$xEventGetSignalScope": { + "class": "$xEvent", + "params": [ + { + "type": "$x_event_handle_t" + }, + { + "type": "$x_event_scope_flags_t*" + } + ] + }, + "$xEventGetWaitScope": { + "class": "$xEvent", + "params": [ + { + "type": "$x_event_handle_t" + }, + { + "type": "$x_event_scope_flags_t*" + } + ] + }, "$xEventHostReset": { "class": "$xEvent", "params": [ @@ -6933,6 +8197,28 @@ } ] }, + "$xEventPoolGetContextHandle": { + "class": "$xEventPool", + "params": [ + { + "type": "$x_event_pool_handle_t" + }, + { + "type": "$x_context_handle_t*" + } + ] + }, + "$xEventPoolGetFlags": { + "class": "$xEventPool", + "params": [ + { + "type": "$x_event_pool_handle_t" + }, + { + "type": "$x_event_pool_flags_t*" + } + ] + }, "$xEventPoolGetIpcHandle": { "class": "$xEventPool", "params": [ @@ -7202,6 +8488,17 @@ } ] }, + "$xImageGetDeviceOffsetExp": { + "class": "$xImage", + "params": [ + { + "type": "$x_image_handle_t" + }, + { + "type": "uint64_t*" + } + ] + }, "$xImageGetMemoryPropertiesExp": { "class": "$xImage", "params": [ @@ -7275,6 +8572,20 @@ } ] }, + "$xInitDrivers": { + "class": "$x", + "params": [ + { + "type": "uint32_t*" + }, + { + "type": "$x_driver_handle_t*" + }, + { + "type": "$x_init_driver_type_desc_t*" + } + ] + }, "$xKernelCreate": { "class": "$xKernel", "params": [ @@ -7669,6 +8980,29 @@ } ] }, + "$xMemGetPitchFor2dImage": { + "class": "$xMem", + "params": [ + { + "type": "$x_context_handle_t" + }, + { + "type": "$x_device_handle_t" + }, + { + "type": "size_t" + }, + { + "type": "size_t" + }, + { + "type": "unsigned int" + }, + { + "type": "size_t *" + } + ] + }, "$xMemOpenIpcHandle": { "class": "$xMem", "params": [ @@ -8211,6 +9545,9 @@ "$s_temp_handle_t": { "class": "$sTemperature" }, + "$s_vf_handle_t": { + "class": "$sVFManagement" + }, "$t_command_list_handle_t": { "class": "$tCommandList" }, @@ -8229,12 +9566,18 @@ "$t_kernel_handle_t": { "class": "$tKernel" }, + "$t_metric_decoder_exp_handle_t": { + "class": "$tMetricDecoder" + }, "$t_metric_group_handle_t": { "class": "$tMetricGroup" }, "$t_metric_handle_t": { "class": "$tMetric" }, + "$t_metric_programmable_exp_handle_t": { + "class": "$tMetricProgrammable" + }, "$t_metric_query_handle_t": { "class": "$tMetricQuery" }, @@ -8244,6 +9587,9 @@ "$t_metric_streamer_handle_t": { "class": "$tMetricStreamer" }, + "$t_metric_tracer_exp_handle_t": { + "class": "$tMetricTracer" + }, "$t_module_handle_t": { "class": "$tModule" }, @@ -8330,6 +9676,18 @@ "32" ] }, + "$S_FIRMWARE_SECURITY_VERSION_EXP_NAME": { + "class": "", + "values": [ + "\"$XS_experimental_firmware_security_version\"" + ] + }, + "$S_MAX_EXTENSION_NAME": { + "class": "", + "values": [ + "256" + ] + }, "$S_MAX_FABRIC_LINK_TYPE_SIZE": { "class": "", "values": [ @@ -8354,6 +9712,24 @@ "16" ] }, + "$S_MEMORY_BANDWIDTH_COUNTER_BITS_EXP_PROPERTIES_NAME": { + "class": "", + "values": [ + "\"$XS_extension_mem_bandwidth_counter_bits_properties\"" + ] + }, + "$S_MEM_PAGE_OFFLINE_STATE_EXP_NAME": { + "class": "", + "values": [ + "\"$XS_extension_mem_state\"" + ] + }, + "$S_POWER_DOMAIN_PROPERTIES_EXP_NAME": { + "class": "", + "values": [ + "\"$XS_extension_power_domain_properties\"" + ] + }, "$S_POWER_LIMITS_EXT_NAME": { "class": "", "values": [ @@ -8378,12 +9754,30 @@ "64" ] }, + "$S_SYSMAN_DEVICE_MAPPING_EXP_NAME": { + "class": "", + "values": [ + "\"$XS_experimental_sysman_device_mapping\"" + ] + }, + "$S_VIRTUAL_FUNCTION_MANAGEMENT_EXP_NAME": { + "class": "", + "values": [ + "\"$XS_experimental_virtual_function_management\"" + ] + }, "$T_API_TRACING_EXP_NAME": { "class": "", "values": [ "\"$XT_experimental_api_tracing\"" ] }, + "$T_CONCURRENT_METRIC_GROUPS_EXP_NAME": { + "class": "", + "values": [ + "\"$XT_experimental_concurrent_metric_groups\"" + ] + }, "$T_EXPORT_METRICS_DATA_EXP_NAME": { "class": "", "values": [ @@ -8438,18 +9832,72 @@ "256" ] }, + "$T_MAX_METRIC_PROGRAMMABLE_COMPONENT_EXP": { + "class": "", + "values": [ + "128" + ] + }, + "$T_MAX_METRIC_PROGRAMMABLE_DESCRIPTION_EXP": { + "class": "", + "values": [ + "128" + ] + }, + "$T_MAX_METRIC_PROGRAMMABLE_NAME_EXP": { + "class": "", + "values": [ + "128" + ] + }, + "$T_MAX_METRIC_PROGRAMMABLE_PARAMETER_NAME_EXP": { + "class": "", + "values": [ + "128" + ] + }, + "$T_MAX_METRIC_PROGRAMMABLE_VALUE_DESCRIPTION_EXP": { + "class": "", + "values": [ + "128" + ] + }, "$T_MAX_METRIC_RESULT_UNITS": { "class": "", "values": [ "256" ] }, + "$T_MAX_PROGRAMMABLE_METRICS_ELEMENT_DESCRIPTION_EXP": { + "class": "", + "values": [ + "256" + ] + }, + "$T_MAX_PROGRAMMABLE_METRICS_ELEMENT_NAME_EXP": { + "class": "", + "values": [ + "256" + ] + }, + "$T_METRICS_TRACER_EXP_NAME": { + "class": "", + "values": [ + "\"$XT_experimental_metric_tracer\"" + ] + }, "$T_MULTI_METRICS_EXP_NAME": { "class": "", "values": [ "\"$XT_experimental_calculate_multiple_metrics\"" ] }, + "$T_PROGRAMMABLE_METRICS_EXP_NAME": { + "class": "", + "values": [ + "\"$XT_experimental_programmable_metrics\"" + ] + }, "$X_APICALL": { "class": "", "values": [ @@ -8464,6 +9912,12 @@ "" ] }, + "$X_API_VERSION_CURRENT_M": { + "class": "", + "values": [ + "$X_MAKE_VERSION( 1, 11 )" + ] + }, "$X_BANDWIDTH_PROPERTIES_EXP_NAME": { "class": "", "values": [ @@ -8476,6 +9930,12 @@ "\"$X_extension_bfloat16_conversions\"" ] }, + "$X_BINDLESS_IMAGE_EXP_NAME": { + "class": "", + "values": [ + "\"$X_experimental_bindless_image\"" + ] + }, "$X_BIT": { "class": "", "values": [ @@ -8488,6 +9948,12 @@ "\"$X_extension_cache_reservation\"" ] }, + "$X_COMMAND_LIST_CLONE_EXP_NAME": { + "class": "", + "values": [ + "\"$X_experimental_command_list_clone\"" + ] + }, "$X_CONTEXT_POWER_SAVING_HINT_EXP_NAME": { "class": "", "values": [ @@ -8525,6 +9991,12 @@ "\"$X_extension_eu_count\"" ] }, + "$X_EVENT_POOL_COUNTER_BASED_EXP_NAME": { + "class": "", + "values": [ + "\"$X_experimental_event_pool_counter_based\"" + ] + }, "$X_EVENT_QUERY_KERNEL_TIMESTAMPS_EXT_NAME": { "class": "", "values": [ @@ -8549,6 +10021,12 @@ "\"$X_extension_float_atomics\"" ] }, + "$X_GET_KERNEL_BINARY_EXP_NAME": { + "class": "", + "values": [ + "\"$X_extension_kernel_binary_exp\"" + ] + }, "$X_GLOBAL_OFFSET_EXP_NAME": { "class": "", "values": [ @@ -8597,6 +10075,12 @@ "\"$X_extension_image_view_planar\"" ] }, + "$X_IMMEDIATE_COMMAND_LIST_APPEND_EXP_NAME": { + "class": "", + "values": [ + "\"$X_experimental_immediate_command_list_append\"" + ] + }, "$X_KERNEL_MAX_GROUP_SIZE_PROPERTIES_EXT_NAME": { "class": "", "values": [ @@ -8681,6 +10165,12 @@ "16" ] }, + "$X_MAX_METRIC_GROUP_NAME_PREFIX": { + "class": "", + "values": [ + "64" + ] + }, "$X_MAX_MODULE_UUID_SIZE": { "class": "", "values": [ @@ -8723,6 +10213,12 @@ "\"$X_experimental_module_program\"" ] }, + "$X_MUTABLE_COMMAND_LIST_EXP_NAME": { + "class": "", + "values": [ + "\"$X_experimental_mutable_command_list\"" + ] + }, "$X_PCI_PROPERTIES_EXT_NAME": { "class": "", "values": [ @@ -9066,6 +10562,23 @@ } ] }, + "$s_driver_extension_properties_t": { + "class": "$sDriver", + "members": [ + { + "desc": "[out] extension name", + "init": null, + "name": "name[$S_MAX_EXTENSION_NAME]", + "type": "char" + }, + { + "desc": "[out] extension version using $X_MAKE_VERSION", + "init": null, + "name": "version", + "type": "uint32_t" + } + ] + }, "$s_energy_threshold_t": { "class": "$sPower", "members": [ @@ -9127,13 +10640,13 @@ "class": "$sEngine", "members": [ { - "desc": "[out] Monotonic counter for time in microseconds that this resource is actively running workloads.", + "desc": "[out] Monotonic counter where the resource is actively running workloads.", "init": null, "name": "activeTime", "type": "uint64_t" }, { - "desc": "[out] Monotonic timestamp counter in microseconds when activeTime counter was sampled.\nThis timestamp should only be used to calculate delta time between snapshots of this structure.\nNever take the delta of this timestamp with the timestamp from a different structure since they are not guaranteed to have the same base.\nThe absolute value of the timestamp is only valid during within the application and may be different on the next execution.\n", + "desc": "[out] Monotonic counter when activeTime counter was sampled.", "init": null, "name": "timestamp", "type": "uint64_t" @@ -9689,6 +11202,17 @@ } ] }, + "$s_mem_bandwidth_counter_bits_exp_properties_t": { + "class": "$sMemory", + "members": [ + { + "desc": "[out] Returns the number of valid bits in the counter values", + "init": null, + "name": "validBitsCount", + "type": "uint32_t" + } + ] + }, "$s_mem_bandwidth_t": { "class": "$sMemory", "members": [ @@ -9729,6 +11253,23 @@ } ] }, + "$s_mem_page_offline_state_exp_t": { + "class": "$sMemory", + "members": [ + { + "desc": "[out] Returns the number of Memory Pages Offline", + "init": null, + "name": "memoryPageOffline", + "type": "uint32_t" + }, + { + "desc": "[out] Returns the Allowed Memory Pages Offline", + "init": null, + "name": "maxMemoryPageOffline", + "type": "uint32_t" + } + ] + }, "$s_mem_properties_t": { "class": "$sMemory", "members": [ @@ -10178,6 +11719,17 @@ } ] }, + "$s_power_domain_exp_properties_t": { + "class": "$sPower", + "members": [ + { + "desc": "[out] Power domain associated with the power handle.", + "init": null, + "name": "powerDomain", + "type": "$s_power_domain_t" + } + ] + }, "$s_power_energy_counter_t": { "class": "$sPower", "members": [ @@ -10616,6 +12168,23 @@ } ] }, + "$s_subdevice_exp_properties_t": { + "class": "$sDevice", + "members": [ + { + "desc": "[out] this gives the ID of the sub device", + "init": null, + "name": "subdeviceId", + "type": "uint32_t" + }, + { + "desc": "[out] universal unique identifier of the sub device.", + "init": null, + "name": "uuid", + "type": "$s_uuid_t" + } + ] + }, "$s_temp_config_t": { "class": "$sTemperature", "members": [ @@ -10720,6 +12289,52 @@ } ] }, + "$s_vf_exp_capabilities_t": { + "class": "$sVFManagement", + "members": [ + { + "desc": "[out] Virtual function BDF address", + "init": null, + "name": "address", + "type": "$s_pci_address_t" + }, + { + "desc": "[out] Virtual function memory size in bytes", + "init": null, + "name": "vfDeviceMemSize", + "type": "uint32_t" + }, + { + "desc": "[out] Virtual Function ID", + "init": null, + "name": "vfID", + "type": "uint32_t" + } + ] + }, + "$s_vf_exp_properties_t": { + "class": "$sVFManagement", + "members": [ + { + "desc": "[out] Virtual function BDF address", + "init": null, + "name": "address", + "type": "$s_pci_address_t" + }, + { + "desc": "[out] universal unique identifier of the device", + "init": null, + "name": "uuid", + "type": "$s_uuid_t" + }, + { + "desc": "[out] utilization flags available. May be 0 or a valid combination of $s_vf_info_util_exp_flag_t.", + "init": null, + "name": "flags", + "type": "$s_vf_info_util_exp_flags_t" + } + ] + }, "$s_vf_property_t": { "class": "$sOverclock", "members": [ @@ -10761,6 +12376,104 @@ } ] }, + "$s_vf_util_engine_exp2_t": { + "class": "$sVFManagement", + "members": [ + { + "desc": "[out] The engine group.", + "init": null, + "name": "vfEngineType", + "type": "$s_engine_group_t" + }, + { + "desc": "[out] Represents active counter.", + "init": null, + "name": "activeCounterValue", + "type": "uint64_t" + }, + { + "desc": "[out] Represents counter value when activeCounterValue was sampled. Refer to the formulae above for calculating the utilization percent", + "init": null, + "name": "samplingCounterValue", + "type": "uint64_t" + } + ] + }, + "$s_vf_util_engine_exp_t": { + "class": "$sVFManagement", + "members": [ + { + "desc": "[out] The engine group.", + "init": null, + "name": "type", + "type": "$s_engine_group_t" + }, + { + "desc": "[out] Represents active counter.", + "init": null, + "name": "activeCounterValue", + "type": "uint64_t" + }, + { + "desc": "[out] Represents counter value when activeCounterValue was sampled.", + "init": null, + "name": "samplingCounterValue", + "type": "uint64_t" + }, + { + "desc": "[out] Wall clock time when the activeCounterValue was sampled.", + "init": null, + "name": "timestamp", + "type": "uint64_t" + } + ] + }, + "$s_vf_util_mem_exp2_t": { + "class": "$sVFManagement", + "members": [ + { + "desc": "[out] Location of this memory (system, device)", + "init": null, + "name": "vfMemLocation", + "type": "$s_mem_loc_t" + }, + { + "desc": "[out] Free memory size in bytes.", + "init": null, + "name": "vfMemUtilized", + "type": "uint64_t" + } + ] + }, + "$s_vf_util_mem_exp_t": { + "class": "$sVFManagement", + "members": [ + { + "desc": "[out] Memory type flags.", + "init": null, + "name": "memTypeFlags", + "type": "$s_vf_info_mem_type_exp_flags_t" + }, + { + "desc": "[out] Free memory size in bytes.", + "init": null, + "name": "free", + "type": "uint64_t" + }, + { + "desc": "[out] Total allocatable memory in bytes.", + "init": null, + "name": "size", + "type": "uint64_t" + }, + { + "desc": "[out] Wall clock time from VF when value was sampled.", + "init": null, + "name": "timestamp", + "type": "uint64_t" + } + ] + }, "$t_base_desc_t": { "class": "", "members": [ @@ -10978,6 +12691,23 @@ } ] }, + "$t_export_dma_buf_exp_properties_t": { + "class": "$tMetric", + "members": [ + { + "desc": "[out] the file descriptor handle that could be used to import the memory by the host process.", + "init": null, + "name": "fd", + "type": "int" + }, + { + "desc": "[out] size in bytes of the dma_buf", + "init": null, + "name": "size", + "type": "size_t" + } + ] + }, "$t_metric_calculate_exp_desc_t": { "class": "$tMetric", "members": [ @@ -10989,6 +12719,41 @@ } ] }, + "$t_metric_entry_exp_t": { + "class": "", + "members": [ + { + "desc": "[out] value of the decodable metric entry or event. Number is meaningful based on the metric type.", + "init": null, + "name": "value", + "type": "$t_value_t" + }, + { + "desc": "[out] timestamp at which the event happened.", + "init": null, + "name": "timeStamp", + "type": "uint64_t" + }, + { + "desc": "[out] index to the decodable metric handle in the input array (phMetric) in $tMetricTracerDecodeExp().", + "init": null, + "name": "metricIndex", + "type": "uint32_t" + }, + { + "desc": "[out] True if the event occurred on a sub-device; false means the device on which the metric tracer was opened does not have sub-devices.", + "init": null, + "name": "onSubdevice", + "type": "$x_bool_t" + }, + { + "desc": "[out] If onSubdevice is true, this gives the ID of the sub-device.", + "init": null, + "name": "subdeviceId", + "type": "uint32_t" + } + ] + }, "$t_metric_global_timestamps_resolution_exp_t": { "class": "$tMetric", "members": [ @@ -11041,6 +12806,133 @@ } ] }, + "$t_metric_group_type_exp_t": { + "class": "$tMetricGroup", + "members": [ + { + "desc": "[out] metric group type.\nreturns a combination of $t_metric_group_type_exp_flags_t.\n", + "init": null, + "name": "type", + "type": "$t_metric_group_type_exp_flags_t" + } + ] + }, + "$t_metric_programmable_exp_properties_t": { + "class": "$tMetricProgrammable", + "members": [ + { + "desc": "[out] metric programmable name", + "init": null, + "name": "name[$T_MAX_METRIC_PROGRAMMABLE_NAME_EXP]", + "type": "char" + }, + { + "desc": "[out] metric programmable description", + "init": null, + "name": "description[$T_MAX_METRIC_PROGRAMMABLE_DESCRIPTION_EXP]", + "type": "char" + }, + { + "desc": "[out] metric programmable component", + "init": null, + "name": "component[$T_MAX_METRIC_PROGRAMMABLE_COMPONENT_EXP]", + "type": "char" + }, + { + "desc": "[out] tier number", + "init": null, + "name": "tierNumber", + "type": "uint32_t" + }, + { + "desc": "[out] metric domain number.", + "init": null, + "name": "domain", + "type": "uint32_t" + }, + { + "desc": "[out] number of parameters in the programmable", + "init": null, + "name": "parameterCount", + "type": "uint32_t" + }, + { + "desc": "[out] metric sampling type.\nreturns a combination of $t_metric_group_sampling_type_flag_t.\n", + "init": null, + "name": "samplingType", + "type": "$t_metric_group_sampling_type_flags_t" + }, + { + "desc": "[out] unique metric source identifier(within platform)to identify the HW block where the metric is collected.", + "init": null, + "name": "sourceId", + "type": "uint32_t" + } + ] + }, + "$t_metric_programmable_param_info_exp_t": { + "class": "$tMetricProgrammable", + "members": [ + { + "desc": "[out] programmable parameter type", + "init": null, + "name": "type", + "type": "$t_metric_programmable_param_type_exp_t" + }, + { + "desc": "[out] metric programmable parameter name", + "init": null, + "name": "name[$T_MAX_METRIC_PROGRAMMABLE_PARAMETER_NAME_EXP]", + "type": "char" + }, + { + "desc": "[out] value info type", + "init": null, + "name": "valueInfoType", + "type": "$t_value_info_type_exp_t" + }, + { + "desc": "[out] default value for the parameter", + "init": null, + "name": "defaultValue", + "type": "$t_value_t" + }, + { + "desc": "[out] count of $t_metric_programmable_param_value_info_exp_t", + "init": null, + "name": "valueInfoCount", + "type": "uint32_t" + } + ] + }, + "$t_metric_programmable_param_value_exp_t": { + "class": "$tMetricProgrammable", + "members": [ + { + "desc": "[in] parameter value", + "init": null, + "name": "value", + "type": "$t_value_t" + } + ] + }, + "$t_metric_programmable_param_value_info_exp_t": { + "class": "$tMetricProgrammable", + "members": [ + { + "desc": "[out] information about the parameter value", + "init": null, + "name": "valueInfo", + "type": "$t_value_info_exp_t" + }, + { + "desc": "[out] description about the value", + "init": null, + "name": "description[$T_MAX_METRIC_PROGRAMMABLE_VALUE_DESCRIPTION_EXP]", + "type": "char" + } + ] + }, "$t_metric_properties_t": { "class": "$tMetric", "members": [ @@ -11122,6 +13014,17 @@ } ] }, + "$t_metric_tracer_exp_desc_t": { + "class": "$tMetricTracer", + "members": [ + { + "desc": "[in,out] number of collected bytes after which notification event will be signaled. If the requested value is not supported exactly, then the driver may use a value that is the closest supported approximation and shall update this member during $tMetricTracerCreateExp.\n", + "init": null, + "name": "notifyEveryNBytes", + "type": "uint32_t" + } + ] + }, "$t_profile_free_register_token_t": { "class": "$tKernel", "members": [ @@ -11207,6 +13110,40 @@ } ] }, + "$t_value_fp64_range_exp_t": { + "class": "", + "members": [ + { + "desc": "[out] minimum value of the range", + "init": null, + "name": "fp64Min", + "type": "double" + }, + { + "desc": "[out] maximum value of the range", + "init": null, + "name": "fp64Max", + "type": "double" + } + ] + }, + "$t_value_uint64_range_exp_t": { + "class": "", + "members": [ + { + "desc": "[out] minimum value of the range", + "init": null, + "name": "ui64Min", + "type": "uint64_t" + }, + { + "desc": "[out] maximum value of the range", + "init": null, + "name": "ui64Max", + "type": "uint64_t" + } + ] + }, "$x_base_cb_params_t": { "class": "", "members": [ @@ -11854,6 +13791,23 @@ } ] }, + "$x_device_pitched_alloc_exp_properties_t": { + "class": "$xDevice", + "members": [ + { + "desc": "[out] Maximum image linear width.", + "init": null, + "name": "maxImageLinearWidth", + "type": "size_t" + }, + { + "desc": "[out] Maximum image linear height.", + "init": null, + "name": "maxImageLinearHeight", + "type": "size_t" + } + ] + }, "$x_device_properties_t": { "class": "$xDevice", "members": [ @@ -11870,7 +13824,7 @@ "type": "uint32_t" }, { - "desc": "[out] device id from PCI configuration\nNote, the device id uses little-endian format.\n", + "desc": "[out] device id from PCI configuration.\nNote, the device id uses little-endian format.\n", "init": null, "name": "deviceId", "type": "uint32_t" @@ -12131,6 +14085,17 @@ } ] }, + "$x_event_pool_counter_based_exp_desc_t": { + "class": "$xEventPool", + "members": [ + { + "desc": "[in] mode flags.\nmust be 0 (default) or a valid value of $x_event_pool_counter_based_exp_flag_t\ndefault behavior is counter-based event pool is only used for immediate command lists.\n", + "init": "0", + "name": "flags", + "type": "$x_event_pool_counter_based_exp_flags_t" + } + ] + }, "$x_event_pool_desc_t": { "class": "$xEventPool", "members": [ @@ -12445,6 +14410,17 @@ } ] }, + "$x_image_bindless_exp_desc_t": { + "class": "$xImage", + "members": [ + { + "desc": "[in] image flags.\nmust be 0 (default) or a valid value of $x_image_bindless_exp_flag_t\ndefault behavior is bindless images are not used when creating handles via $xImageCreate.\nWhen the flag is passed to $xImageCreate, then only the memory for the image is allocated.\nAdditional image handles can be created with $xImageViewCreateExt.\nWhen $X_IMAGE_BINDLESS_EXP_FLAG_SAMPLED_IMAGE flag is passed, $x_sampler_desc_t must be attached via pNext member of $x_image_bindless_exp_desc_t.\n", + "init": "0", + "name": "flags", + "type": "$x_image_bindless_exp_flags_t" + } + ] + }, "$x_image_desc_t": { "class": "$xImage", "members": [ @@ -12562,6 +14538,17 @@ } ] }, + "$x_image_pitched_exp_desc_t": { + "class": "$xImage", + "members": [ + { + "desc": "[in] pointer to pitched device allocation allocated using $xMemAllocDevice\n", + "init": "0", + "name": "ptr", + "type": "void*" + } + ] + }, "$x_image_properties_t": { "class": "$xImage", "members": [ @@ -12636,6 +14623,17 @@ } ] }, + "$x_init_driver_type_desc_t": { + "class": "$x", + "members": [ + { + "desc": "[in] driver type init flags.\nmust be a valid combination of $x_init_driver_type_flag_t or UINT32_MAX;\ndriver types are init and retrieved based on these init flags in zeInitDrivers().\n", + "init": "0", + "name": "flags", + "type": "$x_init_driver_type_flags_t" + } + ] + }, "$x_ipc_event_pool_handle_t": { "class": "", "members": [ @@ -13002,6 +15000,183 @@ } ] }, + "$x_mutable_command_id_exp_desc_t": { + "class": "$xCommandList", + "members": [ + { + "desc": "[in] mutable command flags.\n - must be 0 (default, equivalent to setting all flags bar kernel instruction), or a valid combination of $x_mutable_command_exp_flag_t\n - in order to include kernel instruction mutation, $X_MUTABLE_COMMAND_EXP_FLAG_KERNEL_INSTRUCTION must be explictly included\n", + "init": null, + "name": "flags", + "type": "$x_mutable_command_exp_flags_t" + } + ] + }, + "$x_mutable_command_list_exp_desc_t": { + "class": "$xCommandList", + "members": [ + { + "desc": "[in] mutable command list flags.\n - must be 0 (default) or a valid combination of $x_mutable_command_list_exp_flag_t\n", + "init": null, + "name": "flags", + "type": "$x_mutable_command_list_exp_flags_t" + } + ] + }, + "$x_mutable_command_list_exp_properties_t": { + "class": "$xCommandList", + "members": [ + { + "desc": "[out] mutable command list flags", + "init": null, + "name": "mutableCommandListFlags", + "type": "$x_mutable_command_list_exp_flags_t" + }, + { + "desc": "[out] mutable command flags", + "init": null, + "name": "mutableCommandFlags", + "type": "$x_mutable_command_exp_flags_t" + } + ] + }, + "$x_mutable_commands_exp_desc_t": { + "class": "$xCommandList", + "members": [ + { + "desc": "[in] must be 0, this field is reserved for future use", + "init": null, + "name": "flags", + "type": "uint32_t" + } + ] + }, + "$x_mutable_global_offset_exp_desc_t": { + "class": "$xCommandList", + "members": [ + { + "desc": "[in] command identifier", + "init": null, + "name": "commandId", + "type": "uint64_t" + }, + { + "desc": "[in] global offset for X dimension to use for this kernel", + "init": null, + "name": "offsetX", + "type": "uint32_t" + }, + { + "desc": "[in] global offset for Y dimension to use for this kernel", + "init": null, + "name": "offsetY", + "type": "uint32_t" + }, + { + "desc": "[in] global offset for Z dimension to use for this kernel", + "init": null, + "name": "offsetZ", + "type": "uint32_t" + } + ] + }, + "$x_mutable_graph_argument_exp_desc_t": { + "class": "$xCommandList", + "members": [ + { + "desc": "[in] command identifier", + "init": null, + "name": "commandId", + "type": "uint64_t" + }, + { + "desc": "[in] graph argument index", + "init": null, + "name": "argIndex", + "type": "uint32_t" + }, + { + "desc": "[in] pointer to graph argument value", + "init": null, + "name": "pArgValue", + "type": "const void*" + } + ] + }, + "$x_mutable_group_count_exp_desc_t": { + "class": "$xCommandList", + "members": [ + { + "desc": "[in] command identifier", + "init": null, + "name": "commandId", + "type": "uint64_t" + }, + { + "desc": "[in] pointer to group count", + "init": null, + "name": "pGroupCount", + "type": "const $x_group_count_t*" + } + ] + }, + "$x_mutable_group_size_exp_desc_t": { + "class": "$xCommandList", + "members": [ + { + "desc": "[in] command identifier", + "init": null, + "name": "commandId", + "type": "uint64_t" + }, + { + "desc": "[in] group size for X dimension to use for the kernel", + "init": null, + "name": "groupSizeX", + "type": "uint32_t" + }, + { + "desc": "[in] group size for Y dimension to use for the kernel", + "init": null, + "name": "groupSizeY", + "type": "uint32_t" + }, + { + "desc": "[in] group size for Z dimension to use for the kernel", + "init": null, + "name": "groupSizeZ", + "type": "uint32_t" + } + ] + }, + "$x_mutable_kernel_argument_exp_desc_t": { + "class": "$xCommandList", + "members": [ + { + "desc": "[in] command identifier", + "init": null, + "name": "commandId", + "type": "uint64_t" + }, + { + "desc": "[in] kernel argument index", + "init": null, + "name": "argIndex", + "type": "uint32_t" + }, + { + "desc": "[in] kernel argument size", + "init": null, + "name": "argSize", + "type": "size_t" + }, + { + "desc": "[in] pointer to kernel argument value", + "init": null, + "name": "pArgValue", + "type": "const void*" + } + ] + }, "$x_native_kernel_uuid_t": { "class": "$xDevice", "members": [ @@ -13086,7 +15261,7 @@ "class": "$xPhysicalMem", "members": [ { - "desc": "[in] creation flags.\nmust be 0 (default) or a valid combination of $x_physical_mem_flag_t.\n", + "desc": "[in] creation flags.\nmust be 0 (default) or a valid combination of $x_physical_mem_flag_t; default is to create physical device memory.\n", "init": "0", "name": "flags", "type": "$x_physical_mem_flags_t" @@ -14043,7 +16218,7 @@ } ] }, - "$t_value_t": { + "$t_value_info_exp_t": { "class": "", "members": [ { @@ -14052,9 +16227,68 @@ "name": "ui32", "type": "uint32_t" }, + { + "desc": "[out] 64-bit unsigned-integer", + "init": null, + "name": "ui64", + "type": "uint64_t" + }, + { + "desc": "[out] 32-bit floating-point", + "init": null, + "name": "fp32", + "type": "float" + }, + { + "desc": "[out] 64-bit floating-point", + "init": null, + "name": "fp64", + "type": "double" + }, + { + "desc": "[out] 8-bit boolean", + "init": null, + "name": "b8", + "type": "$x_bool_t" + }, + { + "desc": "[out] 8-bit unsigned integer", + "init": null, + "name": "ui8", + "type": "uint8_t" + }, + { + "desc": "[out] 16-bit unsigned integer", + "init": null, + "name": "ui16", + "type": "uint16_t" + }, + { + "desc": "[out] minimum and maximum value of the range", + "init": null, + "name": "ui64Range", + "type": "$t_value_uint64_range_exp_t" + }, + { + "desc": "[out] minimum and maximum value of the range", + "init": null, + "name": "fp64Range", + "type": "$t_value_fp64_range_exp_t" + } + ] + }, + "$t_value_t": { + "class": "", + "members": [ { "desc": "[out] 32-bit unsigned-integer", "init": null, + "name": "ui32", + "type": "uint32_t" + }, + { + "desc": "[out] 64-bit unsigned-integer", + "init": null, "name": "ui64", "type": "uint64_t" }, @@ -14765,6 +16999,26 @@ "owner": "zesDevice", "type": "class" }, + "zesVFManagement": { + "desc": "C++ wrapper for a Sysman virtual function management group", + "members": [ + { + "desc": "[in] handle of Sysman virtual function object", + "init": "nullptr", + "name": "handle", + "type": "zes_vf_handle_t" + }, + { + "desc": "[in] pointer to owner object", + "name": "pDevice", + "type": "zesDevice*" + } + ], + "name": "zesVFManagement", + "owner": "zesDevice", + "type": "class", + "version": "1.9" + }, "zetCommandList": { "base": "zeCommandList", "desc": "C++ wrapper for command list", @@ -15001,10 +17255,34 @@ "value": "ZE_MAKE_VERSION( 1, 7 )", "version": "1.7" }, + { + "desc": "version 1.8", + "name": "ZE_API_VERSION_1_8", + "value": "ZE_MAKE_VERSION( 1, 8 )", + "version": "1.8" + }, + { + "desc": "version 1.9", + "name": "ZE_API_VERSION_1_9", + "value": "ZE_MAKE_VERSION( 1, 9 )", + "version": "1.9" + }, + { + "desc": "version 1.10", + "name": "ZE_API_VERSION_1_10", + "value": "ZE_MAKE_VERSION( 1, 10 )", + "version": "1.10" + }, + { + "desc": "version 1.11", + "name": "ZE_API_VERSION_1_11", + "value": "ZE_MAKE_VERSION( 1, 11 )", + "version": "1.11" + }, { "desc": "latest known version", "name": "ZE_API_VERSION_CURRENT", - "value": "ZE_MAKE_VERSION( 1, 7 )" + "value": "ZE_MAKE_VERSION( 1, 11 )" } ], "name": "ze_api_version_t", @@ -15051,6 +17329,24 @@ "type": "enum", "version": "1.5" }, + "ze_bindless_image_exp_version_t": { + "desc": "Bindless Image Extension Version(s)", + "etors": [ + { + "desc": "version 1.0", + "name": "ZE_BINDLESS_IMAGE_EXP_VERSION_1_0", + "value": "ZE_MAKE_VERSION( 1, 0 )" + }, + { + "desc": "latest known version", + "name": "ZE_BINDLESS_IMAGE_EXP_VERSION_CURRENT", + "value": "ZE_MAKE_VERSION( 1, 0 )" + } + ], + "name": "ze_bindless_image_exp_version_t", + "type": "enum", + "version": "1.9" + }, "ze_cache_config_flags_t": { "class": "zeKernel", "desc": "Supported Cache Config flags", @@ -15147,6 +17443,24 @@ "type": "enum", "version": "1.2" }, + "ze_command_list_clone_exp_version_t": { + "desc": "Command List Clone Extension Version(s)", + "etors": [ + { + "desc": "version 1.0", + "name": "ZE_COMMAND_LIST_CLONE_EXP_VERSION_1_0", + "value": "ZE_MAKE_VERSION( 1, 0 )" + }, + { + "desc": "latest known version", + "name": "ZE_COMMAND_LIST_CLONE_EXP_VERSION_CURRENT", + "value": "ZE_MAKE_VERSION( 1, 0 )" + } + ], + "name": "ze_command_list_clone_exp_version_t", + "type": "enum", + "version": "1.9" + }, "ze_command_list_flags_t": { "class": "zeCommandList", "desc": "Supported command list creation flags", @@ -15171,6 +17485,12 @@ "name": "ZE_COMMAND_LIST_FLAG_IN_ORDER", "value": "ZE_BIT(3)", "version": "1.7" + }, + { + "desc": "this command list may be cloned using zeCommandListCreateCloneExp after zeCommandListClose.", + "name": "ZE_COMMAND_LIST_FLAG_EXP_CLONEABLE", + "value": "ZE_BIT(4)", + "version": "1.9" } ], "name": "ze_command_list_flags_t", @@ -15750,6 +18070,43 @@ "type": "enum", "version": "1.3" }, + "ze_event_pool_counter_based_exp_flags_t": { + "class": "zeEventPool", + "desc": "Supported event flags for defining counter-based event pools.", + "etors": [ + { + "desc": "Counter-based event pool is used for immediate command lists (default)", + "name": "ZE_EVENT_POOL_COUNTER_BASED_EXP_FLAG_IMMEDIATE", + "value": "ZE_BIT(0)" + }, + { + "desc": "Counter-based event pool is for non-immediate command lists", + "name": "ZE_EVENT_POOL_COUNTER_BASED_EXP_FLAG_NON_IMMEDIATE", + "value": "ZE_BIT(1)" + } + ], + "name": "ze_event_pool_counter_based_exp_flags_t", + "type": "enum", + "version": "1.8" + }, + "ze_event_pool_counter_based_exp_version_t": { + "desc": "Counter-based Event Pools Extension Version(s)", + "etors": [ + { + "desc": "version 1.0", + "name": "ZE_EVENT_POOL_COUNTER_BASED_EXP_VERSION_1_0", + "value": "ZE_MAKE_VERSION( 1, 0 )" + }, + { + "desc": "latest known version", + "name": "ZE_EVENT_POOL_COUNTER_BASED_EXP_VERSION_CURRENT", + "value": "ZE_MAKE_VERSION( 1, 0 )" + } + ], + "name": "ze_event_pool_counter_based_exp_version_t", + "type": "enum", + "version": "1.8" + }, "ze_event_pool_flags_t": { "class": "zeEventPool", "desc": "Supported event pool creation flags", @@ -16041,6 +18398,25 @@ "name": "ze_host_mem_alloc_flags_t", "type": "enum" }, + "ze_image_bindless_exp_flags_t": { + "class": "zeImage", + "desc": "Image flags for Bindless images", + "etors": [ + { + "desc": "Bindless images are created with zeImageCreate. The image handle created with this flag is valid on both host and device.", + "name": "ZE_IMAGE_BINDLESS_EXP_FLAG_BINDLESS", + "value": "ZE_BIT(0)" + }, + { + "desc": "Bindless sampled images are created with zeImageCreate by combining BINDLESS and SAMPLED_IMAGE.\nCreate sampled image view from bindless unsampled image using SAMPLED_IMAGE.\n", + "name": "ZE_IMAGE_BINDLESS_EXP_FLAG_SAMPLED_IMAGE", + "value": "ZE_BIT(1)" + } + ], + "name": "ze_image_bindless_exp_flags_t", + "type": "enum", + "version": "1.9" + }, "ze_image_copy_ext_version_t": { "desc": "Image Copy Extension Version(s)", "etors": [ @@ -16295,6 +18671,24 @@ "desc": "Media Format: BRGP. Format type and swizzle is ignored for this.", "name": "ZE_IMAGE_FORMAT_LAYOUT_BRGP", "value": "42" + }, + { + "desc": "3-component 8-bit layout", + "name": "ZE_IMAGE_FORMAT_LAYOUT_8_8_8", + "value": "43", + "version": "1.9" + }, + { + "desc": "3-component 16-bit layout", + "name": "ZE_IMAGE_FORMAT_LAYOUT_16_16_16", + "value": "44", + "version": "1.9" + }, + { + "desc": "3-component 32-bit layout", + "name": "ZE_IMAGE_FORMAT_LAYOUT_32_32_32", + "value": "45", + "version": "1.9" } ], "name": "ze_image_format_layout_t", @@ -16540,6 +18934,52 @@ "type": "enum", "version": "1.5" }, + "ze_immediate_command_list_append_exp_version_t": { + "desc": "Immediate Command List Append Extension Version(s)", + "etors": [ + { + "desc": "version 1.0", + "name": "ZE_IMMEDIATE_COMMAND_LIST_APPEND_EXP_VERSION_1_0", + "value": "ZE_MAKE_VERSION( 1, 0 )" + }, + { + "desc": "latest known version", + "name": "ZE_IMMEDIATE_COMMAND_LIST_APPEND_EXP_VERSION_CURRENT", + "value": "ZE_MAKE_VERSION( 1, 0 )" + } + ], + "name": "ze_immediate_command_list_append_exp_version_t", + "type": "enum", + "version": "1.9" + }, + "ze_init_driver_type_flags_t": { + "class": "ze", + "desc": "Supported driver initialization type flags", + "details": [ + "Bit Field which details the driver types to be initialized and returned to the user.", + "Value Definition:", + "0, do not init or retrieve any drivers.", + "ZE_INIT_DRIVER_TYPE_FLAG_GPU,\tGPU Drivers are Init and driver handles retrieved.", + "ZE_INIT_DRIVER_TYPE_FLAG_NPU,\tNPU Drivers are Init and driver handles retrieved.", + "ZE_INIT_DRIVER_TYPE_FLAG_GPU | ZE_INIT_DRIVER_TYPE_FLAG_NPU, NPU & GPU Drivers are Init and driver handles retrieved.", + "UINT32_MAX\tAll Drivers of any type are Init and driver handles retrieved." + ], + "etors": [ + { + "desc": "initialize and retrieve GPU drivers", + "name": "ZE_INIT_DRIVER_TYPE_FLAG_GPU", + "value": "ZE_BIT(0)" + }, + { + "desc": "initialize and retrieve NPU drivers", + "name": "ZE_INIT_DRIVER_TYPE_FLAG_NPU", + "value": "ZE_BIT(1)" + } + ], + "name": "ze_init_driver_type_flags_t", + "type": "enum", + "version": "1.10" + }, "ze_init_flags_t": { "class": "ze", "desc": "Supported initialization flags", @@ -17051,6 +19491,95 @@ "name": "ze_module_property_flags_t", "type": "enum" }, + "ze_mutable_command_exp_flags_t": { + "class": "zeCommandList", + "desc": "Mutable command flags", + "etors": [ + { + "desc": "kernel arguments", + "name": "ZE_MUTABLE_COMMAND_EXP_FLAG_KERNEL_ARGUMENTS", + "value": "ZE_BIT(0)" + }, + { + "desc": "kernel group count", + "name": "ZE_MUTABLE_COMMAND_EXP_FLAG_GROUP_COUNT", + "value": "ZE_BIT(1)" + }, + { + "desc": "kernel group size", + "name": "ZE_MUTABLE_COMMAND_EXP_FLAG_GROUP_SIZE", + "value": "ZE_BIT(2)" + }, + { + "desc": "kernel global offset", + "name": "ZE_MUTABLE_COMMAND_EXP_FLAG_GLOBAL_OFFSET", + "value": "ZE_BIT(3)" + }, + { + "desc": "command signal event", + "name": "ZE_MUTABLE_COMMAND_EXP_FLAG_SIGNAL_EVENT", + "value": "ZE_BIT(4)" + }, + { + "desc": "command wait events", + "name": "ZE_MUTABLE_COMMAND_EXP_FLAG_WAIT_EVENTS", + "value": "ZE_BIT(5)" + }, + { + "desc": "command kernel", + "name": "ZE_MUTABLE_COMMAND_EXP_FLAG_KERNEL_INSTRUCTION", + "value": "ZE_BIT(6)", + "version": "1.10" + }, + { + "desc": "graph arguments", + "name": "ZE_MUTABLE_COMMAND_EXP_FLAG_GRAPH_ARGUMENTS", + "value": "ZE_BIT(7)", + "version": "1.10" + } + ], + "name": "ze_mutable_command_exp_flags_t", + "type": "enum", + "version": "1.9" + }, + "ze_mutable_command_list_exp_flags_t": { + "class": "zeCommandList", + "desc": "Mutable command list flags", + "etors": [ + { + "desc": "reserved", + "name": "ZE_MUTABLE_COMMAND_LIST_EXP_FLAG_RESERVED", + "value": "ZE_BIT(0)" + } + ], + "name": "ze_mutable_command_list_exp_flags_t", + "type": "enum", + "version": "1.9" + }, + "ze_mutable_command_list_exp_version_t": { + "desc": "Mutable Command List Extension Version(s)", + "etors": [ + { + "desc": "version 1.0", + "name": "ZE_MUTABLE_COMMAND_LIST_EXP_VERSION_1_0", + "value": "ZE_MAKE_VERSION( 1, 0 )" + }, + { + "desc": "version 1.1", + "name": "ZE_MUTABLE_COMMAND_LIST_EXP_VERSION_1_1", + "value": "ZE_MAKE_VERSION( 1, 1 )", + "version": "1.10" + }, + { + "desc": "latest known version", + "name": "ZE_MUTABLE_COMMAND_LIST_EXP_VERSION_CURRENT", + "value": "ZE_MAKE_VERSION( 1, 1 )" + } + ], + "name": "ze_mutable_command_list_exp_version_t", + "type": "enum", + "version": "1.9" + }, "ze_pci_properties_ext_version_t": { "desc": "PCI Properties Extension Version(s)", "etors": [ @@ -17074,9 +19603,14 @@ "desc": "Supported physical memory creation flags", "etors": [ { - "desc": "reserved for future use.", - "name": "ZE_PHYSICAL_MEM_FLAG_TBD", + "desc": "[default] allocate physical device memory.", + "name": "ZE_PHYSICAL_MEM_FLAG_ALLOCATE_ON_DEVICE", "value": "ZE_BIT(0)" + }, + { + "desc": "Allocate physical host memory instead.", + "name": "ZE_PHYSICAL_MEM_FLAG_ALLOCATE_ON_HOST", + "value": "ZE_BIT(1)" } ], "name": "ze_physical_mem_flags_t", @@ -17425,6 +19959,12 @@ "name": "ZE_RESULT_WARNING_ACTION_REQUIRED", "value": "0x7800001b" }, + { + "desc": "[Core, Validation] kernel handle is invalid for the operation", + "name": "ZE_RESULT_ERROR_INVALID_KERNEL_HANDLE", + "value": "0x7800001c", + "version": "1.10" + }, { "desc": "[Core] unknown or internal error", "name": "ZE_RESULT_ERROR_UNKNOWN", @@ -18204,6 +20744,90 @@ "name": "ZE_STRUCTURE_TYPE_RTAS_GEOMETRY_AABBS_EXP_CB_PARAMS", "value": "0x00020013", "version": "1.7" + }, + { + "desc": "ze_event_pool_counter_based_exp_desc_t", + "name": "ZE_STRUCTURE_TYPE_COUNTER_BASED_EVENT_POOL_EXP_DESC", + "value": "0x00020014", + "version": "1.8" + }, + { + "desc": "ze_mutable_command_list_exp_properties_t", + "name": "ZE_STRUCTURE_TYPE_MUTABLE_COMMAND_LIST_EXP_PROPERTIES", + "value": "0x00020015", + "version": "1.9" + }, + { + "desc": "ze_mutable_command_list_exp_desc_t", + "name": "ZE_STRUCTURE_TYPE_MUTABLE_COMMAND_LIST_EXP_DESC", + "value": "0x00020016", + "version": "1.9" + }, + { + "desc": "ze_mutable_command_id_exp_desc_t", + "name": "ZE_STRUCTURE_TYPE_MUTABLE_COMMAND_ID_EXP_DESC", + "value": "0x00020017", + "version": "1.9" + }, + { + "desc": "ze_mutable_commands_exp_desc_t", + "name": "ZE_STRUCTURE_TYPE_MUTABLE_COMMANDS_EXP_DESC", + "value": "0x00020018", + "version": "1.9" + }, + { + "desc": "ze_mutable_kernel_argument_exp_desc_t", + "name": "ZE_STRUCTURE_TYPE_MUTABLE_KERNEL_ARGUMENT_EXP_DESC", + "value": "0x00020019", + "version": "1.9" + }, + { + "desc": "ze_mutable_group_count_exp_desc_t", + "name": "ZE_STRUCTURE_TYPE_MUTABLE_GROUP_COUNT_EXP_DESC", + "value": "0x0002001A", + "version": "1.9" + }, + { + "desc": "ze_mutable_group_size_exp_desc_t", + "name": "ZE_STRUCTURE_TYPE_MUTABLE_GROUP_SIZE_EXP_DESC", + "value": "0x0002001B", + "version": "1.9" + }, + { + "desc": "ze_mutable_global_offset_exp_desc_t", + "name": "ZE_STRUCTURE_TYPE_MUTABLE_GLOBAL_OFFSET_EXP_DESC", + "value": "0x0002001C", + "version": "1.9" + }, + { + "desc": "ze_device_pitched_alloc_exp_properties_t", + "name": "ZE_STRUCTURE_TYPE_PITCHED_ALLOC_DEVICE_EXP_PROPERTIES", + "value": "0x0002001D", + "version": "1.9" + }, + { + "desc": "ze_image_bindless_exp_desc_t", + "name": "ZE_STRUCTURE_TYPE_BINDLESS_IMAGE_EXP_DESC", + "value": "0x0002001E", + "version": "1.9" + }, + { + "desc": "ze_image_pitched_exp_desc_t", + "name": "ZE_STRUCTURE_TYPE_PITCHED_IMAGE_EXP_DESC", + "value": "0x0002001F", + "version": "1.9" + }, + { + "desc": "ze_mutable_graph_argument_exp_desc_t", + "name": "ZE_STRUCTURE_TYPE_MUTABLE_GRAPH_ARGUMENT_EXP_DESC", + "value": "0x00020020", + "version": "1.10" + }, + { + "desc": "ze_init_driver_type_desc_t", + "name": "ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC", + "value": "0x00020021", + "version": "1.10" } ], "name": "ze_structure_type_t", @@ -18466,12 +21090,12 @@ "value": "5" }, { - "desc": "Access information about a single media decode engine. Note that single engines may share the same underlying accelerator resources as other engines so activity of such an engine may not be indicative of the underlying resource utilization - use ZES_ENGINE_GROUP_MEDIA_ALL for that.", + "desc": "[DEPRECATED] No longer supported.", "name": "ZES_ENGINE_GROUP_MEDIA_DECODE_SINGLE", "value": "6" }, { - "desc": "Access information about a single media encode engine. Note that single engines may share the same underlying accelerator resources as other engines so activity of such an engine may not be indicative of the underlying resource utilization - use ZES_ENGINE_GROUP_MEDIA_ALL for that.", + "desc": "[DEPRECATED] No longer supported.", "name": "ZES_ENGINE_GROUP_MEDIA_ENCODE_SINGLE", "value": "7" }, @@ -18486,12 +21110,12 @@ "value": "9" }, { - "desc": "Access information about a single 3D engine - this is an engine that can process 3D content only. Note that single engines may share the same underlying accelerator resources as other engines so activity of such an engine may not be indicative of the underlying resource utilization - use ZES_ENGINE_GROUP_3D_RENDER_COMPUTE_ALL for that.", + "desc": "[DEPRECATED] No longer supported.", "name": "ZES_ENGINE_GROUP_3D_SINGLE", "value": "10" }, { - "desc": "Access information about all 3D/render/compute engines combined.", + "desc": "[DEPRECATED] No longer supported.", "name": "ZES_ENGINE_GROUP_3D_RENDER_COMPUTE_ALL", "value": "11" }, @@ -18501,9 +21125,15 @@ "value": "12" }, { - "desc": "Access information about all 3D engines combined. 3D engines can process 3D content only (no compute kernels).", + "desc": "[DEPRECATED] No longer supported.", "name": "ZES_ENGINE_GROUP_3D_ALL", "value": "13" + }, + { + "desc": "Access information about a single media engine. Note that single engines may share the same underlying accelerator resources as other engines so activity of such an engine may not be indicative of the underlying resource utilization - use ZES_ENGINE_GROUP_MEDIA_ALL for that.", + "name": "ZES_ENGINE_GROUP_MEDIA_CODEC_SINGLE", + "value": "14", + "version": "1.8" } ], "name": "zes_engine_group_t", @@ -18625,6 +21255,12 @@ "desc": "Event is triggered when the device needs to be reset (use zesDeviceGetState() to determine the reasons for the reset).", "name": "ZES_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED", "value": "ZE_BIT(14)" + }, + { + "desc": "Event is triggered when graphics driver encounter an error condition.", + "name": "ZES_EVENT_TYPE_FLAG_SURVIVABILITY_MODE_DETECTED", + "value": "ZE_BIT(15)", + "version": "1.9" } ], "name": "zes_event_type_flags_t", @@ -18745,6 +21381,24 @@ "name": "zes_fan_speed_units_t", "type": "enum" }, + "zes_firmware_security_exp_version_t": { + "desc": "Firmware security version Extension Version(s)", + "etors": [ + { + "desc": "version 1.0", + "name": "ZES_FIRMWARE_SECURITY_EXP_VERSION_1_0", + "value": "ZE_MAKE_VERSION( 1, 0 )" + }, + { + "desc": "latest known version", + "name": "ZES_FIRMWARE_SECURITY_EXP_VERSION_CURRENT", + "value": "ZE_MAKE_VERSION( 1, 0 )" + } + ], + "name": "zes_firmware_security_exp_version_t", + "type": "enum", + "version": "1.9" + }, "zes_freq_domain_t": { "class": "zesDevice", "desc": "Frequency domains.", @@ -18850,6 +21504,24 @@ "type": "enum", "version": "1.4" }, + "zes_mem_bandwidth_counter_bits_exp_version_t": { + "desc": "Memory Bandwidth Counter Valid Bits Extension Version(s)", + "etors": [ + { + "desc": "version 1.0", + "name": "ZES_MEM_BANDWIDTH_COUNTER_BITS_EXP_VERSION_1_0", + "value": "ZE_MAKE_VERSION( 1, 0 )" + }, + { + "desc": "latest known version", + "name": "ZES_MEM_BANDWIDTH_COUNTER_BITS_EXP_VERSION_CURRENT", + "value": "ZE_MAKE_VERSION( 1, 0 )" + } + ], + "name": "zes_mem_bandwidth_counter_bits_exp_version_t", + "type": "enum", + "version": "1.8" + }, "zes_mem_health_t": { "class": "zesMemory", "desc": "Memory health", @@ -18901,6 +21573,24 @@ "name": "zes_mem_loc_t", "type": "enum" }, + "zes_mem_page_offline_state_exp_version_t": { + "desc": "Memory State Extension Version(s)", + "etors": [ + { + "desc": "version 1.0", + "name": "ZES_MEM_PAGE_OFFLINE_STATE_EXP_VERSION_1_0", + "value": "ZE_MAKE_VERSION( 1, 0 )" + }, + { + "desc": "latest known version", + "name": "ZES_MEM_PAGE_OFFLINE_STATE_EXP_VERSION_CURRENT", + "value": "ZE_MAKE_VERSION( 1, 0 )" + } + ], + "name": "zes_mem_page_offline_state_exp_version_t", + "type": "enum", + "version": "1.8" + }, "zes_mem_type_t": { "class": "zesMemory", "desc": "Memory module types", @@ -19012,6 +21702,9 @@ "zes_oc_mode_t": { "class": "zesFrequency", "desc": "Overclocking modes", + "details": [ + "[DEPRECATED] No longer supported." + ], "etors": [ { "desc": "Overclocking if off - hardware is running using factory default voltages/frequencies.", @@ -19305,6 +21998,24 @@ "type": "enum", "version": "1.5" }, + "zes_power_domain_properties_exp_version_t": { + "desc": "Power Domain Properties Extension Version(s)", + "etors": [ + { + "desc": "version 1.0", + "name": "ZES_POWER_DOMAIN_PROPERTIES_EXP_VERSION_1_0", + "value": "ZE_MAKE_VERSION( 1, 0 )" + }, + { + "desc": "latest known version", + "name": "ZES_POWER_DOMAIN_PROPERTIES_EXP_VERSION_CURRENT", + "value": "ZE_MAKE_VERSION( 1, 0 )" + } + ], + "name": "zes_power_domain_properties_exp_version_t", + "type": "enum", + "version": "1.8" + }, "zes_power_domain_t": { "class": "zesPower", "desc": "Power Domain", @@ -19328,6 +22039,18 @@ "desc": "The PUnit power domain is a stack-level power domain.", "name": "ZES_POWER_DOMAIN_STACK", "value": "3" + }, + { + "desc": "The PUnit power domain is a memory-level power domain.", + "name": "ZES_POWER_DOMAIN_MEMORY", + "value": "4", + "version": "1.8" + }, + { + "desc": "The PUnit power domain is a GPU-level power domain.", + "name": "ZES_POWER_DOMAIN_GPU", + "value": "5", + "version": "1.8" } ], "name": "zes_power_domain_t", @@ -19671,7 +22394,7 @@ "value": "2" }, { - "desc": "This is a special mode that must ben enabled when debugging an application that uses this device e.g. using the Level0 Debug API. It has the effect of disabling any timeouts on workload execution time and will change workload scheduling to ensure debug accuracy.", + "desc": "[DEPRECATED] No longer supported.", "name": "ZES_SCHED_MODE_COMPUTE_UNIT_DEBUG", "value": "3" } @@ -19953,11 +22676,89 @@ "name": "ZES_STRUCTURE_TYPE_DEVICE_UUID", "value": "0x2e", "version": "1.7" + }, + { + "desc": "zes_power_domain_exp_properties_t", + "name": "ZES_STRUCTURE_TYPE_POWER_DOMAIN_EXP_PROPERTIES", + "value": "0x00020001", + "version": "1.8" + }, + { + "desc": "zes_mem_bandwidth_counter_bits_exp_properties_t", + "name": "ZES_STRUCTURE_TYPE_MEM_BANDWIDTH_COUNTER_BITS_EXP_PROPERTIES", + "value": "0x00020002", + "version": "1.8" + }, + { + "desc": "zes_mem_page_offline_state_exp_t", + "name": "ZES_STRUCTURE_TYPE_MEMORY_PAGE_OFFLINE_STATE_EXP", + "value": "0x00020003", + "version": "1.8" + }, + { + "desc": "zes_subdevice_exp_properties_t", + "name": "ZES_STRUCTURE_TYPE_SUBDEVICE_EXP_PROPERTIES", + "value": "0x00020004", + "version": "1.9" + }, + { + "desc": "zes_vf_exp_properties_t", + "name": "ZES_STRUCTURE_TYPE_VF_EXP_PROPERTIES", + "value": "0x00020005", + "version": "1.10" + }, + { + "desc": "zes_vf_util_mem_exp_t", + "name": "ZES_STRUCTURE_TYPE_VF_UTIL_MEM_EXP", + "value": "0x00020006", + "version": "1.9" + }, + { + "desc": "zes_vf_util_engine_exp_t", + "name": "ZES_STRUCTURE_TYPE_VF_UTIL_ENGINE_EXP", + "value": "0x00020007", + "version": "1.9" + }, + { + "desc": "zes_vf_exp_capabilities_t", + "name": "ZES_STRUCTURE_TYPE_VF_EXP_CAPABILITIES", + "value": "0x00020008", + "version": "1.10" + }, + { + "desc": "zes_vf_util_mem_exp2_t", + "name": "ZES_STRUCTURE_TYPE_VF_UTIL_MEM_EXP2", + "value": "0x00020009", + "version": "1.10" + }, + { + "desc": "zes_vf_util_engine_exp2_t", + "name": "ZES_STRUCTURE_TYPE_VF_UTIL_ENGINE_EXP2", + "value": "0x00020010", + "version": "1.10" } ], "name": "zes_structure_type_t", "type": "enum" }, + "zes_sysman_device_mapping_exp_version_t": { + "desc": "Sysman Device Mapping Extension Version(s)", + "etors": [ + { + "desc": "version 1.0", + "name": "ZES_SYSMAN_DEVICE_MAPPING_EXP_VERSION_1_0", + "value": "ZE_MAKE_VERSION( 1, 0 )" + }, + { + "desc": "latest known version", + "name": "ZES_SYSMAN_DEVICE_MAPPING_EXP_VERSION_CURRENT", + "value": "ZE_MAKE_VERSION( 1, 0 )" + } + ], + "name": "zes_sysman_device_mapping_exp_version_t", + "type": "enum", + "version": "1.9" + }, "zes_temp_sensors_t": { "class": "zesTemperature", "desc": "Temperature sensors", @@ -19991,6 +22792,24 @@ "desc": "The minimum temperature across all sensors in the local device memory", "name": "ZES_TEMP_SENSORS_MEMORY_MIN", "value": "5" + }, + { + "desc": "The maximum temperature across all sensors in the GPU Board", + "name": "ZES_TEMP_SENSORS_GPU_BOARD", + "value": "6", + "version": "1.8" + }, + { + "desc": "The minimum temperature across all sensors in the GPU Board", + "name": "ZES_TEMP_SENSORS_GPU_BOARD_MIN", + "value": "7", + "version": "1.8" + }, + { + "desc": "The maximum temperature across all sensors in the Voltage Regulator", + "name": "ZES_TEMP_SENSORS_VOLTAGE_REGULATOR", + "value": "8", + "version": "1.10" } ], "name": "zes_temp_sensors_t", @@ -20020,6 +22839,82 @@ "type": "enum", "version": "1.5" }, + "zes_vf_info_mem_type_exp_flags_t": { + "class": "zesVFManagement", + "desc": "Virtual function memory types (deprecated)", + "etors": [ + { + "desc": "System memory", + "name": "ZES_VF_INFO_MEM_TYPE_EXP_FLAG_MEM_TYPE_SYSTEM", + "value": "ZE_BIT(0)" + }, + { + "desc": "Device local memory", + "name": "ZES_VF_INFO_MEM_TYPE_EXP_FLAG_MEM_TYPE_DEVICE", + "value": "ZE_BIT(1)" + } + ], + "name": "zes_vf_info_mem_type_exp_flags_t", + "type": "enum", + "version": "1.9" + }, + "zes_vf_info_util_exp_flags_t": { + "class": "zesVFManagement", + "desc": "Virtual function utilization flag bit fields (deprecated)", + "etors": [ + { + "desc": "No info associated with virtual function", + "name": "ZES_VF_INFO_UTIL_EXP_FLAG_INFO_NONE", + "value": "ZE_BIT(0)" + }, + { + "desc": "System memory utilization associated with virtual function", + "name": "ZES_VF_INFO_UTIL_EXP_FLAG_INFO_MEM_CPU", + "value": "ZE_BIT(1)" + }, + { + "desc": "Device memory utilization associated with virtual function", + "name": "ZES_VF_INFO_UTIL_EXP_FLAG_INFO_MEM_GPU", + "value": "ZE_BIT(2)" + }, + { + "desc": "Engine utilization associated with virtual function", + "name": "ZES_VF_INFO_UTIL_EXP_FLAG_INFO_ENGINE", + "value": "ZE_BIT(3)" + } + ], + "name": "zes_vf_info_util_exp_flags_t", + "type": "enum", + "version": "1.9" + }, + "zes_vf_management_exp_version_t": { + "desc": "Virtual Function Management Extension Version(s)", + "etors": [ + { + "desc": "version 1.0 (deprecated)", + "name": "ZES_VF_MANAGEMENT_EXP_VERSION_1_0", + "value": "ZE_MAKE_VERSION( 1, 0 )" + }, + { + "desc": "version 1.1 (deprecated)", + "name": "ZES_VF_MANAGEMENT_EXP_VERSION_1_1", + "value": "ZE_MAKE_VERSION( 1, 1 )" + }, + { + "desc": "version 1.2", + "name": "ZES_VF_MANAGEMENT_EXP_VERSION_1_2", + "value": "ZE_MAKE_VERSION( 1, 2 )" + }, + { + "desc": "latest known version", + "name": "ZES_VF_MANAGEMENT_EXP_VERSION_CURRENT", + "value": "ZE_MAKE_VERSION( 1, 2 )" + } + ], + "name": "zes_vf_management_exp_version_t", + "type": "enum", + "version": "1.9" + }, "zes_vf_program_type_t": { "class": "zesOverclock", "desc": "Overclock V-F curve programing.", @@ -20080,6 +22975,24 @@ "name": "zet_api_tracing_exp_version_t", "type": "enum" }, + "zet_concurrent_metric_groups_exp_version_t": { + "desc": "Concurrent Metric Groups Experimental Extension Version(s)", + "etors": [ + { + "desc": "version 1.0", + "name": "ZET_CONCURRENT_METRIC_GROUPS_EXP_VERSION_1_0", + "value": "ZE_MAKE_VERSION( 1, 0 )" + }, + { + "desc": "latest known version", + "name": "ZET_CONCURRENT_METRIC_GROUPS_EXP_VERSION_CURRENT", + "value": "ZE_MAKE_VERSION( 1, 0 )" + } + ], + "name": "zet_concurrent_metric_groups_exp_version_t", + "type": "enum", + "version": "1.10" + }, "zet_debug_detach_reason_t": { "class": "zetDebug", "desc": "Supported debug detach reasons.", @@ -20178,6 +23091,12 @@ "desc": "shared local memory space (GPU-only)", "name": "ZET_DEBUG_MEMORY_SPACE_TYPE_SLM", "value": "1" + }, + { + "desc": "ELF file memory space", + "name": "ZET_DEBUG_MEMORY_SPACE_TYPE_ELF", + "value": "2", + "version": "1.10" } ], "name": "zet_debug_memory_space_type_t", @@ -20287,11 +23206,98 @@ "desc": "Time based sampling", "name": "ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED", "value": "ZE_BIT(1)" + }, + { + "desc": "Experimental Tracer based sampling", + "name": "ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EXP_TRACER_BASED", + "value": "ZE_BIT(2)", + "version": "1.10" } ], "name": "zet_metric_group_sampling_type_flags_t", "type": "enum" }, + "zet_metric_group_type_exp_flags_t": { + "class": "zetMetricGroup", + "desc": "Metric group type", + "etors": [ + { + "desc": "Metric group and metrics exports memory using linux dma-buf, which could be imported/mapped to the host process. Properties of the dma_buf could be queried using zet_export_dma_buf_exp_properties_t.", + "name": "ZET_METRIC_GROUP_TYPE_EXP_FLAG_EXPORT_DMA_BUF", + "value": "ZE_BIT(0)" + }, + { + "desc": "Metric group created using zetMetricGroupCreateExp", + "name": "ZET_METRIC_GROUP_TYPE_EXP_FLAG_USER_CREATED", + "value": "ZE_BIT(1)" + }, + { + "desc": "Metric group which has a collection of metrics", + "name": "ZET_METRIC_GROUP_TYPE_EXP_FLAG_OTHER", + "value": "ZE_BIT(2)" + } + ], + "name": "zet_metric_group_type_exp_flags_t", + "type": "enum" + }, + "zet_metric_programmable_exp_version_t": { + "desc": "Programmable Metrics Experimental Extension Version(s)", + "etors": [ + { + "desc": "version 1.1", + "name": "ZET_METRIC_PROGRAMMABLE_EXP_VERSION_1_1", + "value": "ZE_MAKE_VERSION( 1, 1 )" + }, + { + "desc": "latest known version", + "name": "ZET_METRIC_PROGRAMMABLE_EXP_VERSION_CURRENT", + "value": "ZE_MAKE_VERSION( 1, 1 )" + } + ], + "name": "zet_metric_programmable_exp_version_t", + "type": "enum", + "version": "1.9" + }, + "zet_metric_programmable_param_type_exp_t": { + "class": "zetMetricProgrammable", + "desc": "Metric Programmable Parameter types", + "etors": [ + { + "desc": "Metric is disaggregated.", + "name": "ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_DISAGGREGATION", + "value": "0" + }, + { + "desc": "Metric for latency measurement.", + "name": "ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_LATENCY", + "value": "1" + }, + { + "desc": "Produces normalization in percent using raw_metric * 100 / cycles / HW instance_count.", + "name": "ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_NORMALIZATION_UTILIZATION", + "value": "2" + }, + { + "desc": "Produces normalization using raw_metric / HW instance_count.", + "name": "ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_NORMALIZATION_AVERAGE", + "value": "3" + }, + { + "desc": "Produces normalization average using raw_metric / timestamp.", + "name": "ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_NORMALIZATION_RATE", + "value": "4" + }, + { + "desc": "Produces normalization average using raw_metric * n bytes.", + "name": "ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_NORMALIZATION_BYTES", + "value": "5", + "version": "1.10" + } + ], + "name": "zet_metric_programmable_param_type_exp_t", + "type": "enum", + "version": "1.9" + }, "zet_metric_query_pool_type_t": { "class": "zetMetricQueryPool", "desc": "Metric query pool types", @@ -20310,6 +23316,24 @@ "name": "zet_metric_query_pool_type_t", "type": "enum" }, + "zet_metric_tracer_exp_version_t": { + "desc": "Metric Tracer Experimental Extension Version(s)", + "etors": [ + { + "desc": "version 1.0", + "name": "ZET_METRIC_TRACER_EXP_VERSION_1_0", + "value": "ZE_MAKE_VERSION( 1, 0 )" + }, + { + "desc": "latest known version", + "name": "ZET_METRIC_TRACER_EXP_VERSION_CURRENT", + "value": "ZE_MAKE_VERSION( 1, 0 )" + } + ], + "name": "zet_metric_tracer_exp_version_t", + "type": "enum", + "version": "1.10" + }, "zet_metric_type_t": { "class": "zetMetric", "desc": "Metric types", @@ -20357,13 +23381,43 @@ { "desc": "Metric type: instruction pointer. Deprecated, use ZET_METRIC_TYPE_IP.", "name": "ZET_METRIC_TYPE_IP_EXP", - "value": "0x7ffffffe" + "value": "8" }, { "desc": "Metric type: instruction pointer", "name": "ZET_METRIC_TYPE_IP", - "value": "0x7ffffffe", + "value": "9", "version": "1.7" + }, + { + "desc": "Metric type: event with only timestamp and value has no meaning", + "name": "ZET_METRIC_TYPE_EVENT_EXP_TIMESTAMP", + "value": "10", + "version": "1.10" + }, + { + "desc": "Metric type: the first event of a start/end event pair", + "name": "ZET_METRIC_TYPE_EVENT_EXP_START", + "value": "11", + "version": "1.10" + }, + { + "desc": "Metric type: the second event of a start/end event pair", + "name": "ZET_METRIC_TYPE_EVENT_EXP_END", + "value": "12", + "version": "1.10" + }, + { + "desc": "Metric which exports linux dma_buf, which could be imported/mapped to the host process", + "name": "ZET_METRIC_TYPE_EXPORT_DMA_BUF", + "value": "0x7ffffffd", + "version": "1.11" + }, + { + "desc": "Metric type: value of the event is a monotonically increasing value that can wrap around", + "name": "ZET_METRIC_TYPE_EVENT_EXP_MONOTONIC_WRAPS_VALUE", + "value": "0x7ffffffe", + "version": "1.10" } ], "name": "zet_metric_type_t", @@ -20484,11 +23538,101 @@ "name": "ZET_STRUCTURE_TYPE_METRIC_CALCULATE_EXP_DESC", "value": "0x00010002", "version": "1.7" + }, + { + "desc": "zet_metric_programmable_exp_properties_t", + "name": "ZET_STRUCTURE_TYPE_METRIC_PROGRAMMABLE_EXP_PROPERTIES", + "value": "0x00010003", + "version": "1.9" + }, + { + "desc": "zet_metric_programmable_param_info_exp_t", + "name": "ZET_STRUCTURE_TYPE_METRIC_PROGRAMMABLE_PARAM_INFO_EXP", + "value": "0x00010004", + "version": "1.9" + }, + { + "desc": "zet_metric_programmable_param_value_info_exp_t", + "name": "ZET_STRUCTURE_TYPE_METRIC_PROGRAMMABLE_PARAM_VALUE_INFO_EXP", + "value": "0x00010005", + "version": "1.9" + }, + { + "desc": "zet_metric_group_type_exp_t", + "name": "ZET_STRUCTURE_TYPE_METRIC_GROUP_TYPE_EXP", + "value": "0x00010006", + "version": "1.11" + }, + { + "desc": "zet_export_dma_buf_exp_properties_t", + "name": "ZET_STRUCTURE_TYPE_EXPORT_DMA_EXP_PROPERTIES", + "value": "0x00010007", + "version": "1.11" + }, + { + "desc": "zet_metric_tracer_exp_desc_t", + "name": "ZET_STRUCTURE_TYPE_METRIC_TRACER_EXP_DESC", + "value": "0x00010008", + "version": "1.10" } ], "name": "zet_structure_type_t", "type": "enum" }, + "zet_value_info_type_exp_t": { + "desc": "Supported value info types", + "etors": [ + { + "desc": "32-bit unsigned-integer", + "name": "ZET_VALUE_INFO_TYPE_EXP_UINT32", + "value": "0" + }, + { + "desc": "64-bit unsigned-integer", + "name": "ZET_VALUE_INFO_TYPE_EXP_UINT64", + "value": "1" + }, + { + "desc": "32-bit floating-point", + "name": "ZET_VALUE_INFO_TYPE_EXP_FLOAT32", + "value": "2" + }, + { + "desc": "64-bit floating-point", + "name": "ZET_VALUE_INFO_TYPE_EXP_FLOAT64", + "value": "3" + }, + { + "desc": "8-bit boolean", + "name": "ZET_VALUE_INFO_TYPE_EXP_BOOL8", + "value": "4" + }, + { + "desc": "8-bit unsigned-integer", + "name": "ZET_VALUE_INFO_TYPE_EXP_UINT8", + "value": "5" + }, + { + "desc": "16-bit unsigned-integer", + "name": "ZET_VALUE_INFO_TYPE_EXP_UINT16", + "value": "6" + }, + { + "desc": "64-bit unsigned-integer range (minimum and maximum)", + "name": "ZET_VALUE_INFO_TYPE_EXP_UINT64_RANGE", + "value": "7" + }, + { + "desc": "64-bit floating point range (minimum and maximum)", + "name": "ZET_VALUE_INFO_TYPE_EXP_FLOAT64_RANGE", + "value": "8", + "version": "1.10" + } + ], + "name": "zet_value_info_type_exp_t", + "type": "enum", + "version": "1.9" + }, "zet_value_type_t": { "desc": "Supported value types", "etors": [ @@ -20707,6 +23851,76 @@ ], "type": "function" }, + "AddMetricExp": { + "class": "zetMetricGroup", + "decl": "static", + "desc": "Add a metric handle to the metric group handle created using zetMetricGroupCreateExp.", + "details": [ + "Reasons for failing to add the metric could be queried using pErrorString", + "Multiple additions of same metric would add the metric only once to the hMetricGroup", + "Metric handles from multiple domains may be used in a single metric group.", + "Metric handles from different sourceIds (refer zet_metric_programmable_exp_properties_t) are not allowed in a single metric group." + ], + "hash": "d1255facd6f043c17b1ba82228f5f8512c857c19455fa60dc9b52a534b907652", + "name": "AddMetricExp", + "params": [ + { + "desc": "[in] Handle of the metric group", + "name": "hMetricGroup", + "type": "zet_metric_group_handle_t" + }, + { + "desc": "[in] Metric to be added to the group.", + "name": "hMetric", + "type": "zet_metric_handle_t" + }, + { + "desc": "[in,out][optional] Size of the error string to query, if an error was reported during adding the metric handle.\nif *pErrorStringSize is zero, then the driver shall update the value with the size of the error string in bytes.\n", + "name": "pErrorStringSize", + "type": "size_t *" + }, + { + "desc": "[in,out][optional][range(0, *pErrorStringSize)] Error string.\nif *pErrorStringSize is less than the length of the error string available, then driver shall only retrieve that length of error string.\n", + "name": "pErrorString", + "type": "char*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricGroup`", + "`nullptr == hMetric`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_ARGUMENT": [ + "If a Metric handle from a pre-defined metric group is requested to be added." + ] + }, + { + "ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE": [ + "If the metric group is currently activated." + ] + } + ], + "type": "function", + "version": "1.9" + }, "AllocDevice": { "class": "zeMem", "decl": "static", @@ -23792,6 +27006,61 @@ ], "type": "function" }, + "CloseExp": { + "class": "zetMetricGroup", + "decl": "static", + "desc": "Closes a created metric group using zetMetricGroupCreateExp, so that it can be activated.", + "details": [ + "Finalizes the zetMetricGroupAddMetricExp and zetMetricGroupRemoveMetricExp operations on the metric group.", + "This is a necessary step before activation of the created metric group.", + "Add / Remove of metrics is possible after zetMetricGroupCloseExp. However, a call to zetMetricGroupCloseExp is necessary after modifying the metric group.", + "Implementations could choose to add new metrics to the group during zetMetricGroupCloseExp, which are related and might add value to the metrics already added by the application", + "Applications can query the list of metrics in the metric group using zetMetricGet" + ], + "hash": "c943d1cdc0583f994fba50ef3d22b20a6df1b03df8a87b03a59bbcdb79fc85a4", + "name": "CloseExp", + "params": [ + { + "desc": "[in] Handle of the metric group", + "name": "hMetricGroup", + "type": "zet_metric_group_handle_t" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricGroup`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_ARGUMENT": [ + "If the input metric group is a pre-defined metric group" + ] + }, + { + "ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE": [ + "If the metric group is currently activated" + ] + } + ], + "type": "function", + "version": "1.9" + }, "CloseIpcHandle": { "class": "zeMem", "decl": "static", @@ -23905,6 +27174,65 @@ ], "type": "function" }, + "CreateCloneExp": { + "class": "zeCommandList", + "decl": "static", + "desc": "Creates a command list as the clone of another command list.", + "details": [ + "The source command list must be created with the ZE_COMMAND_LIST_FLAG_EXP_CLONEABLE flag.", + "The source command list must be closed prior to cloning.", + "The source command list may be cloned while it is running on the device.", + "The cloned command list inherits all properties of the source command list.", + "The cloned command list must be destroyed prior to the source command list.", + "The application must only use the command list for the device, or its sub-devices, which was provided during creation.", + "The application may call this function from simultaneous threads.", + "The implementation of this function must be thread-safe." + ], + "hash": "6e959078748eb9317921759dd20b827a809d81c7a9b6243599dc43a8f1e854cd", + "name": "CreateCloneExp", + "ordinal": "0", + "params": [ + { + "desc": "[in] handle to source command list (the command list to clone)", + "name": "hCommandList", + "type": "ze_command_list_handle_t" + }, + { + "desc": "[out] pointer to handle of the cloned command list", + "name": "phClonedCommandList", + "type": "ze_command_list_handle_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hCommandList`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == phClonedCommandList`" + ] + } + ], + "type": "function", + "version": "1.9" + }, "CreateEx": { "class": "zeContext", "decl": "static", @@ -23986,151 +27314,499 @@ "version": "1.1" }, "CreateExp": { - "class": "zeRTASParallelOperation", - "desc": "Creates a ray tracing acceleration structure builder parallel operation object", - "details": [ - "The application may call this function from simultaneous threads.", - "The implementation of this function must be thread-safe.", - "The implementation must support ZE_experimental_rtas_builder extension." - ], - "hash": "324930a8492161bf3d335c6e360038a06bea8600cf15aec51610993fedc165e4", - "name": "CreateExp", - "params": [ - { - "desc": "[in] handle of driver object", - "name": "hDriver", - "type": "ze_driver_handle_t" - }, - { - "desc": "[out] handle of parallel operation object", - "name": "phParallelOperation", - "type": "ze_rtas_parallel_operation_exp_handle_t*" - } - ], - "returns": [ - { - "ZE_RESULT_SUCCESS": [] - }, - { - "ZE_RESULT_ERROR_UNINITIALIZED": [] - }, - { - "ZE_RESULT_ERROR_DEVICE_LOST": [] - }, - { - "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] - }, - { - "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] - }, - { - "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDriver`" - ] - }, - { - "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == phParallelOperation`" - ] - } - ], - "type": "function", - "version": "1.7" - }, - "CreateImmediate": { - "class": "zeCommandList", + "class": "zetMetricGroup", "decl": "static", - "desc": "Creates an immediate command list on the context.", + "desc": "Create metric group handle.", "details": [ - "An immediate command list is used for low-latency submission of commands.", - "An immediate command list creates an implicit command queue.", - "Immediate command lists must not be passed to zeCommandQueueExecuteCommandLists.", - "Commands appended into an immediate command list may execute synchronously, by blocking until the command is complete.", - "The command list is created in the 'open' state and never needs to be closed.", - "The application must only use the command list for the device, or its sub-devices, which was provided during creation.", - "The application may call this function from simultaneous threads.", - "The implementation of this function must be thread-safe." + "This API is deprecated. Please use zetCreateMetricGroupsFromMetricsExp() " ], - "hash": "1563ad20ea2a985de2198858084ef59027e1f44676ac696ddf7356143ad9a544", - "name": "CreateImmediate", - "ordinal": "0", + "hash": "911fc9ce16d58fd7864f8c461aa27bf5b547abd68657eb09965799166f83c882", + "name": "CreateExp", "params": [ { - "desc": "[in] handle of the context object", - "name": "hContext", - "type": "ze_context_handle_t" - }, - { - "desc": "[in] handle of the device object", + "desc": "[in] handle of the device", "name": "hDevice", - "type": "ze_device_handle_t" - }, - { - "desc": "[in] pointer to command queue descriptor", - "name": "altdesc", - "type": "const ze_command_queue_desc_t*" - }, - { - "desc": "[out] pointer to handle of command list object created", - "name": "phCommandList", - "type": "ze_command_list_handle_t*" - } - ], - "returns": [ - { - "ZE_RESULT_SUCCESS": [] - }, - { - "ZE_RESULT_ERROR_UNINITIALIZED": [] - }, - { - "ZE_RESULT_ERROR_DEVICE_LOST": [] - }, - { - "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "type": "zet_device_handle_t" }, { - "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + "desc": "[in] pointer to metric group name. Must point to a null-terminated character array no longer than ZET_MAX_METRIC_GROUP_NAME.", + "name": "pName", + "type": "const char*" }, { - "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hContext`", - "`nullptr == hDevice`" - ] + "desc": "[in] pointer to metric group description. Must point to a null-terminated character array no longer than ZET_MAX_METRIC_GROUP_DESCRIPTION.", + "name": "pDescription", + "type": "const char*" }, { - "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == altdesc`", - "`nullptr == phCommandList`" - ] + "desc": "[in] Sampling type for the metric group.", + "name": "samplingType", + "type": "zet_metric_group_sampling_type_flags_t" }, { - "ZE_RESULT_ERROR_INVALID_ENUMERATION": [ - "`0x3 < altdesc->flags`", - "`ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS < altdesc->mode`", - "`ZE_COMMAND_QUEUE_PRIORITY_PRIORITY_HIGH < altdesc->priority`" - ] - } - ], - "type": "function" - }, - "Destroy": { - "class": "zetTracerExp", - "decl": "static", - "desc": "Destroys a tracer.", - "details": [ - "The application must **not** call this function from simultaneous threads with the same tracer handle.", - "The implementation of this function must be thread-safe.", - "The implementation of this function will stall and wait on any outstanding threads executing callbacks before freeing any Host allocations associated with this tracer." - ], - "hash": "93988865d3b59785a30efbb5b38fea9024972b775e1ec2b82b52cfcd53e0fac2", - "name": "Destroy", - "ordinal": "0", - "params": [ - { - "desc": "[in][release] handle of tracer object to destroy", - "name": "hTracer", - "type": "zet_tracer_exp_handle_t" + "desc": "[in,out] Created Metric group handle", + "name": "phMetricGroup", + "type": "zet_metric_group_handle_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDevice`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pName`", + "`nullptr == pDescription`", + "`nullptr == phMetricGroup`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_ENUMERATION": [ + "`0x7 < samplingType`" + ] + } + ], + "type": "function", + "version": "1.9" + }, + "CreateFromProgrammableExp": { + "class": "zetMetric", + "decl": "static", + "desc": "Create metric handles by applying parameter values on the metric programmable handle.", + "details": [ + "This API is deprecated. Please use zetMetricCreateFromProgrammableExp2()" + ], + "hash": "1f79d41fa245802ffbdb926fdf47717e4073e63661216306b543d0d93e079c0f", + "name": "CreateFromProgrammableExp", + "params": [ + { + "desc": "[in] handle of the metric programmable", + "name": "hMetricProgrammable", + "type": "zet_metric_programmable_exp_handle_t" + }, + { + "desc": "[in] list of parameter values to be set.", + "name": "pParameterValues", + "type": "zet_metric_programmable_param_value_exp_t*" + }, + { + "desc": "[in] Count of parameters to set.", + "name": "parameterCount", + "type": "uint32_t" + }, + { + "desc": "[in] pointer to metric name to be used. Must point to a null-terminated character array no longer than ZET_MAX_METRIC_NAME.", + "name": "pName", + "type": "const char*" + }, + { + "desc": "[in] pointer to metric description to be used. Must point to a null-terminated character array no longer than ZET_MAX_METRIC_DESCRIPTION.", + "name": "pDescription", + "type": "const char*" + }, + { + "desc": "[in,out] Pointer to the number of metric handles.\nif count is zero, then the driver shall update the value with the number of metric handles available for this programmable.\nif count is greater than the number of metric handles available, then the driver shall update the value with the correct number of metric handles available.\n", + "name": "pMetricHandleCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0,*pMetricHandleCount)] array of handle of metrics.\nif count is less than the number of metrics available, then driver shall only retrieve that number of metric handles.\n", + "name": "phMetricHandles", + "type": "zet_metric_handle_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricProgrammable`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pParameterValues`", + "`nullptr == pName`", + "`nullptr == pDescription`", + "`nullptr == pMetricHandleCount`" + ] + } + ], + "type": "function", + "version": "1.9" + }, + "CreateFromProgrammableExp2": { + "class": "zetMetric", + "decl": "static", + "desc": "Create metric handles by applying parameter values on the metric programmable handle.", + "details": [ + "Multiple parameter values could be used to prepare a metric.", + "If parameterCount = 0, the default value of the metric programmable would be used for all parameters.", + "The implementation can post-fix a C string to the metric name and description, based on the parameter values chosen.", + "zetMetricProgrammableGetParamInfoExp() returns a list of parameters in a defined order.", + "Therefore, the list of values passed in to the API should respect the same order such that the desired parameter is set with expected value" + ], + "hash": "dbb77dc5d0fa8c02a2fdb02c1bc1418b8cd656185111e57b2c76fe53f5b528c2", + "name": "CreateFromProgrammableExp2", + "params": [ + { + "desc": "[in] handle of the metric programmable", + "name": "hMetricProgrammable", + "type": "zet_metric_programmable_exp_handle_t" + }, + { + "desc": "[in] Count of parameters to set.", + "name": "parameterCount", + "type": "uint32_t" + }, + { + "desc": "[in] list of parameter values to be set.", + "name": "pParameterValues", + "type": "zet_metric_programmable_param_value_exp_t*" + }, + { + "desc": "[in] pointer to metric name to be used. Must point to a null-terminated character array no longer than ZET_MAX_METRIC_NAME.", + "name": "pName", + "type": "const char*" + }, + { + "desc": "[in] pointer to metric description to be used. Must point to a null-terminated character array no longer than ZET_MAX_METRIC_DESCRIPTION.", + "name": "pDescription", + "type": "const char*" + }, + { + "desc": "[in,out] Pointer to the number of metric handles.\nif count is zero, then the driver shall update the value with the number of metric handles available for this programmable.\nif count is greater than the number of metric handles available, then the driver shall update the value with the correct number of metric handles available.\n", + "name": "pMetricHandleCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0,*pMetricHandleCount)] array of handle of metrics.\nif count is less than the number of metrics available, then driver shall only retrieve that number of metric handles.\n", + "name": "phMetricHandles", + "type": "zet_metric_handle_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricProgrammable`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pParameterValues`", + "`nullptr == pName`", + "`nullptr == pDescription`", + "`nullptr == pMetricHandleCount`" + ] + } + ], + "type": "function", + "version": "1.11" + }, + "CreateImmediate": { + "class": "zeCommandList", + "decl": "static", + "desc": "Creates an immediate command list on the context.", + "details": [ + "An immediate command list is used for low-latency submission of commands.", + "An immediate command list creates an implicit command queue.", + "Immediate command lists must not be passed to zeCommandQueueExecuteCommandLists.", + "Commands appended into an immediate command list may execute synchronously, by blocking until the command is complete.", + "The command list is created in the 'open' state and never needs to be closed.", + "The application must only use the command list for the device, or its sub-devices, which was provided during creation.", + "The application may call this function from simultaneous threads.", + "The implementation of this function must be thread-safe." + ], + "hash": "1563ad20ea2a985de2198858084ef59027e1f44676ac696ddf7356143ad9a544", + "name": "CreateImmediate", + "ordinal": "0", + "params": [ + { + "desc": "[in] handle of the context object", + "name": "hContext", + "type": "ze_context_handle_t" + }, + { + "desc": "[in] handle of the device object", + "name": "hDevice", + "type": "ze_device_handle_t" + }, + { + "desc": "[in] pointer to command queue descriptor", + "name": "altdesc", + "type": "const ze_command_queue_desc_t*" + }, + { + "desc": "[out] pointer to handle of command list object created", + "name": "phCommandList", + "type": "ze_command_list_handle_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hContext`", + "`nullptr == hDevice`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == altdesc`", + "`nullptr == phCommandList`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_ENUMERATION": [ + "`0x3 < altdesc->flags`", + "`ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS < altdesc->mode`", + "`ZE_COMMAND_QUEUE_PRIORITY_PRIORITY_HIGH < altdesc->priority`" + ] + } + ], + "type": "function" + }, + "CreateMetricGroupsFromMetricsExp": { + "class": "zetDevice", + "decl": "static", + "desc": "Create multiple metric group handles from metric handles.", + "details": [ + "Creates multiple metric groups from metrics which were created using zetMetricCreateFromProgrammableExp2().", + "Metrics whose Hardware resources do not overlap are added to same metric group.", + "The metric groups created using this API are managed by the application and cannot be retrieved using zetMetricGroupGet().", + "The created metric groups are ready for activation and collection." + ], + "hash": "ee04ae2896c387da5871785e7599c03a4d78d896df59a843f7776ff538f754ec", + "name": "CreateMetricGroupsFromMetricsExp", + "params": [ + { + "desc": "[in] handle of the device.", + "name": "hDevice", + "type": "zet_device_handle_t" + }, + { + "desc": "[in] number of metric handles.", + "name": "metricCount", + "type": "uint32_t" + }, + { + "desc": "[in] metric handles to be added to the metric groups.", + "name": "phMetrics", + "type": "zet_metric_handle_t *" + }, + { + "desc": "[in] prefix to the name created for the metric groups. Must point to a null-terminated character array no longer than ZEX_MAX_METRIC_GROUP_NAME_PREFIX.", + "name": "pMetricGroupNamePrefix", + "type": "const char *" + }, + { + "desc": "[in] pointer to description of the metric groups. Must point to a null-terminated character array no longer than ZET_MAX_METRIC_GROUP_DESCRIPTION.", + "name": "pDescription", + "type": "const char *" + }, + { + "desc": "[in,out] pointer to the number of metric group handles to be created.\nif pMetricGroupCount is zero, then the driver shall update the value with the maximum possible number of metric group handles that could be created.\nif pMetricGroupCount is greater than the number of metric group handles that could be created, then the driver shall update the value with the correct number of metric group handles generated.\nif pMetricGroupCount is lesser than the number of metric group handles that could be created, then ZE_RESULT_ERROR_INVALID_ARGUMENT is returned.\n", + "name": "pMetricGroupCount", + "type": "uint32_t *" + }, + { + "desc": "[in,out][optional][range(0, *pMetricGroupCount)] array of handle of metric group handles.\nCreated Metric group handles.\n", + "name": "phMetricGroup", + "type": "zet_metric_group_handle_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDevice`", + "`nullptr == phMetrics`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_ARGUMENT": [ + "metricGroupCount is lesser than the number of metric group handles that could be created." + ] + } + ], + "type": "function", + "version": "1.10" + }, + "DecodeExp": { + "class": "zetMetricTracer", + "desc": "Decode raw events collected from a tracer.", + "hash": "07e0bc42a335a52149afacfd2297ba845ca79452fc78671bc2d3e06299c2aca1", + "name": "DecodeExp", + "params": [ + { + "desc": "[in] handle of the metric decoder object", + "name": "phMetricDecoder", + "type": "zet_metric_decoder_exp_handle_t" + }, + { + "desc": "[in,out] size in bytes of raw data buffer. If pMetricEntriesCount is greater than zero but less than total number of \ndecodable metrics available in the raw data buffer, then driver shall update this value with actual number of raw \ndata bytes processed.\n", + "name": "pRawDataSize", + "type": "size_t*" + }, + { + "desc": "[in,out][optional][range(0, *pRawDataSize)] buffer containing tracer data in raw format", + "name": "pRawData", + "type": "uint8_t*" + }, + { + "desc": "[in] number of decodable metrics in the tracer for which the hMetricDecoder handle was provided. See \nzetMetricDecoderGetDecodableMetricsExp(). If metricCount is greater than zero but less than the number decodable \nmetrics available in the raw data buffer, then driver shall only decode those.\n", + "name": "metricsCount", + "type": "uint32_t" + }, + { + "desc": "[in] [range(0, metricsCount)] array of handles of decodable metrics in the decoder for which the hMetricDecoder handle was \nprovided. Metrics handles are expected to be for decodable metrics, see zetMetricDecoderGetDecodableMetrics() \n", + "name": "phMetrics", + "type": "zet_metric_handle_t*" + }, + { + "desc": "[in,out] pointer to number of metric sets. If count is zero, then the driver shall update the value with the total\nnumber of metric sets to be decoded. If count is greater than the number available in the raw data buffer, then the\ndriver shall update the value with the actual number of metric sets to be decoded. There is a 1:1 relation between\nthe number of sets and sub-devices returned in the decoded entries.\n", + "name": "pSetCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pSetCount)] buffer of metric entries counts per metric set, one value per set.\n", + "name": "pMetricEntriesCountPerSet", + "type": "uint32_t*" + }, + { + "desc": "[in,out] pointer to the total number of metric entries decoded, for all metric sets. If count is zero, then the\ndriver shall update the value with the total number of metric entries to be decoded. If count is greater than zero\nbut less than the total number of metric entries available in the raw data, then user provided number will be decoded.\nIf count is greater than the number available in the raw data buffer, then the driver shall update the value with\nthe actual number of decodable metric entries decoded. If set to null, then driver will only update the value of\npSetCount.\n", + "name": "pMetricEntriesCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pMetricEntriesCount)] buffer containing decoded metric entries", + "name": "pMetricEntries", + "type": "zet_metric_entry_exp_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == phMetricDecoder`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pRawDataSize`", + "`nullptr == phMetrics`", + "`nullptr == pSetCount`", + "`nullptr == pMetricEntriesCount`" + ] + } + ], + "type": "function", + "version": "1.10" + }, + "Destroy": { + "class": "zetTracerExp", + "decl": "static", + "desc": "Destroys a tracer.", + "details": [ + "The application must **not** call this function from simultaneous threads with the same tracer handle.", + "The implementation of this function must be thread-safe.", + "The implementation of this function will stall and wait on any outstanding threads executing callbacks before freeing any Host allocations associated with this tracer." + ], + "hash": "93988865d3b59785a30efbb5b38fea9024972b775e1ec2b82b52cfcd53e0fac2", + "name": "Destroy", + "ordinal": "0", + "params": [ + { + "desc": "[in][release] handle of tracer object to destroy", + "name": "hTracer", + "type": "zet_tracer_exp_handle_t" } ], "returns": [ @@ -24161,20 +27837,19 @@ "type": "function" }, "DestroyExp": { - "class": "zeRTASParallelOperation", - "desc": "Destroys a ray tracing acceleration structure builder parallel operation object", + "class": "zetMetric", + "decl": "static", + "desc": "Destroy a metric created using zetMetricCreateFromProgrammableExp2.", "details": [ - "The implementation of this function may immediately release any internal Host and Device resources associated with this parallel operation.", - "The application must **not** call this function from simultaneous threads with the same parallel operation handle.", - "The implementation of this function must be thread-safe." + "If a metric is added to a metric group, the metric has to be removed using zetMetricGroupRemoveMetricExp before it can be destroyed." ], - "hash": "1371aca73bc98168b52b7ef394df4034d67304927b620cd3199fda16fcf3082b", + "hash": "2ba0a66809e327a7e1946aefe3ac00b4df3c601551e7677b92e2ee03ebe5d195", "name": "DestroyExp", "params": [ { - "desc": "[in][release] handle of parallel operation object to destroy", - "name": "hParallelOperation", - "type": "ze_rtas_parallel_operation_exp_handle_t" + "desc": "[in] Handle of the metric to destroy", + "name": "hMetric", + "type": "zet_metric_handle_t" } ], "returns": [ @@ -24195,12 +27870,22 @@ }, { "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hParallelOperation`" + "`nullptr == hMetric`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_ARGUMENT": [ + "If trying to destroy a metric from pre-defined metric group" + ] + }, + { + "ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE": [ + "If trying to destroy a metric currently added to a metric group" ] } ], "type": "function", - "version": "1.7" + "version": "1.9" }, "Detach": { "class": "zetDebug", @@ -24238,6 +27923,52 @@ ], "type": "function" }, + "DisableExp": { + "class": "zetMetricTracer", + "desc": "Stop events collection", + "details": [ + "Driver implementations must make this API call have as minimal overhead as possible, to allow applications start/stop event collection at any point during execution", + "The application must **not** call this function from simultaneous threads with the same metric tracer handle." + ], + "hash": "bd1d3df88b48f5feadd445e8944c5a243ef6d2fed1ef23e9a5a25880f79fcf7b", + "name": "DisableExp", + "params": [ + { + "desc": "[in] handle of the metric tracer", + "name": "hMetricTracer", + "type": "zet_metric_tracer_exp_handle_t" + }, + { + "desc": "[in] request synchronous behavior. Confirmation of successful asynchronous operation is done by calling zetMetricTracerReadDataExp()\nand checking the return status: ZE_RESULT_SUCCESS will be returned when the tracer is active or when it is inactive but still has data. \nZE_RESULT_NOT_READY will be returned when the tracer is inactive and has no more data to be retrieved.\n", + "name": "synchronous", + "type": "ze_bool_t" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricTracer`" + ] + } + ], + "type": "function", + "version": "1.10" + }, "DynamicLink": { "class": "zeModule", "decl": "static", @@ -24405,30 +28136,25 @@ "type": "function", "version": "1.4" }, - "EnumDiagnosticTestSuites": { - "class": "zesDevice", - "desc": "Get handle of diagnostics test suites", + "EnableExp": { + "class": "zetMetricTracer", + "desc": "Start events collection", "details": [ - "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "Driver implementations must make this API call have as minimal overhead as possible, to allow applications start/stop event collection at any point during execution", + "The application must **not** call this function from simultaneous threads with the same metric tracer handle." ], - "hash": "59ed350ef7e70b37e52550c3ab609f5379d8b887c910db4babc51892f01acaed", - "name": "EnumDiagnosticTestSuites", + "hash": "1e622842ff448bf8d5e1177c89702e45f7bc41daf0ff063cc4f9b85875ccae37", + "name": "EnableExp", "params": [ { - "desc": "[in] Sysman handle of the device.", - "name": "hDevice", - "type": "zes_device_handle_t" - }, - { - "desc": "[in,out] pointer to the number of components of this type.\nif count is zero, then the driver shall update the value with the total number of components of this type that are available.\nif count is greater than the number of components of this type that are available, then the driver shall update the value with the correct number of components.\n", - "name": "pCount", - "type": "uint32_t*" + "desc": "[in] handle of the metric tracer", + "name": "hMetricTracer", + "type": "zet_metric_tracer_exp_handle_t" }, { - "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", - "name": "phDiagnostics", - "type": "zes_diag_handle_t*" + "desc": "[in] request synchronous behavior. Confirmation of successful asynchronous operation is done by calling zetMetricTracerReadDataExp()\nand checking the return status: ZE_RESULT_NOT_READY will be returned when the tracer is inactive. ZE_RESULT_SUCCESS will be returned \nwhen the tracer is active.\n", + "name": "synchronous", + "type": "ze_bool_t" } ], "returns": [ @@ -24449,26 +28175,23 @@ }, { "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDevice`" - ] - }, - { - "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pCount`" + "`nullptr == hMetricTracer`" ] } ], - "type": "function" + "type": "function", + "version": "1.10" }, - "EnumEngineGroups": { + "EnumActiveVFExp": { "class": "zesDevice", - "desc": "Get handle of engine groups", + "desc": "Get handle of virtual function modules", "details": [ + "[DEPRECATED] No longer supported. Use zesDeviceEnumEnabledVFExp.", "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "25e6a47559c32a64fa8b2e4c45eae905a6ec1127530dcbbeb65637befa658e26", - "name": "EnumEngineGroups", + "hash": "ad00f044ce01e761f48e29a6a5d305df3d362dc8bb0dfe6b707e698b6dc392d7", + "name": "EnumActiveVFExp", "params": [ { "desc": "[in] Sysman handle of the device.", @@ -24482,8 +28205,8 @@ }, { "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", - "name": "phEngine", - "type": "zes_engine_handle_t*" + "name": "phVFhandle", + "type": "zes_vf_handle_t*" } ], "returns": [ @@ -24513,17 +28236,18 @@ ] } ], - "type": "function" + "type": "function", + "version": "1.9" }, - "EnumFabricPorts": { + "EnumDiagnosticTestSuites": { "class": "zesDevice", - "desc": "Get handle of Fabric ports in a device", + "desc": "Get handle of diagnostics test suites", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "f8b22e29f845c563af633d8a69c44bcecceda14be9ca6c0151d348a192c5f7ff", - "name": "EnumFabricPorts", + "hash": "59ed350ef7e70b37e52550c3ab609f5379d8b887c910db4babc51892f01acaed", + "name": "EnumDiagnosticTestSuites", "params": [ { "desc": "[in] Sysman handle of the device.", @@ -24537,8 +28261,8 @@ }, { "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", - "name": "phPort", - "type": "zes_fabric_port_handle_t*" + "name": "phDiagnostics", + "type": "zes_diag_handle_t*" } ], "returns": [ @@ -24570,15 +28294,15 @@ ], "type": "function" }, - "EnumFans": { + "EnumEnabledVFExp": { "class": "zesDevice", - "desc": "Get handle of fans", + "desc": "Get handle of virtual function modules", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "cd402f983e5dc2e1f226dccb0609064e6bd118037410019a20723a8a58c6c4a5", - "name": "EnumFans", + "hash": "3bda6a79097a23aa3e3ea29bbe7201d2cf0ce2d2e24feff71563a4bcbfefb1fa", + "name": "EnumEnabledVFExp", "params": [ { "desc": "[in] Sysman handle of the device.", @@ -24592,8 +28316,8 @@ }, { "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", - "name": "phFan", - "type": "zes_fan_handle_t*" + "name": "phVFhandle", + "type": "zes_vf_handle_t*" } ], "returns": [ @@ -24623,17 +28347,18 @@ ] } ], - "type": "function" + "type": "function", + "version": "1.10" }, - "EnumFirmwares": { + "EnumEngineGroups": { "class": "zesDevice", - "desc": "Get handle of firmwares", + "desc": "Get handle of engine groups", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "9ba0753daddbd3a471d4b8ecb7290ed7990b77741e191e3498fd13a8961ca8bf", - "name": "EnumFirmwares", + "hash": "25e6a47559c32a64fa8b2e4c45eae905a6ec1127530dcbbeb65637befa658e26", + "name": "EnumEngineGroups", "params": [ { "desc": "[in] Sysman handle of the device.", @@ -24647,8 +28372,8 @@ }, { "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", - "name": "phFirmware", - "type": "zes_firmware_handle_t*" + "name": "phEngine", + "type": "zes_engine_handle_t*" } ], "returns": [ @@ -24680,15 +28405,15 @@ ], "type": "function" }, - "EnumFrequencyDomains": { + "EnumFabricPorts": { "class": "zesDevice", - "desc": "Get handle of frequency domains", + "desc": "Get handle of Fabric ports in a device", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "3a4d3adfa79bc56aef50d3cd79d36487a13688f3b3c2bf544441d95b1271691a", - "name": "EnumFrequencyDomains", + "hash": "f8b22e29f845c563af633d8a69c44bcecceda14be9ca6c0151d348a192c5f7ff", + "name": "EnumFabricPorts", "params": [ { "desc": "[in] Sysman handle of the device.", @@ -24702,8 +28427,8 @@ }, { "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", - "name": "phFrequency", - "type": "zes_freq_handle_t*" + "name": "phPort", + "type": "zes_fabric_port_handle_t*" } ], "returns": [ @@ -24735,15 +28460,15 @@ ], "type": "function" }, - "EnumLeds": { + "EnumFans": { "class": "zesDevice", - "desc": "Get handle of LEDs", + "desc": "Get handle of fans", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "8c338f22d1047a3079b9f4adf6b0598674b17ba06e0605b1aaa547b901ecae6a", - "name": "EnumLeds", + "hash": "cd402f983e5dc2e1f226dccb0609064e6bd118037410019a20723a8a58c6c4a5", + "name": "EnumFans", "params": [ { "desc": "[in] Sysman handle of the device.", @@ -24757,8 +28482,8 @@ }, { "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", - "name": "phLed", - "type": "zes_led_handle_t*" + "name": "phFan", + "type": "zes_fan_handle_t*" } ], "returns": [ @@ -24790,15 +28515,15 @@ ], "type": "function" }, - "EnumMemoryModules": { + "EnumFirmwares": { "class": "zesDevice", - "desc": "Get handle of memory modules", + "desc": "Get handle of firmwares", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "dfed3a82c29b73a59785c50f0149f1e08aa7664d6df89896aded435611614784", - "name": "EnumMemoryModules", + "hash": "9ba0753daddbd3a471d4b8ecb7290ed7990b77741e191e3498fd13a8961ca8bf", + "name": "EnumFirmwares", "params": [ { "desc": "[in] Sysman handle of the device.", @@ -24812,8 +28537,8 @@ }, { "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", - "name": "phMemory", - "type": "zes_mem_handle_t*" + "name": "phFirmware", + "type": "zes_firmware_handle_t*" } ], "returns": [ @@ -24845,15 +28570,15 @@ ], "type": "function" }, - "EnumOverclockDomains": { + "EnumFrequencyDomains": { "class": "zesDevice", - "desc": "Get handle of overclock domains", + "desc": "Get handle of frequency domains", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "4b879a76b3b04fde6760e7c52a1df27690607bd6f77d8eefa431bfe0bde261db", - "name": "EnumOverclockDomains", + "hash": "3a4d3adfa79bc56aef50d3cd79d36487a13688f3b3c2bf544441d95b1271691a", + "name": "EnumFrequencyDomains", "params": [ { "desc": "[in] Sysman handle of the device.", @@ -24867,8 +28592,8 @@ }, { "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", - "name": "phDomainHandle", - "type": "zes_overclock_handle_t*" + "name": "phFrequency", + "type": "zes_freq_handle_t*" } ], "returns": [ @@ -24898,12 +28623,177 @@ ] } ], - "type": "function", - "version": "1.5" + "type": "function" }, - "EnumPerformanceFactorDomains": { + "EnumLeds": { "class": "zesDevice", - "desc": "Get handles to accelerator domains whose performance can be optimized via a Performance Factor", + "desc": "Get handle of LEDs", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "8c338f22d1047a3079b9f4adf6b0598674b17ba06e0605b1aaa547b901ecae6a", + "name": "EnumLeds", + "params": [ + { + "desc": "[in] Sysman handle of the device.", + "name": "hDevice", + "type": "zes_device_handle_t" + }, + { + "desc": "[in,out] pointer to the number of components of this type.\nif count is zero, then the driver shall update the value with the total number of components of this type that are available.\nif count is greater than the number of components of this type that are available, then the driver shall update the value with the correct number of components.\n", + "name": "pCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", + "name": "phLed", + "type": "zes_led_handle_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDevice`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCount`" + ] + } + ], + "type": "function" + }, + "EnumMemoryModules": { + "class": "zesDevice", + "desc": "Get handle of memory modules", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "dfed3a82c29b73a59785c50f0149f1e08aa7664d6df89896aded435611614784", + "name": "EnumMemoryModules", + "params": [ + { + "desc": "[in] Sysman handle of the device.", + "name": "hDevice", + "type": "zes_device_handle_t" + }, + { + "desc": "[in,out] pointer to the number of components of this type.\nif count is zero, then the driver shall update the value with the total number of components of this type that are available.\nif count is greater than the number of components of this type that are available, then the driver shall update the value with the correct number of components.\n", + "name": "pCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", + "name": "phMemory", + "type": "zes_mem_handle_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDevice`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCount`" + ] + } + ], + "type": "function" + }, + "EnumOverclockDomains": { + "class": "zesDevice", + "desc": "Get handle of overclock domains", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "4b879a76b3b04fde6760e7c52a1df27690607bd6f77d8eefa431bfe0bde261db", + "name": "EnumOverclockDomains", + "params": [ + { + "desc": "[in] Sysman handle of the device.", + "name": "hDevice", + "type": "zes_device_handle_t" + }, + { + "desc": "[in,out] pointer to the number of components of this type.\nif count is zero, then the driver shall update the value with the total number of components of this type that are available.\nif count is greater than the number of components of this type that are available, then the driver shall update the value with the correct number of components.\n", + "name": "pCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", + "name": "phDomainHandle", + "type": "zes_overclock_handle_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDevice`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCount`" + ] + } + ], + "type": "function", + "version": "1.5" + }, + "EnumPerformanceFactorDomains": { + "class": "zesDevice", + "desc": "Get handles to accelerator domains whose performance can be optimized via a Performance Factor", "details": [ "A Performance Factor should be tuned for each workload.", "The application may call this function from simultaneous threads.", @@ -25504,7 +29394,7 @@ }, { "ZE_RESULT_ERROR_INVALID_ENUMERATION": [ - "`0x7fff < events`" + "`0xffff < events`" ] } ], @@ -25713,8 +29603,10 @@ "class": "zesFirmware", "desc": "Flash a new firmware image", "details": [ + "Any running workload must be gracefully closed before invoking this function.", "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The implementation of this function should be lock-free.", + "This is a non-blocking call. Application may call zesFirmwareGetFlashProgress to get completion status." ], "hash": "a6cc43172f030767262ce409a236ed03fd2f41a4abb336ece7e0e1bd642004b4", "name": "Flash", @@ -26688,7 +30580,8 @@ "desc": "Get handle of the PCIe card-level power", "details": [ "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The implementation of this function should be lock-free.", + "[DEPRECATED] No longer supported." ], "hash": "047ca99995666fe5cefd48dde4b5e5262fd4ac1916c75723f18649b25c4e6942", "name": "GetCardPowerDomain", @@ -26854,6 +30747,68 @@ ], "type": "function" }, + "GetConcurrentMetricGroupsExp": { + "class": "zetDevice", + "decl": "static", + "desc": "Get sets of metric groups which could be collected concurrently.", + "details": [ + "Re-arrange the input metric groups to provide sets of concurrent metric groups." + ], + "hash": "dff2f294997531b6afb852cad66aae3432985a730c3ffcabc927d9283ed49649", + "name": "GetConcurrentMetricGroupsExp", + "params": [ + { + "desc": "[in] handle of the device", + "name": "hDevice", + "type": "zet_device_handle_t" + }, + { + "desc": "[in] metric group count", + "name": "metricGroupCount", + "type": "uint32_t" + }, + { + "desc": "[in,out] metrics groups to be re-arranged to be sets of concurrent groups", + "name": "phMetricGroups", + "type": "zet_metric_group_handle_t *" + }, + { + "desc": "[in,out][optional][*pConcurrentGroupCount] count of metric groups per concurrent group.\n", + "name": "pMetricGroupsCountPerConcurrentGroup", + "type": "uint32_t *" + }, + { + "desc": "[out] number of concurrent groups.\nThe value of this parameter could be used to determine the number of replays necessary.", + "name": "pConcurrentGroupCount", + "type": "uint32_t *" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDevice`", + "`nullptr == phMetricGroups`" + ] + } + ], + "type": "function", + "version": "1.10" + }, "GetConfig": { "class": "zesTemperature", "desc": "Get temperature configuration for this sensor - which events are triggered and the trigger conditions", @@ -26915,30 +30870,32 @@ ], "type": "function" }, - "GetControlCurrentValue": { - "class": "zesOverclock", - "desc": "Read the current value for a given overclock control", + "GetConsoleLogs": { + "class": "zesFirmware", + "desc": "Get Firmware Console Logs", "details": [ + "The caller may pass nullptr for pFirmwareLog and set pSize to zero when querying only for size.", + "The caller must provide memory for Firmware log.", "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "d9b4cc3a89e0a244a5748ef773a56340b963b51a15ff79e6e84a53598a2a8e06", - "name": "GetControlCurrentValue", + "hash": "e19514a02c0880e3755bae04de8e0394819ec81d1beb2bac36d5d0b79d56be33", + "name": "GetConsoleLogs", "params": [ { "desc": "[in] Handle for the component.", - "name": "hDomainHandle", - "type": "zes_overclock_handle_t" + "name": "hFirmware", + "type": "zes_firmware_handle_t" }, { - "desc": "[in] Overclock Control.", - "name": "DomainControl", - "type": "zes_overclock_control_t" + "desc": "[in,out] size of firmware log", + "name": "pSize", + "type": "size_t*" }, { - "desc": "[in,out] Getting overclock control value for the specified control.", - "name": "pValue", - "type": "double*" + "desc": "[in,out][optional] pointer to null-terminated string of the log.", + "name": "pFirmwareLog", + "type": "char*" } ], "returns": [ @@ -26959,40 +30916,81 @@ }, { "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDomainHandle`" + "`nullptr == hFirmware`" ] }, { - "ZE_RESULT_ERROR_INVALID_ENUMERATION": [ - "`ZES_OVERCLOCK_CONTROL_ACM_DISABLE < DomainControl`" + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pSize`" ] + } + ], + "type": "function", + "version": "1.9" + }, + "GetContextHandle": { + "class": "zeEventPool", + "desc": "Gets the handle of the context on which the event pool was created.", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "d7f550b2814d0c5a32588cef3b988a5aed42e25889c3692dab7565da4041f523", + "name": "GetContextHandle", + "params": [ + { + "desc": "[in] handle of the event pool", + "name": "hEventPool", + "type": "ze_event_pool_handle_t" }, { - "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pValue`" + "desc": "[out] handle of the context on which the event pool was created", + "name": "phContext", + "type": "ze_context_handle_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hEventPool`" ] }, { - "ZE_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "Overclocking is not supported on this control domain" + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == phContext`" ] } ], "type": "function", - "version": "1.5" + "version": "1.9" }, - "GetControlPendingValue": { + "GetControlCurrentValue": { "class": "zesOverclock", - "desc": "Read the the reset pending value for a given overclock control", + "desc": "Read the current value for a given overclock control", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "9ba2bc75c2454afb04fa795e698945acb130400573382ae99ebf3105a50b4f27", - "name": "GetControlPendingValue", + "hash": "d9b4cc3a89e0a244a5748ef773a56340b963b51a15ff79e6e84a53598a2a8e06", + "name": "GetControlCurrentValue", "params": [ { - "desc": "[in] Handle for the component domain.", + "desc": "[in] Handle for the component.", "name": "hDomainHandle", "type": "zes_overclock_handle_t" }, @@ -27002,7 +31000,73 @@ "type": "zes_overclock_control_t" }, { - "desc": "[out] Returns the pending value for a given control. The units and format of the value depend on the control type.", + "desc": "[in,out] Getting overclock control value for the specified control.", + "name": "pValue", + "type": "double*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDomainHandle`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_ENUMERATION": [ + "`ZES_OVERCLOCK_CONTROL_ACM_DISABLE < DomainControl`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pValue`" + ] + }, + { + "ZE_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "Overclocking is not supported on this control domain" + ] + } + ], + "type": "function", + "version": "1.5" + }, + "GetControlPendingValue": { + "class": "zesOverclock", + "desc": "Read the the reset pending value for a given overclock control", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "9ba2bc75c2454afb04fa795e698945acb130400573382ae99ebf3105a50b4f27", + "name": "GetControlPendingValue", + "params": [ + { + "desc": "[in] Handle for the component domain.", + "name": "hDomainHandle", + "type": "zes_overclock_handle_t" + }, + { + "desc": "[in] Overclock Control.", + "name": "DomainControl", + "type": "zes_overclock_control_t" + }, + { + "desc": "[out] Returns the pending value for a given control. The units and format of the value depend on the control type.", "name": "pValue", "type": "double*" } @@ -27341,6 +31405,131 @@ ], "type": "function" }, + "GetDecodableMetricsExp": { + "class": "zetMetricDecoder", + "desc": "Return the list of the decodable metrics from the decoder.", + "details": [ + "The decodable metrics handles returned by this API are defined by the metric groups in the tracer on which the decoder was created.", + "The decodable metrics handles returned by this API are only valid to decode metrics raw data with zetMetricTracerDecodeExp(). Decodable metric handles are not valid to compare with metrics handles included in metric groups." + ], + "hash": "3d1ac19733022f5c93c944a43f72fd41b0c9fbe93bce83ba5063fd16d7cb6dcf", + "name": "GetDecodableMetricsExp", + "params": [ + { + "desc": "[in] handle of the metric decoder object", + "name": "hMetricDecoder", + "type": "zet_metric_decoder_exp_handle_t" + }, + { + "desc": "[in,out] pointer to number of decodable metric in the hMetricDecoder handle. If count is zero, then the driver shall \nupdate the value with the total number of decodable metrics available in the decoder. if count is greater than zero \nbut less than the total number of decodable metrics available in the decoder, then only that number will be returned. \nif count is greater than the number of decodable metrics available in the decoder, then the driver shall update the \nvalue with the actual number of decodable metrics available. \n", + "name": "pCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out] [range(0, *pCount)] array of handles of decodable metrics in the hMetricDecoder handle provided.", + "name": "phMetrics", + "type": "zet_metric_handle_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricDecoder`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCount`", + "`nullptr == phMetrics`" + ] + } + ], + "type": "function", + "version": "1.10" + }, + "GetDeviceByUuidExp": { + "class": "zesDriver", + "desc": "Retrieves sysman device and subdevice index for the given UUID and sysman driver", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "602d4db6503d6bd7f5fc359621651cf2632c93a3ea12d3c68070ee245ccd67cd", + "name": "GetDeviceByUuidExp", + "params": [ + { + "desc": "[in] handle of the sysman driver instance", + "name": "hDriver", + "type": "zes_driver_handle_t" + }, + { + "desc": "[in] universal unique identifier.", + "name": "uuid", + "type": "zes_uuid_t" + }, + { + "desc": "[out] Sysman handle of the device.", + "name": "phDevice", + "type": "zes_device_handle_t*" + }, + { + "desc": "[out] True if the UUID belongs to the sub-device; false means that UUID belongs to the root device.", + "name": "onSubdevice", + "type": "ze_bool_t*" + }, + { + "desc": "[out] If onSubdevice is true, this gives the ID of the sub-device", + "name": "subdeviceId", + "type": "uint32_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDriver`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == phDevice`", + "`nullptr == onSubdevice`", + "`nullptr == subdeviceId`" + ] + } + ], + "type": "function", + "version": "1.9" + }, "GetDeviceExp": { "class": "zeFabricVertex", "desc": "Returns device handle from fabric vertex handle.", @@ -27402,6 +31591,111 @@ "type": "function", "version": "1.4" }, + "GetDeviceHandle": { + "class": "zeCommandList", + "desc": "Gets the handle of the device on which the command list was created.", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "415fb57c3d440d14edcfc2f819c0096d3782ee45669422a820701781eeae9f87", + "name": "GetDeviceHandle", + "params": [ + { + "desc": "[in] handle of the command list", + "name": "hCommandList", + "type": "ze_command_list_handle_t" + }, + { + "desc": "[out] handle of the device on which the command list was created", + "name": "phDevice", + "type": "ze_device_handle_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hCommandList`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == phDevice`" + ] + } + ], + "type": "function", + "version": "1.9" + }, + "GetDeviceOffsetExp": { + "class": "zeImage", + "decl": "static", + "desc": "Get bindless device offset for image", + "details": [ + "The application may call this function from simultaneous threads", + "The implementation of this function must be thread-safe.", + "The implementation of this function should be lock-free.", + "The implementation must support ::ZE_experimental_bindless_image extension." + ], + "hash": "1f03cf9c6d99001fb5152d3c9a3c14dfa99199145fa5a5fbf50ea0792c049cc5", + "name": "GetDeviceOffsetExp", + "params": [ + { + "desc": "[in] handle of the image", + "name": "hImage", + "type": "ze_image_handle_t" + }, + { + "desc": "[out] bindless device offset for image", + "name": "pDeviceOffset", + "type": "uint64_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hImage`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pDeviceOffset`" + ] + } + ], + "type": "function", + "version": "1.9" + }, "GetDomainControlProperties": { "class": "zesOverclock", "desc": "Read overclock control values - min/max/step/default/ref", @@ -27741,38 +32035,83 @@ ], "type": "function" }, - "GetExp": { - "class": "zeFabricEdge", - "decl": "static", - "desc": "Retrieves all fabric edges between provided pair of fabric vertices", + "GetEventPool": { + "class": "zeEvent", + "desc": "Gets the handle of the event pool for the event.", "details": [ - "A fabric edge represents one or more physical links between two fabric vertices.", "The application may call this function from simultaneous threads.", - "The implementation of this function must be thread-safe." + "The implementation of this function should be lock-free." ], - "hash": "49c8b5bf1db998a1e71e1f5cbd3960b2389a55e949acf172171586c40d5bdc14", - "name": "GetExp", - "ordinal": "0", + "hash": "5518688c8da46d797af03c0e44d8222976d72478a9d8d3cd742fabb125bab9a8", + "name": "GetEventPool", "params": [ { - "desc": "[in] handle of first fabric vertex instance", - "name": "hVertexA", - "type": "ze_fabric_vertex_handle_t" + "desc": "[in] handle of the event", + "name": "hEvent", + "type": "ze_event_handle_t" }, { - "desc": "[in] handle of second fabric vertex instance", - "name": "hVertexB", - "type": "ze_fabric_vertex_handle_t" + "desc": "[out] handle of the event pool for the event", + "name": "phEventPool", + "type": "ze_event_pool_handle_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hEvent`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == phEventPool`" + ] + } + ], + "type": "function", + "version": "1.9" + }, + "GetExp": { + "class": "zetMetricProgrammable", + "decl": "static", + "desc": "Query and get the available metric programmable handles.", + "details": [ + "Query the available programmable handles using *pCount = 0.", + "Returns all programmable metric handles available in the device.", + "The application may call this function from simultaneous threads." + ], + "hash": "ccc0dd6c7a4ed0f7160b301fdbfe0382c093f26bded09a2577f66e276d5c3336", + "name": "GetExp", + "params": [ + { + "desc": "[in] handle of the device", + "name": "hDevice", + "type": "zet_device_handle_t" }, { - "desc": "[in,out] pointer to the number of fabric edges.\nif count is zero, then the driver shall update the value with the total number of fabric edges available.\nif count is greater than the number of fabric edges available, then the driver shall update the value with the correct number of fabric edges available.\n", + "desc": "[in,out] pointer to the number of metric programmable handles.\nif count is zero, then the driver shall update the value with the total number of metric programmable handles available.\nif count is greater than the number of metric programmable handles available, then the driver shall update the value with the correct number of metric programmable handles available.\n", "name": "pCount", "type": "uint32_t*" }, { - "desc": "[in,out][optional][range(0, *pCount)] array of handle of fabric edges.\nif count is less than the number of fabric edges available, then driver shall only retrieve that number of fabric edges.\n", - "name": "phEdges", - "type": "ze_fabric_edge_handle_t*" + "desc": "[in,out][optional][range(0, *pCount)] array of handle of metric programmables.\nif count is less than the number of metric programmables available, then driver shall only retrieve that number of metric programmables.\n", + "name": "phMetricProgrammables", + "type": "zet_metric_programmable_exp_handle_t*" } ], "returns": [ @@ -27793,8 +32132,7 @@ }, { "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hVertexA`", - "`nullptr == hVertexB`" + "`nullptr == hDevice`" ] }, { @@ -27804,7 +32142,7 @@ } ], "type": "function", - "version": "1.4" + "version": "1.9" }, "GetExportDataExp": { "class": "zetMetricGroup", @@ -27876,19 +32214,19 @@ "version": "1.6" }, "GetExtensionFunctionAddress": { - "class": "zeDriver", + "class": "zesDriver", "desc": "Retrieves function pointer for vendor-specific or experimental extensions", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "06b81bd7c84e1d4a4ce904b9123444ca519be82720267c97f602201ac5009dc8", + "hash": "f9e53cbf6dd9fb646d04ca02d88d69da064b659dcd4e935e0a8a799656259ffc", "name": "GetExtensionFunctionAddress", "params": [ { "desc": "[in] handle of the driver instance", "name": "hDriver", - "type": "ze_driver_handle_t" + "type": "zes_driver_handle_t" }, { "desc": "[in] extension function name", @@ -27930,25 +32268,22 @@ } ], "type": "function", - "version": "1.1" + "version": "1.8" }, "GetExtensionProperties": { - "analogue": [ - "**vkEnumerateInstanceExtensionProperties**" - ], - "class": "zeDriver", + "class": "zesDriver", "desc": "Retrieves extension properties", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "8e44ae247d11d858ca4bad79512a3bf69323a900b1ac782903bb513479bba13a", + "hash": "dff8b1c749c24800e4522d72ec77d0d2f80e86dcd753f1f4131dfd642cffd285", "name": "GetExtensionProperties", "params": [ { "desc": "[in] handle of the driver instance", "name": "hDriver", - "type": "ze_driver_handle_t" + "type": "zes_driver_handle_t" }, { "desc": "[in,out] pointer to the number of extension properties.\nif count is zero, then the driver shall update the value with the total number of extension properties available.\nif count is greater than the number of extension properties available, then the driver shall update the value with the correct number of extension properties available.\n", @@ -27958,7 +32293,7 @@ { "desc": "[in,out][optional][range(0, *pCount)] array of query results for extension properties.\nif count is less than the number of extension properties available, then driver shall only retrieve that number of extension properties.\n", "name": "pExtensionProperties", - "type": "ze_driver_extension_properties_t*" + "type": "zes_driver_extension_properties_t*" } ], "returns": [ @@ -27988,7 +32323,8 @@ ] } ], - "type": "function" + "type": "function", + "version": "1.8" }, "GetExternalMemoryProperties": { "class": "zeDevice", @@ -28212,6 +32548,108 @@ "type": "function", "version": "1.6" }, + "GetFlags": { + "class": "zeEventPool", + "desc": "Gets the creation flags used to create the event pool.", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "f132708d6d6b4e42b911405306c79565a83cb1e6e19d94d904406f7375c72e7d", + "name": "GetFlags", + "params": [ + { + "desc": "[in] handle of the event pool", + "name": "hEventPool", + "type": "ze_event_pool_handle_t" + }, + { + "desc": "[out] creation flags used to create the event pool; may be 0 or a valid combination of ze_event_pool_flag_t", + "name": "pFlags", + "type": "ze_event_pool_flags_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hEventPool`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pFlags`" + ] + } + ], + "type": "function", + "version": "1.9" + }, + "GetFlashProgress": { + "class": "zesFirmware", + "desc": "Get Firmware Flash Progress", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "372362463218b6c44bc0ebc304c24d5aa9b4f8225422f4ad37537dea53167a1e", + "name": "GetFlashProgress", + "params": [ + { + "desc": "[in] Handle for the component.", + "name": "hFirmware", + "type": "zes_firmware_handle_t" + }, + { + "desc": "[in,out] Pointer to the Completion Percentage of Firmware Update", + "name": "pCompletionPercent", + "type": "uint32_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hFirmware`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCompletionPercent`" + ] + } + ], + "type": "function", + "version": "1.8" + }, "GetFunctionPointer": { "class": "zeModule", "desc": "Retrieve a function pointer from a module by name", @@ -28355,12 +32793,12 @@ "type": "ze_device_handle_t" }, { - "desc": "[out] value of the Host's global timestamp that correlates with the Device's global timestamp value", + "desc": "[out] value of the Host's global timestamp that correlates with the Device's global timestamp value.", "name": "hostTimestamp", "type": "uint64_t*" }, { - "desc": "[out] value of the Device's global timestamp that correlates with the Host's global timestamp value", + "desc": "[out] value of the Device's global timestamp that correlates with the Host's global timestamp value.", "name": "deviceTimestamp", "type": "uint64_t*" } @@ -28391,6 +32829,11 @@ "`nullptr == hostTimestamp`", "`nullptr == deviceTimestamp`" ] + }, + { + "ZE_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "The feature is not supported by the underlying platform." + ] } ], "type": "function", @@ -28512,6 +32955,57 @@ ], "type": "function" }, + "GetIndex": { + "class": "zeCommandQueue", + "desc": "Gets the command queue index within the group.", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "0b83e32e93540fc3317a0ad0d0aed594e1462e9760098d31db597ffb61dfc941", + "name": "GetIndex", + "params": [ + { + "desc": "[in] handle of the command queue", + "name": "hCommandQueue", + "type": "ze_command_queue_handle_t" + }, + { + "desc": "[out] command queue index within the group", + "name": "pIndex", + "type": "uint32_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hCommandQueue`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pIndex`" + ] + } + ], + "type": "function", + "version": "1.9" + }, "GetIndirectAccess": { "class": "zeKernel", "desc": "Retrieve kernel indirect access flags.", @@ -28846,7 +33340,7 @@ "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free.", - "Note: This function is deprecated and replaced by zesPowerGetLimitsExt." + "[DEPRECATED] Use zesPowerGetLimitsExt." ], "hash": "ed0462ffcd8d44a95439a0ea86fbb1bc0e13e357c0d73fabd1d3322abd658e18", "name": "GetLimits", @@ -29454,29 +33948,218 @@ ], "type": "function" }, - "GetOverclockControls": { - "class": "zesDevice", - "desc": "Get the list of supported overclock controls available for one of the supported overclock domains on the device", + "GetNextCommandIdExp": { + "class": "zeCommandList", + "desc": "Returns a unique command identifier for the next command to be appended to a command list.", "details": [ - "The application may call this function from simultaneous threads.", + "This function may only be called for a mutable command list.", + "This function may not be called on a closed command list.", + "This function may be called from simultaneous threads with the same command list handle.", "The implementation of this function should be lock-free." ], - "hash": "4377753972c5b509120ab9c0d528b6c7428abbbaa4b0eb1c0704a51a7d8c351c", - "name": "GetOverclockControls", + "hash": "28875c3d2d60a7e128e2c5e59a8f61ecbcc89611d9e4acfffdb858380e4108c1", + "name": "GetNextCommandIdExp", "params": [ { - "desc": "[in] Sysman handle of the device.", - "name": "hDevice", - "type": "zes_device_handle_t" + "desc": "[in] handle of the command list", + "name": "hCommandList", + "type": "ze_command_list_handle_t" }, { - "desc": "[in] Domain type.", - "name": "domainType", - "type": "zes_overclock_domain_t" + "desc": "[in] pointer to mutable command identifier descriptor", + "name": "desc", + "type": "const ze_mutable_command_id_exp_desc_t*" }, { - "desc": "[in,out] Returns the overclock controls that are supported for the specified overclock domain (a bit for each of enum zes_overclock_control_t).", - "name": "pAvailableControls", + "desc": "[out] pointer to mutable command identifier to be written", + "name": "pCommandId", + "type": "uint64_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hCommandList`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == desc`", + "`nullptr == pCommandId`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_ENUMERATION": [ + "`0xff < desc->flags`" + ] + } + ], + "type": "function", + "version": "1.9" + }, + "GetNextCommandIdWithKernelsExp": { + "class": "zeCommandList", + "desc": "Returns a unique command identifier for the next command to be appended to a command list. Provides possible kernel handles for kernel mutation when ZE_MUTABLE_COMMAND_EXP_FLAG_KERNEL_INSTRUCTION flag is present.", + "details": [ + "This function may only be called for a mutable command list.", + "This function may not be called on a closed command list.", + "This function may be called from simultaneous threads with the same command list handle.", + "The implementation of this function should be lock-free." + ], + "hash": "02bc9e0e195f5db27434ca8289d060761dc869d97a04d925c1631786b9369b35", + "name": "GetNextCommandIdWithKernelsExp", + "params": [ + { + "desc": "[in] handle of the command list", + "name": "hCommandList", + "type": "ze_command_list_handle_t" + }, + { + "desc": "[in][out] pointer to mutable command identifier descriptor", + "name": "desc", + "type": "const ze_mutable_command_id_exp_desc_t*" + }, + { + "desc": "[in][optional] number of entries on phKernels list", + "name": "numKernels", + "type": "uint32_t" + }, + { + "desc": "[in][optional][range(0, numKernels)] list of kernels that user can switch between using zeCommandListUpdateMutableCommandKernelsExp call", + "name": "phKernels", + "type": "ze_kernel_handle_t*" + }, + { + "desc": "[out] pointer to mutable command identifier to be written", + "name": "pCommandId", + "type": "uint64_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hCommandList`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == desc`", + "`nullptr == pCommandId`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_ENUMERATION": [ + "`0xff < desc->flags`" + ] + } + ], + "type": "function", + "version": "1.10" + }, + "GetOrdinal": { + "class": "zeCommandList", + "desc": "Gets the command queue group ordinal to which the command list is submitted.", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "159b34a235fe830e296aebab56b274790d8df31c64f6cdedd8c2be26891c0091", + "name": "GetOrdinal", + "params": [ + { + "desc": "[in] handle of the command list", + "name": "hCommandList", + "type": "ze_command_list_handle_t" + }, + { + "desc": "[out] command queue group ordinal to which command list is submitted", + "name": "pOrdinal", + "type": "uint32_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hCommandList`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pOrdinal`" + ] + } + ], + "type": "function", + "version": "1.9" + }, + "GetOverclockControls": { + "class": "zesDevice", + "desc": "Get the list of supported overclock controls available for one of the supported overclock domains on the device", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "4377753972c5b509120ab9c0d528b6c7428abbbaa4b0eb1c0704a51a7d8c351c", + "name": "GetOverclockControls", + "params": [ + { + "desc": "[in] Sysman handle of the device.", + "name": "hDevice", + "type": "zes_device_handle_t" + }, + { + "desc": "[in] Domain type.", + "name": "domainType", + "type": "zes_overclock_domain_t" + }, + { + "desc": "[in,out] Returns the overclock controls that are supported for the specified overclock domain (a bit for each of enum zes_overclock_control_t).", + "name": "pAvailableControls", "type": "uint32_t*" } ], @@ -29633,6 +34316,197 @@ ], "type": "function" }, + "GetParamInfoExp": { + "class": "zetMetricProgrammable", + "decl": "static", + "desc": "Get the information about the parameters of the metric programmable.", + "details": [ + "Returns information about the parameters of the metric programmable handle." + ], + "hash": "2dba3c29b34868dc86f76c5bc9d0f483e4538e6bd784e228ee342dc9f3b30769", + "name": "GetParamInfoExp", + "params": [ + { + "desc": "[in] handle of the metric programmable", + "name": "hMetricProgrammable", + "type": "zet_metric_programmable_exp_handle_t" + }, + { + "desc": "[in,out] count of the parameters to retrieve parameter info.\nif value pParameterCount is greater than count of parameters available, then pParameterCount will be updated with count of parameters available.\nThe count of parameters available can be queried using zetMetricProgrammableGetPropertiesExp.\n", + "name": "pParameterCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][range(1, *pParameterCount)] array of parameter info.\nif parameterCount is less than the number of parameters available, then driver shall only retrieve that number of parameter info.\n", + "name": "pParameterInfo", + "type": "zet_metric_programmable_param_info_exp_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricProgrammable`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pParameterCount`", + "`nullptr == pParameterInfo`" + ] + } + ], + "type": "function", + "version": "1.9" + }, + "GetParamValueInfoExp": { + "class": "zetMetricProgrammable", + "decl": "static", + "desc": "Get the information about the parameter value of the metric programmable.", + "details": [ + "Returns the value-information about the parameter at the specific ordinal of the metric programmable handle." + ], + "hash": "a8bbacea8ada7ba67f03ef7e159d10bc7e9f5cdd98d334eb2f0c0c88b8debe78", + "name": "GetParamValueInfoExp", + "params": [ + { + "desc": "[in] handle of the metric programmable", + "name": "hMetricProgrammable", + "type": "zet_metric_programmable_exp_handle_t" + }, + { + "desc": "[in] ordinal of the parameter in the metric programmable", + "name": "parameterOrdinal", + "type": "uint32_t" + }, + { + "desc": "[in,out] count of parameter value information to retrieve.\nif value at pValueInfoCount is greater than count of value info available, then pValueInfoCount will be updated with count of value info available.\nThe count of parameter value info available can be queried using zetMetricProgrammableGetParamInfoExp.\n", + "name": "pValueInfoCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][range(1, *pValueInfoCount)] array of parameter value info.\nif pValueInfoCount is less than the number of value info available, then driver shall only retrieve that number of value info.\n", + "name": "pValueInfo", + "type": "zet_metric_programmable_param_value_info_exp_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricProgrammable`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pValueInfoCount`", + "`nullptr == pValueInfo`" + ] + } + ], + "type": "function", + "version": "1.9" + }, + "GetPitchFor2dImage": { + "class": "zeMem", + "decl": "static", + "desc": "Allocate pitched USM memory for images", + "details": [ + "Retrieves pitch for 2D image given the width, height and size in bytes", + "The memory is then allocated using zeMemAllocDevice by providing input size calculated as the returned pitch value multiplied by image height\n", + "The application may call this function from simultaneous threads\n", + "The implementation of this function must be thread-safe.\n", + "The implementation of this function should be lock-free.\n", + "The implementation must support ::ZE_experimental_bindless_image extension.\n" + ], + "hash": "64b9697e4ad99d2f8fc6bb66aea9c3491a82a53ef4f58a56efdff7c2fad4ce7c", + "name": "GetPitchFor2dImage", + "params": [ + { + "desc": "[in] handle of the context object", + "name": "hContext", + "type": "ze_context_handle_t" + }, + { + "desc": "[in] handle of the device", + "name": "hDevice", + "type": "ze_device_handle_t" + }, + { + "desc": "[in] imageWidth", + "name": "imageWidth", + "type": "size_t" + }, + { + "desc": "[in] imageHeight", + "name": "imageHeight", + "type": "size_t" + }, + { + "desc": "[in] Element size in bytes", + "name": "elementSizeInBytes", + "type": "unsigned int" + }, + { + "desc": "[out] rowPitch", + "name": "rowPitch", + "type": "size_t *" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hContext`", + "`nullptr == hDevice`" + ] + } + ], + "type": "function", + "version": "1.9" + }, "GetProfileInfo": { "class": "zetKernel", "desc": "Retrieve profiling information generated for the kernel.", @@ -29740,25 +34614,24 @@ "type": "function" }, "GetPropertiesExp": { - "class": "zeRTASParallelOperation", - "desc": "Retrieves ray tracing acceleration structure builder parallel operation properties", + "class": "zetMetricProgrammable", + "decl": "static", + "desc": "Get the properties of the metric programmable.", "details": [ - "The application must first bind the parallel operation object to a build operation before it may query the parallel operation properties. In other words, the application must first call zeRTASBuilderBuildExp with **hParallelOperation** before calling this function.", - "The application may call this function from simultaneous threads.", - "The implementation of this function must be thread-safe." + "Returns the properties of the metric programmable." ], - "hash": "7f52d48c631cdad4d5d9f6e9bfa9ba6bf2567c0d9f00637d921a927df1e0b279", + "hash": "f3d786fa9ed476cde98243d2f15cbb74d893e0f478af2773f52e52bd77e9d7f0", "name": "GetPropertiesExp", "params": [ { - "desc": "[in] handle of parallel operation object", - "name": "hParallelOperation", - "type": "ze_rtas_parallel_operation_exp_handle_t" + "desc": "[in] handle of the metric programmable", + "name": "hMetricProgrammable", + "type": "zet_metric_programmable_exp_handle_t" }, { - "desc": "[in,out] query result for parallel operation properties", + "desc": "[in,out] properties of the metric programmable", "name": "pProperties", - "type": "ze_rtas_parallel_operation_exp_properties_t*" + "type": "zet_metric_programmable_exp_properties_t*" } ], "returns": [ @@ -29779,7 +34652,7 @@ }, { "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hParallelOperation`" + "`nullptr == hMetricProgrammable`" ] }, { @@ -29789,7 +34662,7 @@ } ], "type": "function", - "version": "1.7" + "version": "1.9" }, "GetRange": { "class": "zesFrequency", @@ -29948,6 +34821,109 @@ "type": "function", "version": "1.7" }, + "GetSecurityVersionExp": { + "class": "zesFirmware", + "desc": "Get the firmware security version number of the currently running firmware", + "details": [ + "The application should create a character array of size ZES_STRING_PROPERTY_SIZE and reference it for the `pVersion` parameter.", + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "8bfb2f51442d4d44ac783eca20b0571cf2ec53eae8d980c0d6563a27fceb3621", + "name": "GetSecurityVersionExp", + "params": [ + { + "desc": "[in] Handle for the component.", + "name": "hFirmware", + "type": "zes_firmware_handle_t" + }, + { + "desc": "[in,out] NULL terminated string value. The string \"unknown\" will be returned if this property cannot be determined.", + "name": "pVersion", + "type": "char*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hFirmware`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pVersion`" + ] + } + ], + "type": "function", + "version": "1.9" + }, + "GetSignalScope": { + "class": "zeEvent", + "desc": "Gets the signal event scope.", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "45873fc0a8cf42795ff4ea08245febb66889290d4665547f189d93b60d01f4b4", + "name": "GetSignalScope", + "params": [ + { + "desc": "[in] handle of the event", + "name": "hEvent", + "type": "ze_event_handle_t" + }, + { + "desc": "[out] signal event scope. This is the scope of relevant cache hierarchies that are flushed on a signal action before the event is triggered. May be 0 or a valid combination of ze_event_scope_flag_t.", + "name": "pSignalScope", + "type": "ze_event_scope_flags_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hEvent`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pSignalScope`" + ] + } + ], + "type": "function", + "version": "1.9" + }, "GetSourceAttributes": { "class": "zeKernel", "desc": "Retrieve all declared kernel attributes (i.e. can be specified with __attribute__ in runtime language).", @@ -30216,6 +35192,62 @@ ], "type": "function" }, + "GetSubDevicePropertiesExp": { + "class": "zesDevice", + "desc": "Retrieves sub device properties for the given sysman device handle", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "b70947b84c614acc4479f10069c7ca7e74ecdaa8cd88f460dbaddc7a823ed5d8", + "name": "GetSubDevicePropertiesExp", + "params": [ + { + "desc": "[in] Sysman handle of the device.", + "name": "hDevice", + "type": "zes_device_handle_t" + }, + { + "desc": "[in,out] pointer to the number of sub devices.\nif count is zero, then the driver shall update the value with the total number of sub devices currently attached to the device.\nif count is greater than the number of sub devices currently attached to the device, then the driver shall update the value with the correct number of sub devices.\n", + "name": "pCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pCount)] array of sub device property structures.\nif count is less than the number of sysman sub devices available, then the driver shall only retrieve that number of sub device property structures.\n", + "name": "pSubdeviceProps", + "type": "zes_subdevice_exp_properties_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDevice`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCount`" + ] + } + ], + "type": "function", + "version": "1.9" + }, "GetSubDevices": { "analogue": [ "clCreateSubDevices" @@ -30686,40 +35718,82 @@ ], "type": "function" }, - "GetVFPointValues": { - "class": "zesOverclock", - "desc": "Read the frequency or voltage of a V-F point from the default or custom V-F curve.", + "GetVFCapabilitiesExp": { + "class": "zesVFManagement", + "desc": "Get virtual function management capabilities", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "8b56f4fb8f854cf65406481cf251f0a09fd6ab09ae35df9a0d8a7362529153a8", - "name": "GetVFPointValues", + "hash": "22600193b186ac613b617456cf8b8137226ed86c7fa0bd3e678f002ebc8924a4", + "name": "GetVFCapabilitiesExp", "params": [ { - "desc": "[in] Handle for the component domain.", - "name": "hDomainHandle", - "type": "zes_overclock_handle_t" + "desc": "[in] Sysman handle for the VF component.", + "name": "hVFhandle", + "type": "zes_vf_handle_t" }, { - "desc": "[in] Voltage or Freqency point to read.", - "name": "VFType", - "type": "zes_vf_type_t" + "desc": "[in,out] Will contain VF capability.", + "name": "pCapability", + "type": "zes_vf_exp_capabilities_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] }, { - "desc": "[in] User,Default or Live VF array to read from", - "name": "VFArrayType", - "type": "zes_vf_array_type_t" + "ZE_RESULT_ERROR_UNINITIALIZED": [] }, { - "desc": "[in] Point index - number between (0, max_num_points - 1).", - "name": "PointIndex", - "type": "uint32_t" + "ZE_RESULT_ERROR_DEVICE_LOST": [] }, { - "desc": "[out] Returns the frequency in 1kHz units or voltage in millivolt units from the custom V-F curve at the specified zero-based index ", - "name": "PointValue", + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hVFhandle`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCapability`" + ] + } + ], + "type": "function", + "version": "1.10" + }, + "GetVFEngineUtilizationExp": { + "class": "zesVFManagement", + "desc": "Get engine activity stats for each available engine group associated with Virtual Function (VF)", + "details": [ + "[DEPRECATED] No longer supported. Use zesVFManagementGetVFEngineUtilizationExp2.", + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "fa212c5c1badd54bea1e467b77401545e8b539ed4aaba4231c8287790c8784ad", + "name": "GetVFEngineUtilizationExp", + "params": [ + { + "desc": "[in] Sysman handle for the component.", + "name": "hVFhandle", + "type": "zes_vf_handle_t" + }, + { + "desc": "[in,out] Pointer to the number of VF engine stats descriptors.\n - if count is zero, the driver shall update the value with the total number of engine stats available.\n - if count is greater than the total number of engine stats available, the driver shall update the value with the correct number of engine stats available.\n - The count returned is the sum of number of VF instances currently available and the PF instance.\n", + "name": "pCount", "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pCount)] array of engine group activity counters.\n - if count is less than the total number of engine stats available, then driver shall only retrieve that number of stats.\n - the implementation shall populate the vector pCount-1 number of VF engine stats.\n", + "name": "pEngineUtil", + "type": "zes_vf_util_engine_exp_t*" } ], "returns": [ @@ -30740,56 +35814,100 @@ }, { "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDomainHandle`" + "`nullptr == hVFhandle`" ] }, { - "ZE_RESULT_ERROR_INVALID_ENUMERATION": [ - "`ZES_VF_TYPE_FREQ < VFType`", - "`ZES_VF_ARRAY_TYPE_LIVE_VF_ARRAY < VFArrayType`" + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCount`" ] + } + ], + "type": "function", + "version": "1.9" + }, + "GetVFEngineUtilizationExp2": { + "class": "zesVFManagement", + "desc": "Get engine activity stats for each available engine group associated with Virtual Function (VF)", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free.", + "If VF is disable/pause/not active, utilization will give zero value." + ], + "hash": "b25cb052495243ec02a18cbbe9ab6c1a6c6e787700508fb90109b76bb5e6757a", + "name": "GetVFEngineUtilizationExp2", + "params": [ + { + "desc": "[in] Sysman handle for the component.", + "name": "hVFhandle", + "type": "zes_vf_handle_t" }, { - "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == PointValue`" + "desc": "[in,out] Pointer to the number of VF engine stats descriptors.\n - if count is zero, the driver shall update the value with the total number of engine stats available.\n - if count is greater than the total number of engine stats available, the driver shall update the value with the correct number of engine stats available.\n", + "name": "pCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pCount)] array of engine group activity counters.\n - if count is less than the total number of engine stats available, then driver shall only retrieve that number of stats.\n - the implementation shall populate the vector pCount-1 number of VF engine stats.\n", + "name": "pEngineUtil", + "type": "zes_vf_util_engine_exp2_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hVFhandle`" ] }, { - "ZE_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "Overclocking is not supported on this control domain" + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCount`" ] } ], "type": "function", - "version": "1.5" + "version": "1.10" }, - "GetVerticesExp": { - "class": "zeFabricEdge", - "decl": "static", - "desc": "Retrieves fabric vertices connected by a fabric edge", + "GetVFMemoryUtilizationExp": { + "class": "zesVFManagement", + "desc": "Get memory activity stats for each available memory types associated with Virtual Function (VF)", "details": [ - "A fabric vertex represents either a device or a switch connected to other fabric vertices via a fabric edge.", + "[DEPRECATED] No longer supported. Use zesVFManagementGetVFMemoryUtilizationExp2.", "The application may call this function from simultaneous threads.", - "The implementation of this function must be thread-safe." + "The implementation of this function should be lock-free." ], - "hash": "d124cc6c609daf4e248dde72e0ef67facc7ddc419f4feb4ea6f29e5f347ec2f6", - "name": "GetVerticesExp", - "ordinal": "1", + "hash": "50945d884fd1b8fbaef5d6a67253a9f11828433790a8a752661a2a41575bd7f2", + "name": "GetVFMemoryUtilizationExp", "params": [ { - "desc": "[in] handle of the fabric edge instance", - "name": "hEdge", - "type": "ze_fabric_edge_handle_t" + "desc": "[in] Sysman handle for the component.", + "name": "hVFhandle", + "type": "zes_vf_handle_t" }, { - "desc": "[out] fabric vertex connected to one end of the given fabric edge.", - "name": "phVertexA", - "type": "ze_fabric_vertex_handle_t*" + "desc": "[in,out] Pointer to the number of VF memory stats descriptors.\n - if count is zero, the driver shall update the value with the total number of memory stats available.\n - if count is greater than the total number of memory stats available, the driver shall update the value with the correct number of memory stats available.\n - The count returned is the sum of number of VF instances currently available and the PF instance.\n", + "name": "pCount", + "type": "uint32_t*" }, { - "desc": "[out] fabric vertex connected to other end of the given fabric edge.", - "name": "phVertexB", - "type": "ze_fabric_vertex_handle_t*" + "desc": "[in,out][optional][range(0, *pCount)] array of memory group activity counters.\n - if count is less than the total number of memory stats available, then driver shall only retrieve that number of stats.\n - the implementation shall populate the vector pCount-1 number of VF memory stats.\n", + "name": "pMemUtil", + "type": "zes_vf_util_mem_exp_t*" } ], "returns": [ @@ -30810,36 +35928,332 @@ }, { "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hEdge`" + "`nullptr == hVFhandle`" ] }, { "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == phVertexA`", - "`nullptr == phVertexB`" + "`nullptr == pCount`" ] } ], "type": "function", - "version": "1.4" + "version": "1.9" }, - "HostReset": { - "analogue": [ - "vkResetEvent" + "GetVFMemoryUtilizationExp2": { + "class": "zesVFManagement", + "desc": "Get memory activity stats for each available memory types associated with Virtual Function (VF)", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free.", + "If VF is disable/pause/not active, utilization will give zero value." ], - "class": "zeEvent", - "desc": "The current host thread resets an event back to not signaled state.", + "hash": "d25a77106be7eeb28f474e755cd6dfa7521b603ae2983e133f4aeb441c3b2dc1", + "name": "GetVFMemoryUtilizationExp2", + "params": [ + { + "desc": "[in] Sysman handle for the component.", + "name": "hVFhandle", + "type": "zes_vf_handle_t" + }, + { + "desc": "[in,out] Pointer to the number of VF memory stats descriptors.\n - if count is zero, the driver shall update the value with the total number of memory stats available.\n - if count is greater than the total number of memory stats available, the driver shall update the value with the correct number of memory stats available.\n", + "name": "pCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pCount)] array of memory group activity counters.\n - if count is less than the total number of memory stats available, then driver shall only retrieve that number of stats.\n - the implementation shall populate the vector pCount-1 number of VF memory stats.\n", + "name": "pMemUtil", + "type": "zes_vf_util_mem_exp2_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hVFhandle`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCount`" + ] + } + ], + "type": "function", + "version": "1.10" + }, + "GetVFPointValues": { + "class": "zesOverclock", + "desc": "Read the frequency or voltage of a V-F point from the default or custom V-F curve.", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "cb686654e319bb98f202bace7ac3af520e7df43764c02d371a2fea219c0693ae", - "name": "HostReset", + "hash": "8b56f4fb8f854cf65406481cf251f0a09fd6ab09ae35df9a0d8a7362529153a8", + "name": "GetVFPointValues", "params": [ { - "desc": "[in] handle of the event", - "name": "hEvent", - "type": "ze_event_handle_t" + "desc": "[in] Handle for the component domain.", + "name": "hDomainHandle", + "type": "zes_overclock_handle_t" + }, + { + "desc": "[in] Voltage or Freqency point to read.", + "name": "VFType", + "type": "zes_vf_type_t" + }, + { + "desc": "[in] User,Default or Live VF array to read from", + "name": "VFArrayType", + "type": "zes_vf_array_type_t" + }, + { + "desc": "[in] Point index - number between (0, max_num_points - 1).", + "name": "PointIndex", + "type": "uint32_t" + }, + { + "desc": "[out] Returns the frequency in 1kHz units or voltage in millivolt units from the custom V-F curve at the specified zero-based index ", + "name": "PointValue", + "type": "uint32_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDomainHandle`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_ENUMERATION": [ + "`ZES_VF_TYPE_FREQ < VFType`", + "`ZES_VF_ARRAY_TYPE_LIVE_VF_ARRAY < VFArrayType`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == PointValue`" + ] + }, + { + "ZE_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "Overclocking is not supported on this control domain" + ] + } + ], + "type": "function", + "version": "1.5" + }, + "GetVFPropertiesExp": { + "class": "zesVFManagement", + "desc": "Get virtual function management properties", + "details": [ + "[DEPRECATED] No longer supported. Use zesVFManagementGetVFCapabilitiesExp.", + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "75432f3511889072076423640ab99950187fc2a2fa38769aae5dddbe094e6a1a", + "name": "GetVFPropertiesExp", + "params": [ + { + "desc": "[in] Sysman handle for the VF component.", + "name": "hVFhandle", + "type": "zes_vf_handle_t" + }, + { + "desc": "[in,out] Will contain VF properties.", + "name": "pProperties", + "type": "zes_vf_exp_properties_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hVFhandle`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pProperties`" + ] + } + ], + "type": "function", + "version": "1.9" + }, + "GetVerticesExp": { + "class": "zeFabricEdge", + "decl": "static", + "desc": "Retrieves fabric vertices connected by a fabric edge", + "details": [ + "A fabric vertex represents either a device or a switch connected to other fabric vertices via a fabric edge.", + "The application may call this function from simultaneous threads.", + "The implementation of this function must be thread-safe." + ], + "hash": "d124cc6c609daf4e248dde72e0ef67facc7ddc419f4feb4ea6f29e5f347ec2f6", + "name": "GetVerticesExp", + "ordinal": "1", + "params": [ + { + "desc": "[in] handle of the fabric edge instance", + "name": "hEdge", + "type": "ze_fabric_edge_handle_t" + }, + { + "desc": "[out] fabric vertex connected to one end of the given fabric edge.", + "name": "phVertexA", + "type": "ze_fabric_vertex_handle_t*" + }, + { + "desc": "[out] fabric vertex connected to other end of the given fabric edge.", + "name": "phVertexB", + "type": "ze_fabric_vertex_handle_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hEdge`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == phVertexA`", + "`nullptr == phVertexB`" + ] + } + ], + "type": "function", + "version": "1.4" + }, + "GetWaitScope": { + "class": "zeEvent", + "desc": "Gets the wait event scope.", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "3ce87fd2651a21b4431a92db0a97cda3f124b0ec380a2adf909fda30027ff382", + "name": "GetWaitScope", + "params": [ + { + "desc": "[in] handle of the event", + "name": "hEvent", + "type": "ze_event_handle_t" + }, + { + "desc": "[out] wait event scope. This is the scope of relevant cache hierarchies invalidated on a wait action after the event is complete. May be 0 or a valid combination of ze_event_scope_flag_t.", + "name": "pWaitScope", + "type": "ze_event_scope_flags_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hEvent`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pWaitScope`" + ] + } + ], + "type": "function", + "version": "1.9" + }, + "HostReset": { + "analogue": [ + "vkResetEvent" + ], + "class": "zeEvent", + "desc": "The current host thread resets an event back to not signaled state.", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "cb686654e319bb98f202bace7ac3af520e7df43764c02d371a2fea219c0693ae", + "name": "HostReset", + "params": [ + { + "desc": "[in] handle of the event", + "name": "hEvent", + "type": "ze_event_handle_t" } ], "returns": [ @@ -30972,6 +36386,136 @@ ], "type": "function" }, + "ImmediateAppendCommandListsExp": { + "class": "zeCommandList", + "desc": "Appends command lists to dispatch from an immediate command list.", + "details": [ + "The application must call this function only with command lists created with zeCommandListCreateImmediate.", + "The command lists passed to this function in the `phCommandLists` argument must be regular command lists (i.e. not immediate command lists).", + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "eb1dc341b9622faf5a33a8825ec784019fb23a518d32d9a1ab55e02e12593ee2", + "name": "ImmediateAppendCommandListsExp", + "params": [ + { + "desc": "[in] handle of the immediate command list", + "name": "hCommandListImmediate", + "type": "ze_command_list_handle_t" + }, + { + "desc": "[in] number of command lists", + "name": "numCommandLists", + "type": "uint32_t" + }, + { + "desc": "[in][range(0, numCommandLists)] handles of command lists", + "name": "phCommandLists", + "type": "ze_command_list_handle_t*" + }, + { + "desc": "[in][optional] handle of the event to signal on completion\n - if not null, this event is signaled after the completion of all appended command lists\n", + "name": "hSignalEvent", + "type": "ze_event_handle_t" + }, + { + "desc": "[in][optional] number of events to wait on before executing appended command lists; must be 0 if nullptr == phWaitEvents", + "name": "numWaitEvents", + "type": "uint32_t" + }, + { + "desc": "[in][optional][range(0, numWaitEvents)] handle of the events to wait on before executing appended command lists.\n - if not null, all wait events must be satisfied prior to the start of any appended command list(s)\n", + "name": "phWaitEvents", + "type": "ze_event_handle_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hCommandListImmediate`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == phCommandLists`" + ] + } + ], + "type": "function", + "version": "1.9" + }, + "ImmediateGetIndex": { + "class": "zeCommandList", + "desc": "Gets the command queue index within the group to which the immediate command list is submitted.", + "details": [ + "The application must call this function only with command lists created with zeCommandListCreateImmediate.", + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "2ba71703e037b0798da609ac5b0a06f5c548ec1e09f064d1241edd8fd8cb1a10", + "name": "ImmediateGetIndex", + "params": [ + { + "desc": "[in] handle of the immediate command list", + "name": "hCommandListImmediate", + "type": "ze_command_list_handle_t" + }, + { + "desc": "[out] command queue index within the group to which the immediate command list is submitted", + "name": "pIndex", + "type": "uint32_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hCommandListImmediate`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pIndex`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_ARGUMENT": [ + "handle does not correspond to an immediate command list" + ] + } + ], + "type": "function", + "version": "1.9" + }, "Init": { "class": "zes", "decl": "static", @@ -31025,6 +36569,78 @@ "type": "function", "version": "1.5" }, + "InitDrivers": { + "class": "ze", + "decl": "static", + "desc": "Initialize the 'oneAPI' driver(s) based on the driver types requested and retrieve the driver handles.", + "details": [ + "The application must call this function or zeInit before calling any other function.", + "The application can call InitDrivers or zeInit to init the drivers on the system.", + "Calls to zeInit or InitDrivers will not alter the drivers retrieved thru either api.", + "Drivers init thru zeInit or InitDrivers will not be reInitialized once init in an application. The Loader will determine if the already init driver needs to be delivered to the user thru the init type flags.", + "Already init Drivers will not be uninitialized if the call to InitDrivers does not include that driver's type. Those init drivers which don't match the init flags will not have their driver handles returned to the user in that InitDrivers call.", + "If this function or zeInit is not called, then all other functions will return ZE_RESULT_ERROR_UNINITIALIZED.", + "Only one instance of each driver will be initialized per process.", + "A driver represents a collection of physical devices.", + "Multiple calls to this function will return identical driver handles, in the same order.", + "The drivers returned to the caller will be based on the init types which state the drivers to be included.", + "The application may pass nullptr for pDrivers when only querying the number of drivers.", + "The application may call this function multiple times with different flags or environment variables enabled.", + "The application must call this function after forking new processes. Each forked process must call this function.", + "The application may call this function from simultaneous threads.", + "The implementation of this function must be thread-safe for scenarios where multiple libraries may initialize the driver(s) simultaneously." + ], + "hash": "052160fb988c1bc12ca5af59e157df515791bd22739648deda7708ab05b93cb1", + "name": "InitDrivers", + "ordinal": "0", + "params": [ + { + "desc": "[in,out] pointer to the number of driver instances.\nif count is zero, then the loader shall update the value with the total number of drivers available.\nif count is greater than the number of drivers available, then the loader shall update the value with the correct number of drivers available.\n", + "name": "pCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pCount)] array of driver instance handles.\nif count is less than the number of drivers available, then the loader shall only retrieve that number of drivers.\n", + "name": "phDrivers", + "type": "ze_driver_handle_t*" + }, + { + "desc": "[in] descriptor containing the driver type initialization details including ze_init_driver_type_flag_t combinations.\n", + "name": "desc", + "type": "ze_init_driver_type_desc_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCount`", + "`nullptr == desc`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_ENUMERATION": [ + "`0x0 == desc->flags`" + ] + } + ], + "type": "function", + "version": "1.10" + }, "InspectLinkageExt": { "analogue": [ "None" @@ -31137,6 +36753,57 @@ ], "type": "function" }, + "IsImmediate": { + "class": "zeCommandList", + "desc": "Query whether a command list is an immediate command list.", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "3ca7b41b9bb728b65fab80dfb01560316982e5614a21213d30a4e77756d83e90", + "name": "IsImmediate", + "params": [ + { + "desc": "[in] handle of the command list", + "name": "hCommandList", + "type": "ze_command_list_handle_t" + }, + { + "desc": "[out] Boolean indicating whether the command list is an immediate command list (true) or not (false)", + "name": "pIsImmediate", + "type": "ze_bool_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hCommandList`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pIsImmediate`" + ] + } + ], + "type": "function", + "version": "1.9" + }, "JoinExp": { "class": "zeRTASParallelOperation", "desc": "Joins a parallel build operation", @@ -31288,6 +36955,11 @@ "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ "`nullptr == ptr`" ] + }, + { + "ZE_RESULT_ERROR_INVALID_ARGUMENT": [ + "ptr is not recognized by the implementation" + ] } ], "type": "function" @@ -31387,7 +37059,8 @@ "desc": "Get the overclocking capabilities.", "details": [ "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The implementation of this function should be lock-free.", + "[DEPRECATED] No longer supported." ], "hash": "27bf6388e5923bdaa0967f8e74b1675ffd0e7c82980c7974dda6e82d24efc5c2", "name": "OcGetCapabilities", @@ -31437,7 +37110,8 @@ "desc": "Get the current overclocking frequency target, if extended moded is supported, will returned in 1 Mhz granularity.", "details": [ "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The implementation of this function should be lock-free.", + "[DEPRECATED] No longer supported." ], "hash": "a1fee7e08b70a9ff9017be269ccba56a321c80f2a1bd0f08f4bf25b80edb8e87", "name": "OcGetFrequencyTarget", @@ -31504,7 +37178,8 @@ "desc": "Get the maximum current limit setting.", "details": [ "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The implementation of this function should be lock-free.", + "[DEPRECATED] No longer supported." ], "hash": "dd3afa560c90667b89253d02e45759933e6ee6a5f4a4657c783e821f9b8d8660", "name": "OcGetIccMax", @@ -31560,7 +37235,8 @@ "desc": "Get the current overclocking mode.", "details": [ "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The implementation of this function should be lock-free.", + "[DEPRECATED] No longer supported." ], "hash": "62c4575e249097bdec5d726201f5f1259da813d0d7c0045814a5b917ff6a1308", "name": "OcGetMode", @@ -31627,7 +37303,8 @@ "desc": "Get the maximum temperature limit setting.", "details": [ "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The implementation of this function should be lock-free.", + "[DEPRECATED] No longer supported." ], "hash": "c1758ddfd68bb1988d3753bb71636b3b666c3f011d35cd830c8d0434c777d5e3", "name": "OcGetTjMax", @@ -31682,7 +37359,8 @@ "desc": "Get the current overclocking voltage settings.", "details": [ "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The implementation of this function should be lock-free.", + "[DEPRECATED] No longer supported." ], "hash": "f6a3671ccc34ac2d3e6af12869ff5edfc85e3cc20db0d48b61cfe96781198c94", "name": "OcGetVoltageTarget", @@ -31755,7 +37433,8 @@ "desc": "Set the current overclocking frequency target, if extended moded is supported, can be set in 1 Mhz granularity.", "details": [ "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The implementation of this function should be lock-free.", + "[DEPRECATED] No longer supported." ], "hash": "3a6b01a51f459abd4b5094093ec355d270545a80ddac2792d06d29aee7463e1b", "name": "OcSetFrequencyTarget", @@ -31818,7 +37497,8 @@ "details": [ "Setting ocIccMax to 0.0 will return the value to the factory default.", "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The implementation of this function should be lock-free.", + "[DEPRECATED] No longer supported." ], "hash": "e75fd6668d4a7b5f10fc95f5830293547df215abe25c798afb1b88def4360fe6", "name": "OcSetIccMax", @@ -31884,7 +37564,8 @@ "desc": "Set the current overclocking mode.", "details": [ "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The implementation of this function should be lock-free.", + "[DEPRECATED] No longer supported." ], "hash": "309c17c47d975efe332fedbe4501950c7216615dbfaeec37f3de3576ee3d5407", "name": "OcSetMode", @@ -31952,7 +37633,8 @@ "details": [ "Setting ocTjMax to 0.0 will return the value to the factory default.", "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The implementation of this function should be lock-free.", + "[DEPRECATED] No longer supported." ], "hash": "742e421c8ae9294b2993a07eab549a060b678d7a5c74c5c71ce6e012f22d50aa", "name": "OcSetTjMax", @@ -32018,7 +37700,8 @@ "desc": "Set the current overclocking voltage settings.", "details": [ "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The implementation of this function should be lock-free.", + "[DEPRECATED] No longer supported." ], "hash": "5f4c50d38e299212417f47798a74b4da436371eaee20c92098f13d3192b8b590", "name": "OcSetVoltageTarget", @@ -33060,6 +38743,72 @@ ], "type": "function" }, + "ReadDataExp": { + "class": "zetMetricTracer", + "desc": "Read data from the metric tracer", + "details": [ + "The application must **not** call this function from simultaneous threads with the same metric tracer handle.", + "Data can be retrieved after tracer is disabled. When buffers are drained ZE_RESULT_NOT_READY will be returned" + ], + "hash": "5487726b2e17dbb2ac53d54468778abe6c7d2a8aa49934adbf22b4cf032f6dc7", + "name": "ReadDataExp", + "params": [ + { + "desc": "[in] handle of the metric tracer", + "name": "hMetricTracer", + "type": "zet_metric_tracer_exp_handle_t" + }, + { + "desc": "[in,out] pointer to size in bytes of raw data requested to read.\nif size is zero, then the driver will update the value with the total size in bytes needed for all data available.\nif size is non-zero, then driver will only retrieve that amount of data. \nif size is larger than size needed for all data, then driver will update the value with the actual size needed.\n", + "name": "pRawDataSize", + "type": "size_t*" + }, + { + "desc": "[in,out][optional][range(0, *pRawDataSize)] buffer containing tracer data in raw format", + "name": "pRawData", + "type": "uint8_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricTracer`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pRawDataSize`" + ] + }, + { + "ZE_RESULT_WARNING_DROPPED_DATA": [ + "Metric tracer data may have been dropped." + ] + }, + { + "ZE_RESULT_NOT_READY": [ + "Metric tracer is disabled and no data is available to read." + ] + } + ], + "type": "function", + "version": "1.10" + }, "ReadEvent": { "class": "zetDebug", "desc": "Read the topmost debug event.", @@ -33180,7 +38929,7 @@ }, { "ZE_RESULT_ERROR_INVALID_ENUMERATION": [ - "`ZET_DEBUG_MEMORY_SPACE_TYPE_SLM < desc->type`" + "`ZET_DEBUG_MEMORY_SPACE_TYPE_ELF < desc->type`" ] }, { @@ -33338,6 +39087,64 @@ ], "type": "function" }, + "RemoveMetricExp": { + "class": "zetMetricGroup", + "decl": "static", + "desc": "Remove a metric from the metric group handle created using zetMetricGroupCreateExp.", + "details": [ + "Remove an already added metric handle from the metric group." + ], + "hash": "435763728c9824dcd58b6bfaef35731211e78fd3d83b41b602bb2aedc2c1e79d", + "name": "RemoveMetricExp", + "params": [ + { + "desc": "[in] Handle of the metric group", + "name": "hMetricGroup", + "type": "zet_metric_group_handle_t" + }, + { + "desc": "[in] Metric handle to be removed from the metric group.", + "name": "hMetric", + "type": "zet_metric_handle_t" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricGroup`", + "`nullptr == hMetric`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_ARGUMENT": [ + "If trying to remove a metric not previously added to the metric group", + "If the input metric group is a pre-defined metric group" + ] + }, + { + "ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE": [ + "If the metric group is currently activated" + ] + } + ], + "type": "function", + "version": "1.9" + }, "Reserve": { "class": "zeVirtualMem", "decl": "static", @@ -34221,7 +40028,8 @@ "This is a special mode that must ben enabled when debugging an application that uses this device e.g. using the Level0 Debug API.", "It ensures that only one command queue can execute work on the hardware at a given time. Work is permitted to run as long as needed without enforcing any scheduler fairness policies.", "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The implementation of this function should be lock-free.", + "[DEPRECATED] No longer supported." ], "hash": "20f2f46d786180d013bcdd048e18fa11689f100439628591f3d4d26a33d3d071", "name": "SetComputeUnitDebugMode", @@ -34988,7 +40796,7 @@ "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free.", - "Note: This function is deprecated and replaced by zesPowerSetLimitsExt." + "[DEPRECATED] Use zesPowerSetLimitsExt." ], "hash": "adfce6f8e5ca88571ca8d3c876751c1de2ba0acca3d52639c128be64a18c4550", "name": "SetLimits", @@ -35273,6 +41081,7 @@ "class": "zesFrequency", "desc": "Set frequency range between which the hardware can operate.", "details": [ + "The application may call this function with the frequency range min and max values set to `-1` to request the frequency be (re)set to the default values.", "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], @@ -35324,6 +41133,47 @@ ], "type": "function" }, + "SetSecurityVersionExp": { + "class": "zesFirmware", + "desc": "Set the firmware security version number", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "a91c856e491e2efea9ee77674c05a32792102c8a9407553ac3fd45346e8de534", + "name": "SetSecurityVersionExp", + "params": [ + { + "desc": "[in] Handle for the component.", + "name": "hFirmware", + "type": "zes_firmware_handle_t" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hFirmware`" + ] + } + ], + "type": "function", + "version": "1.9" + }, "SetSpeedTableMode": { "class": "zesFan", "desc": "Configure the fan to adjust speed based on a temperature/speed table (set mode to ZES_FAN_SPEED_MODE_TABLE)", @@ -35639,51 +41489,88 @@ "type": "function", "version": "1.5" }, - "SuggestGroupSize": { - "class": "zeKernel", - "desc": "Query a suggested group size for a kernel given a global size for each dimension.", + "SetVFTelemetryModeExp": { + "class": "zesVFManagement", + "desc": "Configure utilization telemetry enabled or disabled associated with Virtual Function (VF)", "details": [ - "This function ignores the group size that is set using zeKernelSetGroupSize.", + "[DEPRECATED] No longer supported.", "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "3ddaa55cddcdc68068314af08f3053ce0c6ce9bbb37edf06da21812e5a669b77", - "name": "SuggestGroupSize", + "hash": "2b7409e8dbea86bf1bb7d1552880fd2f3eab20773a39bcacf875ff30e742fcf4", + "name": "SetVFTelemetryModeExp", "params": [ { - "desc": "[in] handle of the kernel object", - "name": "hKernel", - "type": "ze_kernel_handle_t" + "desc": "[in] Sysman handle for the component.", + "name": "hVFhandle", + "type": "zes_vf_handle_t" }, { - "desc": "[in] global width for X dimension", - "name": "globalSizeX", - "type": "uint32_t" + "desc": "[in] utilization flags to enable or disable. May be 0 or a valid combination of zes_vf_info_util_exp_flag_t.", + "name": "flags", + "type": "zes_vf_info_util_exp_flags_t" }, { - "desc": "[in] global width for Y dimension", - "name": "globalSizeY", - "type": "uint32_t" + "desc": "[in] Enable utilization telemetry.", + "name": "enable", + "type": "ze_bool_t" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] }, { - "desc": "[in] global width for Z dimension", - "name": "globalSizeZ", - "type": "uint32_t" + "ZE_RESULT_ERROR_UNINITIALIZED": [] }, { - "desc": "[out] recommended size of group for X dimension", - "name": "groupSizeX", - "type": "uint32_t*" + "ZE_RESULT_ERROR_DEVICE_LOST": [] }, { - "desc": "[out] recommended size of group for Y dimension", - "name": "groupSizeY", - "type": "uint32_t*" + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] }, { - "desc": "[out] recommended size of group for Z dimension", - "name": "groupSizeZ", - "type": "uint32_t*" + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hVFhandle`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_ENUMERATION": [ + "`0xf < flags`" + ] + } + ], + "type": "function", + "version": "1.9" + }, + "SetVFTelemetrySamplingIntervalExp": { + "class": "zesVFManagement", + "desc": "Set sampling interval to monitor for a particular utilization telemetry associated with Virtual Function (VF)", + "details": [ + "[DEPRECATED] No longer supported.", + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "15215d47c7c50ee6f92ecced859d742286cd66e2fdeae6e88419fc4abd7d08dc", + "name": "SetVFTelemetrySamplingIntervalExp", + "params": [ + { + "desc": "[in] Sysman handle for the component.", + "name": "hVFhandle", + "type": "zes_vf_handle_t" + }, + { + "desc": "[in] utilization flags to set sampling interval. May be 0 or a valid combination of zes_vf_info_util_exp_flag_t.", + "name": "flag", + "type": "zes_vf_info_util_exp_flags_t" + }, + { + "desc": "[in] Sampling interval value.", + "name": "samplingInterval", + "type": "uint64_t" } ], "returns": [ @@ -35704,31 +41591,28 @@ }, { "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hKernel`" + "`nullptr == hVFhandle`" ] }, { - "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == groupSizeX`", - "`nullptr == groupSizeY`", - "`nullptr == groupSizeZ`" + "ZE_RESULT_ERROR_INVALID_ENUMERATION": [ + "`0xf < flag`" ] - }, - { - "ZE_RESULT_ERROR_INVALID_GLOBAL_WIDTH_DIMENSION": [] } ], - "type": "function" + "type": "function", + "version": "1.9" }, - "SuggestMaxCooperativeGroupCount": { + "SuggestGroupSize": { "class": "zeKernel", - "desc": "Query a suggested max group count for a cooperative kernel.", + "desc": "Query a suggested group size for a kernel given a global size for each dimension.", "details": [ + "This function ignores the group size that is set using zeKernelSetGroupSize.", "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "35146bbbfe48d099b66c9436975ff150cb0aeeb0f86e25226681b3e3676fb233", - "name": "SuggestMaxCooperativeGroupCount", + "hash": "3ddaa55cddcdc68068314af08f3053ce0c6ce9bbb37edf06da21812e5a669b77", + "name": "SuggestGroupSize", "params": [ { "desc": "[in] handle of the kernel object", @@ -35736,8 +41620,88 @@ "type": "ze_kernel_handle_t" }, { - "desc": "[out] recommended total group count.", - "name": "totalGroupCount", + "desc": "[in] global width for X dimension", + "name": "globalSizeX", + "type": "uint32_t" + }, + { + "desc": "[in] global width for Y dimension", + "name": "globalSizeY", + "type": "uint32_t" + }, + { + "desc": "[in] global width for Z dimension", + "name": "globalSizeZ", + "type": "uint32_t" + }, + { + "desc": "[out] recommended size of group for X dimension", + "name": "groupSizeX", + "type": "uint32_t*" + }, + { + "desc": "[out] recommended size of group for Y dimension", + "name": "groupSizeY", + "type": "uint32_t*" + }, + { + "desc": "[out] recommended size of group for Z dimension", + "name": "groupSizeZ", + "type": "uint32_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hKernel`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == groupSizeX`", + "`nullptr == groupSizeY`", + "`nullptr == groupSizeZ`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_GLOBAL_WIDTH_DIMENSION": [] + } + ], + "type": "function" + }, + "SuggestMaxCooperativeGroupCount": { + "class": "zeKernel", + "desc": "Query a suggested max group count for a cooperative kernel.", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "35146bbbfe48d099b66c9436975ff150cb0aeeb0f86e25226681b3e3676fb233", + "name": "SuggestMaxCooperativeGroupCount", + "params": [ + { + "desc": "[in] handle of the kernel object", + "name": "hKernel", + "type": "ze_kernel_handle_t" + }, + { + "desc": "[out] recommended total group count.", + "name": "totalGroupCount", "type": "uint32_t*" } ], @@ -35937,6 +41901,260 @@ ], "type": "function" }, + "UpdateMutableCommandKernelsExp": { + "class": "zeCommandList", + "desc": "Updates the kernel for a mutable command in a mutable command list.", + "details": [ + "This function may only be called for a mutable command list.", + "The kernel handle must be from the provided list for given command id.", + "The application must synchronize mutable command list execution before calling this function.", + "The application must close a mutable command list after completing all updates.", + "This function must not be called from simultaneous threads with the same command list handle.", + "This function must be called before updating kernel arguments and dispatch parameters, when kernel is mutated.", + "The implementation of this function should be lock-free." + ], + "hash": "11a9c042cb0ca1a81b887cb422885a133f4f45b7da7bcaf1f1174a8356959c7d", + "name": "UpdateMutableCommandKernelsExp", + "params": [ + { + "desc": "[in] handle of the command list", + "name": "hCommandList", + "type": "ze_command_list_handle_t" + }, + { + "desc": "[in] the number of kernels to update", + "name": "numKernels", + "type": "uint32_t" + }, + { + "desc": "[in][range(0, numKernels)] command identifier", + "name": "pCommandId", + "type": "uint64_t*" + }, + { + "desc": "[in][range(0, numKernels)] handle of the kernel for a command identifier to switch to", + "name": "phKernels", + "type": "ze_kernel_handle_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hCommandList`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCommandId`", + "`nullptr == phKernels`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_KERNEL_HANDLE": [ + "Invalid kernel handle provided for the mutation kernel instruction operation." + ] + } + ], + "type": "function", + "version": "1.10" + }, + "UpdateMutableCommandSignalEventExp": { + "class": "zeCommandList", + "desc": "Updates the signal event for a mutable command in a mutable command list.", + "details": [ + "This function may only be called for a mutable command list.", + "The type, scope and flags of the signal event must match those of the source command.", + "The application must synchronize mutable command list execution before calling this function.", + "The application must close a mutable command list after completing all updates.", + "This function must not be called from simultaneous threads with the same command list handle.", + "The implementation of this function should be lock-free." + ], + "hash": "5455be497bf5c99fa40bc3fc88726bbf6368edb78275288662f6c9b20d562840", + "name": "UpdateMutableCommandSignalEventExp", + "params": [ + { + "desc": "[in] handle of the command list", + "name": "hCommandList", + "type": "ze_command_list_handle_t" + }, + { + "desc": "[in] command identifier", + "name": "commandId", + "type": "uint64_t" + }, + { + "desc": "[in][optional] handle of the event to signal on completion", + "name": "hSignalEvent", + "type": "ze_event_handle_t" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hCommandList`" + ] + } + ], + "type": "function", + "version": "1.9" + }, + "UpdateMutableCommandWaitEventsExp": { + "class": "zeCommandList", + "desc": "Updates the wait events for a mutable command in a mutable command list.", + "details": [ + "This function may only be called for a mutable command list.", + "The number of wait events must match that of the source command.", + "The type, scope and flags of the wait events must match those of the source command.", + "Passing `nullptr` as the wait events will update the command to not wait on any events prior to dispatch.", + "Passing `nullptr` as an event on event wait list will remove event dependency from this wait list slot.", + "The application must synchronize mutable command list execution before calling this function.", + "The application must close a mutable command list after completing all updates.", + "This function must not be called from simultaneous threads with the same command list handle.", + "The implementation of this function should be lock-free." + ], + "hash": "bd38d0ceddc1fa04f51ef3570b94fd67616e9425e482dda215793797a7a05ad8", + "name": "UpdateMutableCommandWaitEventsExp", + "params": [ + { + "desc": "[in] handle of the command list", + "name": "hCommandList", + "type": "ze_command_list_handle_t" + }, + { + "desc": "[in] command identifier", + "name": "commandId", + "type": "uint64_t" + }, + { + "desc": "[in][optional] the number of wait events", + "name": "numWaitEvents", + "type": "uint32_t" + }, + { + "desc": "[in][optional][range(0, numWaitEvents)] handle of the events to wait on before launching", + "name": "phWaitEvents", + "type": "ze_event_handle_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hCommandList`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_SIZE": [ + "The `numWaitEvents` parameter does not match that of the original command." + ] + } + ], + "type": "function", + "version": "1.9" + }, + "UpdateMutableCommandsExp": { + "class": "zeCommandList", + "desc": "Updates mutable commands.", + "details": [ + "This function may only be called for a mutable command list.", + "The application must synchronize mutable command list execution before calling this function.", + "The application must close a mutable command list after completing all updates.", + "This function must not be called from simultaneous threads with the same command list handle.", + "The implementation of this function should be lock-free." + ], + "hash": "af5c4a23fd99e2938a356fc1e4a2c0a44f5f8fb2a7200d4f9a01a292b75c3b68", + "name": "UpdateMutableCommandsExp", + "params": [ + { + "desc": "[in] handle of the command list", + "name": "hCommandList", + "type": "ze_command_list_handle_t" + }, + { + "desc": "[in] pointer to mutable commands descriptor; multiple descriptors may be chained via `pNext` member", + "name": "desc", + "type": "const ze_mutable_commands_exp_desc_t*" + } + ], + "returns": [ + { + "ZE_RESULT_SUCCESS": [] + }, + { + "ZE_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "ZE_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hCommandList`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == desc`" + ] + }, + { + "ZE_RESULT_ERROR_INVALID_ARGUMENT": [ + "Invalid kernel argument or not matching update descriptor provided" + ] + } + ], + "type": "function", + "version": "1.9" + }, "ViewCreateExp": { "analogue": [ "None" @@ -36180,7 +42398,7 @@ }, { "ZE_RESULT_ERROR_INVALID_ENUMERATION": [ - "`ZET_DEBUG_MEMORY_SPACE_TYPE_SLM < desc->type`" + "`ZET_DEBUG_MEMORY_SPACE_TYPE_ELF < desc->type`" ] }, { @@ -36483,6 +42701,13 @@ "name": "zes_temp_handle_t", "type": "handle" }, + "zes_vf_handle_t": { + "class": "zesVFManagement", + "desc": "Handle for a Sysman virtual function management domain", + "name": "zes_vf_handle_t", + "type": "handle", + "version": "1.9" + }, "zet_command_list_handle_t": { "alias": "ze_command_list_handle_t", "class": "zetCommandList", @@ -36524,6 +42749,13 @@ "name": "zet_kernel_handle_t", "type": "handle" }, + "zet_metric_decoder_exp_handle_t": { + "class": "zetMetricDecoder", + "desc": "Handle of metric decoder's object", + "name": "zet_metric_decoder_exp_handle_t", + "type": "handle", + "version": "1.10" + }, "zet_metric_group_handle_t": { "class": "zetMetricGroup", "desc": "Handle of metric group's object", @@ -36536,6 +42768,13 @@ "name": "zet_metric_handle_t", "type": "handle" }, + "zet_metric_programmable_exp_handle_t": { + "class": "zetMetricProgrammable", + "desc": "Handle of metric programmable's object", + "name": "zet_metric_programmable_exp_handle_t", + "type": "handle", + "version": "1.9" + }, "zet_metric_query_handle_t": { "class": "zetMetricQuery", "desc": "Handle of metric query's object", @@ -36554,6 +42793,13 @@ "name": "zet_metric_streamer_handle_t", "type": "handle" }, + "zet_metric_tracer_exp_handle_t": { + "class": "zetMetricTracer", + "desc": "Handle of metric tracer's object", + "name": "zet_metric_tracer_exp_handle_t", + "type": "handle", + "version": "1.10" + }, "zet_module_handle_t": { "alias": "ze_module_handle_t", "class": "zetModule", @@ -36594,6 +42840,20 @@ "type": "macro", "value": "32" }, + "ZES_FIRMWARE_SECURITY_VERSION_EXP_NAME": { + "desc": "Firmware security version", + "name": "ZES_FIRMWARE_SECURITY_VERSION_EXP_NAME", + "type": "macro", + "value": "\"ZES_experimental_firmware_security_version\"", + "version": "1.9" + }, + "ZES_MAX_EXTENSION_NAME": { + "desc": "Maximum extension name string size", + "name": "ZES_MAX_EXTENSION_NAME", + "type": "macro", + "value": "256", + "version": "1.8" + }, "ZES_MAX_FABRIC_LINK_TYPE_SIZE": { "desc": "Maximum size of the buffer that will return information about link types", "name": "ZES_MAX_FABRIC_LINK_TYPE_SIZE", @@ -36618,6 +42878,27 @@ "type": "macro", "value": "16" }, + "ZES_MEMORY_BANDWIDTH_COUNTER_BITS_EXP_PROPERTIES_NAME": { + "desc": "Memory Bandwidth Counter Valid Bits Extension Name", + "name": "ZES_MEMORY_BANDWIDTH_COUNTER_BITS_EXP_PROPERTIES_NAME", + "type": "macro", + "value": "\"ZES_extension_mem_bandwidth_counter_bits_properties\"", + "version": "1.8" + }, + "ZES_MEM_PAGE_OFFLINE_STATE_EXP_NAME": { + "desc": "Memory State Extension Name", + "name": "ZES_MEM_PAGE_OFFLINE_STATE_EXP_NAME", + "type": "macro", + "value": "\"ZES_extension_mem_state\"", + "version": "1.8" + }, + "ZES_POWER_DOMAIN_PROPERTIES_EXP_NAME": { + "desc": "Power Domain Properties Name", + "name": "ZES_POWER_DOMAIN_PROPERTIES_EXP_NAME", + "type": "macro", + "value": "\"ZES_extension_power_domain_properties\"", + "version": "1.8" + }, "ZES_POWER_LIMITS_EXT_NAME": { "desc": "Power Limits Extension Name", "name": "ZES_POWER_LIMITS_EXT_NAME", @@ -36644,12 +42925,33 @@ "type": "macro", "value": "64" }, + "ZES_SYSMAN_DEVICE_MAPPING_EXP_NAME": { + "desc": "Sysman Device Mapping Extension Name", + "name": "ZES_SYSMAN_DEVICE_MAPPING_EXP_NAME", + "type": "macro", + "value": "\"ZES_experimental_sysman_device_mapping\"", + "version": "1.9" + }, + "ZES_VIRTUAL_FUNCTION_MANAGEMENT_EXP_NAME": { + "desc": "Virtual Function Management Extension Name", + "name": "ZES_VIRTUAL_FUNCTION_MANAGEMENT_EXP_NAME", + "type": "macro", + "value": "\"ZES_experimental_virtual_function_management\"", + "version": "1.9" + }, "ZET_API_TRACING_EXP_NAME": { "desc": "API Tracing Experimental Extension Name", "name": "ZET_API_TRACING_EXP_NAME", "type": "macro", "value": "\"ZET_experimental_api_tracing\"" }, + "ZET_CONCURRENT_METRIC_GROUPS_EXP_NAME": { + "desc": "Concurrent Metric Groups Experimental Extension Name", + "name": "ZET_CONCURRENT_METRIC_GROUPS_EXP_NAME", + "type": "macro", + "value": "\"ZET_experimental_concurrent_metric_groups\"", + "version": "1.10" + }, "ZET_EXPORT_METRICS_DATA_EXP_NAME": { "desc": "Exporting Metrics Data Experimental Extension Name", "name": "ZET_EXPORT_METRICS_DATA_EXP_NAME", @@ -36708,12 +43010,68 @@ "type": "macro", "value": "256" }, + "ZET_MAX_METRIC_PROGRAMMABLE_COMPONENT_EXP": { + "desc": "Maximum metric programmable component string size", + "name": "ZET_MAX_METRIC_PROGRAMMABLE_COMPONENT_EXP", + "type": "macro", + "value": "128", + "version": "1.9" + }, + "ZET_MAX_METRIC_PROGRAMMABLE_DESCRIPTION_EXP": { + "desc": "Maximum metric programmable description string size", + "name": "ZET_MAX_METRIC_PROGRAMMABLE_DESCRIPTION_EXP", + "type": "macro", + "value": "128", + "version": "1.9" + }, + "ZET_MAX_METRIC_PROGRAMMABLE_NAME_EXP": { + "desc": "Maximum metric programmable name string size", + "name": "ZET_MAX_METRIC_PROGRAMMABLE_NAME_EXP", + "type": "macro", + "value": "128", + "version": "1.9" + }, + "ZET_MAX_METRIC_PROGRAMMABLE_PARAMETER_NAME_EXP": { + "desc": "Maximum metric programmable parameter string size", + "name": "ZET_MAX_METRIC_PROGRAMMABLE_PARAMETER_NAME_EXP", + "type": "macro", + "value": "128", + "version": "1.9" + }, + "ZET_MAX_METRIC_PROGRAMMABLE_VALUE_DESCRIPTION_EXP": { + "desc": "Maximum value for programmable value description", + "name": "ZET_MAX_METRIC_PROGRAMMABLE_VALUE_DESCRIPTION_EXP", + "type": "macro", + "value": "128", + "version": "1.9" + }, "ZET_MAX_METRIC_RESULT_UNITS": { "desc": "Maximum metric result units string size", "name": "ZET_MAX_METRIC_RESULT_UNITS", "type": "macro", "value": "256" }, + "ZET_MAX_PROGRAMMABLE_METRICS_ELEMENT_DESCRIPTION_EXP": { + "desc": "Maximum export data element description string size", + "name": "ZET_MAX_PROGRAMMABLE_METRICS_ELEMENT_DESCRIPTION_EXP", + "type": "macro", + "value": "256", + "version": "1.9" + }, + "ZET_MAX_PROGRAMMABLE_METRICS_ELEMENT_NAME_EXP": { + "desc": "Maximum count of characters in export data element name", + "name": "ZET_MAX_PROGRAMMABLE_METRICS_ELEMENT_NAME_EXP", + "type": "macro", + "value": "256", + "version": "1.9" + }, + "ZET_METRICS_TRACER_EXP_NAME": { + "desc": "Metric Tracer Experimental Extension Name", + "name": "ZET_METRICS_TRACER_EXP_NAME", + "type": "macro", + "value": "\"ZET_experimental_metric_tracer\"", + "version": "1.10" + }, "ZET_MULTI_METRICS_EXP_NAME": { "desc": "Calculating Multiple Metrics Experimental Extension Name", "name": "ZET_MULTI_METRICS_EXP_NAME", @@ -36721,6 +43079,13 @@ "value": "\"ZET_experimental_calculate_multiple_metrics\"", "version": "1.2" }, + "ZET_PROGRAMMABLE_METRICS_EXP_NAME": { + "desc": "Programmable Metrics Experimental Extension Name", + "name": "ZET_PROGRAMMABLE_METRICS_EXP_NAME", + "type": "macro", + "value": "\"ZET_experimental_programmable_metrics\"", + "version": "1.9" + }, "ZE_APICALL": { "altvalue": "", "condition": "defined(_WIN32)", @@ -36737,6 +43102,13 @@ "type": "macro", "value": "__attribute__ ((visibility (\"default\")))" }, + "ZE_API_VERSION_CURRENT_M": { + "desc": "Current API version as a macro", + "name": "ZE_API_VERSION_CURRENT_M", + "type": "macro", + "value": "ZE_MAKE_VERSION( 1, 11 )", + "version": "1.10" + }, "ZE_BANDWIDTH_PROPERTIES_EXP_NAME": { "desc": "Bandwidth Extension Name", "name": "ZE_BANDWIDTH_PROPERTIES_EXP_NAME", @@ -36751,6 +43123,13 @@ "value": "\"ZE_extension_bfloat16_conversions\"", "version": "1.5" }, + "ZE_BINDLESS_IMAGE_EXP_NAME": { + "desc": "Image Memory Properties Extension Name", + "name": "ZE_BINDLESS_IMAGE_EXP_NAME", + "type": "macro", + "value": "\"ZE_experimental_bindless_image\"", + "version": "1.9" + }, "ZE_BIT": { "desc": "Generic macro for enumerator bit masks", "name": "ZE_BIT( _i )", @@ -36764,6 +43143,13 @@ "value": "\"ZE_extension_cache_reservation\"", "version": "1.2" }, + "ZE_COMMAND_LIST_CLONE_EXP_NAME": { + "desc": "Command List Clone Extension Name", + "name": "ZE_COMMAND_LIST_CLONE_EXP_NAME", + "type": "macro", + "value": "\"ZE_experimental_command_list_clone\"", + "version": "1.9" + }, "ZE_CONTEXT_POWER_SAVING_HINT_EXP_NAME": { "desc": "Power Saving Hint Extension Name", "name": "ZE_CONTEXT_POWER_SAVING_HINT_EXP_NAME", @@ -36807,6 +43193,13 @@ "value": "\"ZE_extension_eu_count\"", "version": "1.3" }, + "ZE_EVENT_POOL_COUNTER_BASED_EXP_NAME": { + "desc": "Counter-based Event Pools Extension Name", + "name": "ZE_EVENT_POOL_COUNTER_BASED_EXP_NAME", + "type": "macro", + "value": "\"ZE_experimental_event_pool_counter_based\"", + "version": "1.8" + }, "ZE_EVENT_QUERY_KERNEL_TIMESTAMPS_EXT_NAME": { "desc": "Event Query Kernel Timestamps Extension Name", "name": "ZE_EVENT_QUERY_KERNEL_TIMESTAMPS_EXT_NAME", @@ -36835,6 +43228,13 @@ "value": "\"ZE_extension_float_atomics\"", "version": "1.1" }, + "ZE_GET_KERNEL_BINARY_EXP_NAME": { + "desc": "Get Kernel Binary Extension Name", + "name": "ZE_GET_KERNEL_BINARY_EXP_NAME", + "type": "macro", + "value": "\"ZE_extension_kernel_binary_exp\"", + "version": "1.11" + }, "ZE_GLOBAL_OFFSET_EXP_NAME": { "desc": "Global Offset Extension Name", "name": "ZE_GLOBAL_OFFSET_EXP_NAME", @@ -36891,6 +43291,13 @@ "value": "\"ZE_extension_image_view_planar\"", "version": "1.5" }, + "ZE_IMMEDIATE_COMMAND_LIST_APPEND_EXP_NAME": { + "desc": "Immediate Command List Append Extension Name", + "name": "ZE_IMMEDIATE_COMMAND_LIST_APPEND_EXP_NAME", + "type": "macro", + "value": "\"ZE_experimental_immediate_command_list_append\"", + "version": "1.9" + }, "ZE_KERNEL_MAX_GROUP_SIZE_PROPERTIES_EXT_NAME": { "desc": "Kernel Max Group Size Properties Extension Name", "name": "ZE_KERNEL_MAX_GROUP_SIZE_PROPERTIES_EXT_NAME", @@ -36980,6 +43387,13 @@ "type": "macro", "value": "16" }, + "ZE_MAX_METRIC_GROUP_NAME_PREFIX": { + "desc": "Maximum value metric group name prefix", + "name": "ZE_MAX_METRIC_GROUP_NAME_PREFIX", + "type": "macro", + "value": "64", + "version": "1.10" + }, "ZE_MAX_MODULE_UUID_SIZE": { "desc": "Maximum module universal unique id (UUID) size in bytes", "name": "ZE_MAX_MODULE_UUID_SIZE", @@ -37026,6 +43440,13 @@ "value": "\"ZE_experimental_module_program\"", "version": "1.0" }, + "ZE_MUTABLE_COMMAND_LIST_EXP_NAME": { + "desc": "Mutable Command List Extension Name", + "name": "ZE_MUTABLE_COMMAND_LIST_EXP_NAME", + "type": "macro", + "value": "\"ZE_experimental_mutable_command_list\"", + "version": "1.9" + }, "ZE_PCI_PROPERTIES_EXT_NAME": { "desc": "PCI Properties Extension Name", "name": "ZE_PCI_PROPERTIES_EXT_NAME", @@ -37799,7 +44220,7 @@ "type": "ze_device_memory_ext_type_t" }, { - "desc": "[out] Physical memory size in bytes. A value of 0 indicates that this property is not known. However, a call to $sMemoryGetState() will correctly return the total size of usable memory.", + "desc": "[out] Physical memory size in bytes. A value of 0 indicates that this property is not known. However, a call to zesMemoryGetState() will correctly return the total size of usable memory.", "name": "physicalSize", "type": "uint64_t" }, @@ -38011,6 +44432,41 @@ "name": "ze_device_p2p_properties_t", "type": "struct" }, + "ze_device_pitched_alloc_exp_properties_t": { + "base": "ze_base_properties_t", + "class": "zeDevice", + "desc": "Device specific properties for pitched allocations", + "details": [ + "This structure may be passed to zeDeviceGetImageProperties via the pNext member of ze_device_image_properties_t." + ], + "members": [ + { + "desc": "[in] type of this structure", + "init": "ZE_STRUCTURE_TYPE_DEVICE_PITCHED_ALLOC_EXP_PROPERTIES", + "name": "stype", + "type": "ze_structure_type_t" + }, + { + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" + }, + { + "desc": "[out] Maximum image linear width.", + "name": "maxImageLinearWidth", + "type": "size_t" + }, + { + "desc": "[out] Maximum image linear height.", + "name": "maxImageLinearHeight", + "type": "size_t" + } + ], + "name": "ze_device_pitched_alloc_exp_properties_t", + "type": "struct", + "version": "1.9" + }, "ze_device_properties_t": { "base": "ze_base_properties_t", "class": "zeDevice", @@ -38039,7 +44495,7 @@ "type": "uint32_t" }, { - "desc": "[out] device id from PCI configuration\nNote, the device id uses little-endian format.\n", + "desc": "[out] device id from PCI configuration.\nNote, the device id uses little-endian format.\n", "name": "deviceId", "type": "uint32_t" }, @@ -38389,6 +44845,34 @@ "name": "ze_event_desc_t", "type": "struct" }, + "ze_event_pool_counter_based_exp_desc_t": { + "base": "ze_base_desc_t", + "class": "zeEventPool", + "desc": "Event pool descriptor for counter-based events. This structure may be passed to zeEventPoolCreate as pNext member of ze_event_pool_desc_t.", + "members": [ + { + "desc": "[in] type of this structure", + "init": "ZE_STRUCTURE_TYPE_EVENT_POOL_COUNTER_BASED_EXP_DESC", + "name": "stype", + "type": "ze_structure_type_t" + }, + { + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, + { + "desc": "[in] mode flags.\nmust be 0 (default) or a valid value of ze_event_pool_counter_based_exp_flag_t\ndefault behavior is counter-based event pool is only used for immediate command lists.\n", + "init": "0", + "name": "flags", + "type": "ze_event_pool_counter_based_exp_flags_t" + } + ], + "name": "ze_event_pool_counter_based_exp_desc_t", + "type": "struct", + "version": "1.8" + }, "ze_event_pool_desc_t": { "base": "ze_base_desc_t", "class": "zeEventPool", @@ -38947,6 +45431,34 @@ "type": "struct", "version": "1.3" }, + "ze_image_bindless_exp_desc_t": { + "base": "ze_base_desc_t", + "class": "zeImage", + "desc": "Image descriptor for bindless images. This structure may be passed to zeImageCreate via pNext member of ze_image_desc_t.", + "members": [ + { + "desc": "[in] type of this structure", + "init": "ZE_STRUCTURE_TYPE_IMAGE_BINDLESS_EXP_DESC", + "name": "stype", + "type": "ze_structure_type_t" + }, + { + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, + { + "desc": "[in] image flags.\nmust be 0 (default) or a valid value of ze_image_bindless_exp_flag_t\ndefault behavior is bindless images are not used when creating handles via zeImageCreate.\nWhen the flag is passed to zeImageCreate, then only the memory for the image is allocated.\nAdditional image handles can be created with zeImageViewCreateExt.\nWhen ZE_IMAGE_BINDLESS_EXP_FLAG_SAMPLED_IMAGE flag is passed, ze_sampler_desc_t must be attached via pNext member of ze_image_bindless_exp_desc_t.\n", + "init": "0", + "name": "flags", + "type": "ze_image_bindless_exp_flags_t" + } + ], + "name": "ze_image_bindless_exp_desc_t", + "type": "struct", + "version": "1.9" + }, "ze_image_desc_t": { "base": "ze_base_desc_t", "class": "zeImage", @@ -39088,6 +45600,34 @@ "type": "struct", "version": "1.2" }, + "ze_image_pitched_exp_desc_t": { + "base": "ze_base_desc_t", + "class": "zeImage", + "desc": "Image descriptor for bindless images created from pitched allocations. This structure may be passed to zeImageCreate via pNext member of ze_image_desc_t.", + "members": [ + { + "desc": "[in] type of this structure", + "init": "ZE_STRUCTURE_TYPE_IMAGE_PITCHED_EXP_DESC", + "name": "stype", + "type": "ze_structure_type_t" + }, + { + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, + { + "desc": "[in] pointer to pitched device allocation allocated using zeMemAllocDevice\n", + "init": "0", + "name": "ptr", + "type": "void*" + } + ], + "name": "ze_image_pitched_exp_desc_t", + "type": "struct", + "version": "1.9" + }, "ze_image_properties_t": { "base": "ze_base_properties_t", "class": "zeImage", @@ -39206,6 +45746,34 @@ "type": "struct", "version": "1.5" }, + "ze_init_driver_type_desc_t": { + "base": "ze_base_desc_t", + "class": "ze", + "desc": "Init Driver Type descriptor", + "members": [ + { + "desc": "[in] type of this structure", + "init": "ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC", + "name": "stype", + "type": "ze_structure_type_t" + }, + { + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, + { + "desc": "[in] driver type init flags.\nmust be a valid combination of ze_init_driver_type_flag_t or UINT32_MAX;\ndriver types are init and retrieved based on these init flags in zeInitDrivers().\n", + "init": "0", + "name": "flags", + "type": "ze_init_driver_type_flags_t" + } + ], + "name": "ze_init_driver_type_desc_t", + "type": "struct", + "version": "1.10" + }, "ze_ipc_event_pool_handle_t": { "desc": "IPC handle to a event pool allocation", "members": [ @@ -39778,6 +46346,314 @@ "name": "ze_module_properties_t", "type": "struct" }, + "ze_mutable_command_id_exp_desc_t": { + "base": "ze_base_desc_t", + "class": "zeCommandList", + "desc": "Mutable command identifier descriptor", + "members": [ + { + "desc": "[in] type of this structure", + "init": "ZE_STRUCTURE_TYPE_MUTABLE_COMMAND_ID_EXP_DESC", + "name": "stype", + "type": "ze_structure_type_t" + }, + { + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, + { + "desc": "[in] mutable command flags.\n - must be 0 (default, equivalent to setting all flags bar kernel instruction), or a valid combination of ze_mutable_command_exp_flag_t\n - in order to include kernel instruction mutation, ZE_MUTABLE_COMMAND_EXP_FLAG_KERNEL_INSTRUCTION must be explictly included\n", + "name": "flags", + "type": "ze_mutable_command_exp_flags_t" + } + ], + "name": "ze_mutable_command_id_exp_desc_t", + "type": "struct", + "version": "1.9" + }, + "ze_mutable_command_list_exp_desc_t": { + "base": "ze_base_desc_t", + "class": "zeCommandList", + "desc": "Mutable command list descriptor", + "members": [ + { + "desc": "[in] type of this structure", + "init": "ZE_STRUCTURE_TYPE_MUTABLE_COMMAND_LIST_EXP_DESC", + "name": "stype", + "type": "ze_structure_type_t" + }, + { + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, + { + "desc": "[in] mutable command list flags.\n - must be 0 (default) or a valid combination of ze_mutable_command_list_exp_flag_t\n", + "name": "flags", + "type": "ze_mutable_command_list_exp_flags_t" + } + ], + "name": "ze_mutable_command_list_exp_desc_t", + "type": "struct", + "version": "1.9" + }, + "ze_mutable_command_list_exp_properties_t": { + "base": "ze_base_properties_t", + "class": "zeCommandList", + "desc": "Mutable command list properties", + "members": [ + { + "desc": "[in] type of this structure", + "init": "ZE_STRUCTURE_TYPE_MUTABLE_COMMAND_LIST_EXP_PROPERTIES", + "name": "stype", + "type": "ze_structure_type_t" + }, + { + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" + }, + { + "desc": "[out] mutable command list flags", + "name": "mutableCommandListFlags", + "type": "ze_mutable_command_list_exp_flags_t" + }, + { + "desc": "[out] mutable command flags", + "name": "mutableCommandFlags", + "type": "ze_mutable_command_exp_flags_t" + } + ], + "name": "ze_mutable_command_list_exp_properties_t", + "type": "struct", + "version": "1.9" + }, + "ze_mutable_commands_exp_desc_t": { + "base": "ze_base_desc_t", + "class": "zeCommandList", + "desc": "Mutable commands descriptor", + "members": [ + { + "desc": "[in] type of this structure", + "init": "ZE_STRUCTURE_TYPE_MUTABLE_COMMANDS_EXP_DESC", + "name": "stype", + "type": "ze_structure_type_t" + }, + { + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, + { + "desc": "[in] must be 0, this field is reserved for future use", + "name": "flags", + "type": "uint32_t" + } + ], + "name": "ze_mutable_commands_exp_desc_t", + "type": "struct", + "version": "1.9" + }, + "ze_mutable_global_offset_exp_desc_t": { + "base": "ze_base_desc_t", + "class": "zeCommandList", + "desc": "Mutable kernel global offset descriptor", + "members": [ + { + "desc": "[in] type of this structure", + "init": "ZE_STRUCTURE_TYPE_MUTABLE_GLOBAL_OFFSET_EXP_DESC", + "name": "stype", + "type": "ze_structure_type_t" + }, + { + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, + { + "desc": "[in] command identifier", + "name": "commandId", + "type": "uint64_t" + }, + { + "desc": "[in] global offset for X dimension to use for this kernel", + "name": "offsetX", + "type": "uint32_t" + }, + { + "desc": "[in] global offset for Y dimension to use for this kernel", + "name": "offsetY", + "type": "uint32_t" + }, + { + "desc": "[in] global offset for Z dimension to use for this kernel", + "name": "offsetZ", + "type": "uint32_t" + } + ], + "name": "ze_mutable_global_offset_exp_desc_t", + "type": "struct", + "version": "1.9" + }, + "ze_mutable_graph_argument_exp_desc_t": { + "base": "ze_base_desc_t", + "class": "zeCommandList", + "desc": "Mutable graph argument descriptor", + "members": [ + { + "desc": "[in] type of this structure", + "init": "ZE_STRUCTURE_TYPE_MUTABLE_GRAPH_ARGUMENT_EXP_DESC", + "name": "stype", + "type": "ze_structure_type_t" + }, + { + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, + { + "desc": "[in] command identifier", + "name": "commandId", + "type": "uint64_t" + }, + { + "desc": "[in] graph argument index", + "name": "argIndex", + "type": "uint32_t" + }, + { + "desc": "[in] pointer to graph argument value", + "name": "pArgValue", + "type": "const void*" + } + ], + "name": "ze_mutable_graph_argument_exp_desc_t", + "type": "struct", + "version": "1.10" + }, + "ze_mutable_group_count_exp_desc_t": { + "base": "ze_base_desc_t", + "class": "zeCommandList", + "desc": "Mutable kernel group count descriptor", + "members": [ + { + "desc": "[in] type of this structure", + "init": "ZE_STRUCTURE_TYPE_MUTABLE_GROUP_COUNT_EXP_DESC", + "name": "stype", + "type": "ze_structure_type_t" + }, + { + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, + { + "desc": "[in] command identifier", + "name": "commandId", + "type": "uint64_t" + }, + { + "desc": "[in] pointer to group count", + "name": "pGroupCount", + "type": "const ze_group_count_t*" + } + ], + "name": "ze_mutable_group_count_exp_desc_t", + "type": "struct", + "version": "1.9" + }, + "ze_mutable_group_size_exp_desc_t": { + "base": "ze_base_desc_t", + "class": "zeCommandList", + "desc": "Mutable kernel group size descriptor", + "members": [ + { + "desc": "[in] type of this structure", + "init": "ZE_STRUCTURE_TYPE_MUTABLE_GROUP_SIZE_EXP_DESC", + "name": "stype", + "type": "ze_structure_type_t" + }, + { + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, + { + "desc": "[in] command identifier", + "name": "commandId", + "type": "uint64_t" + }, + { + "desc": "[in] group size for X dimension to use for the kernel", + "name": "groupSizeX", + "type": "uint32_t" + }, + { + "desc": "[in] group size for Y dimension to use for the kernel", + "name": "groupSizeY", + "type": "uint32_t" + }, + { + "desc": "[in] group size for Z dimension to use for the kernel", + "name": "groupSizeZ", + "type": "uint32_t" + } + ], + "name": "ze_mutable_group_size_exp_desc_t", + "type": "struct", + "version": "1.9" + }, + "ze_mutable_kernel_argument_exp_desc_t": { + "base": "ze_base_desc_t", + "class": "zeCommandList", + "desc": "Mutable kernel argument descriptor", + "members": [ + { + "desc": "[in] type of this structure", + "init": "ZE_STRUCTURE_TYPE_MUTABLE_KERNEL_ARGUMENT_EXP_DESC", + "name": "stype", + "type": "ze_structure_type_t" + }, + { + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, + { + "desc": "[in] command identifier", + "name": "commandId", + "type": "uint64_t" + }, + { + "desc": "[in] kernel argument index", + "name": "argIndex", + "type": "uint32_t" + }, + { + "desc": "[in] kernel argument size", + "name": "argSize", + "type": "size_t" + }, + { + "desc": "[in] pointer to kernel argument value", + "name": "pArgValue", + "type": "const void*" + } + ], + "name": "ze_mutable_kernel_argument_exp_desc_t", + "type": "struct", + "version": "1.9" + }, "ze_native_kernel_uuid_t": { "class": "zeDevice", "desc": "Native kernel universal unique id (UUID)", @@ -39897,7 +46773,7 @@ "type": "const void*" }, { - "desc": "[in] creation flags.\nmust be 0 (default) or a valid combination of ze_physical_mem_flag_t.\n", + "desc": "[in] creation flags.\nmust be 0 (default) or a valid combination of ze_physical_mem_flag_t; default is to create physical device memory.\n", "init": "0", "name": "flags", "type": "ze_physical_mem_flags_t" @@ -41370,6 +48246,25 @@ "name": "zes_diag_test_t", "type": "struct" }, + "zes_driver_extension_properties_t": { + "class": "zesDriver", + "desc": "Extension properties queried using zesDriverGetExtensionProperties", + "members": [ + { + "desc": "[out] extension name", + "name": "name[ZES_MAX_EXTENSION_NAME]", + "type": "char" + }, + { + "desc": "[out] extension version using ZE_MAKE_VERSION", + "name": "version", + "type": "uint32_t" + } + ], + "name": "zes_driver_extension_properties_t", + "type": "struct", + "version": "1.8" + }, "zes_energy_threshold_t": { "class": "zesPower", "desc": "Energy threshold", @@ -41467,16 +48362,21 @@ "class": "zesEngine", "desc": "Engine activity counters", "details": [ - "Percent utilization is calculated by taking two snapshots (s1, s2) and using the equation: %util = (s2.activeTime - s1.activeTime) / (s2.timestamp - s1.timestamp)" + "Percent utilization is calculated by taking two snapshots (s1, s2) and using the equation: %util = (s2.activeTime - s1.activeTime) / (s2.timestamp - s1.timestamp)", + "The `activeTime` time units are implementation-specific since the value is only intended to be used for calculating utilization percentage.", + "The `timestamp` should only be used to calculate delta between snapshots of this structure.", + "The application should never take the delta of `timestamp` with the timestamp from a different structure since they are not guaranteed to have the same base.", + "When taking the delta, the difference between `timestamp` samples could be `0`, if the frequency of sampling the snapshots is higher than the frequency of the timestamp update.", + "The absolute value of `timestamp` is only valid during within the application and may be different on the next execution." ], "members": [ { - "desc": "[out] Monotonic counter for time in microseconds that this resource is actively running workloads.", + "desc": "[out] Monotonic counter where the resource is actively running workloads.", "name": "activeTime", "type": "uint64_t" }, { - "desc": "[out] Monotonic timestamp counter in microseconds when activeTime counter was sampled.\nThis timestamp should only be used to calculate delta time between snapshots of this structure.\nNever take the delta of this timestamp with the timestamp from a different structure since they are not guaranteed to have the same base.\nThe absolute value of the timestamp is only valid during within the application and may be different on the next execution.\n", + "desc": "[out] Monotonic counter when activeTime counter was sampled.", "name": "timestamp", "type": "uint64_t" } @@ -42182,6 +49082,38 @@ "name": "zes_led_state_t", "type": "struct" }, + "zes_mem_bandwidth_counter_bits_exp_properties_t": { + "base": "zes_base_properties_t", + "class": "zesMemory", + "desc": "Extension properties for reporting valid bit count for memory bandwidth counter value", + "details": [ + "Number of valid read and write counter bits of memory bandwidth", + "This structure may be returned from zesMemoryGetProperties via the `pNext` member of zes_mem_properties_t.", + "Used for denoting number of valid bits in the counter value returned in zes_mem_bandwidth_t." + ], + "members": [ + { + "desc": "[in] type of this structure", + "init": "ZES_STRUCTURE_TYPE_MEM_BANDWIDTH_COUNTER_BITS_EXP_PROPERTIES", + "name": "stype", + "type": "zes_structure_type_t" + }, + { + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" + }, + { + "desc": "[out] Returns the number of valid bits in the counter values", + "name": "validBitsCount", + "type": "uint32_t" + } + ], + "name": "zes_mem_bandwidth_counter_bits_exp_properties_t", + "type": "struct", + "version": "1.8" + }, "zes_mem_bandwidth_t": { "class": "zesMemory", "desc": "Memory bandwidth", @@ -42219,7 +49151,8 @@ "class": "zesMemory", "desc": "Extension properties for Memory bandwidth", "details": [ - "Number of counter bits" + "Number of counter bits", + "[DEPRECATED] No longer supported." ], "members": [ { @@ -42232,6 +49165,42 @@ "type": "struct", "version": "1.7" }, + "zes_mem_page_offline_state_exp_t": { + "base": "zes_base_state_t", + "class": "zesMemory", + "desc": "Extension properties for Memory State", + "details": [ + "This structure may be returned from zesMemoryGetState via the `pNext` member of zes_mem_state_t", + "These additional parameters get Memory Page Offline Metrics" + ], + "members": [ + { + "desc": "[in] type of this structure", + "init": "ZES_STRUCTURE_TYPE_MEM_PAGE_OFFLINE_STATE_EXP", + "name": "stype", + "type": "zes_structure_type_t" + }, + { + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, + { + "desc": "[out] Returns the number of Memory Pages Offline", + "name": "memoryPageOffline", + "type": "uint32_t" + }, + { + "desc": "[out] Returns the Allowed Memory Pages Offline", + "name": "maxMemoryPageOffline", + "type": "uint32_t" + } + ], + "name": "zes_mem_page_offline_state_exp_t", + "type": "struct", + "version": "1.8" + }, "zes_mem_properties_t": { "base": "zes_base_properties_t", "class": "zesMemory", @@ -42333,7 +49302,8 @@ "class": "zesFrequency", "desc": "Overclocking properties", "details": [ - "Provides all the overclocking capabilities and properties supported by the device for the frequency domain." + "Provides all the overclocking capabilities and properties supported by the device for the frequency domain.", + "[DEPRECATED] No longer supported." ], "members": [ { @@ -42775,7 +49745,8 @@ "class": "zesPower", "desc": "Burst power limit", "details": [ - "The power controller (Punit) will throttle the operating frequency of the device if the power averaged over a few milliseconds exceeds a limit known as PL2. Typically PL2 > PL1 so that it permits the frequency to burst higher for short periods than would be otherwise permitted by PL1." + "The power controller (Punit) will throttle the operating frequency of the device if the power averaged over a few milliseconds exceeds a limit known as PL2. Typically PL2 > PL1 so that it permits the frequency to burst higher for short periods than would be otherwise permitted by PL1.", + "[DEPRECATED] No longer supported." ], "members": [ { @@ -42792,6 +49763,37 @@ "name": "zes_power_burst_limit_t", "type": "struct" }, + "zes_power_domain_exp_properties_t": { + "base": "zes_base_properties_t", + "class": "zesPower", + "desc": "Extension structure for providing power domain information associated with a power handle", + "details": [ + "This structure may be returned from zesPowerGetProperties via the `pNext` member of zes_power_properties_t.", + "Used for associating a power handle with a power domain." + ], + "members": [ + { + "desc": "[in] type of this structure", + "init": "ZES_STRUCTURE_TYPE_POWER_DOMAIN_EXP_PROPERTIES", + "name": "stype", + "type": "zes_structure_type_t" + }, + { + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" + }, + { + "desc": "[out] Power domain associated with the power handle.", + "name": "powerDomain", + "type": "zes_power_domain_t" + } + ], + "name": "zes_power_domain_exp_properties_t", + "type": "struct", + "version": "1.8" + }, "zes_power_energy_counter_t": { "class": "zesPower", "desc": "Energy counter snapshot", @@ -42922,7 +49924,8 @@ "desc": "Peak power limit", "details": [ "The power controller (Punit) will reactively/proactively throttle the operating frequency of the device when the instantaneous/100usec power exceeds this limit. The limit is known as PL4 or Psys. It expresses the maximum power that can be drawn from the power supply.", - "If this power limit is removed or set too high, the power supply will generate an interrupt when it detects an overcurrent condition and the power controller will throttle the device frequencies down to min. It is thus better to tune the PL4 value in order to avoid such excursions." + "If this power limit is removed or set too high, the power supply will generate an interrupt when it detects an overcurrent condition and the power controller will throttle the device frequencies down to min. It is thus better to tune the PL4 value in order to avoid such excursions.", + "[DEPRECATED] No longer supported." ], "members": [ { @@ -42999,7 +50002,8 @@ "class": "zesPower", "desc": "Sustained power limits", "details": [ - "The power controller (Punit) will throttle the operating frequency if the power averaged over a window (typically seconds) exceeds this limit." + "The power controller (Punit) will throttle the operating frequency if the power averaged over a window (typically seconds) exceeds this limit.", + "[DEPRECATED] No longer supported." ], "members": [ { @@ -43434,6 +50438,38 @@ "name": "zes_standby_properties_t", "type": "struct" }, + "zes_subdevice_exp_properties_t": { + "base": "zes_base_properties_t", + "class": "zesDevice", + "desc": "Sub Device Properties", + "members": [ + { + "desc": "[in] type of this structure", + "init": "ZES_STRUCTURE_TYPE_SUBDEVICE_EXP_PROPERTIES", + "name": "stype", + "type": "zes_structure_type_t" + }, + { + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" + }, + { + "desc": "[out] this gives the ID of the sub device", + "name": "subdeviceId", + "type": "uint32_t" + }, + { + "desc": "[out] universal unique identifier of the sub device.", + "name": "uuid", + "type": "zes_uuid_t" + } + ], + "name": "zes_subdevice_exp_properties_t", + "type": "struct", + "version": "1.9" + }, "zes_temp_config_t": { "base": "zes_base_config_t", "class": "zesTemperature", @@ -43563,6 +50599,80 @@ "type": "struct", "version": "1.7" }, + "zes_vf_exp_capabilities_t": { + "base": "zes_base_properties_t", + "class": "zesVFManagement", + "desc": "Virtual function management capabilities", + "members": [ + { + "desc": "[in] type of this structure", + "init": "ZES_STRUCTURE_TYPE_VF_EXP_CAPABILITIES", + "name": "stype", + "type": "zes_structure_type_t" + }, + { + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" + }, + { + "desc": "[out] Virtual function BDF address", + "name": "address", + "type": "zes_pci_address_t" + }, + { + "desc": "[out] Virtual function memory size in bytes", + "name": "vfDeviceMemSize", + "type": "uint32_t" + }, + { + "desc": "[out] Virtual Function ID", + "name": "vfID", + "type": "uint32_t" + } + ], + "name": "zes_vf_exp_capabilities_t", + "type": "struct", + "version": "1.10" + }, + "zes_vf_exp_properties_t": { + "base": "zes_base_properties_t", + "class": "zesVFManagement", + "desc": "Virtual function management properties (deprecated)", + "members": [ + { + "desc": "[in] type of this structure", + "init": "ZES_STRUCTURE_TYPE_VF_EXP_PROPERTIES", + "name": "stype", + "type": "zes_structure_type_t" + }, + { + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" + }, + { + "desc": "[out] Virtual function BDF address", + "name": "address", + "type": "zes_pci_address_t" + }, + { + "desc": "[out] universal unique identifier of the device", + "name": "uuid", + "type": "zes_uuid_t" + }, + { + "desc": "[out] utilization flags available. May be 0 or a valid combination of zes_vf_info_util_exp_flag_t.", + "name": "flags", + "type": "zes_vf_info_util_exp_flags_t" + } + ], + "name": "zes_vf_exp_properties_t", + "type": "struct", + "version": "1.9" + }, "zes_vf_property_t": { "class": "zesOverclock", "desc": "Overclock VF properties", @@ -43605,6 +50715,162 @@ "type": "struct", "version": "1.5" }, + "zes_vf_util_engine_exp2_t": { + "base": "zes_base_state_t", + "class": "zesVFManagement", + "desc": "Provides engine utilization values for a virtual function", + "details": [ + "Percent utilization is calculated by taking two snapshots (s1, s2) and using the equation: %util = (s2.activeCounterValue - s1.activeCounterValue) / (s2.samplingCounterValue - s1.samplingCounterValue)" + ], + "members": [ + { + "desc": "[in] type of this structure", + "init": "ZES_STRUCTURE_TYPE_VF_UTIL_ENGINE_EXP2", + "name": "stype", + "type": "zes_structure_type_t" + }, + { + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, + { + "desc": "[out] The engine group.", + "name": "vfEngineType", + "type": "zes_engine_group_t" + }, + { + "desc": "[out] Represents active counter.", + "name": "activeCounterValue", + "type": "uint64_t" + }, + { + "desc": "[out] Represents counter value when activeCounterValue was sampled. Refer to the formulae above for calculating the utilization percent", + "name": "samplingCounterValue", + "type": "uint64_t" + } + ], + "name": "zes_vf_util_engine_exp2_t", + "type": "struct", + "version": "1.10" + }, + "zes_vf_util_engine_exp_t": { + "base": "zes_base_state_t", + "class": "zesVFManagement", + "desc": "Provides engine utilization values for a virtual function (deprecated)", + "members": [ + { + "desc": "[in] type of this structure", + "init": "ZES_STRUCTURE_TYPE_VF_UTIL_ENGINE_EXP", + "name": "stype", + "type": "zes_structure_type_t" + }, + { + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, + { + "desc": "[out] The engine group.", + "name": "type", + "type": "zes_engine_group_t" + }, + { + "desc": "[out] Represents active counter.", + "name": "activeCounterValue", + "type": "uint64_t" + }, + { + "desc": "[out] Represents counter value when activeCounterValue was sampled.", + "name": "samplingCounterValue", + "type": "uint64_t" + }, + { + "desc": "[out] Wall clock time when the activeCounterValue was sampled.", + "name": "timestamp", + "type": "uint64_t" + } + ], + "name": "zes_vf_util_engine_exp_t", + "type": "struct", + "version": "1.9" + }, + "zes_vf_util_mem_exp2_t": { + "base": "zes_base_state_t", + "class": "zesVFManagement", + "desc": "Provides memory utilization values for a virtual function", + "members": [ + { + "desc": "[in] type of this structure", + "init": "ZES_STRUCTURE_TYPE_VF_UTIL_MEM_EXP2", + "name": "stype", + "type": "zes_structure_type_t" + }, + { + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, + { + "desc": "[out] Location of this memory (system, device)", + "name": "vfMemLocation", + "type": "zes_mem_loc_t" + }, + { + "desc": "[out] Free memory size in bytes.", + "name": "vfMemUtilized", + "type": "uint64_t" + } + ], + "name": "zes_vf_util_mem_exp2_t", + "type": "struct", + "version": "1.10" + }, + "zes_vf_util_mem_exp_t": { + "base": "zes_base_state_t", + "class": "zesVFManagement", + "desc": "Provides memory utilization values for a virtual function (deprecated)", + "members": [ + { + "desc": "[in] type of this structure", + "init": "ZES_STRUCTURE_TYPE_VF_UTIL_MEM_EXP", + "name": "stype", + "type": "zes_structure_type_t" + }, + { + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, + { + "desc": "[out] Memory type flags.", + "name": "memTypeFlags", + "type": "zes_vf_info_mem_type_exp_flags_t" + }, + { + "desc": "[out] Free memory size in bytes.", + "name": "free", + "type": "uint64_t" + }, + { + "desc": "[out] Total allocatable memory in bytes.", + "name": "size", + "type": "uint64_t" + }, + { + "desc": "[out] Wall clock time from VF when value was sampled.", + "name": "timestamp", + "type": "uint64_t" + } + ], + "name": "zes_vf_util_mem_exp_t", + "type": "struct", + "version": "1.9" + }, "zet_base_desc_t": { "desc": "Base for all descriptor types", "members": [ @@ -43868,6 +51134,37 @@ "name": "zet_device_debug_properties_t", "type": "struct" }, + "zet_export_dma_buf_exp_properties_t": { + "base": "zet_base_properties_t", + "class": "zetMetric", + "desc": "Exported dma_buf properties queried using `pNext` of zet_metric_group_properties_t or zet_metric_properties_t", + "members": [ + { + "desc": "[in] type of this structure", + "init": "ZET_STRUCTURE_TYPE_EXPORT_DMA_BUF_EXP_PROPERTIES", + "name": "stype", + "type": "zet_structure_type_t" + }, + { + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" + }, + { + "desc": "[out] the file descriptor handle that could be used to import the memory by the host process.", + "name": "fd", + "type": "int" + }, + { + "desc": "[out] size in bytes of the dma_buf", + "name": "size", + "type": "size_t" + } + ], + "name": "zet_export_dma_buf_exp_properties_t", + "type": "struct" + }, "zet_metric_calculate_exp_desc_t": { "base": "zet_base_desc_t", "class": "zetMetric", @@ -43895,6 +51192,39 @@ "type": "struct", "version": "1.6" }, + "zet_metric_entry_exp_t": { + "desc": "Decoded metric entry", + "members": [ + { + "desc": "[out] value of the decodable metric entry or event. Number is meaningful based on the metric type.", + "name": "value", + "type": "zet_value_t" + }, + { + "desc": "[out] timestamp at which the event happened.", + "name": "timeStamp", + "type": "uint64_t" + }, + { + "desc": "[out] index to the decodable metric handle in the input array (phMetric) in zetMetricTracerDecodeExp().", + "name": "metricIndex", + "type": "uint32_t" + }, + { + "desc": "[out] True if the event occurred on a sub-device; false means the device on which the metric tracer was opened does not have sub-devices.", + "name": "onSubdevice", + "type": "ze_bool_t" + }, + { + "desc": "[out] If onSubdevice is true, this gives the ID of the sub-device.", + "name": "subdeviceId", + "type": "uint32_t" + } + ], + "name": "zet_metric_entry_exp_t", + "type": "struct", + "version": "1.10" + }, "zet_metric_global_timestamps_resolution_exp_t": { "base": "zet_base_desc_t", "class": "zetMetric", @@ -43977,6 +51307,187 @@ "name": "zet_metric_group_properties_t", "type": "struct" }, + "zet_metric_group_type_exp_t": { + "base": "zet_base_properties_t", + "class": "zetMetricGroup", + "desc": "Query the metric group type using `pNext` of zet_metric_group_properties_t", + "members": [ + { + "desc": "[in] type of this structure", + "init": "ZET_STRUCTURE_TYPE_METRIC_GROUP_TYPE_EXP", + "name": "stype", + "type": "zet_structure_type_t" + }, + { + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" + }, + { + "desc": "[out] metric group type.\nreturns a combination of zet_metric_group_type_exp_flags_t.\n", + "name": "type", + "type": "zet_metric_group_type_exp_flags_t" + } + ], + "name": "zet_metric_group_type_exp_t", + "type": "struct" + }, + "zet_metric_programmable_exp_properties_t": { + "base": "zet_base_properties_t", + "class": "zetMetricProgrammable", + "desc": "Metric Programmable properties queried using zetMetricProgrammableGetPropertiesExp", + "members": [ + { + "desc": "[in] type of this structure", + "init": "ZET_STRUCTURE_TYPE_METRIC_PROGRAMMABLE_EXP_PROPERTIES", + "name": "stype", + "type": "zet_structure_type_t" + }, + { + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" + }, + { + "desc": "[out] metric programmable name", + "name": "name[ZET_MAX_METRIC_PROGRAMMABLE_NAME_EXP]", + "type": "char" + }, + { + "desc": "[out] metric programmable description", + "name": "description[ZET_MAX_METRIC_PROGRAMMABLE_DESCRIPTION_EXP]", + "type": "char" + }, + { + "desc": "[out] metric programmable component", + "name": "component[ZET_MAX_METRIC_PROGRAMMABLE_COMPONENT_EXP]", + "type": "char" + }, + { + "desc": "[out] tier number", + "name": "tierNumber", + "type": "uint32_t" + }, + { + "desc": "[out] metric domain number.", + "name": "domain", + "type": "uint32_t" + }, + { + "desc": "[out] number of parameters in the programmable", + "name": "parameterCount", + "type": "uint32_t" + }, + { + "desc": "[out] metric sampling type.\nreturns a combination of zet_metric_group_sampling_type_flag_t.\n", + "name": "samplingType", + "type": "zet_metric_group_sampling_type_flags_t" + }, + { + "desc": "[out] unique metric source identifier(within platform)to identify the HW block where the metric is collected.", + "name": "sourceId", + "type": "uint32_t" + } + ], + "name": "zet_metric_programmable_exp_properties_t", + "type": "struct", + "version": "1.9" + }, + "zet_metric_programmable_param_info_exp_t": { + "base": "zet_base_properties_t", + "class": "zetMetricProgrammable", + "desc": "Metric Programmable parameter information", + "members": [ + { + "desc": "[in] type of this structure", + "init": "ZET_STRUCTURE_TYPE_METRIC_PROGRAMMABLE_PARAM_INFO_EXP", + "name": "stype", + "type": "zet_structure_type_t" + }, + { + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" + }, + { + "desc": "[out] programmable parameter type", + "name": "type", + "type": "zet_metric_programmable_param_type_exp_t" + }, + { + "desc": "[out] metric programmable parameter name", + "name": "name[ZET_MAX_METRIC_PROGRAMMABLE_PARAMETER_NAME_EXP]", + "type": "char" + }, + { + "desc": "[out] value info type", + "name": "valueInfoType", + "type": "zet_value_info_type_exp_t" + }, + { + "desc": "[out] default value for the parameter", + "name": "defaultValue", + "type": "zet_value_t" + }, + { + "desc": "[out] count of zet_metric_programmable_param_value_info_exp_t", + "name": "valueInfoCount", + "type": "uint32_t" + } + ], + "name": "zet_metric_programmable_param_info_exp_t", + "type": "struct", + "version": "1.9" + }, + "zet_metric_programmable_param_value_exp_t": { + "class": "zetMetricProgrammable", + "desc": "Metric Programmable parameter value", + "members": [ + { + "desc": "[in] parameter value", + "name": "value", + "type": "zet_value_t" + } + ], + "name": "zet_metric_programmable_param_value_exp_t", + "type": "struct", + "version": "1.9" + }, + "zet_metric_programmable_param_value_info_exp_t": { + "base": "zet_base_properties_t", + "class": "zetMetricProgrammable", + "desc": "Metric Programmable parameter value information", + "members": [ + { + "desc": "[in] type of this structure", + "init": "ZET_STRUCTURE_TYPE_METRIC_PROGRAMMABLE_PARAM_VALUE_INFO_EXP", + "name": "stype", + "type": "zet_structure_type_t" + }, + { + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" + }, + { + "desc": "[out] information about the parameter value", + "name": "valueInfo", + "type": "zet_value_info_exp_t" + }, + { + "desc": "[out] description about the value", + "name": "description[ZET_MAX_METRIC_PROGRAMMABLE_VALUE_DESCRIPTION_EXP]", + "type": "char" + } + ], + "name": "zet_metric_programmable_param_value_info_exp_t", + "type": "struct", + "version": "1.9" + }, "zet_metric_properties_t": { "base": "zet_base_properties_t", "class": "zetMetric", @@ -44096,6 +51607,33 @@ "name": "zet_metric_streamer_desc_t", "type": "struct" }, + "zet_metric_tracer_exp_desc_t": { + "base": "zet_base_desc_t", + "class": "zetMetricTracer", + "desc": "Metric tracer descriptor", + "members": [ + { + "desc": "[in] type of this structure", + "init": "ZET_STRUCTURE_TYPE_METRIC_TRACER_EXP_DESC", + "name": "stype", + "type": "zet_structure_type_t" + }, + { + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, + { + "desc": "[in,out] number of collected bytes after which notification event will be signaled. If the requested value is not supported exactly, then the driver may use a value that is the closest supported approximation and shall update this member during zetMetricTracerCreateExp.\n", + "name": "notifyEveryNBytes", + "type": "uint32_t" + } + ], + "name": "zet_metric_tracer_exp_desc_t", + "type": "struct", + "version": "1.10" + }, "zet_profile_free_register_token_t": { "class": "zetKernel", "desc": "Profile free register token detailing unused registers in the current function", @@ -44210,6 +51748,42 @@ ], "name": "zet_typed_value_t", "type": "struct" + }, + "zet_value_fp64_range_exp_t": { + "desc": "Value info of type float64 range", + "members": [ + { + "desc": "[out] minimum value of the range", + "name": "fp64Min", + "type": "double" + }, + { + "desc": "[out] maximum value of the range", + "name": "fp64Max", + "type": "double" + } + ], + "name": "zet_value_fp64_range_exp_t", + "type": "struct", + "version": "1.10" + }, + "zet_value_uint64_range_exp_t": { + "desc": "Value info of type uint64_t range", + "members": [ + { + "desc": "[out] minimum value of the range", + "name": "ui64Min", + "type": "uint64_t" + }, + { + "desc": "[out] maximum value of the range", + "name": "ui64Max", + "type": "uint64_t" + } + ], + "name": "zet_value_uint64_range_exp_t", + "type": "struct", + "version": "1.9" } }, "typedef": { @@ -44296,6 +51870,60 @@ "name": "zet_debug_event_info_t", "type": "union" }, + "zet_value_info_exp_t": { + "desc": "Union of value information", + "members": [ + { + "desc": "[out] 32-bit unsigned-integer", + "name": "ui32", + "type": "uint32_t" + }, + { + "desc": "[out] 64-bit unsigned-integer", + "name": "ui64", + "type": "uint64_t" + }, + { + "desc": "[out] 32-bit floating-point", + "name": "fp32", + "type": "float" + }, + { + "desc": "[out] 64-bit floating-point", + "name": "fp64", + "type": "double" + }, + { + "desc": "[out] 8-bit boolean", + "name": "b8", + "type": "ze_bool_t" + }, + { + "desc": "[out] 8-bit unsigned integer", + "name": "ui8", + "type": "uint8_t" + }, + { + "desc": "[out] 16-bit unsigned integer", + "name": "ui16", + "type": "uint16_t" + }, + { + "desc": "[out] minimum and maximum value of the range", + "name": "ui64Range", + "type": "zet_value_uint64_range_exp_t" + }, + { + "desc": "[out] minimum and maximum value of the range", + "name": "fp64Range", + "type": "zet_value_fp64_range_exp_t", + "version": "1.10" + } + ], + "name": "zet_value_info_exp_t", + "type": "union", + "version": "1.9" + }, "zet_value_t": { "desc": "Union of values", "members": [ @@ -44305,7 +51933,7 @@ "type": "uint32_t" }, { - "desc": "[out] 32-bit unsigned-integer", + "desc": "[out] 64-bit unsigned-integer", "name": "ui64", "type": "uint64_t" }, @@ -44778,6 +52406,12 @@ "name": "$X_RESULT_WARNING_ACTION_REQUIRED", "value": "0x7800001b" }, + { + "desc": "[Core, Validation] kernel handle is invalid for the operation", + "name": "$X_RESULT_ERROR_INVALID_KERNEL_HANDLE", + "value": "0x7800001c", + "version": "1.10" + }, { "desc": "[Core] unknown or internal error", "name": "$X_RESULT_ERROR_UNKNOWN", @@ -45195,6 +52829,90 @@ "name": "$X_STRUCTURE_TYPE_RTAS_GEOMETRY_AABBS_EXP_CB_PARAMS", "value": "0x00020013", "version": "1.7" + }, + { + "desc": "$x_event_pool_counter_based_exp_desc_t", + "name": "$X_STRUCTURE_TYPE_COUNTER_BASED_EVENT_POOL_EXP_DESC", + "value": "0x00020014", + "version": "1.8" + }, + { + "desc": "$x_mutable_command_list_exp_properties_t", + "name": "$X_STRUCTURE_TYPE_MUTABLE_COMMAND_LIST_EXP_PROPERTIES", + "value": "0x00020015", + "version": "1.9" + }, + { + "desc": "$x_mutable_command_list_exp_desc_t", + "name": "$X_STRUCTURE_TYPE_MUTABLE_COMMAND_LIST_EXP_DESC", + "value": "0x00020016", + "version": "1.9" + }, + { + "desc": "$x_mutable_command_id_exp_desc_t", + "name": "$X_STRUCTURE_TYPE_MUTABLE_COMMAND_ID_EXP_DESC", + "value": "0x00020017", + "version": "1.9" + }, + { + "desc": "$x_mutable_commands_exp_desc_t", + "name": "$X_STRUCTURE_TYPE_MUTABLE_COMMANDS_EXP_DESC", + "value": "0x00020018", + "version": "1.9" + }, + { + "desc": "$x_mutable_kernel_argument_exp_desc_t", + "name": "$X_STRUCTURE_TYPE_MUTABLE_KERNEL_ARGUMENT_EXP_DESC", + "value": "0x00020019", + "version": "1.9" + }, + { + "desc": "$x_mutable_group_count_exp_desc_t", + "name": "$X_STRUCTURE_TYPE_MUTABLE_GROUP_COUNT_EXP_DESC", + "value": "0x0002001A", + "version": "1.9" + }, + { + "desc": "$x_mutable_group_size_exp_desc_t", + "name": "$X_STRUCTURE_TYPE_MUTABLE_GROUP_SIZE_EXP_DESC", + "value": "0x0002001B", + "version": "1.9" + }, + { + "desc": "$x_mutable_global_offset_exp_desc_t", + "name": "$X_STRUCTURE_TYPE_MUTABLE_GLOBAL_OFFSET_EXP_DESC", + "value": "0x0002001C", + "version": "1.9" + }, + { + "desc": "$x_device_pitched_alloc_exp_properties_t", + "name": "$X_STRUCTURE_TYPE_PITCHED_ALLOC_DEVICE_EXP_PROPERTIES", + "value": "0x0002001D", + "version": "1.9" + }, + { + "desc": "$x_image_bindless_exp_desc_t", + "name": "$X_STRUCTURE_TYPE_BINDLESS_IMAGE_EXP_DESC", + "value": "0x0002001E", + "version": "1.9" + }, + { + "desc": "$x_image_pitched_exp_desc_t", + "name": "$X_STRUCTURE_TYPE_PITCHED_IMAGE_EXP_DESC", + "value": "0x0002001F", + "version": "1.9" + }, + { + "desc": "$x_mutable_graph_argument_exp_desc_t", + "name": "$X_STRUCTURE_TYPE_MUTABLE_GRAPH_ARGUMENT_EXP_DESC", + "value": "0x00020020", + "version": "1.10" + }, + { + "desc": "$x_init_driver_type_desc_t", + "name": "$X_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC", + "value": "0x00020021", + "version": "1.10" } ], "name": "$x_structure_type_t", @@ -45538,6 +53256,134 @@ ], "type": "function" }, + { + "class": "$x", + "desc": "Supported driver initialization type flags", + "details": [ + "Bit Field which details the driver types to be initialized and returned to the user.", + "Value Definition:", + "0, do not init or retrieve any drivers.", + "ZE_INIT_DRIVER_TYPE_FLAG_GPU,\tGPU Drivers are Init and driver handles retrieved.", + "ZE_INIT_DRIVER_TYPE_FLAG_NPU,\tNPU Drivers are Init and driver handles retrieved.", + "ZE_INIT_DRIVER_TYPE_FLAG_GPU | ZE_INIT_DRIVER_TYPE_FLAG_NPU, NPU & GPU Drivers are Init and driver handles retrieved.", + "UINT32_MAX\tAll Drivers of any type are Init and driver handles retrieved." + ], + "etors": [ + { + "desc": "initialize and retrieve GPU drivers", + "name": "$X_INIT_DRIVER_TYPE_FLAG_GPU", + "value": "$X_BIT(0)" + }, + { + "desc": "initialize and retrieve NPU drivers", + "name": "$X_INIT_DRIVER_TYPE_FLAG_NPU", + "value": "$X_BIT(1)" + } + ], + "name": "$x_init_driver_type_flags_t", + "type": "enum", + "version": "1.10" + }, + { + "base": "$x_base_desc_t", + "class": "$x", + "desc": "Init Driver Type descriptor", + "members": [ + { + "desc": "[in] type of this structure", + "init": "$X_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC", + "name": "stype", + "type": "$x_structure_type_t" + }, + { + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, + { + "desc": "[in] driver type init flags.\nmust be a valid combination of $x_init_driver_type_flag_t or UINT32_MAX;\ndriver types are init and retrieved based on these init flags in zeInitDrivers().\n", + "init": "0", + "name": "flags", + "type": "$x_init_driver_type_flags_t" + } + ], + "name": "$x_init_driver_type_desc_t", + "type": "struct", + "version": "1.10" + }, + { + "class": "$x", + "decl": "static", + "desc": "Initialize the $OneApi driver(s) based on the driver types requested and retrieve the driver handles.", + "details": [ + "The application must call this function or zeInit before calling any other function.", + "The application can call InitDrivers or zeInit to init the drivers on the system.", + "Calls to zeInit or InitDrivers will not alter the drivers retrieved thru either api.", + "Drivers init thru zeInit or InitDrivers will not be reInitialized once init in an application. The Loader will determine if the already init driver needs to be delivered to the user thru the init type flags.", + "Already init Drivers will not be uninitialized if the call to InitDrivers does not include that driver's type. Those init drivers which don't match the init flags will not have their driver handles returned to the user in that InitDrivers call.", + "If this function or zeInit is not called, then all other functions will return $X_RESULT_ERROR_UNINITIALIZED.", + "Only one instance of each driver will be initialized per process.", + "A driver represents a collection of physical devices.", + "Multiple calls to this function will return identical driver handles, in the same order.", + "The drivers returned to the caller will be based on the init types which state the drivers to be included.", + "The application may pass nullptr for pDrivers when only querying the number of drivers.", + "The application may call this function multiple times with different flags or environment variables enabled.", + "The application must call this function after forking new processes. Each forked process must call this function.", + "The application may call this function from simultaneous threads.", + "The implementation of this function must be thread-safe for scenarios where multiple libraries may initialize the driver(s) simultaneously." + ], + "hash": "052160fb988c1bc12ca5af59e157df515791bd22739648deda7708ab05b93cb1", + "name": "InitDrivers", + "ordinal": "0", + "params": [ + { + "desc": "[in,out] pointer to the number of driver instances.\nif count is zero, then the loader shall update the value with the total number of drivers available.\nif count is greater than the number of drivers available, then the loader shall update the value with the correct number of drivers available.\n", + "name": "pCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pCount)] array of driver instance handles.\nif count is less than the number of drivers available, then the loader shall only retrieve that number of drivers.\n", + "name": "phDrivers", + "type": "$x_driver_handle_t*" + }, + { + "desc": "[in] descriptor containing the driver type initialization details including $x_init_driver_type_flag_t combinations.\n", + "name": "desc", + "type": "$x_init_driver_type_desc_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCount`", + "`nullptr == desc`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_ENUMERATION": [ + "`0x0 == desc->flags`" + ] + } + ], + "type": "function", + "version": "1.10" + }, { "class": "$xDriver", "desc": "Supported API versions", @@ -45592,15 +53438,46 @@ "value": "$X_MAKE_VERSION( 1, 7 )", "version": "1.7" }, + { + "desc": "version 1.8", + "name": "$X_API_VERSION_1_8", + "value": "$X_MAKE_VERSION( 1, 8 )", + "version": "1.8" + }, + { + "desc": "version 1.9", + "name": "$X_API_VERSION_1_9", + "value": "$X_MAKE_VERSION( 1, 9 )", + "version": "1.9" + }, + { + "desc": "version 1.10", + "name": "$X_API_VERSION_1_10", + "value": "$X_MAKE_VERSION( 1, 10 )", + "version": "1.10" + }, + { + "desc": "version 1.11", + "name": "$X_API_VERSION_1_11", + "value": "$X_MAKE_VERSION( 1, 11 )", + "version": "1.11" + }, { "desc": "latest known version", "name": "$X_API_VERSION_CURRENT", - "value": "$X_MAKE_VERSION( 1, 7 )" + "value": "$X_MAKE_VERSION( 1, 11 )" } ], "name": "$x_api_version_t", "type": "enum" }, + { + "desc": "Current API version as a macro", + "name": "$X_API_VERSION_CURRENT_M", + "type": "macro", + "value": "$X_MAKE_VERSION( 1, 11 )", + "version": "1.10" + }, { "class": "$xDriver", "desc": "Returns the API version supported by the specified driver", @@ -46355,7 +54232,7 @@ "type": "uint32_t" }, { - "desc": "[out] device id from PCI configuration\nNote, the device id uses little-endian format.\n", + "desc": "[out] device id from PCI configuration.\nNote, the device id uses little-endian format.\n", "name": "deviceId", "type": "uint32_t" }, @@ -47784,12 +55661,12 @@ "type": "$x_device_handle_t" }, { - "desc": "[out] value of the Host's global timestamp that correlates with the Device's global timestamp value", + "desc": "[out] value of the Host's global timestamp that correlates with the Device's global timestamp value.", "name": "hostTimestamp", "type": "uint64_t*" }, { - "desc": "[out] value of the Device's global timestamp that correlates with the Host's global timestamp value", + "desc": "[out] value of the Device's global timestamp that correlates with the Host's global timestamp value.", "name": "deviceTimestamp", "type": "uint64_t*" } @@ -47820,6 +55697,11 @@ "`nullptr == hostTimestamp`", "`nullptr == deviceTimestamp`" ] + }, + { + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "The feature is not supported by the underlying platform." + ] } ], "type": "function", @@ -48537,6 +56419,108 @@ ], "type": "function" }, + { + "class": "$xCommandQueue", + "desc": "Gets the command queue group ordinal.", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "f4318804875371e1917a40fd41221d640979f2e79485a928396214e501a0f20d", + "name": "GetOrdinal", + "params": [ + { + "desc": "[in] handle of the command queue", + "name": "hCommandQueue", + "type": "$x_command_queue_handle_t" + }, + { + "desc": "[out] command queue group ordinal", + "name": "pOrdinal", + "type": "uint32_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hCommandQueue`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pOrdinal`" + ] + } + ], + "type": "function", + "version": "1.9" + }, + { + "class": "$xCommandQueue", + "desc": "Gets the command queue index within the group.", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "0b83e32e93540fc3317a0ad0d0aed594e1462e9760098d31db597ffb61dfc941", + "name": "GetIndex", + "params": [ + { + "desc": "[in] handle of the command queue", + "name": "hCommandQueue", + "type": "$x_command_queue_handle_t" + }, + { + "desc": "[out] command queue index within the group", + "name": "pIndex", + "type": "uint32_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hCommandQueue`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pIndex`" + ] + } + ], + "type": "function", + "version": "1.9" + }, { "desc": "C++ wrapper for command queue", "members": [ @@ -48594,6 +56578,12 @@ "name": "$X_COMMAND_LIST_FLAG_IN_ORDER", "value": "$X_BIT(3)", "version": "1.7" + }, + { + "desc": "this command list may be cloned using $xCommandListCreateCloneExp after $xCommandListClose.", + "name": "$X_COMMAND_LIST_FLAG_EXP_CLONEABLE", + "value": "$X_BIT(4)", + "version": "1.9" } ], "name": "$x_command_list_flags_t", @@ -48697,7 +56687,7 @@ }, { "$X_RESULT_ERROR_INVALID_ENUMERATION": [ - "`0xf < desc->flags`" + "`0x1f < desc->flags`" ] } ], @@ -49047,55 +57037,14 @@ "version": "1.6" }, { - "desc": "C++ wrapper for command list", - "members": [ - { - "desc": "[in] handle of command list object", - "name": "handle", - "type": "$x_command_list_handle_t" - }, - { - "desc": "[in] pointer to owner object", - "name": "pDevice", - "type": "$xDevice*" - }, - { - "desc": "[in] descriptor of the command list object", - "name": "desc", - "type": "$x_command_list_desc_t" - } - ], - "name": "$xCommandList", - "owner": "$xDevice", - "type": "class" - } - ] - }, - { - "header": { - "desc": "Intel $OneApi Level-Zero APIs for Barrier", - "ordinal": 1000, - "type": "header" - }, - "name": "barrier", - "objects": [ - { - "analogue": [ - "**vkCmdPipelineBarrier**", - "clEnqueueBarrierWithWaitList" - ], "class": "$xCommandList", - "desc": "Appends an execution and global memory barrier into a command list.", + "desc": "Gets the handle of the device on which the command list was created.", "details": [ - "The application must ensure the events are accessible by the device on which the command list was created.", - "If numWaitEvents is zero, then all previous commands, enqueued on same command queue, must complete prior to the execution of the barrier. This is not the case when numWaitEvents is non-zero.", - "If numWaitEvents is non-zero, then only all phWaitEvents must be signaled prior to the execution of the barrier.", - "This command blocks all following commands from beginning until the execution of the barrier completes.", - "The application must **not** call this function from simultaneous threads with the same command list handle.", + "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "5a1b934c89a448d55bf286086ad31aa09ca2ccdf5e12b073074de61f54adaec1", - "name": "AppendBarrier", + "hash": "415fb57c3d440d14edcfc2f819c0096d3782ee45669422a820701781eeae9f87", + "name": "GetDeviceHandle", "params": [ { "desc": "[in] handle of the command list", @@ -49103,19 +57052,321 @@ "type": "$x_command_list_handle_t" }, { - "desc": "[in][optional] handle of the event to signal on completion", - "name": "hSignalEvent", - "type": "$x_event_handle_t" - }, - { - "desc": "[in][optional] number of events to wait on before executing barrier; must be 0 if `nullptr == phWaitEvents`", - "name": "numWaitEvents", - "type": "uint32_t" - }, - { - "desc": "[in][optional][range(0, numWaitEvents)] handle of the events to wait on before executing barrier", - "name": "phWaitEvents", - "type": "$x_event_handle_t*" + "desc": "[out] handle of the device on which the command list was created", + "name": "phDevice", + "type": "$x_device_handle_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hCommandList`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == phDevice`" + ] + } + ], + "type": "function", + "version": "1.9" + }, + { + "class": "$xCommandList", + "desc": "Gets the handle of the context on which the command list was created.", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "f610bde36ba229c05e8d120131e498da494063180c7b6076e875cbd12ee5fae0", + "name": "GetContextHandle", + "params": [ + { + "desc": "[in] handle of the command list", + "name": "hCommandList", + "type": "$x_command_list_handle_t" + }, + { + "desc": "[out] handle of the context on which the command list was created", + "name": "phContext", + "type": "$x_context_handle_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hCommandList`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == phContext`" + ] + } + ], + "type": "function", + "version": "1.9" + }, + { + "class": "$xCommandList", + "desc": "Gets the command queue group ordinal to which the command list is submitted.", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "159b34a235fe830e296aebab56b274790d8df31c64f6cdedd8c2be26891c0091", + "name": "GetOrdinal", + "params": [ + { + "desc": "[in] handle of the command list", + "name": "hCommandList", + "type": "$x_command_list_handle_t" + }, + { + "desc": "[out] command queue group ordinal to which command list is submitted", + "name": "pOrdinal", + "type": "uint32_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hCommandList`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pOrdinal`" + ] + } + ], + "type": "function", + "version": "1.9" + }, + { + "class": "$xCommandList", + "desc": "Gets the command queue index within the group to which the immediate command list is submitted.", + "details": [ + "The application must call this function only with command lists created with $xCommandListCreateImmediate.", + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "2ba71703e037b0798da609ac5b0a06f5c548ec1e09f064d1241edd8fd8cb1a10", + "name": "ImmediateGetIndex", + "params": [ + { + "desc": "[in] handle of the immediate command list", + "name": "hCommandListImmediate", + "type": "$x_command_list_handle_t" + }, + { + "desc": "[out] command queue index within the group to which the immediate command list is submitted", + "name": "pIndex", + "type": "uint32_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hCommandListImmediate`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pIndex`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_ARGUMENT": [ + "handle does not correspond to an immediate command list" + ] + } + ], + "type": "function", + "version": "1.9" + }, + { + "class": "$xCommandList", + "desc": "Query whether a command list is an immediate command list.", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "3ca7b41b9bb728b65fab80dfb01560316982e5614a21213d30a4e77756d83e90", + "name": "IsImmediate", + "params": [ + { + "desc": "[in] handle of the command list", + "name": "hCommandList", + "type": "$x_command_list_handle_t" + }, + { + "desc": "[out] Boolean indicating whether the command list is an immediate command list (true) or not (false)", + "name": "pIsImmediate", + "type": "$x_bool_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hCommandList`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pIsImmediate`" + ] + } + ], + "type": "function", + "version": "1.9" + }, + { + "desc": "C++ wrapper for command list", + "members": [ + { + "desc": "[in] handle of command list object", + "name": "handle", + "type": "$x_command_list_handle_t" + }, + { + "desc": "[in] pointer to owner object", + "name": "pDevice", + "type": "$xDevice*" + }, + { + "desc": "[in] descriptor of the command list object", + "name": "desc", + "type": "$x_command_list_desc_t" + } + ], + "name": "$xCommandList", + "owner": "$xDevice", + "type": "class" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero APIs for Barrier", + "ordinal": 1000, + "type": "header" + }, + "name": "barrier", + "objects": [ + { + "analogue": [ + "**vkCmdPipelineBarrier**", + "clEnqueueBarrierWithWaitList" + ], + "class": "$xCommandList", + "desc": "Appends an execution and global memory barrier into a command list.", + "details": [ + "The application must ensure the events are accessible by the device on which the command list was created.", + "If numWaitEvents is zero, then all previous commands, enqueued on same command queue, must complete prior to the execution of the barrier. This is not the case when numWaitEvents is non-zero.", + "If numWaitEvents is non-zero, then only all phWaitEvents must be signaled prior to the execution of the barrier.", + "This command blocks all following commands from beginning until the execution of the barrier completes.", + "The application must **not** call this function from simultaneous threads with the same command list handle.", + "The implementation of this function should be lock-free." + ], + "hash": "5a1b934c89a448d55bf286086ad31aa09ca2ccdf5e12b073074de61f54adaec1", + "name": "AppendBarrier", + "params": [ + { + "desc": "[in] handle of the command list", + "name": "hCommandList", + "type": "$x_command_list_handle_t" + }, + { + "desc": "[in][optional] handle of the event to signal on completion", + "name": "hSignalEvent", + "type": "$x_event_handle_t" + }, + { + "desc": "[in][optional] number of events to wait on before executing barrier; must be 0 if `nullptr == phWaitEvents`", + "name": "numWaitEvents", + "type": "uint32_t" + }, + { + "desc": "[in][optional][range(0, numWaitEvents)] handle of the events to wait on before executing barrier", + "name": "phWaitEvents", + "type": "$x_event_handle_t*" } ], "returns": [ @@ -50829,6 +59080,8 @@ "details": [ "Multiple calls to this function with the same IPC handle will return unique event pool handles.", "The event handle in this process should not be freed with $xEventPoolDestroy, but rather with $xEventPoolCloseIpcHandle.", + "If the original event pool has been created for a device containing a number of sub-devices, then the event pool\nreturned by this call may be used on a device containing the same number of sub-devices, or on any of\nthose sub-devices.\n", + "However, if the original event pool has been created for a sub-device, then the event pool returned by this call\ncannot be used on a device containing any number of sub-devices, and must be used only in a sub-device. This ensures\nfunctional correctness for any implementation or optimizations the underlying Level Zero driver may do on\nevent pools and events.\n", "The application may call this function from simultaneous threads." ], "hash": "f22842988b4dc4537adb8fdb8930c1c09a19d59a39e4418c89d2d7f1da73048a", @@ -51485,6 +59738,261 @@ ], "type": "function" }, + { + "class": "$xEvent", + "desc": "Gets the handle of the event pool for the event.", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "5518688c8da46d797af03c0e44d8222976d72478a9d8d3cd742fabb125bab9a8", + "name": "GetEventPool", + "params": [ + { + "desc": "[in] handle of the event", + "name": "hEvent", + "type": "$x_event_handle_t" + }, + { + "desc": "[out] handle of the event pool for the event", + "name": "phEventPool", + "type": "$x_event_pool_handle_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hEvent`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == phEventPool`" + ] + } + ], + "type": "function", + "version": "1.9" + }, + { + "class": "$xEvent", + "desc": "Gets the signal event scope.", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "45873fc0a8cf42795ff4ea08245febb66889290d4665547f189d93b60d01f4b4", + "name": "GetSignalScope", + "params": [ + { + "desc": "[in] handle of the event", + "name": "hEvent", + "type": "$x_event_handle_t" + }, + { + "desc": "[out] signal event scope. This is the scope of relevant cache hierarchies that are flushed on a signal action before the event is triggered. May be 0 or a valid combination of $x_event_scope_flag_t.", + "name": "pSignalScope", + "type": "$x_event_scope_flags_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hEvent`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pSignalScope`" + ] + } + ], + "type": "function", + "version": "1.9" + }, + { + "class": "$xEvent", + "desc": "Gets the wait event scope.", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "3ce87fd2651a21b4431a92db0a97cda3f124b0ec380a2adf909fda30027ff382", + "name": "GetWaitScope", + "params": [ + { + "desc": "[in] handle of the event", + "name": "hEvent", + "type": "$x_event_handle_t" + }, + { + "desc": "[out] wait event scope. This is the scope of relevant cache hierarchies invalidated on a wait action after the event is complete. May be 0 or a valid combination of $x_event_scope_flag_t.", + "name": "pWaitScope", + "type": "$x_event_scope_flags_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hEvent`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pWaitScope`" + ] + } + ], + "type": "function", + "version": "1.9" + }, + { + "class": "$xEventPool", + "desc": "Gets the handle of the context on which the event pool was created.", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "d7f550b2814d0c5a32588cef3b988a5aed42e25889c3692dab7565da4041f523", + "name": "GetContextHandle", + "params": [ + { + "desc": "[in] handle of the event pool", + "name": "hEventPool", + "type": "$x_event_pool_handle_t" + }, + { + "desc": "[out] handle of the context on which the event pool was created", + "name": "phContext", + "type": "$x_context_handle_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hEventPool`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == phContext`" + ] + } + ], + "type": "function", + "version": "1.9" + }, + { + "class": "$xEventPool", + "desc": "Gets the creation flags used to create the event pool.", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "f132708d6d6b4e42b911405306c79565a83cb1e6e19d94d904406f7375c72e7d", + "name": "GetFlags", + "params": [ + { + "desc": "[in] handle of the event pool", + "name": "hEventPool", + "type": "$x_event_pool_handle_t" + }, + { + "desc": "[out] creation flags used to create the event pool; may be 0 or a valid combination of $x_event_pool_flag_t", + "name": "pFlags", + "type": "$x_event_pool_flags_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hEventPool`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pFlags`" + ] + } + ], + "type": "function", + "version": "1.9" + }, { "desc": "C++ wrapper for event pool", "members": [ @@ -52156,6 +60664,24 @@ "desc": "Media Format: BRGP. Format type and swizzle is ignored for this.", "name": "$X_IMAGE_FORMAT_LAYOUT_BRGP", "value": "42" + }, + { + "desc": "3-component 8-bit layout", + "name": "$X_IMAGE_FORMAT_LAYOUT_8_8_8", + "value": "43", + "version": "1.9" + }, + { + "desc": "3-component 16-bit layout", + "name": "$X_IMAGE_FORMAT_LAYOUT_16_16_16", + "value": "44", + "version": "1.9" + }, + { + "desc": "3-component 32-bit layout", + "name": "$X_IMAGE_FORMAT_LAYOUT_32_32_32", + "value": "45", + "version": "1.9" } ], "name": "$x_image_format_layout_t", @@ -56378,6 +64904,11 @@ "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ "`nullptr == ptr`" ] + }, + { + "$X_RESULT_ERROR_INVALID_ARGUMENT": [ + "ptr is not recognized by the implementation" + ] } ], "type": "function" @@ -57037,9 +65568,14 @@ "desc": "Supported physical memory creation flags", "etors": [ { - "desc": "reserved for future use.", - "name": "$X_PHYSICAL_MEM_FLAG_TBD", + "desc": "[default] allocate physical device memory.", + "name": "$X_PHYSICAL_MEM_FLAG_ALLOCATE_ON_DEVICE", "value": "$X_BIT(0)" + }, + { + "desc": "Allocate physical host memory instead.", + "name": "$X_PHYSICAL_MEM_FLAG_ALLOCATE_ON_HOST", + "value": "$X_BIT(1)" } ], "name": "$x_physical_mem_flags_t", @@ -57063,7 +65599,7 @@ "type": "const void*" }, { - "desc": "[in] creation flags.\nmust be 0 (default) or a valid combination of $x_physical_mem_flag_t.\n", + "desc": "[in] creation flags.\nmust be 0 (default) or a valid combination of $x_physical_mem_flag_t; default is to create physical device memory.\n", "init": "0", "name": "flags", "type": "$x_physical_mem_flags_t" @@ -57083,7 +65619,7 @@ "desc": "Creates a physical memory object for the context.", "details": [ "The application must only use the physical memory object on the context for which it was created.", - "The size must be page aligned. See $xVirtualMemQueryPageSize.", + "The size must be page aligned. For host memory, the operating system page size should be used. For device memory, see $xVirtualMemQueryPageSize.", "The application may call this function from simultaneous threads.", "The implementation of this function must be thread-safe." ], @@ -57097,7 +65633,7 @@ "type": "$x_context_handle_t" }, { - "desc": "[in] handle of the device object", + "desc": "[in] handle of the device object, can be `nullptr` if creating physical host memory.", "name": "hDevice", "type": "$x_device_handle_t" }, @@ -57142,7 +65678,7 @@ }, { "$X_RESULT_ERROR_INVALID_ENUMERATION": [ - "`0x1 < desc->flags`" + "`0x3 < desc->flags`" ] }, { @@ -57848,6 +66384,24 @@ } ] }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Extension for retrieving kernel binary program data.", + "ordinal": 1110, + "type": "header", + "version": "1.11" + }, + "name": "kernelBinary", + "objects": [ + { + "desc": "Get Kernel Binary Extension Name", + "name": "$X_GET_KERNEL_BINARY_EXP_NAME", + "type": "macro", + "value": "\"$X_extension_kernel_binary_exp\"", + "version": "1.11" + } + ] + }, { "header": { "desc": "Intel $OneApi Level-Zero Extension APIs for Cache Reservation", @@ -63413,442 +71967,328 @@ "version": "1.7" } ] - } - ], - [ + }, { "header": { - "desc": "Intel $OneApi Level-Zero Tool API common types", - "ordinal": 0, - "type": "header" + "desc": "Intel $OneApi Level-Zero Extension APIs for Counter-based Event Pools", + "ordinal": 1800, + "type": "header", + "version": "1.8" }, - "name": "common", + "name": "counterbasedeventpool", "objects": [ { - "alias": "$x_driver_handle_t", - "class": "$tDriver", - "desc": "Handle to a driver instance", - "name": "$t_driver_handle_t", - "type": "handle" - }, - { - "alias": "$x_device_handle_t", - "class": "$tDevice", - "desc": "Handle of device object", - "name": "$t_device_handle_t", - "type": "handle" - }, - { - "alias": "$x_context_handle_t", - "class": "$tContext", - "desc": "Handle of context object", - "name": "$t_context_handle_t", - "type": "handle" - }, - { - "alias": "$x_command_list_handle_t", - "class": "$tCommandList", - "desc": "Handle of command list object", - "name": "$t_command_list_handle_t", - "type": "handle" - }, - { - "alias": "$x_module_handle_t", - "class": "$tModule", - "desc": "Handle of module object", - "name": "$t_module_handle_t", - "type": "handle" - }, - { - "alias": "$x_kernel_handle_t", - "class": "$tKernel", - "desc": "Handle of function object", - "name": "$t_kernel_handle_t", - "type": "handle" - }, - { - "class": "$tMetricGroup", - "desc": "Handle of metric group's object", - "name": "$t_metric_group_handle_t", - "type": "handle" - }, - { - "class": "$tMetric", - "desc": "Handle of metric's object", - "name": "$t_metric_handle_t", - "type": "handle" - }, - { - "class": "$tMetricStreamer", - "desc": "Handle of metric streamer's object", - "name": "$t_metric_streamer_handle_t", - "type": "handle" - }, - { - "class": "$tMetricQueryPool", - "desc": "Handle of metric query pool's object", - "name": "$t_metric_query_pool_handle_t", - "type": "handle" - }, - { - "class": "$tMetricQuery", - "desc": "Handle of metric query's object", - "name": "$t_metric_query_handle_t", - "type": "handle" - }, - { - "class": "$tTracerExp", - "desc": "Handle of tracer object", - "name": "$t_tracer_exp_handle_t", - "type": "handle" - }, - { - "class": "$tDebug", - "desc": "Debug session handle", - "name": "$t_debug_session_handle_t", - "type": "handle" + "desc": "Counter-based Event Pools Extension Name", + "name": "$X_EVENT_POOL_COUNTER_BASED_EXP_NAME", + "type": "macro", + "value": "\"$X_experimental_event_pool_counter_based\"", + "version": "1.8" }, { - "desc": "Defines structure types", + "desc": "Counter-based Event Pools Extension Version(s)", "etors": [ { - "desc": "$t_metric_group_properties_t", - "name": "$T_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES", - "value": "0x1" - }, - { - "desc": "$t_metric_properties_t", - "name": "$T_STRUCTURE_TYPE_METRIC_PROPERTIES", - "value": "0x2" - }, - { - "desc": "$t_metric_streamer_desc_t", - "name": "$T_STRUCTURE_TYPE_METRIC_STREAMER_DESC", - "value": "0x3" + "desc": "version 1.0", + "name": "$X_EVENT_POOL_COUNTER_BASED_EXP_VERSION_1_0", + "value": "$X_MAKE_VERSION( 1, 0 )" }, { - "desc": "$t_metric_query_pool_desc_t", - "name": "$T_STRUCTURE_TYPE_METRIC_QUERY_POOL_DESC", - "value": "0x4" - }, + "desc": "latest known version", + "name": "$X_EVENT_POOL_COUNTER_BASED_EXP_VERSION_CURRENT", + "value": "$X_MAKE_VERSION( 1, 0 )" + } + ], + "name": "$x_event_pool_counter_based_exp_version_t", + "type": "enum", + "version": "1.8" + }, + { + "class": "$xEventPool", + "desc": "Supported event flags for defining counter-based event pools.", + "etors": [ { - "desc": "$t_profile_properties_t", - "name": "$T_STRUCTURE_TYPE_PROFILE_PROPERTIES", - "value": "0x5" + "desc": "Counter-based event pool is used for immediate command lists (default)", + "name": "$X_EVENT_POOL_COUNTER_BASED_EXP_FLAG_IMMEDIATE", + "value": "$X_BIT(0)" }, { - "desc": "$t_device_debug_properties_t", - "name": "$T_STRUCTURE_TYPE_DEVICE_DEBUG_PROPERTIES", - "value": "0x6" - }, + "desc": "Counter-based event pool is for non-immediate command lists", + "name": "$X_EVENT_POOL_COUNTER_BASED_EXP_FLAG_NON_IMMEDIATE", + "value": "$X_BIT(1)" + } + ], + "name": "$x_event_pool_counter_based_exp_flags_t", + "type": "enum", + "version": "1.8" + }, + { + "base": "$x_base_desc_t", + "class": "$xEventPool", + "desc": "Event pool descriptor for counter-based events. This structure may be passed to $xEventPoolCreate as pNext member of $x_event_pool_desc_t.", + "members": [ { - "desc": "$t_debug_memory_space_desc_t", - "name": "$T_STRUCTURE_TYPE_DEBUG_MEMORY_SPACE_DESC", - "value": "0x7" + "desc": "[in] type of this structure", + "init": "$X_STRUCTURE_TYPE_EVENT_POOL_COUNTER_BASED_EXP_DESC", + "name": "stype", + "type": "$x_structure_type_t" }, { - "desc": "$t_debug_regset_properties_t", - "name": "$T_STRUCTURE_TYPE_DEBUG_REGSET_PROPERTIES", - "value": "0x8" + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" }, { - "desc": "$t_metric_global_timestamps_resolution_exp_t. Deprecated, use $T_STRUCTURE_TYPE_METRIC_GLOBAL_TIMESTAMPS_RESOLUTION_EXP.", - "name": "$T_STRUCTURE_TYPE_GLOBAL_METRICS_TIMESTAMPS_EXP_PROPERTIES", - "value": "0x9", - "version": "1.5" - }, + "desc": "[in] mode flags.\nmust be 0 (default) or a valid value of $x_event_pool_counter_based_exp_flag_t\ndefault behavior is counter-based event pool is only used for immediate command lists.\n", + "init": "0", + "name": "flags", + "type": "$x_event_pool_counter_based_exp_flags_t" + } + ], + "name": "$x_event_pool_counter_based_exp_desc_t", + "type": "struct", + "version": "1.8" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Extension for supporting bindless images.", + "ordinal": 1900, + "type": "header", + "version": "1.9" + }, + "name": "bindlessimages", + "objects": [ + { + "desc": "Image Memory Properties Extension Name", + "name": "$X_BINDLESS_IMAGE_EXP_NAME", + "type": "macro", + "value": "\"$X_experimental_bindless_image\"", + "version": "1.9" + }, + { + "desc": "Bindless Image Extension Version(s)", + "etors": [ { - "desc": "$t_metric_global_timestamps_resolution_exp_t", - "name": "$T_STRUCTURE_TYPE_METRIC_GLOBAL_TIMESTAMPS_RESOLUTION_EXP", - "value": "0x9", - "version": "1.7" + "desc": "version 1.0", + "name": "$X_BINDLESS_IMAGE_EXP_VERSION_1_0", + "value": "$X_MAKE_VERSION( 1, 0 )" }, { - "desc": "$t_tracer_exp_desc_t", - "name": "$T_STRUCTURE_TYPE_TRACER_EXP_DESC", - "value": "0x00010001" - }, + "desc": "latest known version", + "name": "$X_BINDLESS_IMAGE_EXP_VERSION_CURRENT", + "value": "$X_MAKE_VERSION( 1, 0 )" + } + ], + "name": "$x_bindless_image_exp_version_t", + "type": "enum", + "version": "1.9" + }, + { + "class": "$xImage", + "desc": "Image flags for Bindless images", + "etors": [ { - "desc": "$t_metric_calculate_exp_desc_t. Deprecated, use $T_STRUCTURE_TYPE_METRIC_CALCULATE_EXP_DESC.", - "name": "$T_STRUCTURE_TYPE_METRICS_CALCULATE_EXP_DESC", - "value": "0x00010002", - "version": "1.6" + "desc": "Bindless images are created with $xImageCreate. The image handle created with this flag is valid on both host and device.", + "name": "$X_IMAGE_BINDLESS_EXP_FLAG_BINDLESS", + "value": "$X_BIT(0)" }, { - "desc": "$t_metric_calculate_exp_desc_t", - "name": "$T_STRUCTURE_TYPE_METRIC_CALCULATE_EXP_DESC", - "value": "0x00010002", - "version": "1.7" + "desc": "Bindless sampled images are created with $xImageCreate by combining BINDLESS and SAMPLED_IMAGE.\nCreate sampled image view from bindless unsampled image using SAMPLED_IMAGE.\n", + "name": "$X_IMAGE_BINDLESS_EXP_FLAG_SAMPLED_IMAGE", + "value": "$X_BIT(1)" } ], - "name": "$t_structure_type_t", - "type": "enum" + "name": "$x_image_bindless_exp_flags_t", + "type": "enum", + "version": "1.9" }, { - "desc": "Base for all properties types", + "base": "$x_base_desc_t", + "class": "$xImage", + "desc": "Image descriptor for bindless images. This structure may be passed to $xImageCreate via pNext member of $x_image_desc_t.", "members": [ { "desc": "[in] type of this structure", + "init": "$X_STRUCTURE_TYPE_IMAGE_BINDLESS_EXP_DESC", "name": "stype", - "type": "$t_structure_type_t" + "type": "$x_structure_type_t" }, { - "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", "init": "nullptr", "name": "pNext", - "type": "void*" + "type": "const void*" + }, + { + "desc": "[in] image flags.\nmust be 0 (default) or a valid value of $x_image_bindless_exp_flag_t\ndefault behavior is bindless images are not used when creating handles via $xImageCreate.\nWhen the flag is passed to $xImageCreate, then only the memory for the image is allocated.\nAdditional image handles can be created with $xImageViewCreateExt.\nWhen $X_IMAGE_BINDLESS_EXP_FLAG_SAMPLED_IMAGE flag is passed, $x_sampler_desc_t must be attached via pNext member of $x_image_bindless_exp_desc_t.\n", + "init": "0", + "name": "flags", + "type": "$x_image_bindless_exp_flags_t" } ], - "name": "$t_base_properties_t", - "type": "struct" + "name": "$x_image_bindless_exp_desc_t", + "type": "struct", + "version": "1.9" }, { - "desc": "Base for all descriptor types", + "base": "$x_base_desc_t", + "class": "$xImage", + "desc": "Image descriptor for bindless images created from pitched allocations. This structure may be passed to $xImageCreate via pNext member of $x_image_desc_t.", "members": [ { "desc": "[in] type of this structure", + "init": "$X_STRUCTURE_TYPE_IMAGE_PITCHED_EXP_DESC", "name": "stype", - "type": "$t_structure_type_t" + "type": "$x_structure_type_t" }, { "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", "init": "nullptr", "name": "pNext", "type": "const void*" + }, + { + "desc": "[in] pointer to pitched device allocation allocated using $xMemAllocDevice\n", + "init": "0", + "name": "ptr", + "type": "void*" } ], - "name": "$t_base_desc_t", - "type": "struct" + "name": "$x_image_pitched_exp_desc_t", + "type": "struct", + "version": "1.9" }, { - "desc": "Supported value types", - "etors": [ + "base": "$x_base_properties_t", + "class": "$xDevice", + "desc": "Device specific properties for pitched allocations", + "details": [ + "This structure may be passed to $xDeviceGetImageProperties via the pNext member of $x_device_image_properties_t." + ], + "members": [ { - "desc": "32-bit unsigned-integer", - "name": "$T_VALUE_TYPE_UINT32", - "value": "0" + "desc": "[in] type of this structure", + "init": "$X_STRUCTURE_TYPE_DEVICE_PITCHED_ALLOC_EXP_PROPERTIES", + "name": "stype", + "type": "$x_structure_type_t" }, { - "desc": "64-bit unsigned-integer", - "name": "$T_VALUE_TYPE_UINT64", - "value": "1" + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" }, { - "desc": "32-bit floating-point", - "name": "$T_VALUE_TYPE_FLOAT32", - "value": "2" + "desc": "[out] Maximum image linear width.", + "name": "maxImageLinearWidth", + "type": "size_t" }, { - "desc": "64-bit floating-point", - "name": "$T_VALUE_TYPE_FLOAT64", - "value": "3" + "desc": "[out] Maximum image linear height.", + "name": "maxImageLinearHeight", + "type": "size_t" + } + ], + "name": "$x_device_pitched_alloc_exp_properties_t", + "type": "struct", + "version": "1.9" + }, + { + "class": "$xMem", + "decl": "static", + "desc": "Allocate pitched USM memory for images", + "details": [ + "Retrieves pitch for 2D image given the width, height and size in bytes", + "The memory is then allocated using $xMemAllocDevice by providing input size calculated as the returned pitch value multiplied by image height\n", + "The application may call this function from simultaneous threads\n", + "The implementation of this function must be thread-safe.\n", + "The implementation of this function should be lock-free.\n", + "The implementation must support ::ZE_experimental_bindless_image extension.\n" + ], + "hash": "64b9697e4ad99d2f8fc6bb66aea9c3491a82a53ef4f58a56efdff7c2fad4ce7c", + "name": "GetPitchFor2dImage", + "params": [ + { + "desc": "[in] handle of the context object", + "name": "hContext", + "type": "$x_context_handle_t" }, { - "desc": "8-bit boolean", - "name": "$T_VALUE_TYPE_BOOL8", - "value": "4" + "desc": "[in] handle of the device", + "name": "hDevice", + "type": "$x_device_handle_t" }, { - "desc": "C string", - "name": "$T_VALUE_TYPE_STRING", - "value": "5" + "desc": "[in] imageWidth", + "name": "imageWidth", + "type": "size_t" }, { - "desc": "8-bit unsigned-integer", - "name": "$T_VALUE_TYPE_UINT8", - "value": "6" + "desc": "[in] imageHeight", + "name": "imageHeight", + "type": "size_t" }, { - "desc": "16-bit unsigned-integer", - "name": "$T_VALUE_TYPE_UINT16", - "value": "7" + "desc": "[in] Element size in bytes", + "name": "elementSizeInBytes", + "type": "unsigned int" + }, + { + "desc": "[out] rowPitch", + "name": "rowPitch", + "type": "size_t *" } ], - "name": "$t_value_type_t", - "type": "enum" - }, - { - "desc": "Union of values", - "members": [ + "returns": [ { - "desc": "[out] 32-bit unsigned-integer", - "name": "ui32", - "type": "uint32_t" + "$X_RESULT_SUCCESS": [] }, { - "desc": "[out] 32-bit unsigned-integer", - "name": "ui64", - "type": "uint64_t" + "$X_RESULT_ERROR_UNINITIALIZED": [] }, { - "desc": "[out] 32-bit floating-point", - "name": "fp32", - "type": "float" + "$X_RESULT_ERROR_DEVICE_LOST": [] }, { - "desc": "[out] 64-bit floating-point", - "name": "fp64", - "type": "double" + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] }, { - "desc": "[out] 8-bit boolean", - "name": "b8", - "type": "$x_bool_t" - } - ], - "name": "$t_value_t", - "type": "union" - }, - { - "desc": "Typed value", - "members": [ - { - "desc": "[out] type of value", - "name": "type", - "type": "$t_value_type_t" + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] }, { - "desc": "[out] value", - "name": "value", - "type": "$t_value_t" - } - ], - "name": "$t_typed_value_t", - "type": "struct" - }, - { - "category": "Driver", - "desc": "Enables driver instrumentation and dependencies for device metrics", - "name": "$T_ENABLE_METRICS", - "type": "env", - "values": "0, 1" - }, - { - "category": "Driver", - "desc": "Enables driver instrumentation and dependencies for program instrumentation", - "name": "$T_ENABLE_PROGRAM_INSTRUMENTATION", - "type": "env", - "values": "0, 1" - }, - { - "category": "Driver", - "desc": "Enables driver instrumentation and dependencies for program debugging", - "name": "$T_ENABLE_PROGRAM_DEBUGGING", - "type": "env", - "values": "0, 1" - } - ] - }, - { - "header": { - "desc": "Intel $OneApi Level-Zero Tool APIs for Device", - "ordinal": 2, - "type": "header" - }, - "name": "device", - "objects": [ - { - "base": "$xDriver", - "desc": "C++ wrapper for driver instance", - "members": [], - "name": "$tDriver", - "type": "class" - }, - { - "base": "$xDevice", - "desc": "C++ wrapper for device", - "members": [], - "name": "$tDevice", - "type": "class" - } - ] - }, - { - "header": { - "desc": "Intel $OneApi Level-Zero Tool APIs for Context", - "ordinal": 3, - "type": "header" - }, - "name": "context", - "objects": [ - { - "base": "$xContext", - "desc": "C++ wrapper for context", - "members": [], - "name": "$tContext", - "type": "class" - } - ] - }, - { - "header": { - "desc": "Intel $OneApi Level-Zero Tool APIs for Command List", - "ordinal": 5, - "type": "header" - }, - "name": "cmdlist", - "objects": [ - { - "base": "$xCommandList", - "desc": "C++ wrapper for command list", - "members": [], - "name": "$tCommandList", - "type": "class" - } - ] - }, - { - "header": { - "desc": "Intel $OneApi Level-Zero Tool APIs for Module", - "ordinal": 6, - "type": "header" - }, - "name": "module", - "objects": [ - { - "class": "$tModule", - "desc": "Supported module debug info formats.", - "etors": [ - { - "desc": "Format is ELF/DWARF", - "name": "$T_MODULE_DEBUG_INFO_FORMAT_ELF_DWARF", - "value": "0" + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hContext`", + "`nullptr == hDevice`" + ] } ], - "name": "$t_module_debug_info_format_t", - "type": "enum" + "type": "function", + "version": "1.9" }, { - "class": "$tModule", - "desc": "Retrieve debug info from module.", + "class": "$xImage", + "decl": "static", + "desc": "Get bindless device offset for image", "details": [ - "The caller can pass nullptr for pDebugInfo when querying only for size.", - "The implementation will copy the native binary into a buffer supplied by the caller.", - "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The application may call this function from simultaneous threads", + "The implementation of this function must be thread-safe.", + "The implementation of this function should be lock-free.", + "The implementation must support ::ZE_experimental_bindless_image extension." ], - "hash": "8cd9f86cd846e4d9733e3bc32027b2def4b4376df1cb35f5521f692a1ee88ecc", - "name": "GetDebugInfo", + "hash": "1f03cf9c6d99001fb5152d3c9a3c14dfa99199145fa5a5fbf50ea0792c049cc5", + "name": "GetDeviceOffsetExp", "params": [ { - "desc": "[in] handle of the module", - "name": "hModule", - "type": "$t_module_handle_t" - }, - { - "desc": "[in] debug info format requested", - "name": "format", - "type": "$t_module_debug_info_format_t" - }, - { - "desc": "[in,out] size of debug info in bytes", - "name": "pSize", - "type": "size_t*" + "desc": "[in] handle of the image", + "name": "hImage", + "type": "$x_image_handle_t" }, { - "desc": "[in,out][optional] byte pointer to debug info", - "name": "pDebugInfo", - "type": "uint8_t*" + "desc": "[out] bindless device offset for image", + "name": "pDeviceOffset", + "type": "uint64_t*" } ], "returns": [ @@ -63869,100 +72309,81 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hModule`" - ] - }, - { - "$X_RESULT_ERROR_INVALID_ENUMERATION": [ - "`$T_MODULE_DEBUG_INFO_FORMAT_ELF_DWARF < format`" + "`nullptr == hImage`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pSize`" + "`nullptr == pDeviceOffset`" ] } ], - "type": "function" - }, - { - "base": "$xModule", - "desc": "C++ wrapper for module", - "members": [], - "name": "$tModule", - "type": "class" - }, - { - "base": "$xKernel", - "desc": "C++ wrapper for kernel", - "members": [], - "name": "$tKernel", - "type": "class" + "type": "function", + "version": "1.9" } ] }, { "header": { - "desc": "Intel $OneApi Level-Zero Tool APIs for Program Debug", - "ordinal": 1000, - "type": "header" + "desc": "Intel $OneApi Level-Zero Extension for supporting compute graphs.", + "ordinal": 1900, + "type": "header", + "version": "1.9" }, - "name": "debug", + "name": "commandListClone", "objects": [ { - "class": "$tDevice", - "desc": "Supported device debug property flags", - "etors": [ - { - "desc": "the device supports attaching for debug", - "name": "$T_DEVICE_DEBUG_PROPERTY_FLAG_ATTACH", - "value": "$X_BIT(0)" - } - ], - "name": "$t_device_debug_property_flags_t", - "type": "enum" + "desc": "Command List Clone Extension Name", + "name": "$X_COMMAND_LIST_CLONE_EXP_NAME", + "type": "macro", + "value": "\"$X_experimental_command_list_clone\"", + "version": "1.9" }, { - "base": "$t_base_properties_t", - "class": "$tDevice", - "desc": "Device debug properties queried using $tDeviceGetDebugProperties.", - "members": [ - { - "desc": "[in] type of this structure", - "init": "$T_STRUCTURE_TYPE_DEVICE_DEBUG_PROPERTIES", - "name": "stype", - "type": "$t_structure_type_t" - }, + "desc": "Command List Clone Extension Version(s)", + "etors": [ { - "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "void*" + "desc": "version 1.0", + "name": "$X_COMMAND_LIST_CLONE_EXP_VERSION_1_0", + "value": "$X_MAKE_VERSION( 1, 0 )" }, { - "desc": "[out] returns 0 (none) or a valid combination of $t_device_debug_property_flag_t", - "name": "flags", - "type": "$t_device_debug_property_flags_t" + "desc": "latest known version", + "name": "$X_COMMAND_LIST_CLONE_EXP_VERSION_CURRENT", + "value": "$X_MAKE_VERSION( 1, 0 )" } ], - "name": "$t_device_debug_properties_t", - "type": "struct" + "name": "$x_command_list_clone_exp_version_t", + "type": "enum", + "version": "1.9" }, { - "class": "$tDevice", - "desc": "Retrieves debug properties of the device.", - "hash": "c3d026b82778fe2460ab811b9c2e883dd0be74d7bdcb48098e3fe0d9be5ea054", - "name": "GetDebugProperties", + "class": "$xCommandList", + "decl": "static", + "desc": "Creates a command list as the clone of another command list.", + "details": [ + "The source command list must be created with the $X_COMMAND_LIST_FLAG_EXP_CLONEABLE flag.", + "The source command list must be closed prior to cloning.", + "The source command list may be cloned while it is running on the device.", + "The cloned command list inherits all properties of the source command list.", + "The cloned command list must be destroyed prior to the source command list.", + "The application must only use the command list for the device, or its sub-devices, which was provided during creation.", + "The application may call this function from simultaneous threads.", + "The implementation of this function must be thread-safe." + ], + "hash": "6e959078748eb9317921759dd20b827a809d81c7a9b6243599dc43a8f1e854cd", + "name": "CreateCloneExp", + "ordinal": "0", "params": [ { - "desc": "[in] device handle", - "name": "hDevice", - "type": "$t_device_handle_t" + "desc": "[in] handle to source command list (the command list to clone)", + "name": "hCommandList", + "type": "$x_command_list_handle_t" }, { - "desc": "[in,out] query result for debug properties", - "name": "pDebugProperties", - "type": "$t_device_debug_properties_t*" + "desc": "[out] pointer to handle of the cloned command list", + "name": "phClonedCommandList", + "type": "$x_command_list_handle_t*" } ], "returns": [ @@ -63983,54 +72404,95 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDevice`" + "`nullptr == hCommandList`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pDebugProperties`" + "`nullptr == phClonedCommandList`" ] } ], - "type": "function" + "type": "function", + "version": "1.9" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Extension for supporting compute graphs.", + "ordinal": 1900, + "type": "header", + "version": "1.9" + }, + "name": "immediateCommandListAppend", + "objects": [ + { + "desc": "Immediate Command List Append Extension Name", + "name": "$X_IMMEDIATE_COMMAND_LIST_APPEND_EXP_NAME", + "type": "macro", + "value": "\"$X_experimental_immediate_command_list_append\"", + "version": "1.9" }, { - "class": "$tDebug", - "desc": "Debug configuration provided to $tDebugAttach", - "members": [ + "desc": "Immediate Command List Append Extension Version(s)", + "etors": [ { - "desc": "[in] the host process identifier", - "name": "pid", - "type": "uint32_t" + "desc": "version 1.0", + "name": "$X_IMMEDIATE_COMMAND_LIST_APPEND_EXP_VERSION_1_0", + "value": "$X_MAKE_VERSION( 1, 0 )" + }, + { + "desc": "latest known version", + "name": "$X_IMMEDIATE_COMMAND_LIST_APPEND_EXP_VERSION_CURRENT", + "value": "$X_MAKE_VERSION( 1, 0 )" } ], - "name": "$t_debug_config_t", - "type": "struct" + "name": "$x_immediate_command_list_append_exp_version_t", + "type": "enum", + "version": "1.9" }, { - "class": "$tDebug", - "decl": "static", - "desc": "Attach to a device.", + "class": "$xCommandList", + "desc": "Appends command lists to dispatch from an immediate command list.", "details": [ - "The device must be enabled for debug; see $xsSchedulerSetComputeUnitDebugMode." + "The application must call this function only with command lists created with $xCommandListCreateImmediate.", + "The command lists passed to this function in the `phCommandLists` argument must be regular command lists (i.e. not immediate command lists).", + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." ], - "hash": "74b0dd833de78ddc67ac82d65994001fac9a4efcc3faf3db5862b8824404bfe6", - "name": "Attach", + "hash": "eb1dc341b9622faf5a33a8825ec784019fb23a518d32d9a1ab55e02e12593ee2", + "name": "ImmediateAppendCommandListsExp", "params": [ { - "desc": "[in] device handle", - "name": "hDevice", - "type": "$t_device_handle_t" + "desc": "[in] handle of the immediate command list", + "name": "hCommandListImmediate", + "type": "$x_command_list_handle_t" }, { - "desc": "[in] the debug configuration", - "name": "config", - "type": "const $t_debug_config_t*" + "desc": "[in] number of command lists", + "name": "numCommandLists", + "type": "uint32_t" }, { - "desc": "[out] debug session handle", - "name": "phDebug", - "type": "$t_debug_session_handle_t*" + "desc": "[in][range(0, numCommandLists)] handles of command lists", + "name": "phCommandLists", + "type": "$x_command_list_handle_t*" + }, + { + "desc": "[in][optional] handle of the event to signal on completion\n - if not null, this event is signaled after the completion of all appended command lists\n", + "name": "hSignalEvent", + "type": "$x_event_handle_t" + }, + { + "desc": "[in][optional] number of events to wait on before executing appended command lists; must be 0 if nullptr == phWaitEvents", + "name": "numWaitEvents", + "type": "uint32_t" + }, + { + "desc": "[in][optional][range(0, numWaitEvents)] handle of the events to wait on before executing appended command lists.\n - if not null, all wait events must be satisfied prior to the start of any appended command list(s)\n", + "name": "phWaitEvents", + "type": "$x_event_handle_t*" } ], "returns": [ @@ -64051,328 +72513,459 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDevice`" + "`nullptr == hCommandListImmediate`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == config`", - "`nullptr == phDebug`" + "`nullptr == phCommandLists`" ] - }, + } + ], + "type": "function", + "version": "1.9" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Extension for supporting compute graphs with dynamic properties.", + "ordinal": 1900, + "type": "header", + "version": "1.9" + }, + "name": "mutableCommandList", + "objects": [ + { + "desc": "Mutable Command List Extension Name", + "name": "$X_MUTABLE_COMMAND_LIST_EXP_NAME", + "type": "macro", + "value": "\"$X_experimental_mutable_command_list\"", + "version": "1.9" + }, + { + "desc": "Mutable Command List Extension Version(s)", + "etors": [ { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "attaching to this device is not supported" - ] + "desc": "version 1.0", + "name": "$X_MUTABLE_COMMAND_LIST_EXP_VERSION_1_0", + "value": "$X_MAKE_VERSION( 1, 0 )" }, { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "caller does not have sufficient permissions" - ] + "desc": "version 1.1", + "name": "$X_MUTABLE_COMMAND_LIST_EXP_VERSION_1_1", + "value": "$X_MAKE_VERSION( 1, 1 )", + "version": "1.10" }, { - "$X_RESULT_ERROR_NOT_AVAILABLE": [ - "a debugger is already attached" - ] + "desc": "latest known version", + "name": "$X_MUTABLE_COMMAND_LIST_EXP_VERSION_CURRENT", + "value": "$X_MAKE_VERSION( 1, 1 )" } ], - "type": "function" + "name": "$x_mutable_command_list_exp_version_t", + "type": "enum", + "version": "1.9" }, { - "class": "$tDebug", - "desc": "Close a debug session.", - "hash": "93beca3b9d167f52e7252bb79962171d25e1face643e2fdc0b256ce88cfd1500", - "name": "Detach", - "params": [ + "class": "$xCommandList", + "desc": "Mutable command flags", + "etors": [ { - "desc": "[in][release] debug session handle", - "name": "hDebug", - "type": "$t_debug_session_handle_t" - } - ], - "returns": [ + "desc": "kernel arguments", + "name": "$X_MUTABLE_COMMAND_EXP_FLAG_KERNEL_ARGUMENTS", + "value": "$X_BIT(0)" + }, { - "$X_RESULT_SUCCESS": [] + "desc": "kernel group count", + "name": "$X_MUTABLE_COMMAND_EXP_FLAG_GROUP_COUNT", + "value": "$X_BIT(1)" }, { - "$X_RESULT_ERROR_UNINITIALIZED": [] + "desc": "kernel group size", + "name": "$X_MUTABLE_COMMAND_EXP_FLAG_GROUP_SIZE", + "value": "$X_BIT(2)" }, { - "$X_RESULT_ERROR_DEVICE_LOST": [] + "desc": "kernel global offset", + "name": "$X_MUTABLE_COMMAND_EXP_FLAG_GLOBAL_OFFSET", + "value": "$X_BIT(3)" }, { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "desc": "command signal event", + "name": "$X_MUTABLE_COMMAND_EXP_FLAG_SIGNAL_EVENT", + "value": "$X_BIT(4)" }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + "desc": "command wait events", + "name": "$X_MUTABLE_COMMAND_EXP_FLAG_WAIT_EVENTS", + "value": "$X_BIT(5)" }, { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDebug`" - ] + "desc": "command kernel", + "name": "$X_MUTABLE_COMMAND_EXP_FLAG_KERNEL_INSTRUCTION", + "value": "$X_BIT(6)", + "version": "1.10" + }, + { + "desc": "graph arguments", + "name": "$X_MUTABLE_COMMAND_EXP_FLAG_GRAPH_ARGUMENTS", + "value": "$X_BIT(7)", + "version": "1.10" } ], - "type": "function" + "name": "$x_mutable_command_exp_flags_t", + "type": "enum", + "version": "1.9" }, { - "class": "$tDebug", - "desc": "Supported debug event flags.", + "base": "$x_base_desc_t", + "class": "$xCommandList", + "desc": "Mutable command identifier descriptor", + "members": [ + { + "desc": "[in] type of this structure", + "init": "$X_STRUCTURE_TYPE_MUTABLE_COMMAND_ID_EXP_DESC", + "name": "stype", + "type": "$x_structure_type_t" + }, + { + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, + { + "desc": "[in] mutable command flags.\n - must be 0 (default, equivalent to setting all flags bar kernel instruction), or a valid combination of $x_mutable_command_exp_flag_t\n - in order to include kernel instruction mutation, $X_MUTABLE_COMMAND_EXP_FLAG_KERNEL_INSTRUCTION must be explictly included\n", + "name": "flags", + "type": "$x_mutable_command_exp_flags_t" + } + ], + "name": "$x_mutable_command_id_exp_desc_t", + "type": "struct", + "version": "1.9" + }, + { + "class": "$xCommandList", + "desc": "Mutable command list flags", "etors": [ { - "desc": "The event needs to be acknowledged by calling $tDebugAcknowledgeEvent.", - "name": "$T_DEBUG_EVENT_FLAG_NEED_ACK", + "desc": "reserved", + "name": "$X_MUTABLE_COMMAND_LIST_EXP_FLAG_RESERVED", "value": "$X_BIT(0)" } ], - "name": "$t_debug_event_flags_t", - "type": "enum" + "name": "$x_mutable_command_list_exp_flags_t", + "type": "enum", + "version": "1.9" }, { - "class": "$tDebug", - "desc": "Supported debug event types.", - "etors": [ + "base": "$x_base_properties_t", + "class": "$xCommandList", + "desc": "Mutable command list properties", + "members": [ { - "desc": "The event is invalid", - "name": "$T_DEBUG_EVENT_TYPE_INVALID", - "value": "0" + "desc": "[in] type of this structure", + "init": "$X_STRUCTURE_TYPE_MUTABLE_COMMAND_LIST_EXP_PROPERTIES", + "name": "stype", + "type": "$x_structure_type_t" }, { - "desc": "The tool was detached", - "name": "$T_DEBUG_EVENT_TYPE_DETACHED", - "value": "1" + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" }, { - "desc": "The debuggee process created command queues on the device", - "name": "$T_DEBUG_EVENT_TYPE_PROCESS_ENTRY", - "value": "2" + "desc": "[out] mutable command list flags", + "name": "mutableCommandListFlags", + "type": "$x_mutable_command_list_exp_flags_t" }, { - "desc": "The debuggee process destroyed all command queues on the device", - "name": "$T_DEBUG_EVENT_TYPE_PROCESS_EXIT", - "value": "3" - }, + "desc": "[out] mutable command flags", + "name": "mutableCommandFlags", + "type": "$x_mutable_command_exp_flags_t" + } + ], + "name": "$x_mutable_command_list_exp_properties_t", + "type": "struct", + "version": "1.9" + }, + { + "base": "$x_base_desc_t", + "class": "$xCommandList", + "desc": "Mutable command list descriptor", + "members": [ { - "desc": "An in-memory module was loaded onto the device", - "name": "$T_DEBUG_EVENT_TYPE_MODULE_LOAD", - "value": "4" + "desc": "[in] type of this structure", + "init": "$X_STRUCTURE_TYPE_MUTABLE_COMMAND_LIST_EXP_DESC", + "name": "stype", + "type": "$x_structure_type_t" }, { - "desc": "An in-memory module is about to get unloaded from the device", - "name": "$T_DEBUG_EVENT_TYPE_MODULE_UNLOAD", - "value": "5" - }, - { - "desc": "The thread stopped due to a device exception", - "name": "$T_DEBUG_EVENT_TYPE_THREAD_STOPPED", - "value": "6" - }, - { - "desc": "The thread is not available to be stopped", - "name": "$T_DEBUG_EVENT_TYPE_THREAD_UNAVAILABLE", - "value": "7" + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" }, { - "desc": "A page request could not be completed on the device", - "name": "$T_DEBUG_EVENT_TYPE_PAGE_FAULT", - "value": "8", - "version": "1.1" + "desc": "[in] mutable command list flags.\n - must be 0 (default) or a valid combination of $x_mutable_command_list_exp_flag_t\n", + "name": "flags", + "type": "$x_mutable_command_list_exp_flags_t" } ], - "name": "$t_debug_event_type_t", - "type": "enum" + "name": "$x_mutable_command_list_exp_desc_t", + "type": "struct", + "version": "1.9" }, { - "class": "$tDebug", - "desc": "Supported debug detach reasons.", - "etors": [ + "base": "$x_base_desc_t", + "class": "$xCommandList", + "desc": "Mutable commands descriptor", + "members": [ { - "desc": "The detach reason is not valid", - "name": "$T_DEBUG_DETACH_REASON_INVALID", - "value": "0" + "desc": "[in] type of this structure", + "init": "$X_STRUCTURE_TYPE_MUTABLE_COMMANDS_EXP_DESC", + "name": "stype", + "type": "$x_structure_type_t" }, { - "desc": "The host process exited", - "name": "$T_DEBUG_DETACH_REASON_HOST_EXIT", - "value": "1" - } - ], - "name": "$t_debug_detach_reason_t", - "type": "enum" - }, - { - "class": "$tDebug", - "desc": "Event information for $T_DEBUG_EVENT_TYPE_DETACHED", - "members": [ + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, { - "desc": "[out] the detach reason", - "name": "reason", - "type": "$t_debug_detach_reason_t" + "desc": "[in] must be 0, this field is reserved for future use", + "name": "flags", + "type": "uint32_t" } ], - "name": "$t_debug_event_info_detached_t", - "type": "struct" + "name": "$x_mutable_commands_exp_desc_t", + "type": "struct", + "version": "1.9" }, { - "class": "$tDebug", - "desc": "Event information for $T_DEBUG_EVENT_TYPE_MODULE_LOAD and $T_DEBUG_EVENT_TYPE_MODULE_UNLOAD", + "base": "$x_base_desc_t", + "class": "$xCommandList", + "desc": "Mutable kernel argument descriptor", "members": [ { - "desc": "[out] the module format", - "name": "format", - "type": "$t_module_debug_info_format_t" + "desc": "[in] type of this structure", + "init": "$X_STRUCTURE_TYPE_MUTABLE_KERNEL_ARGUMENT_EXP_DESC", + "name": "stype", + "type": "$x_structure_type_t" }, { - "desc": "[out] the begin address of the in-memory module (inclusive)", - "name": "moduleBegin", - "type": "uint64_t" + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" }, { - "desc": "[out] the end address of the in-memory module (exclusive)", - "name": "moduleEnd", + "desc": "[in] command identifier", + "name": "commandId", "type": "uint64_t" }, { - "desc": "[out] the load address of the module on the device", - "name": "load", - "type": "uint64_t" + "desc": "[in] kernel argument index", + "name": "argIndex", + "type": "uint32_t" + }, + { + "desc": "[in] kernel argument size", + "name": "argSize", + "type": "size_t" + }, + { + "desc": "[in] pointer to kernel argument value", + "name": "pArgValue", + "type": "const void*" } ], - "name": "$t_debug_event_info_module_t", - "type": "struct" + "name": "$x_mutable_kernel_argument_exp_desc_t", + "type": "struct", + "version": "1.9" }, { - "class": "$tDebug", - "desc": "Event information for $T_DEBUG_EVENT_TYPE_THREAD_STOPPED and $T_DEBUG_EVENT_TYPE_THREAD_UNAVAILABLE", + "base": "$x_base_desc_t", + "class": "$xCommandList", + "desc": "Mutable kernel group count descriptor", "members": [ { - "desc": "[out] the stopped/unavailable thread", - "name": "thread", - "type": "$x_device_thread_t" - } - ], - "name": "$t_debug_event_info_thread_stopped_t", - "type": "struct" - }, - { - "class": "$tDebug", - "desc": "Page fault reasons.", - "etors": [ + "desc": "[in] type of this structure", + "init": "$X_STRUCTURE_TYPE_MUTABLE_GROUP_COUNT_EXP_DESC", + "name": "stype", + "type": "$x_structure_type_t" + }, { - "desc": "The page fault reason is not valid", - "name": "$T_DEBUG_PAGE_FAULT_REASON_INVALID", - "value": "0" + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" }, { - "desc": "The address is not mapped", - "name": "$T_DEBUG_PAGE_FAULT_REASON_MAPPING_ERROR", - "value": "1" + "desc": "[in] command identifier", + "name": "commandId", + "type": "uint64_t" }, { - "desc": "Invalid access permissions", - "name": "$T_DEBUG_PAGE_FAULT_REASON_PERMISSION_ERROR", - "value": "2" + "desc": "[in] pointer to group count", + "name": "pGroupCount", + "type": "const $x_group_count_t*" } ], - "name": "$t_debug_page_fault_reason_t", - "type": "enum", - "version": "1.1" + "name": "$x_mutable_group_count_exp_desc_t", + "type": "struct", + "version": "1.9" }, { - "class": "$tDebug", - "desc": "Event information for $T_DEBUG_EVENT_TYPE_PAGE_FAULT", + "base": "$x_base_desc_t", + "class": "$xCommandList", + "desc": "Mutable kernel group size descriptor", "members": [ { - "desc": "[out] the faulting address", - "name": "address", - "type": "uint64_t" + "desc": "[in] type of this structure", + "init": "$X_STRUCTURE_TYPE_MUTABLE_GROUP_SIZE_EXP_DESC", + "name": "stype", + "type": "$x_structure_type_t" }, { - "desc": "[out] the alignment mask", - "name": "mask", + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, + { + "desc": "[in] command identifier", + "name": "commandId", "type": "uint64_t" }, { - "desc": "[out] the page fault reason", - "name": "reason", - "type": "$t_debug_page_fault_reason_t" + "desc": "[in] group size for X dimension to use for the kernel", + "name": "groupSizeX", + "type": "uint32_t" + }, + { + "desc": "[in] group size for Y dimension to use for the kernel", + "name": "groupSizeY", + "type": "uint32_t" + }, + { + "desc": "[in] group size for Z dimension to use for the kernel", + "name": "groupSizeZ", + "type": "uint32_t" } ], - "name": "$t_debug_event_info_page_fault_t", + "name": "$x_mutable_group_size_exp_desc_t", "type": "struct", - "version": "1.1" + "version": "1.9" }, { - "class": "$tDebug", - "desc": "Event type-specific information", + "base": "$x_base_desc_t", + "class": "$xCommandList", + "desc": "Mutable kernel global offset descriptor", "members": [ { - "desc": "[out] type == $T_DEBUG_EVENT_TYPE_DETACHED", - "name": "detached", - "type": "$t_debug_event_info_detached_t" + "desc": "[in] type of this structure", + "init": "$X_STRUCTURE_TYPE_MUTABLE_GLOBAL_OFFSET_EXP_DESC", + "name": "stype", + "type": "$x_structure_type_t" }, { - "desc": "[out] type == $T_DEBUG_EVENT_TYPE_MODULE_LOAD or $T_DEBUG_EVENT_TYPE_MODULE_UNLOAD", - "name": "module", - "type": "$t_debug_event_info_module_t" + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" }, { - "desc": "[out] type == $T_DEBUG_EVENT_TYPE_THREAD_STOPPED or $T_DEBUG_EVENT_TYPE_THREAD_UNAVAILABLE", - "name": "thread", - "type": "$t_debug_event_info_thread_stopped_t" + "desc": "[in] command identifier", + "name": "commandId", + "type": "uint64_t" }, { - "desc": "[out] type == $T_DEBUG_EVENT_TYPE_PAGE_FAULT", - "name": "page_fault", - "type": "$t_debug_event_info_page_fault_t", - "version": "1.1" + "desc": "[in] global offset for X dimension to use for this kernel", + "name": "offsetX", + "type": "uint32_t" + }, + { + "desc": "[in] global offset for Y dimension to use for this kernel", + "name": "offsetY", + "type": "uint32_t" + }, + { + "desc": "[in] global offset for Z dimension to use for this kernel", + "name": "offsetZ", + "type": "uint32_t" } ], - "name": "$t_debug_event_info_t", - "type": "union" + "name": "$x_mutable_global_offset_exp_desc_t", + "type": "struct", + "version": "1.9" }, { - "class": "$tDebug", - "desc": "A debug event on the device.", + "base": "$x_base_desc_t", + "class": "$xCommandList", + "desc": "Mutable graph argument descriptor", "members": [ { - "desc": "[out] the event type", - "name": "type", - "type": "$t_debug_event_type_t" + "desc": "[in] type of this structure", + "init": "$X_STRUCTURE_TYPE_MUTABLE_GRAPH_ARGUMENT_EXP_DESC", + "name": "stype", + "type": "$x_structure_type_t" }, { - "desc": "[out] returns 0 (none) or a combination of $t_debug_event_flag_t", - "name": "flags", - "type": "$t_debug_event_flags_t" + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" }, { - "desc": "[out] event type specific information", - "name": "info", - "type": "$t_debug_event_info_t" + "desc": "[in] command identifier", + "name": "commandId", + "type": "uint64_t" + }, + { + "desc": "[in] graph argument index", + "name": "argIndex", + "type": "uint32_t" + }, + { + "desc": "[in] pointer to graph argument value", + "name": "pArgValue", + "type": "const void*" } ], - "name": "$t_debug_event_t", - "type": "struct" + "name": "$x_mutable_graph_argument_exp_desc_t", + "type": "struct", + "version": "1.10" }, { - "class": "$tDebug", - "desc": "Read the topmost debug event.", - "hash": "fd2eafa037418a5cbc68fa5bf7a0fe66ada619637cd7ce2a926e5a71032fc51b", - "name": "ReadEvent", + "class": "$xCommandList", + "desc": "Returns a unique command identifier for the next command to be appended to a command list.", + "details": [ + "This function may only be called for a mutable command list.", + "This function may not be called on a closed command list.", + "This function may be called from simultaneous threads with the same command list handle.", + "The implementation of this function should be lock-free." + ], + "hash": "28875c3d2d60a7e128e2c5e59a8f61ecbcc89611d9e4acfffdb858380e4108c1", + "name": "GetNextCommandIdExp", "params": [ { - "desc": "[in] debug session handle", - "name": "hDebug", - "type": "$t_debug_session_handle_t" + "desc": "[in] handle of the command list", + "name": "hCommandList", + "type": "$x_command_list_handle_t" }, { - "desc": "[in] if non-zero, then indicates the maximum time (in milliseconds) to yield before returning $X_RESULT_SUCCESS or $X_RESULT_NOT_READY;\nif zero, then immediately returns the status of the event;\nif `UINT64_MAX`, then function will not return until complete or device is lost.\nDue to external dependencies, timeout may be rounded to the closest value allowed by the accuracy of those dependencies.\n", - "name": "timeout", - "type": "uint64_t" + "desc": "[in] pointer to mutable command identifier descriptor", + "name": "desc", + "type": "const $x_mutable_command_id_exp_desc_t*" }, { - "desc": "[in,out] a pointer to a $t_debug_event_t.", - "name": "event", - "type": "$t_debug_event_t*" + "desc": "[out] pointer to mutable command identifier to be written", + "name": "pCommandId", + "type": "uint64_t*" } ], "returns": [ @@ -64393,37 +72986,60 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDebug`" + "`nullptr == hCommandList`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == event`" + "`nullptr == desc`", + "`nullptr == pCommandId`" ] }, { - "$X_RESULT_NOT_READY": [ - "the timeout expired" + "$X_RESULT_ERROR_INVALID_ENUMERATION": [ + "`0xff < desc->flags`" ] } ], - "type": "function" + "type": "function", + "version": "1.9" }, { - "class": "$tDebug", - "desc": "Acknowledge a debug event.", - "hash": "2dbda584161c89afdaa2f2d7e25811fa56eb13db68b335e167373e2d1db654a2", - "name": "AcknowledgeEvent", + "class": "$xCommandList", + "desc": "Returns a unique command identifier for the next command to be appended to a command list. Provides possible kernel handles for kernel mutation when $X_MUTABLE_COMMAND_EXP_FLAG_KERNEL_INSTRUCTION flag is present.", + "details": [ + "This function may only be called for a mutable command list.", + "This function may not be called on a closed command list.", + "This function may be called from simultaneous threads with the same command list handle.", + "The implementation of this function should be lock-free." + ], + "hash": "02bc9e0e195f5db27434ca8289d060761dc869d97a04d925c1631786b9369b35", + "name": "GetNextCommandIdWithKernelsExp", "params": [ { - "desc": "[in] debug session handle", - "name": "hDebug", - "type": "$t_debug_session_handle_t" + "desc": "[in] handle of the command list", + "name": "hCommandList", + "type": "$x_command_list_handle_t" }, { - "desc": "[in] a pointer to a $t_debug_event_t.", - "name": "event", - "type": "const $t_debug_event_t*" + "desc": "[in][out] pointer to mutable command identifier descriptor", + "name": "desc", + "type": "const $x_mutable_command_id_exp_desc_t*" + }, + { + "desc": "[in][optional] number of entries on phKernels list", + "name": "numKernels", + "type": "uint32_t" + }, + { + "desc": "[in][optional][range(0, numKernels)] list of kernels that user can switch between using $xCommandListUpdateMutableCommandKernelsExp call", + "name": "phKernels", + "type": "$x_kernel_handle_t*" + }, + { + "desc": "[out] pointer to mutable command identifier to be written", + "name": "pCommandId", + "type": "uint64_t*" } ], "returns": [ @@ -64444,32 +73060,46 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDebug`" + "`nullptr == hCommandList`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == event`" + "`nullptr == desc`", + "`nullptr == pCommandId`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_ENUMERATION": [ + "`0xff < desc->flags`" ] } ], - "type": "function" + "type": "function", + "version": "1.10" }, { - "class": "$tDebug", - "desc": "Interrupt device threads.", - "hash": "97d57d2337376beea4fcf5647996d6a695c408b43c4402bc50cb7f1f849100c8", - "name": "Interrupt", + "class": "$xCommandList", + "desc": "Updates mutable commands.", + "details": [ + "This function may only be called for a mutable command list.", + "The application must synchronize mutable command list execution before calling this function.", + "The application must close a mutable command list after completing all updates.", + "This function must not be called from simultaneous threads with the same command list handle.", + "The implementation of this function should be lock-free." + ], + "hash": "af5c4a23fd99e2938a356fc1e4a2c0a44f5f8fb2a7200d4f9a01a292b75c3b68", + "name": "UpdateMutableCommandsExp", "params": [ { - "desc": "[in] debug session handle", - "name": "hDebug", - "type": "$t_debug_session_handle_t" + "desc": "[in] handle of the command list", + "name": "hCommandList", + "type": "$x_command_list_handle_t" }, { - "desc": "[in] the thread to interrupt", - "name": "thread", - "type": "$x_device_thread_t" + "desc": "[in] pointer to mutable commands descriptor; multiple descriptors may be chained via `pNext` member", + "name": "desc", + "type": "const $x_mutable_commands_exp_desc_t*" } ], "returns": [ @@ -64490,32 +73120,51 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDebug`" + "`nullptr == hCommandList`" ] }, { - "$X_RESULT_ERROR_NOT_AVAILABLE": [ - "the thread is already stopped or unavailable" + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == desc`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_ARGUMENT": [ + "Invalid kernel argument or not matching update descriptor provided" ] } ], - "type": "function" + "type": "function", + "version": "1.9" }, { - "class": "$tDebug", - "desc": "Resume device threads.", - "hash": "55072197ef54909f2ff6ecbf176fccb95dbad2a2266b806d585e46715fb65173", - "name": "Resume", + "class": "$xCommandList", + "desc": "Updates the signal event for a mutable command in a mutable command list.", + "details": [ + "This function may only be called for a mutable command list.", + "The type, scope and flags of the signal event must match those of the source command.", + "The application must synchronize mutable command list execution before calling this function.", + "The application must close a mutable command list after completing all updates.", + "This function must not be called from simultaneous threads with the same command list handle.", + "The implementation of this function should be lock-free." + ], + "hash": "5455be497bf5c99fa40bc3fc88726bbf6368edb78275288662f6c9b20d562840", + "name": "UpdateMutableCommandSignalEventExp", "params": [ { - "desc": "[in] debug session handle", - "name": "hDebug", - "type": "$t_debug_session_handle_t" + "desc": "[in] handle of the command list", + "name": "hCommandList", + "type": "$x_command_list_handle_t" }, { - "desc": "[in] the thread to resume", - "name": "thread", - "type": "$x_device_thread_t" + "desc": "[in] command identifier", + "name": "commandId", + "type": "uint64_t" + }, + { + "desc": "[in][optional] handle of the event to signal on completion", + "name": "hSignalEvent", + "type": "$x_event_handle_t" } ], "returns": [ @@ -64536,99 +73185,49 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDebug`" - ] - }, - { - "$X_RESULT_ERROR_NOT_AVAILABLE": [ - "the thread is already running or unavailable" + "`nullptr == hCommandList`" ] } ], - "type": "function" - }, - { - "class": "$tDebug", - "desc": "Supported device memory space types.", - "etors": [ - { - "desc": "default memory space (attribute may be omitted)", - "name": "$T_DEBUG_MEMORY_SPACE_TYPE_DEFAULT", - "value": "0" - }, - { - "desc": "shared local memory space (GPU-only)", - "name": "$T_DEBUG_MEMORY_SPACE_TYPE_SLM", - "value": "1" - } - ], - "name": "$t_debug_memory_space_type_t", - "type": "enum" - }, - { - "base": "$t_base_desc_t", - "class": "$tDebug", - "desc": "Device memory space descriptor", - "members": [ - { - "desc": "[in] type of this structure", - "init": "$T_STRUCTURE_TYPE_DEBUG_MEMORY_SPACE_DESC", - "name": "stype", - "type": "$t_structure_type_t" - }, - { - "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "const void*" - }, - { - "desc": "[in] type of memory space", - "name": "type", - "type": "$t_debug_memory_space_type_t" - }, - { - "desc": "[in] the virtual address within the memory space", - "name": "address", - "type": "uint64_t" - } - ], - "name": "$t_debug_memory_space_desc_t", - "type": "struct" + "type": "function", + "version": "1.9" }, { - "class": "$tDebug", - "desc": "Read memory.", + "class": "$xCommandList", + "desc": "Updates the wait events for a mutable command in a mutable command list.", "details": [ - "The thread identifier 'all' can be used for accessing the default memory space, e.g. for setting breakpoints." + "This function may only be called for a mutable command list.", + "The number of wait events must match that of the source command.", + "The type, scope and flags of the wait events must match those of the source command.", + "Passing `nullptr` as the wait events will update the command to not wait on any events prior to dispatch.", + "Passing `nullptr` as an event on event wait list will remove event dependency from this wait list slot.", + "The application must synchronize mutable command list execution before calling this function.", + "The application must close a mutable command list after completing all updates.", + "This function must not be called from simultaneous threads with the same command list handle.", + "The implementation of this function should be lock-free." ], - "hash": "32d1103937128d0fdc73b46974a88ff0502d29fdd3bdbe361a6819eea9e2af36", - "name": "ReadMemory", + "hash": "bd38d0ceddc1fa04f51ef3570b94fd67616e9425e482dda215793797a7a05ad8", + "name": "UpdateMutableCommandWaitEventsExp", "params": [ { - "desc": "[in] debug session handle", - "name": "hDebug", - "type": "$t_debug_session_handle_t" - }, - { - "desc": "[in] the thread identifier.", - "name": "thread", - "type": "$x_device_thread_t" + "desc": "[in] handle of the command list", + "name": "hCommandList", + "type": "$x_command_list_handle_t" }, { - "desc": "[in] memory space descriptor", - "name": "desc", - "type": "const $t_debug_memory_space_desc_t*" + "desc": "[in] command identifier", + "name": "commandId", + "type": "uint64_t" }, { - "desc": "[in] the number of bytes to read", - "name": "size", - "type": "size_t" + "desc": "[in][optional] the number of wait events", + "name": "numWaitEvents", + "type": "uint32_t" }, { - "desc": "[in,out] a buffer to hold a copy of the memory", - "name": "buffer", - "type": "void*" + "desc": "[in][optional][range(0, numWaitEvents)] handle of the events to wait on before launching", + "name": "phWaitEvents", + "type": "$x_event_handle_t*" } ], "returns": [ @@ -64649,62 +73248,52 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDebug`" - ] - }, - { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == desc`", - "`nullptr == buffer`" - ] - }, - { - "$X_RESULT_ERROR_INVALID_ENUMERATION": [ - "`$T_DEBUG_MEMORY_SPACE_TYPE_SLM < desc->type`" + "`nullptr == hCommandList`" ] }, { - "$X_RESULT_ERROR_NOT_AVAILABLE": [ - "the thread is running or unavailable", - "the memory cannot be accessed from the supplied thread" + "$X_RESULT_ERROR_INVALID_SIZE": [ + "The `numWaitEvents` parameter does not match that of the original command." ] } ], - "type": "function" + "type": "function", + "version": "1.9" }, { - "class": "$tDebug", - "desc": "Write memory.", + "class": "$xCommandList", + "desc": "Updates the kernel for a mutable command in a mutable command list.", "details": [ - "The thread identifier 'all' can be used for accessing the default memory space, e.g. for setting breakpoints." + "This function may only be called for a mutable command list.", + "The kernel handle must be from the provided list for given command id.", + "The application must synchronize mutable command list execution before calling this function.", + "The application must close a mutable command list after completing all updates.", + "This function must not be called from simultaneous threads with the same command list handle.", + "This function must be called before updating kernel arguments and dispatch parameters, when kernel is mutated.", + "The implementation of this function should be lock-free." ], - "hash": "9f56cdf99c4ac640421569f841d86c1e915a0929508bb7afe8a44b4a221a93a1", - "name": "WriteMemory", + "hash": "11a9c042cb0ca1a81b887cb422885a133f4f45b7da7bcaf1f1174a8356959c7d", + "name": "UpdateMutableCommandKernelsExp", "params": [ { - "desc": "[in] debug session handle", - "name": "hDebug", - "type": "$t_debug_session_handle_t" - }, - { - "desc": "[in] the thread identifier.", - "name": "thread", - "type": "$x_device_thread_t" + "desc": "[in] handle of the command list", + "name": "hCommandList", + "type": "$x_command_list_handle_t" }, { - "desc": "[in] memory space descriptor", - "name": "desc", - "type": "const $t_debug_memory_space_desc_t*" + "desc": "[in] the number of kernels to update", + "name": "numKernels", + "type": "uint32_t" }, { - "desc": "[in] the number of bytes to write", - "name": "size", - "type": "size_t" + "desc": "[in][range(0, numKernels)] command identifier", + "name": "pCommandId", + "type": "uint64_t*" }, { - "desc": "[in] a buffer holding the pattern to write", - "name": "buffer", - "type": "const void*" + "desc": "[in][range(0, numKernels)] handle of the kernel for a command identifier to switch to", + "name": "phKernels", + "type": "$x_kernel_handle_t*" } ], "returns": [ @@ -64725,55 +73314,237 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDebug`" + "`nullptr == hCommandList`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == desc`", - "`nullptr == buffer`" + "`nullptr == pCommandId`", + "`nullptr == phKernels`" ] }, { - "$X_RESULT_ERROR_INVALID_ENUMERATION": [ - "`$T_DEBUG_MEMORY_SPACE_TYPE_SLM < desc->type`" - ] - }, - { - "$X_RESULT_ERROR_NOT_AVAILABLE": [ - "the thread is running or unavailable", - "the memory cannot be accessed from the supplied thread" + "$X_RESULT_ERROR_INVALID_KERNEL_HANDLE": [ + "Invalid kernel handle provided for the mutation kernel instruction operation." ] } ], - "type": "function" + "type": "function", + "version": "1.10" + } + ] + } + ], + [ + { + "header": { + "desc": "Intel $OneApi Level-Zero Tool API common types", + "ordinal": 0, + "type": "header" + }, + "name": "common", + "objects": [ + { + "alias": "$x_driver_handle_t", + "class": "$tDriver", + "desc": "Handle to a driver instance", + "name": "$t_driver_handle_t", + "type": "handle" + }, + { + "alias": "$x_device_handle_t", + "class": "$tDevice", + "desc": "Handle of device object", + "name": "$t_device_handle_t", + "type": "handle" + }, + { + "alias": "$x_context_handle_t", + "class": "$tContext", + "desc": "Handle of context object", + "name": "$t_context_handle_t", + "type": "handle" + }, + { + "alias": "$x_command_list_handle_t", + "class": "$tCommandList", + "desc": "Handle of command list object", + "name": "$t_command_list_handle_t", + "type": "handle" + }, + { + "alias": "$x_module_handle_t", + "class": "$tModule", + "desc": "Handle of module object", + "name": "$t_module_handle_t", + "type": "handle" + }, + { + "alias": "$x_kernel_handle_t", + "class": "$tKernel", + "desc": "Handle of function object", + "name": "$t_kernel_handle_t", + "type": "handle" + }, + { + "class": "$tMetricGroup", + "desc": "Handle of metric group's object", + "name": "$t_metric_group_handle_t", + "type": "handle" + }, + { + "class": "$tMetric", + "desc": "Handle of metric's object", + "name": "$t_metric_handle_t", + "type": "handle" + }, + { + "class": "$tMetricStreamer", + "desc": "Handle of metric streamer's object", + "name": "$t_metric_streamer_handle_t", + "type": "handle" + }, + { + "class": "$tMetricQueryPool", + "desc": "Handle of metric query pool's object", + "name": "$t_metric_query_pool_handle_t", + "type": "handle" + }, + { + "class": "$tMetricQuery", + "desc": "Handle of metric query's object", + "name": "$t_metric_query_handle_t", + "type": "handle" + }, + { + "class": "$tTracerExp", + "desc": "Handle of tracer object", + "name": "$t_tracer_exp_handle_t", + "type": "handle" }, { "class": "$tDebug", - "desc": "Supported general register set flags.", + "desc": "Debug session handle", + "name": "$t_debug_session_handle_t", + "type": "handle" + }, + { + "desc": "Defines structure types", "etors": [ { - "desc": "register set is readable", - "name": "$T_DEBUG_REGSET_FLAG_READABLE", - "value": "$X_BIT(0)" + "desc": "$t_metric_group_properties_t", + "name": "$T_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES", + "value": "0x1" }, { - "desc": "register set is writeable", - "name": "$T_DEBUG_REGSET_FLAG_WRITEABLE", - "value": "$X_BIT(1)" + "desc": "$t_metric_properties_t", + "name": "$T_STRUCTURE_TYPE_METRIC_PROPERTIES", + "value": "0x2" + }, + { + "desc": "$t_metric_streamer_desc_t", + "name": "$T_STRUCTURE_TYPE_METRIC_STREAMER_DESC", + "value": "0x3" + }, + { + "desc": "$t_metric_query_pool_desc_t", + "name": "$T_STRUCTURE_TYPE_METRIC_QUERY_POOL_DESC", + "value": "0x4" + }, + { + "desc": "$t_profile_properties_t", + "name": "$T_STRUCTURE_TYPE_PROFILE_PROPERTIES", + "value": "0x5" + }, + { + "desc": "$t_device_debug_properties_t", + "name": "$T_STRUCTURE_TYPE_DEVICE_DEBUG_PROPERTIES", + "value": "0x6" + }, + { + "desc": "$t_debug_memory_space_desc_t", + "name": "$T_STRUCTURE_TYPE_DEBUG_MEMORY_SPACE_DESC", + "value": "0x7" + }, + { + "desc": "$t_debug_regset_properties_t", + "name": "$T_STRUCTURE_TYPE_DEBUG_REGSET_PROPERTIES", + "value": "0x8" + }, + { + "desc": "$t_metric_global_timestamps_resolution_exp_t. Deprecated, use $T_STRUCTURE_TYPE_METRIC_GLOBAL_TIMESTAMPS_RESOLUTION_EXP.", + "name": "$T_STRUCTURE_TYPE_GLOBAL_METRICS_TIMESTAMPS_EXP_PROPERTIES", + "value": "0x9", + "version": "1.5" + }, + { + "desc": "$t_metric_global_timestamps_resolution_exp_t", + "name": "$T_STRUCTURE_TYPE_METRIC_GLOBAL_TIMESTAMPS_RESOLUTION_EXP", + "value": "0x9", + "version": "1.7" + }, + { + "desc": "$t_tracer_exp_desc_t", + "name": "$T_STRUCTURE_TYPE_TRACER_EXP_DESC", + "value": "0x00010001" + }, + { + "desc": "$t_metric_calculate_exp_desc_t. Deprecated, use $T_STRUCTURE_TYPE_METRIC_CALCULATE_EXP_DESC.", + "name": "$T_STRUCTURE_TYPE_METRICS_CALCULATE_EXP_DESC", + "value": "0x00010002", + "version": "1.6" + }, + { + "desc": "$t_metric_calculate_exp_desc_t", + "name": "$T_STRUCTURE_TYPE_METRIC_CALCULATE_EXP_DESC", + "value": "0x00010002", + "version": "1.7" + }, + { + "desc": "$t_metric_programmable_exp_properties_t", + "name": "$T_STRUCTURE_TYPE_METRIC_PROGRAMMABLE_EXP_PROPERTIES", + "value": "0x00010003", + "version": "1.9" + }, + { + "desc": "$t_metric_programmable_param_info_exp_t", + "name": "$T_STRUCTURE_TYPE_METRIC_PROGRAMMABLE_PARAM_INFO_EXP", + "value": "0x00010004", + "version": "1.9" + }, + { + "desc": "$t_metric_programmable_param_value_info_exp_t", + "name": "$T_STRUCTURE_TYPE_METRIC_PROGRAMMABLE_PARAM_VALUE_INFO_EXP", + "value": "0x00010005", + "version": "1.9" + }, + { + "desc": "$t_metric_group_type_exp_t", + "name": "$T_STRUCTURE_TYPE_METRIC_GROUP_TYPE_EXP", + "value": "0x00010006", + "version": "1.11" + }, + { + "desc": "$t_export_dma_buf_exp_properties_t", + "name": "$T_STRUCTURE_TYPE_EXPORT_DMA_EXP_PROPERTIES", + "value": "0x00010007", + "version": "1.11" + }, + { + "desc": "$t_metric_tracer_exp_desc_t", + "name": "$T_STRUCTURE_TYPE_METRIC_TRACER_EXP_DESC", + "value": "0x00010008", + "version": "1.10" } ], - "name": "$t_debug_regset_flags_t", + "name": "$t_structure_type_t", "type": "enum" }, { - "base": "$t_base_properties_t", - "class": "$tDebug", - "desc": "Device register set properties queried using $tDebugGetRegisterSetProperties.", + "desc": "Base for all properties types", "members": [ { "desc": "[in] type of this structure", - "init": "$T_STRUCTURE_TYPE_DEBUG_REGSET_PROPERTIES", "name": "stype", "type": "$t_structure_type_t" }, @@ -64782,67 +73553,5796 @@ "init": "nullptr", "name": "pNext", "type": "void*" + } + ], + "name": "$t_base_properties_t", + "type": "struct" + }, + { + "desc": "Base for all descriptor types", + "members": [ + { + "desc": "[in] type of this structure", + "name": "stype", + "type": "$t_structure_type_t" + }, + { + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + } + ], + "name": "$t_base_desc_t", + "type": "struct" + }, + { + "desc": "Supported value types", + "etors": [ + { + "desc": "32-bit unsigned-integer", + "name": "$T_VALUE_TYPE_UINT32", + "value": "0" + }, + { + "desc": "64-bit unsigned-integer", + "name": "$T_VALUE_TYPE_UINT64", + "value": "1" + }, + { + "desc": "32-bit floating-point", + "name": "$T_VALUE_TYPE_FLOAT32", + "value": "2" + }, + { + "desc": "64-bit floating-point", + "name": "$T_VALUE_TYPE_FLOAT64", + "value": "3" + }, + { + "desc": "8-bit boolean", + "name": "$T_VALUE_TYPE_BOOL8", + "value": "4" + }, + { + "desc": "C string", + "name": "$T_VALUE_TYPE_STRING", + "value": "5" + }, + { + "desc": "8-bit unsigned-integer", + "name": "$T_VALUE_TYPE_UINT8", + "value": "6" + }, + { + "desc": "16-bit unsigned-integer", + "name": "$T_VALUE_TYPE_UINT16", + "value": "7" + } + ], + "name": "$t_value_type_t", + "type": "enum" + }, + { + "desc": "Union of values", + "members": [ + { + "desc": "[out] 32-bit unsigned-integer", + "name": "ui32", + "type": "uint32_t" + }, + { + "desc": "[out] 64-bit unsigned-integer", + "name": "ui64", + "type": "uint64_t" + }, + { + "desc": "[out] 32-bit floating-point", + "name": "fp32", + "type": "float" + }, + { + "desc": "[out] 64-bit floating-point", + "name": "fp64", + "type": "double" + }, + { + "desc": "[out] 8-bit boolean", + "name": "b8", + "type": "$x_bool_t" + } + ], + "name": "$t_value_t", + "type": "union" + }, + { + "desc": "Typed value", + "members": [ + { + "desc": "[out] type of value", + "name": "type", + "type": "$t_value_type_t" + }, + { + "desc": "[out] value", + "name": "value", + "type": "$t_value_t" + } + ], + "name": "$t_typed_value_t", + "type": "struct" + }, + { + "category": "Driver", + "desc": "Enables driver instrumentation and dependencies for device metrics", + "name": "$T_ENABLE_METRICS", + "type": "env", + "values": "0, 1" + }, + { + "category": "Driver", + "desc": "Enables driver instrumentation and dependencies for program instrumentation", + "name": "$T_ENABLE_PROGRAM_INSTRUMENTATION", + "type": "env", + "values": "0, 1" + }, + { + "category": "Driver", + "desc": "Enables driver instrumentation and dependencies for program debugging", + "name": "$T_ENABLE_PROGRAM_DEBUGGING", + "type": "env", + "values": "0, 1" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Tool APIs for Device", + "ordinal": 2, + "type": "header" + }, + "name": "device", + "objects": [ + { + "base": "$xDriver", + "desc": "C++ wrapper for driver instance", + "members": [], + "name": "$tDriver", + "type": "class" + }, + { + "base": "$xDevice", + "desc": "C++ wrapper for device", + "members": [], + "name": "$tDevice", + "type": "class" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Tool APIs for Context", + "ordinal": 3, + "type": "header" + }, + "name": "context", + "objects": [ + { + "base": "$xContext", + "desc": "C++ wrapper for context", + "members": [], + "name": "$tContext", + "type": "class" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Tool APIs for Command List", + "ordinal": 5, + "type": "header" + }, + "name": "cmdlist", + "objects": [ + { + "base": "$xCommandList", + "desc": "C++ wrapper for command list", + "members": [], + "name": "$tCommandList", + "type": "class" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Tool APIs for Module", + "ordinal": 6, + "type": "header" + }, + "name": "module", + "objects": [ + { + "class": "$tModule", + "desc": "Supported module debug info formats.", + "etors": [ + { + "desc": "Format is ELF/DWARF", + "name": "$T_MODULE_DEBUG_INFO_FORMAT_ELF_DWARF", + "value": "0" + } + ], + "name": "$t_module_debug_info_format_t", + "type": "enum" + }, + { + "class": "$tModule", + "desc": "Retrieve debug info from module.", + "details": [ + "The caller can pass nullptr for pDebugInfo when querying only for size.", + "The implementation will copy the native binary into a buffer supplied by the caller.", + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "8cd9f86cd846e4d9733e3bc32027b2def4b4376df1cb35f5521f692a1ee88ecc", + "name": "GetDebugInfo", + "params": [ + { + "desc": "[in] handle of the module", + "name": "hModule", + "type": "$t_module_handle_t" + }, + { + "desc": "[in] debug info format requested", + "name": "format", + "type": "$t_module_debug_info_format_t" + }, + { + "desc": "[in,out] size of debug info in bytes", + "name": "pSize", + "type": "size_t*" + }, + { + "desc": "[in,out][optional] byte pointer to debug info", + "name": "pDebugInfo", + "type": "uint8_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hModule`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_ENUMERATION": [ + "`$T_MODULE_DEBUG_INFO_FORMAT_ELF_DWARF < format`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pSize`" + ] + } + ], + "type": "function" + }, + { + "base": "$xModule", + "desc": "C++ wrapper for module", + "members": [], + "name": "$tModule", + "type": "class" + }, + { + "base": "$xKernel", + "desc": "C++ wrapper for kernel", + "members": [], + "name": "$tKernel", + "type": "class" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Tool APIs for Program Debug", + "ordinal": 1000, + "type": "header" + }, + "name": "debug", + "objects": [ + { + "class": "$tDevice", + "desc": "Supported device debug property flags", + "etors": [ + { + "desc": "the device supports attaching for debug", + "name": "$T_DEVICE_DEBUG_PROPERTY_FLAG_ATTACH", + "value": "$X_BIT(0)" + } + ], + "name": "$t_device_debug_property_flags_t", + "type": "enum" + }, + { + "base": "$t_base_properties_t", + "class": "$tDevice", + "desc": "Device debug properties queried using $tDeviceGetDebugProperties.", + "members": [ + { + "desc": "[in] type of this structure", + "init": "$T_STRUCTURE_TYPE_DEVICE_DEBUG_PROPERTIES", + "name": "stype", + "type": "$t_structure_type_t" + }, + { + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" + }, + { + "desc": "[out] returns 0 (none) or a valid combination of $t_device_debug_property_flag_t", + "name": "flags", + "type": "$t_device_debug_property_flags_t" + } + ], + "name": "$t_device_debug_properties_t", + "type": "struct" + }, + { + "class": "$tDevice", + "desc": "Retrieves debug properties of the device.", + "hash": "c3d026b82778fe2460ab811b9c2e883dd0be74d7bdcb48098e3fe0d9be5ea054", + "name": "GetDebugProperties", + "params": [ + { + "desc": "[in] device handle", + "name": "hDevice", + "type": "$t_device_handle_t" + }, + { + "desc": "[in,out] query result for debug properties", + "name": "pDebugProperties", + "type": "$t_device_debug_properties_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDevice`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pDebugProperties`" + ] + } + ], + "type": "function" + }, + { + "class": "$tDebug", + "desc": "Debug configuration provided to $tDebugAttach", + "members": [ + { + "desc": "[in] the host process identifier", + "name": "pid", + "type": "uint32_t" + } + ], + "name": "$t_debug_config_t", + "type": "struct" + }, + { + "class": "$tDebug", + "decl": "static", + "desc": "Attach to a device.", + "details": [ + "The device must be enabled for debug; see $xsSchedulerSetComputeUnitDebugMode." + ], + "hash": "74b0dd833de78ddc67ac82d65994001fac9a4efcc3faf3db5862b8824404bfe6", + "name": "Attach", + "params": [ + { + "desc": "[in] device handle", + "name": "hDevice", + "type": "$t_device_handle_t" + }, + { + "desc": "[in] the debug configuration", + "name": "config", + "type": "const $t_debug_config_t*" + }, + { + "desc": "[out] debug session handle", + "name": "phDebug", + "type": "$t_debug_session_handle_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDevice`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == config`", + "`nullptr == phDebug`" + ] + }, + { + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "attaching to this device is not supported" + ] + }, + { + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "caller does not have sufficient permissions" + ] + }, + { + "$X_RESULT_ERROR_NOT_AVAILABLE": [ + "a debugger is already attached" + ] + } + ], + "type": "function" + }, + { + "class": "$tDebug", + "desc": "Close a debug session.", + "hash": "93beca3b9d167f52e7252bb79962171d25e1face643e2fdc0b256ce88cfd1500", + "name": "Detach", + "params": [ + { + "desc": "[in][release] debug session handle", + "name": "hDebug", + "type": "$t_debug_session_handle_t" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDebug`" + ] + } + ], + "type": "function" + }, + { + "class": "$tDebug", + "desc": "Supported debug event flags.", + "etors": [ + { + "desc": "The event needs to be acknowledged by calling $tDebugAcknowledgeEvent.", + "name": "$T_DEBUG_EVENT_FLAG_NEED_ACK", + "value": "$X_BIT(0)" + } + ], + "name": "$t_debug_event_flags_t", + "type": "enum" + }, + { + "class": "$tDebug", + "desc": "Supported debug event types.", + "etors": [ + { + "desc": "The event is invalid", + "name": "$T_DEBUG_EVENT_TYPE_INVALID", + "value": "0" + }, + { + "desc": "The tool was detached", + "name": "$T_DEBUG_EVENT_TYPE_DETACHED", + "value": "1" + }, + { + "desc": "The debuggee process created command queues on the device", + "name": "$T_DEBUG_EVENT_TYPE_PROCESS_ENTRY", + "value": "2" + }, + { + "desc": "The debuggee process destroyed all command queues on the device", + "name": "$T_DEBUG_EVENT_TYPE_PROCESS_EXIT", + "value": "3" + }, + { + "desc": "An in-memory module was loaded onto the device", + "name": "$T_DEBUG_EVENT_TYPE_MODULE_LOAD", + "value": "4" + }, + { + "desc": "An in-memory module is about to get unloaded from the device", + "name": "$T_DEBUG_EVENT_TYPE_MODULE_UNLOAD", + "value": "5" + }, + { + "desc": "The thread stopped due to a device exception", + "name": "$T_DEBUG_EVENT_TYPE_THREAD_STOPPED", + "value": "6" + }, + { + "desc": "The thread is not available to be stopped", + "name": "$T_DEBUG_EVENT_TYPE_THREAD_UNAVAILABLE", + "value": "7" + }, + { + "desc": "A page request could not be completed on the device", + "name": "$T_DEBUG_EVENT_TYPE_PAGE_FAULT", + "value": "8", + "version": "1.1" + } + ], + "name": "$t_debug_event_type_t", + "type": "enum" + }, + { + "class": "$tDebug", + "desc": "Supported debug detach reasons.", + "etors": [ + { + "desc": "The detach reason is not valid", + "name": "$T_DEBUG_DETACH_REASON_INVALID", + "value": "0" + }, + { + "desc": "The host process exited", + "name": "$T_DEBUG_DETACH_REASON_HOST_EXIT", + "value": "1" + } + ], + "name": "$t_debug_detach_reason_t", + "type": "enum" + }, + { + "class": "$tDebug", + "desc": "Event information for $T_DEBUG_EVENT_TYPE_DETACHED", + "members": [ + { + "desc": "[out] the detach reason", + "name": "reason", + "type": "$t_debug_detach_reason_t" + } + ], + "name": "$t_debug_event_info_detached_t", + "type": "struct" + }, + { + "class": "$tDebug", + "desc": "Event information for $T_DEBUG_EVENT_TYPE_MODULE_LOAD and $T_DEBUG_EVENT_TYPE_MODULE_UNLOAD", + "members": [ + { + "desc": "[out] the module format", + "name": "format", + "type": "$t_module_debug_info_format_t" + }, + { + "desc": "[out] the begin address of the in-memory module (inclusive)", + "name": "moduleBegin", + "type": "uint64_t" + }, + { + "desc": "[out] the end address of the in-memory module (exclusive)", + "name": "moduleEnd", + "type": "uint64_t" + }, + { + "desc": "[out] the load address of the module on the device", + "name": "load", + "type": "uint64_t" + } + ], + "name": "$t_debug_event_info_module_t", + "type": "struct" + }, + { + "class": "$tDebug", + "desc": "Event information for $T_DEBUG_EVENT_TYPE_THREAD_STOPPED and $T_DEBUG_EVENT_TYPE_THREAD_UNAVAILABLE", + "members": [ + { + "desc": "[out] the stopped/unavailable thread", + "name": "thread", + "type": "$x_device_thread_t" + } + ], + "name": "$t_debug_event_info_thread_stopped_t", + "type": "struct" + }, + { + "class": "$tDebug", + "desc": "Page fault reasons.", + "etors": [ + { + "desc": "The page fault reason is not valid", + "name": "$T_DEBUG_PAGE_FAULT_REASON_INVALID", + "value": "0" + }, + { + "desc": "The address is not mapped", + "name": "$T_DEBUG_PAGE_FAULT_REASON_MAPPING_ERROR", + "value": "1" + }, + { + "desc": "Invalid access permissions", + "name": "$T_DEBUG_PAGE_FAULT_REASON_PERMISSION_ERROR", + "value": "2" + } + ], + "name": "$t_debug_page_fault_reason_t", + "type": "enum", + "version": "1.1" + }, + { + "class": "$tDebug", + "desc": "Event information for $T_DEBUG_EVENT_TYPE_PAGE_FAULT", + "members": [ + { + "desc": "[out] the faulting address", + "name": "address", + "type": "uint64_t" + }, + { + "desc": "[out] the alignment mask", + "name": "mask", + "type": "uint64_t" + }, + { + "desc": "[out] the page fault reason", + "name": "reason", + "type": "$t_debug_page_fault_reason_t" + } + ], + "name": "$t_debug_event_info_page_fault_t", + "type": "struct", + "version": "1.1" + }, + { + "class": "$tDebug", + "desc": "Event type-specific information", + "members": [ + { + "desc": "[out] type == $T_DEBUG_EVENT_TYPE_DETACHED", + "name": "detached", + "type": "$t_debug_event_info_detached_t" + }, + { + "desc": "[out] type == $T_DEBUG_EVENT_TYPE_MODULE_LOAD or $T_DEBUG_EVENT_TYPE_MODULE_UNLOAD", + "name": "module", + "type": "$t_debug_event_info_module_t" + }, + { + "desc": "[out] type == $T_DEBUG_EVENT_TYPE_THREAD_STOPPED or $T_DEBUG_EVENT_TYPE_THREAD_UNAVAILABLE", + "name": "thread", + "type": "$t_debug_event_info_thread_stopped_t" + }, + { + "desc": "[out] type == $T_DEBUG_EVENT_TYPE_PAGE_FAULT", + "name": "page_fault", + "type": "$t_debug_event_info_page_fault_t", + "version": "1.1" + } + ], + "name": "$t_debug_event_info_t", + "type": "union" + }, + { + "class": "$tDebug", + "desc": "A debug event on the device.", + "members": [ + { + "desc": "[out] the event type", + "name": "type", + "type": "$t_debug_event_type_t" + }, + { + "desc": "[out] returns 0 (none) or a combination of $t_debug_event_flag_t", + "name": "flags", + "type": "$t_debug_event_flags_t" + }, + { + "desc": "[out] event type specific information", + "name": "info", + "type": "$t_debug_event_info_t" + } + ], + "name": "$t_debug_event_t", + "type": "struct" + }, + { + "class": "$tDebug", + "desc": "Read the topmost debug event.", + "hash": "fd2eafa037418a5cbc68fa5bf7a0fe66ada619637cd7ce2a926e5a71032fc51b", + "name": "ReadEvent", + "params": [ + { + "desc": "[in] debug session handle", + "name": "hDebug", + "type": "$t_debug_session_handle_t" + }, + { + "desc": "[in] if non-zero, then indicates the maximum time (in milliseconds) to yield before returning $X_RESULT_SUCCESS or $X_RESULT_NOT_READY;\nif zero, then immediately returns the status of the event;\nif `UINT64_MAX`, then function will not return until complete or device is lost.\nDue to external dependencies, timeout may be rounded to the closest value allowed by the accuracy of those dependencies.\n", + "name": "timeout", + "type": "uint64_t" + }, + { + "desc": "[in,out] a pointer to a $t_debug_event_t.", + "name": "event", + "type": "$t_debug_event_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDebug`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == event`" + ] + }, + { + "$X_RESULT_NOT_READY": [ + "the timeout expired" + ] + } + ], + "type": "function" + }, + { + "class": "$tDebug", + "desc": "Acknowledge a debug event.", + "hash": "2dbda584161c89afdaa2f2d7e25811fa56eb13db68b335e167373e2d1db654a2", + "name": "AcknowledgeEvent", + "params": [ + { + "desc": "[in] debug session handle", + "name": "hDebug", + "type": "$t_debug_session_handle_t" + }, + { + "desc": "[in] a pointer to a $t_debug_event_t.", + "name": "event", + "type": "const $t_debug_event_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDebug`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == event`" + ] + } + ], + "type": "function" + }, + { + "class": "$tDebug", + "desc": "Interrupt device threads.", + "hash": "97d57d2337376beea4fcf5647996d6a695c408b43c4402bc50cb7f1f849100c8", + "name": "Interrupt", + "params": [ + { + "desc": "[in] debug session handle", + "name": "hDebug", + "type": "$t_debug_session_handle_t" + }, + { + "desc": "[in] the thread to interrupt", + "name": "thread", + "type": "$x_device_thread_t" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDebug`" + ] + }, + { + "$X_RESULT_ERROR_NOT_AVAILABLE": [ + "the thread is already stopped or unavailable" + ] + } + ], + "type": "function" + }, + { + "class": "$tDebug", + "desc": "Resume device threads.", + "hash": "55072197ef54909f2ff6ecbf176fccb95dbad2a2266b806d585e46715fb65173", + "name": "Resume", + "params": [ + { + "desc": "[in] debug session handle", + "name": "hDebug", + "type": "$t_debug_session_handle_t" + }, + { + "desc": "[in] the thread to resume", + "name": "thread", + "type": "$x_device_thread_t" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDebug`" + ] + }, + { + "$X_RESULT_ERROR_NOT_AVAILABLE": [ + "the thread is already running or unavailable" + ] + } + ], + "type": "function" + }, + { + "class": "$tDebug", + "desc": "Supported device memory space types.", + "etors": [ + { + "desc": "default memory space (attribute may be omitted)", + "name": "$T_DEBUG_MEMORY_SPACE_TYPE_DEFAULT", + "value": "0" + }, + { + "desc": "shared local memory space (GPU-only)", + "name": "$T_DEBUG_MEMORY_SPACE_TYPE_SLM", + "value": "1" + }, + { + "desc": "ELF file memory space", + "name": "$T_DEBUG_MEMORY_SPACE_TYPE_ELF", + "value": "2", + "version": "1.10" + } + ], + "name": "$t_debug_memory_space_type_t", + "type": "enum" + }, + { + "base": "$t_base_desc_t", + "class": "$tDebug", + "desc": "Device memory space descriptor", + "members": [ + { + "desc": "[in] type of this structure", + "init": "$T_STRUCTURE_TYPE_DEBUG_MEMORY_SPACE_DESC", + "name": "stype", + "type": "$t_structure_type_t" + }, + { + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, + { + "desc": "[in] type of memory space", + "name": "type", + "type": "$t_debug_memory_space_type_t" + }, + { + "desc": "[in] the virtual address within the memory space", + "name": "address", + "type": "uint64_t" + } + ], + "name": "$t_debug_memory_space_desc_t", + "type": "struct" + }, + { + "class": "$tDebug", + "desc": "Read memory.", + "details": [ + "The thread identifier 'all' can be used for accessing the default memory space, e.g. for setting breakpoints." + ], + "hash": "32d1103937128d0fdc73b46974a88ff0502d29fdd3bdbe361a6819eea9e2af36", + "name": "ReadMemory", + "params": [ + { + "desc": "[in] debug session handle", + "name": "hDebug", + "type": "$t_debug_session_handle_t" + }, + { + "desc": "[in] the thread identifier.", + "name": "thread", + "type": "$x_device_thread_t" + }, + { + "desc": "[in] memory space descriptor", + "name": "desc", + "type": "const $t_debug_memory_space_desc_t*" + }, + { + "desc": "[in] the number of bytes to read", + "name": "size", + "type": "size_t" + }, + { + "desc": "[in,out] a buffer to hold a copy of the memory", + "name": "buffer", + "type": "void*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDebug`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == desc`", + "`nullptr == buffer`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_ENUMERATION": [ + "`$T_DEBUG_MEMORY_SPACE_TYPE_ELF < desc->type`" + ] + }, + { + "$X_RESULT_ERROR_NOT_AVAILABLE": [ + "the thread is running or unavailable", + "the memory cannot be accessed from the supplied thread" + ] + } + ], + "type": "function" + }, + { + "class": "$tDebug", + "desc": "Write memory.", + "details": [ + "The thread identifier 'all' can be used for accessing the default memory space, e.g. for setting breakpoints." + ], + "hash": "9f56cdf99c4ac640421569f841d86c1e915a0929508bb7afe8a44b4a221a93a1", + "name": "WriteMemory", + "params": [ + { + "desc": "[in] debug session handle", + "name": "hDebug", + "type": "$t_debug_session_handle_t" + }, + { + "desc": "[in] the thread identifier.", + "name": "thread", + "type": "$x_device_thread_t" + }, + { + "desc": "[in] memory space descriptor", + "name": "desc", + "type": "const $t_debug_memory_space_desc_t*" + }, + { + "desc": "[in] the number of bytes to write", + "name": "size", + "type": "size_t" + }, + { + "desc": "[in] a buffer holding the pattern to write", + "name": "buffer", + "type": "const void*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDebug`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == desc`", + "`nullptr == buffer`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_ENUMERATION": [ + "`$T_DEBUG_MEMORY_SPACE_TYPE_ELF < desc->type`" + ] + }, + { + "$X_RESULT_ERROR_NOT_AVAILABLE": [ + "the thread is running or unavailable", + "the memory cannot be accessed from the supplied thread" + ] + } + ], + "type": "function" + }, + { + "class": "$tDebug", + "desc": "Supported general register set flags.", + "etors": [ + { + "desc": "register set is readable", + "name": "$T_DEBUG_REGSET_FLAG_READABLE", + "value": "$X_BIT(0)" + }, + { + "desc": "register set is writeable", + "name": "$T_DEBUG_REGSET_FLAG_WRITEABLE", + "value": "$X_BIT(1)" + } + ], + "name": "$t_debug_regset_flags_t", + "type": "enum" + }, + { + "base": "$t_base_properties_t", + "class": "$tDebug", + "desc": "Device register set properties queried using $tDebugGetRegisterSetProperties.", + "members": [ + { + "desc": "[in] type of this structure", + "init": "$T_STRUCTURE_TYPE_DEBUG_REGSET_PROPERTIES", + "name": "stype", + "type": "$t_structure_type_t" + }, + { + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" + }, + { + "desc": "[out] device-specific register set type", + "name": "type", + "type": "uint32_t" + }, + { + "desc": "[out] device-specific version of this register set", + "name": "version", + "type": "uint32_t" + }, + { + "desc": "[out] general register set flags", + "name": "generalFlags", + "type": "$t_debug_regset_flags_t" + }, + { + "desc": "[out] device-specific register set flags", + "name": "deviceFlags", + "type": "uint32_t" + }, + { + "desc": "[out] number of registers in the set", + "name": "count", + "type": "uint32_t" + }, + { + "desc": "[out] the size of a register in bits", + "name": "bitSize", + "type": "uint32_t" + }, + { + "desc": "[out] the size required for reading or writing a register in bytes", + "name": "byteSize", + "type": "uint32_t" + } + ], + "name": "$t_debug_regset_properties_t", + "type": "struct" + }, + { + "class": "$tDebug", + "decl": "static", + "desc": "Retrieves debug register set properties.", + "hash": "66c8f10d019ad513b3749bc9486eacb1dbc5934eb24fdd59ce915c1de01f6fa9", + "name": "GetRegisterSetProperties", + "params": [ + { + "desc": "[in] device handle", + "name": "hDevice", + "type": "$t_device_handle_t" + }, + { + "desc": "[in,out] pointer to the number of register set properties.\nif count is zero, then the driver shall update the value with the total number of register set properties available.\nif count is greater than the number of register set properties available, then the driver shall update the value with the correct number of registry set properties available.\n", + "name": "pCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pCount)] array of query results for register set properties.\nif count is less than the number of register set properties available, then driver shall only retrieve that number of register set properties.\n", + "name": "pRegisterSetProperties", + "type": "$t_debug_regset_properties_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDevice`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCount`" + ] + } + ], + "type": "function" + }, + { + "class": "$tDebug", + "decl": "static", + "desc": "Retrieves debug register set properties for a given thread.", + "hash": "96f5ab4fe190013dfe748f26ae4db3b9d95a62f88dcb7a7e9468b00d94945169", + "name": "GetThreadRegisterSetProperties", + "params": [ + { + "desc": "[in] debug session handle", + "name": "hDebug", + "type": "$t_debug_session_handle_t" + }, + { + "desc": "[in] the thread identifier specifying a single stopped thread", + "name": "thread", + "type": "$x_device_thread_t" + }, + { + "desc": "[in,out] pointer to the number of register set properties.\nif count is zero, then the driver shall update the value with the total number of register set properties available.\nif count is greater than the number of register set properties available, then the driver shall update the value with the correct number of registry set properties available.\n", + "name": "pCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pCount)] array of query results for register set properties.\nif count is less than the number of register set properties available, then driver shall only retrieve that number of register set properties.\n", + "name": "pRegisterSetProperties", + "type": "$t_debug_regset_properties_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDebug`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCount`" + ] + }, + { + "$X_RESULT_ERROR_NOT_AVAILABLE": [ + "the thread is running or unavailable" + ] + }, + { + "$X_RESULT_ERROR_INVALID_ARGUMENT": [ + "the thread argument specifies more than one or a non-existant thread" + ] + } + ], + "type": "function", + "version": "1.5" + }, + { + "class": "$tDebug", + "desc": "Read register state.", + "hash": "4971ff5ff86f5c20fda571c8540832b90f68b99ff6b2c72527ae590fb92ecd13", + "name": "ReadRegisters", + "params": [ + { + "desc": "[in] debug session handle", + "name": "hDebug", + "type": "$t_debug_session_handle_t" + }, + { + "desc": "[in] the thread identifier", + "name": "thread", + "type": "$x_device_thread_t" + }, + { + "desc": "[in] register set type", + "name": "type", + "type": "uint32_t" + }, + { + "desc": "[in] the starting offset into the register state area; must be less than the `count` member of $t_debug_regset_properties_t for the type", + "name": "start", + "type": "uint32_t" + }, + { + "desc": "[in] the number of registers to read; start+count must be less than or equal to the `count` member of $t_debug_register_group_properties_t for the type", + "name": "count", + "type": "uint32_t" + }, + { + "desc": "[in,out][optional][range(0, count)] buffer of register values", + "name": "pRegisterValues", + "type": "void*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDebug`" + ] + }, + { + "$X_RESULT_ERROR_NOT_AVAILABLE": [ + "the thread is running or unavailable" + ] + } + ], + "type": "function" + }, + { + "class": "$tDebug", + "desc": "Write register state.", + "hash": "a7e5e8a068e13a51cbe0643ad035cb7b9c043f5a050593e66978ede75b49023c", + "name": "WriteRegisters", + "params": [ + { + "desc": "[in] debug session handle", + "name": "hDebug", + "type": "$t_debug_session_handle_t" + }, + { + "desc": "[in] the thread identifier", + "name": "thread", + "type": "$x_device_thread_t" + }, + { + "desc": "[in] register set type", + "name": "type", + "type": "uint32_t" + }, + { + "desc": "[in] the starting offset into the register state area; must be less than the `count` member of $t_debug_regset_properties_t for the type", + "name": "start", + "type": "uint32_t" + }, + { + "desc": "[in] the number of registers to write; start+count must be less than or equal to the `count` member of $t_debug_register_group_properties_t for the type", + "name": "count", + "type": "uint32_t" + }, + { + "desc": "[in,out][optional][range(0, count)] buffer of register values", + "name": "pRegisterValues", + "type": "void*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDebug`" + ] + }, + { + "$X_RESULT_ERROR_NOT_AVAILABLE": [ + "the thread is running or unavailable" + ] + } + ], + "type": "function" + }, + { + "desc": "C++ wrapper for Debug API", + "members": [ + { + "desc": "[in] debug session handle", + "name": "handle", + "type": "$t_debug_session_handle_t" + } + ], + "name": "$tDebug", + "type": "class" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Tool APIs for Metric", + "ordinal": 1000, + "type": "header" + }, + "name": "metric", + "objects": [ + { + "class": "$tMetricGroup", + "decl": "static", + "desc": "Retrieves metric group for a device.", + "details": [ + "The application may call this function from simultaneous threads." + ], + "hash": "3c1168f00cd21001f959d5f66f20559a4bf5e396bb1cb1d34116e7729a4f4fc8", + "name": "Get", + "params": [ + { + "desc": "[in] handle of the device", + "name": "hDevice", + "type": "$t_device_handle_t" + }, + { + "desc": "[in,out] pointer to the number of metric groups.\nif count is zero, then the driver shall update the value with the total number of metric groups available.\nif count is greater than the number of metric groups available, then the driver shall update the value with the correct number of metric groups available.\n", + "name": "pCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pCount)] array of handle of metric groups.\nif count is less than the number of metric groups available, then driver shall only retrieve that number of metric groups.\n", + "name": "phMetricGroups", + "type": "$t_metric_group_handle_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDevice`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCount`" + ] + } + ], + "type": "function" + }, + { + "desc": "Maximum metric group name string size", + "name": "$T_MAX_METRIC_GROUP_NAME", + "type": "macro", + "value": "256" + }, + { + "desc": "Maximum metric group description string size", + "name": "$T_MAX_METRIC_GROUP_DESCRIPTION", + "type": "macro", + "value": "256" + }, + { + "class": "$tMetricGroup", + "desc": "Metric group sampling type", + "etors": [ + { + "desc": "Event based sampling", + "name": "$T_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED", + "value": "$X_BIT(0)" + }, + { + "desc": "Time based sampling", + "name": "$T_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED", + "value": "$X_BIT(1)" + }, + { + "desc": "Experimental Tracer based sampling", + "name": "$T_METRIC_GROUP_SAMPLING_TYPE_FLAG_EXP_TRACER_BASED", + "value": "$X_BIT(2)", + "version": "1.10" + } + ], + "name": "$t_metric_group_sampling_type_flags_t", + "type": "enum" + }, + { + "base": "$t_base_properties_t", + "class": "$tMetricGroup", + "desc": "Metric group properties queried using $tMetricGroupGetProperties", + "members": [ + { + "desc": "[in] type of this structure", + "init": "$T_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES", + "name": "stype", + "type": "$t_structure_type_t" + }, + { + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" + }, + { + "desc": "[out] metric group name", + "name": "name[$T_MAX_METRIC_GROUP_NAME]", + "type": "char" + }, + { + "desc": "[out] metric group description", + "name": "description[$T_MAX_METRIC_GROUP_DESCRIPTION]", + "type": "char" + }, + { + "desc": "[out] metric group sampling type.\nreturns a combination of $t_metric_group_sampling_type_flag_t.\n", + "name": "samplingType", + "type": "$t_metric_group_sampling_type_flags_t" + }, + { + "desc": "[out] metric group domain number. Cannot use multiple, simultaneous metric groups from the same domain.", + "name": "domain", + "type": "uint32_t" + }, + { + "desc": "[out] metric count belonging to this group", + "name": "metricCount", + "type": "uint32_t" + } + ], + "name": "$t_metric_group_properties_t", + "type": "struct" + }, + { + "class": "$tMetricGroup", + "desc": "Retrieves attributes of a metric group.", + "details": [ + "The application may call this function from simultaneous threads." + ], + "hash": "78240eaf21bff68383fe29f14362cb160f3ebbb609b183920ba33af1d0792bb9", + "name": "GetProperties", + "params": [ + { + "desc": "[in] handle of the metric group", + "name": "hMetricGroup", + "type": "$t_metric_group_handle_t" + }, + { + "desc": "[in,out] metric group properties", + "name": "pProperties", + "type": "$t_metric_group_properties_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricGroup`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pProperties`" + ] + } + ], + "type": "function" + }, + { + "class": "$tMetric", + "desc": "Metric types", + "etors": [ + { + "desc": "Metric type: duration", + "name": "$T_METRIC_TYPE_DURATION", + "value": "0" + }, + { + "desc": "Metric type: event", + "name": "$T_METRIC_TYPE_EVENT", + "value": "1" + }, + { + "desc": "Metric type: event with range", + "name": "$T_METRIC_TYPE_EVENT_WITH_RANGE", + "value": "2" + }, + { + "desc": "Metric type: throughput", + "name": "$T_METRIC_TYPE_THROUGHPUT", + "value": "3" + }, + { + "desc": "Metric type: timestamp", + "name": "$T_METRIC_TYPE_TIMESTAMP", + "value": "4" + }, + { + "desc": "Metric type: flag", + "name": "$T_METRIC_TYPE_FLAG", + "value": "5" + }, + { + "desc": "Metric type: ratio", + "name": "$T_METRIC_TYPE_RATIO", + "value": "6" + }, + { + "desc": "Metric type: raw", + "name": "$T_METRIC_TYPE_RAW", + "value": "7" + }, + { + "desc": "Metric type: instruction pointer. Deprecated, use $T_METRIC_TYPE_IP.", + "name": "$T_METRIC_TYPE_IP_EXP", + "value": "8" + }, + { + "desc": "Metric type: instruction pointer", + "name": "$T_METRIC_TYPE_IP", + "value": "9", + "version": "1.7" + }, + { + "desc": "Metric type: event with only timestamp and value has no meaning", + "name": "$T_METRIC_TYPE_EVENT_EXP_TIMESTAMP", + "value": "10", + "version": "1.10" + }, + { + "desc": "Metric type: the first event of a start/end event pair", + "name": "$T_METRIC_TYPE_EVENT_EXP_START", + "value": "11", + "version": "1.10" + }, + { + "desc": "Metric type: the second event of a start/end event pair", + "name": "$T_METRIC_TYPE_EVENT_EXP_END", + "value": "12", + "version": "1.10" + }, + { + "desc": "Metric which exports linux dma_buf, which could be imported/mapped to the host process", + "name": "$T_METRIC_TYPE_EXPORT_DMA_BUF", + "value": "0x7ffffffd", + "version": "1.11" + }, + { + "desc": "Metric type: value of the event is a monotonically increasing value that can wrap around", + "name": "$T_METRIC_TYPE_EVENT_EXP_MONOTONIC_WRAPS_VALUE", + "value": "0x7ffffffe", + "version": "1.10" + } + ], + "name": "$t_metric_type_t", + "type": "enum" + }, + { + "class": "$tMetricGroup", + "desc": "Metric group calculation type", + "etors": [ + { + "desc": "Calculated metric values from raw data.", + "name": "$T_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES", + "value": "0" + }, + { + "desc": "Maximum metric values.", + "name": "$T_METRIC_GROUP_CALCULATION_TYPE_MAX_METRIC_VALUES", + "value": "1" + } + ], + "name": "$t_metric_group_calculation_type_t", + "type": "enum" + }, + { + "class": "$tMetricGroup", + "decl": "static", + "desc": "Calculates metric values from raw data.", + "details": [ + "The application may call this function from simultaneous threads." + ], + "hash": "cb6e20cd2535530f4def46834390547217f8eba6eeba1dc0a902555c40af9028", + "name": "CalculateMetricValues", + "params": [ + { + "desc": "[in] handle of the metric group", + "name": "hMetricGroup", + "type": "$t_metric_group_handle_t" + }, + { + "desc": "[in] calculation type to be applied on raw data", + "name": "type", + "type": "$t_metric_group_calculation_type_t" + }, + { + "desc": "[in] size in bytes of raw data buffer", + "name": "rawDataSize", + "type": "size_t" + }, + { + "desc": "[in][range(0, rawDataSize)] buffer of raw data to calculate", + "name": "pRawData", + "type": "const uint8_t*" + }, + { + "desc": "[in,out] pointer to number of metric values calculated.\nif count is zero, then the driver shall update the value with the total number of metric values to be calculated.\nif count is greater than the number available in the raw data buffer, then the driver shall update the value with the actual number of metric values to be calculated.\n", + "name": "pMetricValueCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pMetricValueCount)] buffer of calculated metrics.\nif count is less than the number available in the raw data buffer, then driver shall only calculate that number of metric values.\n", + "name": "pMetricValues", + "type": "$t_typed_value_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricGroup`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_ENUMERATION": [ + "`$T_METRIC_GROUP_CALCULATION_TYPE_MAX_METRIC_VALUES < type`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pRawData`", + "`nullptr == pMetricValueCount`" + ] + } + ], + "type": "function" + }, + { + "class": "$tMetric", + "decl": "static", + "desc": "Retrieves metric from a metric group.", + "details": [ + "The application may call this function from simultaneous threads." + ], + "hash": "23f30faaba53d0a7e0aae5ccd4a7f28d12c9e6c4cdccce6dfa8f8d6b3bc606df", + "name": "Get", + "params": [ + { + "desc": "[in] handle of the metric group", + "name": "hMetricGroup", + "type": "$t_metric_group_handle_t" + }, + { + "desc": "[in,out] pointer to the number of metrics.\nif count is zero, then the driver shall update the value with the total number of metrics available.\nif count is greater than the number of metrics available, then the driver shall update the value with the correct number of metrics available.\n", + "name": "pCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pCount)] array of handle of metrics.\nif count is less than the number of metrics available, then driver shall only retrieve that number of metrics.\n", + "name": "phMetrics", + "type": "$t_metric_handle_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricGroup`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCount`" + ] + } + ], + "type": "function" + }, + { + "desc": "Maximum metric name string size", + "name": "$T_MAX_METRIC_NAME", + "type": "macro", + "value": "256" + }, + { + "desc": "Maximum metric description string size", + "name": "$T_MAX_METRIC_DESCRIPTION", + "type": "macro", + "value": "256" + }, + { + "desc": "Maximum metric component string size", + "name": "$T_MAX_METRIC_COMPONENT", + "type": "macro", + "value": "256" + }, + { + "desc": "Maximum metric result units string size", + "name": "$T_MAX_METRIC_RESULT_UNITS", + "type": "macro", + "value": "256" + }, + { + "base": "$t_base_properties_t", + "class": "$tMetric", + "desc": "Metric properties queried using $tMetricGetProperties", + "members": [ + { + "desc": "[in] type of this structure", + "init": "$T_STRUCTURE_TYPE_METRIC_PROPERTIES", + "name": "stype", + "type": "$t_structure_type_t" + }, + { + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" + }, + { + "desc": "[out] metric name", + "name": "name[$T_MAX_METRIC_NAME]", + "type": "char" + }, + { + "desc": "[out] metric description", + "name": "description[$T_MAX_METRIC_DESCRIPTION]", + "type": "char" + }, + { + "desc": "[out] metric component", + "name": "component[$T_MAX_METRIC_COMPONENT]", + "type": "char" + }, + { + "desc": "[out] number of tier", + "name": "tierNumber", + "type": "uint32_t" + }, + { + "desc": "[out] metric type", + "name": "metricType", + "type": "$t_metric_type_t" + }, + { + "desc": "[out] metric result type", + "name": "resultType", + "type": "$t_value_type_t" + }, + { + "desc": "[out] metric result units", + "name": "resultUnits[$T_MAX_METRIC_RESULT_UNITS]", + "type": "char" + } + ], + "name": "$t_metric_properties_t", + "type": "struct" + }, + { + "class": "$tMetric", + "desc": "Retrieves attributes of a metric.", + "details": [ + "The application may call this function from simultaneous threads." + ], + "hash": "aef6333271f2a5fdf7ab89c275d95405139496cb21c67904139bad5bc9dd0730", + "name": "GetProperties", + "params": [ + { + "desc": "[in] handle of the metric", + "name": "hMetric", + "type": "$t_metric_handle_t" + }, + { + "desc": "[in,out] metric properties", + "name": "pProperties", + "type": "$t_metric_properties_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetric`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pProperties`" + ] + } + ], + "type": "function" + }, + { + "class": "$tContext", + "desc": "Activates metric groups.", + "details": [ + "Immediately reconfigures the device to activate only those metric groups provided.", + "Any metric groups previously activated but not provided will be deactivated.", + "Deactivating metric groups that are still in-use will result in undefined behavior.", + "All metric groups must have different domains, see $t_metric_group_properties_t.", + "The application must **not** call this function from simultaneous threads with the same device handle." + ], + "hash": "34c932ade11f77be736543eb44b6cf7cebfde09ac71f5b67362519b27f763e96", + "name": "ActivateMetricGroups", + "params": [ + { + "desc": "[in] handle of the context object", + "name": "hContext", + "type": "$t_context_handle_t" + }, + { + "desc": "[in] handle of the device", + "name": "hDevice", + "type": "$t_device_handle_t" + }, + { + "desc": "[in] metric group count to activate; must be 0 if `nullptr == phMetricGroups`", + "name": "count", + "type": "uint32_t" + }, + { + "desc": "[in][optional][range(0, count)] handles of the metric groups to activate.\nnullptr deactivates all previously used metric groups.\nall metrics groups must come from a different domains.\nmetric query and metric stream must use activated metric groups.\n", + "name": "phMetricGroups", + "type": "$t_metric_group_handle_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hContext`", + "`nullptr == hDevice`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_SIZE": [ + "`(nullptr == phMetricGroups) && (0 < count)`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_ARGUMENT": [ + "Multiple metric groups share the same domain" + ] + } + ], + "type": "function" + }, + { + "base": "$t_base_desc_t", + "class": "$tMetricStreamer", + "desc": "Metric streamer descriptor", + "members": [ + { + "desc": "[in] type of this structure", + "init": "$T_STRUCTURE_TYPE_METRIC_STREAMER_DESC", + "name": "stype", + "type": "$t_structure_type_t" + }, + { + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, + { + "desc": "[in,out] number of collected reports after which notification event will be signaled. If the requested value is not supported exactly, then the driver may use a value that is the closest supported approximation and shall update this member during $tMetricStreamerOpen.\n", + "name": "notifyEveryNReports", + "type": "uint32_t" + }, + { + "desc": "[in,out] streamer sampling period in nanoseconds. If the requested value is not supported exactly, then the driver may use a value that is the closest supported approximation and shall update this member during $tMetricStreamerOpen.\n", + "name": "samplingPeriod", + "type": "uint32_t" + } + ], + "name": "$t_metric_streamer_desc_t", + "type": "struct" + }, + { + "class": "$tMetricStreamer", + "decl": "static", + "desc": "Opens metric streamer for a device.", + "details": [ + "The notification event must have been created from an event pool that was created using $X_EVENT_POOL_FLAG_HOST_VISIBLE flag.", + "The duration of the signal event created from an event pool that was created using $X_EVENT_POOL_FLAG_KERNEL_TIMESTAMP flag is undefined. However, for consistency and orthogonality the event will report correctly as signaled when used by other event API functionality.", + "The application must **not** call this function from simultaneous threads with the same device handle." + ], + "hash": "fd476dcac868ee20bbfeaa63a804477465714e4b754e0d863151f3f5f39ffc23", + "name": "Open", + "params": [ + { + "desc": "[in] handle of the context object", + "name": "hContext", + "type": "$t_context_handle_t" + }, + { + "desc": "[in] handle of the device", + "name": "hDevice", + "type": "$t_device_handle_t" + }, + { + "desc": "[in] handle of the metric group", + "name": "hMetricGroup", + "type": "$t_metric_group_handle_t" + }, + { + "desc": "[in,out] metric streamer descriptor", + "name": "desc", + "type": "$t_metric_streamer_desc_t*" + }, + { + "desc": "[in][optional] event used for report availability notification", + "name": "hNotificationEvent", + "type": "$x_event_handle_t" + }, + { + "desc": "[out] handle of metric streamer", + "name": "phMetricStreamer", + "type": "$t_metric_streamer_handle_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hContext`", + "`nullptr == hDevice`", + "`nullptr == hMetricGroup`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == desc`", + "`nullptr == phMetricStreamer`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT": [] + } + ], + "type": "function" + }, + { + "class": "$tCommandList", + "desc": "Append metric streamer marker into a command list.", + "details": [ + "The application must ensure the metric streamer is accessible by the device on which the command list was created.", + "The application must ensure the command list and metric streamer were created on the same context.", + "The application must **not** call this function from simultaneous threads with the same command list handle.", + "Allow to associate metric stream time based metrics with executed workload." + ], + "hash": "442249fcbae3e728493309e244e058e9b58dbcd35d8a6e08a27fc30e787152fa", + "name": "AppendMetricStreamerMarker", + "params": [ + { + "desc": "[in] handle of the command list", + "name": "hCommandList", + "type": "$t_command_list_handle_t" + }, + { + "desc": "[in] handle of the metric streamer", + "name": "hMetricStreamer", + "type": "$t_metric_streamer_handle_t" + }, + { + "desc": "[in] streamer marker value", + "name": "value", + "type": "uint32_t" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hCommandList`", + "`nullptr == hMetricStreamer`" + ] + } + ], + "type": "function" + }, + { + "class": "$tMetricStreamer", + "desc": "Closes metric streamer.", + "details": [ + "The application must **not** call this function from simultaneous threads with the same metric streamer handle." + ], + "hash": "f4cbb10d86bc48d25d8daf58501a6a5f561fad25962e1174cdbe30f1a912e97a", + "name": "Close", + "params": [ + { + "desc": "[in][release] handle of the metric streamer", + "name": "hMetricStreamer", + "type": "$t_metric_streamer_handle_t" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricStreamer`" + ] + } + ], + "type": "function" + }, + { + "class": "$tMetricStreamer", + "desc": "Reads data from metric streamer.", + "details": [ + "The application may call this function from simultaneous threads." + ], + "hash": "46f3a51dca41a6993577fdad58dc258e362bc98c7ffac1bdc6f6000b327acd2b", + "name": "ReadData", + "params": [ + { + "desc": "[in] handle of the metric streamer", + "name": "hMetricStreamer", + "type": "$t_metric_streamer_handle_t" + }, + { + "desc": "[in] the maximum number of reports the application wants to receive.\nif `UINT32_MAX`, then function will retrieve all reports available\n", + "name": "maxReportCount", + "type": "uint32_t" + }, + { + "desc": "[in,out] pointer to size in bytes of raw data requested to read.\nif size is zero, then the driver will update the value with the total size in bytes needed for all reports available.\nif size is non-zero, then driver will only retrieve the number of reports that fit into the buffer.\nif size is larger than size needed for all reports, then driver will update the value with the actual size needed.\n", + "name": "pRawDataSize", + "type": "size_t*" + }, + { + "desc": "[in,out][optional][range(0, *pRawDataSize)] buffer containing streamer reports in raw format", + "name": "pRawData", + "type": "uint8_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricStreamer`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pRawDataSize`" + ] + }, + { + "$X_RESULT_WARNING_DROPPED_DATA": [ + "Metric streamer data may have been dropped. Reduce sampling period." + ] + } + ], + "type": "function" + }, + { + "class": "$tMetricQueryPool", + "desc": "Metric query pool types", + "etors": [ + { + "desc": "Performance metric query pool.", + "name": "$T_METRIC_QUERY_POOL_TYPE_PERFORMANCE", + "value": "0" + }, + { + "desc": "Skips workload execution between begin/end calls.", + "name": "$T_METRIC_QUERY_POOL_TYPE_EXECUTION", + "value": "1" + } + ], + "name": "$t_metric_query_pool_type_t", + "type": "enum" + }, + { + "base": "$t_base_desc_t", + "class": "$tMetricQueryPool", + "desc": "Metric query pool description", + "members": [ + { + "desc": "[in] type of this structure", + "init": "$T_STRUCTURE_TYPE_METRIC_QUERY_POOL_DESC", + "name": "stype", + "type": "$t_structure_type_t" + }, + { + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, + { + "desc": "[in] Query pool type.", + "init": "$T_METRIC_QUERY_POOL_TYPE_PERFORMANCE", + "name": "type", + "type": "$t_metric_query_pool_type_t" + }, + { + "desc": "[in] Internal slots count within query pool object.", + "name": "count", + "type": "uint32_t" + } + ], + "name": "$t_metric_query_pool_desc_t", + "type": "struct" + }, + { + "class": "$tMetricQueryPool", + "decl": "static", + "desc": "Creates a pool of metric queries on the context.", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function must be thread-safe." + ], + "hash": "9727a2898e91512de28ffbf2c09ad780be377d517d6dfe36cf34e27eaa723885", + "name": "Create", + "params": [ + { + "desc": "[in] handle of the context object", + "name": "hContext", + "type": "$t_context_handle_t" + }, + { + "desc": "[in] handle of the device", + "name": "hDevice", + "type": "$t_device_handle_t" + }, + { + "desc": "[in] metric group associated with the query object.", + "name": "hMetricGroup", + "type": "$t_metric_group_handle_t" + }, + { + "desc": "[in] metric query pool descriptor", + "name": "desc", + "type": "const $t_metric_query_pool_desc_t*" + }, + { + "desc": "[out] handle of metric query pool", + "name": "phMetricQueryPool", + "type": "$t_metric_query_pool_handle_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hContext`", + "`nullptr == hDevice`", + "`nullptr == hMetricGroup`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == desc`", + "`nullptr == phMetricQueryPool`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_ENUMERATION": [ + "`$T_METRIC_QUERY_POOL_TYPE_EXECUTION < desc->type`" + ] + } + ], + "type": "function" + }, + { + "class": "$tMetricQueryPool", + "decl": "static", + "desc": "Deletes a query pool object.", + "details": [ + "The application must destroy all query handles created from the pool before destroying the pool itself.", + "The application must ensure the device is not currently referencing the any query within the pool before it is deleted.", + "The application must **not** call this function from simultaneous threads with the same query pool handle.", + "The implementation of this function must be thread-safe." + ], + "hash": "b26d02c53519d670c87cb7b785b5df2a25f8a4fcbe931f5ecd168e5730641c6e", + "name": "Destroy", + "params": [ + { + "desc": "[in][release] handle of the metric query pool", + "name": "hMetricQueryPool", + "type": "$t_metric_query_pool_handle_t" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricQueryPool`" + ] + }, + { + "$X_RESULT_ERROR_HANDLE_OBJECT_IN_USE": [] + } + ], + "type": "function" + }, + { + "class": "$tMetricQuery", + "decl": "static", + "desc": "Creates metric query from the pool.", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function must be thread-safe." + ], + "hash": "8644abb74b401f86e5b41611bb4a50a1514db5c88349292c1713315229a8ab50", + "name": "Create", + "params": [ + { + "desc": "[in] handle of the metric query pool", + "name": "hMetricQueryPool", + "type": "$t_metric_query_pool_handle_t" + }, + { + "desc": "[in] index of the query within the pool", + "name": "index", + "type": "uint32_t" + }, + { + "desc": "[out] handle of metric query", + "name": "phMetricQuery", + "type": "$t_metric_query_handle_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricQueryPool`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == phMetricQuery`" + ] + } + ], + "type": "function" + }, + { + "class": "$tMetricQuery", + "decl": "static", + "desc": "Deletes a metric query object.", + "details": [ + "The application must ensure the device is not currently referencing the query before it is deleted.", + "The application must **not** call this function from simultaneous threads with the same query handle.", + "The implementation of this function must be thread-safe." + ], + "hash": "e383c2dd1db9330485352b7dc38681e70be0e44436e2872d7681c5727576c407", + "name": "Destroy", + "params": [ + { + "desc": "[in][release] handle of metric query", + "name": "hMetricQuery", + "type": "$t_metric_query_handle_t" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricQuery`" + ] + }, + { + "$X_RESULT_ERROR_HANDLE_OBJECT_IN_USE": [] + } + ], + "type": "function" + }, + { + "class": "$tMetricQuery", + "desc": "Resets a metric query object back to initial state.", + "details": [ + "The application must ensure the device is not currently referencing the query before it is reset", + "The application must **not** call this function from simultaneous threads with the same query handle." + ], + "hash": "bd549c068b921a3b4d5be8147c1668f747c8b30d5794d06e24821c0531a38cb6", + "name": "Reset", + "params": [ + { + "desc": "[in] handle of metric query", + "name": "hMetricQuery", + "type": "$t_metric_query_handle_t" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricQuery`" + ] + } + ], + "type": "function" + }, + { + "class": "$tCommandList", + "desc": "Appends metric query begin into a command list.", + "details": [ + "The application must ensure the metric query is accessible by the device on which the command list was created.", + "The application must ensure the command list and metric query were created on the same context.", + "This command blocks all following commands from beginning until the execution of the query completes.", + "The application must **not** call this function from simultaneous threads with the same command list handle." + ], + "hash": "84fe1ebe23db5e8ef6eea4d147307ac6af09f6df489af8613329efb938d59e2e", + "name": "AppendMetricQueryBegin", + "params": [ + { + "desc": "[in] handle of the command list", + "name": "hCommandList", + "type": "$t_command_list_handle_t" + }, + { + "desc": "[in] handle of the metric query", + "name": "hMetricQuery", + "type": "$t_metric_query_handle_t" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hCommandList`", + "`nullptr == hMetricQuery`" + ] + } + ], + "type": "function" + }, + { + "class": "$tCommandList", + "desc": "Appends metric query end into a command list.", + "details": [ + "The application must ensure the metric query and events are accessible by the device on which the command list was created.", + "The application must ensure the command list, events and metric query were created on the same context.", + "The duration of the signal event created from an event pool that was created using $X_EVENT_POOL_FLAG_KERNEL_TIMESTAMP flag is undefined. However, for consistency and orthogonality the event will report correctly as signaled when used by other event API functionality.", + "If numWaitEvents is zero, then all previous commands are completed prior to the execution of the query.", + "If numWaitEvents is non-zero, then all phWaitEvents must be signaled prior to the execution of the query.", + "This command blocks all following commands from beginning until the execution of the query completes.", + "The application must **not** call this function from simultaneous threads with the same command list handle." + ], + "hash": "20793bcbc2a57cd3cd64765ed31236e03d78c596d549679ccb5733f2829ff01e", + "name": "AppendMetricQueryEnd", + "params": [ + { + "desc": "[in] handle of the command list", + "name": "hCommandList", + "type": "$t_command_list_handle_t" + }, + { + "desc": "[in] handle of the metric query", + "name": "hMetricQuery", + "type": "$t_metric_query_handle_t" + }, + { + "desc": "[in][optional] handle of the event to signal on completion", + "name": "hSignalEvent", + "type": "$x_event_handle_t" + }, + { + "desc": "[in] must be zero", + "name": "numWaitEvents", + "type": "uint32_t" + }, + { + "desc": "[in][mbz] must be nullptr", + "name": "phWaitEvents", + "type": "$x_event_handle_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hCommandList`", + "`nullptr == hMetricQuery`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT": [] + }, + { + "$X_RESULT_ERROR_INVALID_SIZE": [ + "`(nullptr == phWaitEvents) && (0 < numWaitEvents)`" + ] + } + ], + "type": "function" + }, + { + "class": "$tCommandList", + "desc": "Appends metric query commands to flush all caches.", + "details": [ + "The application must **not** call this function from simultaneous threads with the same command list handle." + ], + "hash": "9f3cba9f6f40a91263c007a1f597465b2b96639756498cbd3a1f6a034e4b6f3a", + "name": "AppendMetricMemoryBarrier", + "params": [ + { + "desc": "[in] handle of the command list", + "name": "hCommandList", + "type": "$t_command_list_handle_t" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hCommandList`" + ] + } + ], + "type": "function" + }, + { + "class": "$tMetricQuery", + "desc": "Retrieves raw data for a given metric query.", + "details": [ + "The application may call this function from simultaneous threads." + ], + "hash": "80cdaba4fc2a26a2427d93307cd9bf45b900a795ffb6f1f21eb0c74ccfd23ba6", + "name": "GetData", + "params": [ + { + "desc": "[in] handle of the metric query", + "name": "hMetricQuery", + "type": "$t_metric_query_handle_t" + }, + { + "desc": "[in,out] pointer to size in bytes of raw data requested to read.\nif size is zero, then the driver will update the value with the total size in bytes needed for all reports available.\nif size is non-zero, then driver will only retrieve the number of reports that fit into the buffer.\nif size is larger than size needed for all reports, then driver will update the value with the actual size needed.\n", + "name": "pRawDataSize", + "type": "size_t*" + }, + { + "desc": "[in,out][optional][range(0, *pRawDataSize)] buffer containing query reports in raw format", + "name": "pRawData", + "type": "uint8_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricQuery`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pRawDataSize`" + ] + } + ], + "type": "function" + }, + { + "attribute": "singleton", + "desc": "C++ wrapper for metric group", + "members": [ + { + "desc": "[in] handle of metric group object", + "init": "nullptr", + "name": "handle", + "type": "$t_metric_group_handle_t" + }, + { + "desc": "[in] pointer to owner object", + "name": "pDevice", + "type": "$tDevice*" + } + ], + "name": "$tMetricGroup", + "owner": "$tDevice", + "type": "class" + }, + { + "attribute": "singleton", + "desc": "C++ wrapper for metric", + "members": [ + { + "desc": "[in] handle of metric object", + "name": "handle", + "type": "$t_metric_handle_t" + }, + { + "desc": "[in] pointer to owner object", + "name": "pMetricGroup", + "type": "$tMetricGroup*" + } + ], + "name": "$tMetric", + "owner": "$tMetricGroup", + "type": "class" + }, + { + "desc": "C++ wrapper for metric streamer", + "members": [ + { + "desc": "[in] handle of metric streamer object", + "name": "handle", + "type": "$t_metric_streamer_handle_t" + }, + { + "desc": "[in] pointer to owner object", + "name": "pDevice", + "type": "$tDevice*" + }, + { + "desc": "[in] descriptor of the metric streamer", + "name": "desc", + "type": "$t_metric_streamer_desc_t" + } + ], + "name": "$tMetricStreamer", + "owner": "$tDevice", + "type": "class" + }, + { + "desc": "C++ wrapper for metric query pool", + "members": [ + { + "desc": "[in] handle of metric query pool object", + "name": "handle", + "type": "$t_metric_query_pool_handle_t" + }, + { + "desc": "[in] pointer to owner object", + "name": "pDevice", + "type": "$tDevice*" + }, + { + "desc": "[in] descriptor of the metric query pool", + "name": "desc", + "type": "$t_metric_query_pool_desc_t" + } + ], + "name": "$tMetricQueryPool", + "owner": "$tDevice", + "type": "class" + }, + { + "desc": "C++ wrapper for metric query", + "members": [ + { + "desc": "[in] handle of metric query object", + "name": "handle", + "type": "$t_metric_query_handle_t" + }, + { + "desc": "[in] pointer to owner object", + "name": "pDevice", + "type": "$tDevice*" + } + ], + "name": "$tMetricQuery", + "owner": "$tDevice", + "type": "class" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Tool APIs for Program Instrumentation (PIN)", + "ordinal": 1000, + "type": "header" + }, + "name": "pin", + "objects": [ + { + "class": "$tKernel", + "desc": "Supportted profile features", + "etors": [ + { + "desc": "request the compiler attempt to minimize register usage as much as possible to allow for instrumentation", + "name": "$T_PROFILE_FLAG_REGISTER_REALLOCATION", + "value": "$X_BIT(0)" + }, + { + "desc": "request the compiler generate free register info", + "name": "$T_PROFILE_FLAG_FREE_REGISTER_INFO", + "value": "$X_BIT(1)" + } + ], + "name": "$t_profile_flags_t", + "type": "enum" + }, + { + "base": "$t_base_properties_t", + "class": "$tKernel", + "desc": "Profiling meta-data for instrumentation", + "members": [ + { + "desc": "[in] type of this structure", + "init": "$T_STRUCTURE_TYPE_PROFILE_PROPERTIES", + "name": "stype", + "type": "$t_structure_type_t" + }, + { + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" + }, + { + "desc": "[out] indicates which flags were enabled during compilation.\nreturns 0 (none) or a combination of $t_profile_flag_t\n", + "name": "flags", + "type": "$t_profile_flags_t" + }, + { + "desc": "[out] number of tokens immediately following this structure", + "name": "numTokens", + "type": "uint32_t" + } + ], + "name": "$t_profile_properties_t", + "type": "struct" + }, + { + "class": "$tKernel", + "desc": "Supported profile token types", + "etors": [ + { + "desc": "GRF info", + "name": "$T_PROFILE_TOKEN_TYPE_FREE_REGISTER", + "value": "0" + } + ], + "name": "$t_profile_token_type_t", + "type": "enum" + }, + { + "class": "$tKernel", + "desc": "Profile free register token detailing unused registers in the current function", + "members": [ + { + "desc": "[out] type of token", + "name": "type", + "type": "$t_profile_token_type_t" + }, + { + "desc": "[out] total size of the token, in bytes", + "name": "size", + "type": "uint32_t" + }, + { + "desc": "[out] number of register sequences immediately following this structure", + "name": "count", + "type": "uint32_t" + } + ], + "name": "$t_profile_free_register_token_t", + "type": "struct" + }, + { + "class": "$tKernel", + "desc": "Profile register sequence detailing consecutive bytes, all of which are unused", + "members": [ + { + "desc": "[out] starting byte in the register table, representing the start of unused bytes in the current function", + "name": "start", + "type": "uint32_t" + }, + { + "desc": "[out] number of consecutive bytes in the sequence, starting from start", + "name": "count", + "type": "uint32_t" + } + ], + "name": "$t_profile_register_sequence_t", + "type": "struct" + }, + { + "class": "$tKernel", + "desc": "Retrieve profiling information generated for the kernel.", + "details": [ + { + "Module must be created using the following build option:": [ + "\"-$t-profile-flags \" - enable generation of profile information", + "\"\" must be a combination of $t_profile_flag_t, in hex" + ] + }, + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "daba304e8f1cfd945f7fcfe506ff1f93db38b2e14d5ec6326ce09a0180dbff9d", + "name": "GetProfileInfo", + "params": [ + { + "desc": "[in] handle to kernel", + "name": "hKernel", + "type": "$t_kernel_handle_t" + }, + { + "desc": "[out] pointer to profile properties", + "name": "pProfileProperties", + "type": "$t_profile_properties_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hKernel`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pProfileProperties`" + ] + } + ], + "type": "function" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Tool Experimental Extension APIs for API Tracing", + "ordinal": 1000, + "type": "header" + }, + "name": "tracing", + "objects": [ + { + "desc": "API Tracing Experimental Extension Name", + "name": "$T_API_TRACING_EXP_NAME", + "type": "macro", + "value": "\"$XT_experimental_api_tracing\"" + }, + { + "desc": "API Tracing Experimental Extension Version(s)", + "etors": [ + { + "desc": "version 1.0", + "name": "$T_API_TRACING_EXP_VERSION_1_0", + "value": "$X_MAKE_VERSION( 1, 0 )" + }, + { + "desc": "latest known version", + "name": "$T_API_TRACING_EXP_VERSION_CURRENT", + "value": "$X_MAKE_VERSION( 1, 0 )" + } + ], + "name": "$t_api_tracing_exp_version_t", + "type": "enum" + }, + { + "class": "$tTracerExp", + "desc": "Alias the existing callbacks definition for 'core' callbacks", + "name": "$t_core_callbacks_t", + "type": "typedef", + "value": "$x_callbacks_t" + }, + { + "base": "$t_base_desc_t", + "class": "$tTracerExp", + "desc": "Tracer descriptor", + "members": [ + { + "desc": "[in] type of this structure", + "init": "$T_STRUCTURE_TYPE_TRACER_EXP_DESC", + "name": "stype", + "type": "$t_structure_type_t" + }, + { + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, + { + "desc": "[in] pointer passed to every tracer's callbacks", + "name": "pUserData", + "type": "void*" + } + ], + "name": "$t_tracer_exp_desc_t", + "type": "struct" + }, + { + "class": "$tTracerExp", + "decl": "static", + "desc": "Creates a tracer on the context.", + "details": [ + "The application must only use the tracer for the context which was provided during creation.", + "The tracer is created in the disabled state.", + "The application may call this function from simultaneous threads.", + "The implementation of this function must be thread-safe." + ], + "hash": "99654d158628fa6f80a407f4c6dd5fc582fec9bef666d5e4e841639ff3ddf90b", + "name": "Create", + "ordinal": "0", + "params": [ + { + "desc": "[in] handle of the context object", + "name": "hContext", + "type": "$t_context_handle_t" + }, + { + "desc": "[in] pointer to tracer descriptor", + "name": "desc", + "type": "const $t_tracer_exp_desc_t*" + }, + { + "desc": "[out] pointer to handle of tracer object created", + "name": "phTracer", + "type": "$t_tracer_exp_handle_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hContext`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == desc`", + "`nullptr == desc->pUserData`", + "`nullptr == phTracer`" + ] + } + ], + "type": "function" + }, + { + "class": "$tTracerExp", + "decl": "static", + "desc": "Destroys a tracer.", + "details": [ + "The application must **not** call this function from simultaneous threads with the same tracer handle.", + "The implementation of this function must be thread-safe.", + "The implementation of this function will stall and wait on any outstanding threads executing callbacks before freeing any Host allocations associated with this tracer." + ], + "hash": "93988865d3b59785a30efbb5b38fea9024972b775e1ec2b82b52cfcd53e0fac2", + "name": "Destroy", + "ordinal": "0", + "params": [ + { + "desc": "[in][release] handle of tracer object to destroy", + "name": "hTracer", + "type": "$t_tracer_exp_handle_t" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hTracer`" + ] + }, + { + "$X_RESULT_ERROR_HANDLE_OBJECT_IN_USE": [] + } + ], + "type": "function" + }, + { + "class": "$tTracerExp", + "desc": "Sets the collection of callbacks to be executed **before** driver execution.", + "details": [ + "The application only needs to set the function pointers it is interested in receiving; all others should be 'nullptr'", + "The application must ensure that no other threads are executing functions for which the tracing functions are changing.", + "The application must **not** call this function from simultaneous threads with the same tracer handle." + ], + "hash": "3757c0ce726200f3b8edc93579a5460a058c240b7c52a06ff74e4756ebfc3eb0", + "name": "SetPrologues", + "params": [ + { + "desc": "[in] handle of the tracer", + "name": "hTracer", + "type": "$t_tracer_exp_handle_t" + }, + { + "desc": "[in] pointer to table of 'core' callback function pointers", + "name": "pCoreCbs", + "type": "$t_core_callbacks_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hTracer`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCoreCbs`" + ] + } + ], + "type": "function" + }, + { + "class": "$tTracerExp", + "desc": "Sets the collection of callbacks to be executed **after** driver execution.", + "details": [ + "The application only needs to set the function pointers it is interested in receiving; all others should be 'nullptr'", + "The application must ensure that no other threads are executing functions for which the tracing functions are changing.", + "The application must **not** call this function from simultaneous threads with the same tracer handle." + ], + "hash": "fe64ecc4c3782cee737bb511673becc83b0a86f22604887853b751fe9ce897df", + "name": "SetEpilogues", + "params": [ + { + "desc": "[in] handle of the tracer", + "name": "hTracer", + "type": "$t_tracer_exp_handle_t" + }, + { + "desc": "[in] pointer to table of 'core' callback function pointers", + "name": "pCoreCbs", + "type": "$t_core_callbacks_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hTracer`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCoreCbs`" + ] + } + ], + "type": "function" + }, + { + "class": "$tTracerExp", + "desc": "Enables (or disables) the tracer", + "details": [ + "The application must **not** call this function from simultaneous threads with the same tracer handle." + ], + "hash": "60691e67f575e8b84d93b29f94642fafd9b9a302bc05b5f0d45340e335804de9", + "name": "SetEnabled", + "params": [ + { + "desc": "[in] handle of the tracer", + "name": "hTracer", + "type": "$t_tracer_exp_handle_t" + }, + { + "desc": "[in] enable the tracer if true; disable if false", + "name": "enable", + "type": "$x_bool_t" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hTracer`" + ] + } + ], + "type": "function" + }, + { + "desc": "C++ wrapper for tracer", + "members": [ + { + "desc": "[in] handle of tracer object", + "name": "handle", + "type": "$t_tracer_exp_handle_t" + }, + { + "desc": "[in] pointer to owner object", + "name": "pDriver", + "type": "$tDriver*" + }, + { + "desc": "[in] descriptor of the tracer object", + "name": "desc", + "type": "$t_tracer_exp_desc_t" + } + ], + "name": "$tTracerExp", + "owner": "$tDriver", + "type": "class" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Tool Experimental Extension to get Concurrent Metric Groups", + "ordinal": 1100, + "type": "header", + "version": "1.10" + }, + "name": "concurrentMetricGroup", + "objects": [ + { + "desc": "Concurrent Metric Groups Experimental Extension Name", + "name": "$T_CONCURRENT_METRIC_GROUPS_EXP_NAME", + "type": "macro", + "value": "\"$XT_experimental_concurrent_metric_groups\"", + "version": "1.10" + }, + { + "desc": "Concurrent Metric Groups Experimental Extension Version(s)", + "etors": [ + { + "desc": "version 1.0", + "name": "$T_CONCURRENT_METRIC_GROUPS_EXP_VERSION_1_0", + "value": "$X_MAKE_VERSION( 1, 0 )" + }, + { + "desc": "latest known version", + "name": "$T_CONCURRENT_METRIC_GROUPS_EXP_VERSION_CURRENT", + "value": "$X_MAKE_VERSION( 1, 0 )" + } + ], + "name": "$t_concurrent_metric_groups_exp_version_t", + "type": "enum", + "version": "1.10" + }, + { + "class": "$tDevice", + "decl": "static", + "desc": "Get sets of metric groups which could be collected concurrently.", + "details": [ + "Re-arrange the input metric groups to provide sets of concurrent metric groups." + ], + "hash": "dff2f294997531b6afb852cad66aae3432985a730c3ffcabc927d9283ed49649", + "name": "GetConcurrentMetricGroupsExp", + "params": [ + { + "desc": "[in] handle of the device", + "name": "hDevice", + "type": "$t_device_handle_t" + }, + { + "desc": "[in] metric group count", + "name": "metricGroupCount", + "type": "uint32_t" + }, + { + "desc": "[in,out] metrics groups to be re-arranged to be sets of concurrent groups", + "name": "phMetricGroups", + "type": "$t_metric_group_handle_t *" + }, + { + "desc": "[in,out][optional][*pConcurrentGroupCount] count of metric groups per concurrent group.\n", + "name": "pMetricGroupsCountPerConcurrentGroup", + "type": "uint32_t *" + }, + { + "desc": "[out] number of concurrent groups.\nThe value of this parameter could be used to determine the number of replays necessary.", + "name": "pConcurrentGroupCount", + "type": "uint32_t *" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDevice`", + "`nullptr == phMetricGroups`" + ] + } + ], + "type": "function", + "version": "1.10" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Tool Experimental Extension for Metrics Tracer", + "ordinal": 1100, + "type": "header", + "version": "1.10" + }, + "name": "metricTracer", + "objects": [ + { + "desc": "Metric Tracer Experimental Extension Name", + "name": "$T_METRICS_TRACER_EXP_NAME", + "type": "macro", + "value": "\"$XT_experimental_metric_tracer\"", + "version": "1.10" + }, + { + "desc": "Metric Tracer Experimental Extension Version(s)", + "etors": [ + { + "desc": "version 1.0", + "name": "$T_METRIC_TRACER_EXP_VERSION_1_0", + "value": "$X_MAKE_VERSION( 1, 0 )" + }, + { + "desc": "latest known version", + "name": "$T_METRIC_TRACER_EXP_VERSION_CURRENT", + "value": "$X_MAKE_VERSION( 1, 0 )" + } + ], + "name": "$t_metric_tracer_exp_version_t", + "type": "enum", + "version": "1.10" + }, + { + "class": "$tMetricTracer", + "desc": "Handle of metric tracer's object", + "name": "$t_metric_tracer_exp_handle_t", + "type": "handle", + "version": "1.10" + }, + { + "class": "$tMetricDecoder", + "desc": "Handle of metric decoder's object", + "name": "$t_metric_decoder_exp_handle_t", + "type": "handle", + "version": "1.10" + }, + { + "base": "$t_base_desc_t", + "class": "$tMetricTracer", + "desc": "Metric tracer descriptor", + "members": [ + { + "desc": "[in] type of this structure", + "init": "$T_STRUCTURE_TYPE_METRIC_TRACER_EXP_DESC", + "name": "stype", + "type": "$t_structure_type_t" + }, + { + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, + { + "desc": "[in,out] number of collected bytes after which notification event will be signaled. If the requested value is not supported exactly, then the driver may use a value that is the closest supported approximation and shall update this member during $tMetricTracerCreateExp.\n", + "name": "notifyEveryNBytes", + "type": "uint32_t" + } + ], + "name": "$t_metric_tracer_exp_desc_t", + "type": "struct", + "version": "1.10" + }, + { + "desc": "Decoded metric entry", + "members": [ + { + "desc": "[out] value of the decodable metric entry or event. Number is meaningful based on the metric type.", + "name": "value", + "type": "$t_value_t" + }, + { + "desc": "[out] timestamp at which the event happened.", + "name": "timeStamp", + "type": "uint64_t" + }, + { + "desc": "[out] index to the decodable metric handle in the input array (phMetric) in $tMetricTracerDecodeExp().", + "name": "metricIndex", + "type": "uint32_t" + }, + { + "desc": "[out] True if the event occurred on a sub-device; false means the device on which the metric tracer was opened does not have sub-devices.", + "name": "onSubdevice", + "type": "$x_bool_t" + }, + { + "desc": "[out] If onSubdevice is true, this gives the ID of the sub-device.", + "name": "subdeviceId", + "type": "uint32_t" + } + ], + "name": "$t_metric_entry_exp_t", + "type": "struct", + "version": "1.10" + }, + { + "class": "$tMetricTracer", + "decl": "static", + "desc": "Create a metric tracer for a device.", + "details": [ + "The notification event must have been created from an event pool that was created using $X_EVENT_POOL_FLAG_HOST_VISIBLE flag.", + "The duration of the signal event created from an event pool that was created using $X_EVENT_POOL_FLAG_KERNEL_TIMESTAMP flag is undefined. However, for consistency and orthogonality the event will report correctly as signaled when used by other event API functionality.", + "The application must **not** call this function from simultaneous threads with the same device handle.", + "The metric tracer is created in disabled state", + "Metric groups must support sampling type ZET_METRIC_SAMPLING_TYPE_EXP_FLAG_TRACER_BASED", + "All metric groups must be first activated" + ], + "hash": "7b7468fec9336a7ac2b4b6a0846260b983444b3f7285a2e3f909e8d213cae0ac", + "name": "CreateExp", + "params": [ + { + "desc": "[in] handle of the context object", + "name": "hContext", + "type": "$t_context_handle_t" + }, + { + "desc": "[in] handle of the device", + "name": "hDevice", + "type": "$t_device_handle_t" + }, + { + "desc": "[in] metric group count", + "name": "metricGroupCount", + "type": "uint32_t" + }, + { + "desc": "[in][range(0, metricGroupCount )] handles of the metric groups to trace", + "name": "phMetricGroups", + "type": "$t_metric_group_handle_t*" + }, + { + "desc": "[in,out] metric tracer descriptor", + "name": "desc", + "type": "$t_metric_tracer_exp_desc_t*" + }, + { + "desc": "[in][optional] event used for report availability notification. Note: If buffer is not drained when the event it flagged, there is a risk of HW event buffer being overrun", + "name": "hNotificationEvent", + "type": "$x_event_handle_t" + }, + { + "desc": "[out] handle of the metric tracer", + "name": "phMetricTracer", + "type": "$t_metric_tracer_exp_handle_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hContext`", + "`nullptr == hDevice`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == phMetricGroups`", + "`nullptr == desc`", + "`nullptr == phMetricTracer`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT": [] + } + ], + "type": "function", + "version": "1.10" + }, + { + "class": "$tMetricTracer", + "desc": "Destroy a metric tracer.", + "details": [ + "The application must **not** call this function from simultaneous threads with the same metric tracer handle." + ], + "hash": "4fe910801b127175d6e8545ac4911e0495cde30c57f9812c2093c60f2b0f844f", + "name": "DestroyExp", + "params": [ + { + "desc": "[in] handle of the metric tracer", + "name": "hMetricTracer", + "type": "$t_metric_tracer_exp_handle_t" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricTracer`" + ] + } + ], + "type": "function", + "version": "1.10" + }, + { + "class": "$tMetricTracer", + "desc": "Start events collection", + "details": [ + "Driver implementations must make this API call have as minimal overhead as possible, to allow applications start/stop event collection at any point during execution", + "The application must **not** call this function from simultaneous threads with the same metric tracer handle." + ], + "hash": "1e622842ff448bf8d5e1177c89702e45f7bc41daf0ff063cc4f9b85875ccae37", + "name": "EnableExp", + "params": [ + { + "desc": "[in] handle of the metric tracer", + "name": "hMetricTracer", + "type": "$t_metric_tracer_exp_handle_t" + }, + { + "desc": "[in] request synchronous behavior. Confirmation of successful asynchronous operation is done by calling $tMetricTracerReadDataExp()\nand checking the return status: $X_RESULT_NOT_READY will be returned when the tracer is inactive. $X_RESULT_SUCCESS will be returned \nwhen the tracer is active.\n", + "name": "synchronous", + "type": "$x_bool_t" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricTracer`" + ] + } + ], + "type": "function", + "version": "1.10" + }, + { + "class": "$tMetricTracer", + "desc": "Stop events collection", + "details": [ + "Driver implementations must make this API call have as minimal overhead as possible, to allow applications start/stop event collection at any point during execution", + "The application must **not** call this function from simultaneous threads with the same metric tracer handle." + ], + "hash": "bd1d3df88b48f5feadd445e8944c5a243ef6d2fed1ef23e9a5a25880f79fcf7b", + "name": "DisableExp", + "params": [ + { + "desc": "[in] handle of the metric tracer", + "name": "hMetricTracer", + "type": "$t_metric_tracer_exp_handle_t" + }, + { + "desc": "[in] request synchronous behavior. Confirmation of successful asynchronous operation is done by calling $tMetricTracerReadDataExp()\nand checking the return status: $X_RESULT_SUCCESS will be returned when the tracer is active or when it is inactive but still has data. \n$X_RESULT_NOT_READY will be returned when the tracer is inactive and has no more data to be retrieved.\n", + "name": "synchronous", + "type": "$x_bool_t" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricTracer`" + ] + } + ], + "type": "function", + "version": "1.10" + }, + { + "class": "$tMetricTracer", + "desc": "Read data from the metric tracer", + "details": [ + "The application must **not** call this function from simultaneous threads with the same metric tracer handle.", + "Data can be retrieved after tracer is disabled. When buffers are drained $X_RESULT_NOT_READY will be returned" + ], + "hash": "5487726b2e17dbb2ac53d54468778abe6c7d2a8aa49934adbf22b4cf032f6dc7", + "name": "ReadDataExp", + "params": [ + { + "desc": "[in] handle of the metric tracer", + "name": "hMetricTracer", + "type": "$t_metric_tracer_exp_handle_t" + }, + { + "desc": "[in,out] pointer to size in bytes of raw data requested to read.\nif size is zero, then the driver will update the value with the total size in bytes needed for all data available.\nif size is non-zero, then driver will only retrieve that amount of data. \nif size is larger than size needed for all data, then driver will update the value with the actual size needed.\n", + "name": "pRawDataSize", + "type": "size_t*" + }, + { + "desc": "[in,out][optional][range(0, *pRawDataSize)] buffer containing tracer data in raw format", + "name": "pRawData", + "type": "uint8_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricTracer`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pRawDataSize`" + ] + }, + { + "$X_RESULT_WARNING_DROPPED_DATA": [ + "Metric tracer data may have been dropped." + ] + }, + { + "$X_RESULT_NOT_READY": [ + "Metric tracer is disabled and no data is available to read." + ] + } + ], + "type": "function", + "version": "1.10" + }, + { + "class": "$tMetricDecoder", + "desc": "Create a metric decoder for a given metric tracer.", + "hash": "b7f88741747f8d30d766cb169deb1050458c1500c3c13ebed313d701cd398f29", + "name": "CreateExp", + "params": [ + { + "desc": "[in] handle of the metric tracer", + "name": "hMetricTracer", + "type": "$t_metric_tracer_exp_handle_t" + }, + { + "desc": "[out] handle of the metric decoder object", + "name": "phMetricDecoder", + "type": "$t_metric_decoder_exp_handle_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricTracer`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == phMetricDecoder`" + ] + } + ], + "type": "function", + "version": "1.10" + }, + { + "class": "$tMetricDecoder", + "desc": "Destroy a metric decoder.", + "hash": "6ead8daade93dfc75b4e1943ba909f418ce3e7d3078da0b65f5831f87218cc15", + "name": "DestroyExp", + "params": [ + { + "desc": "[in] handle of the metric decoder object", + "name": "phMetricDecoder", + "type": "$t_metric_decoder_exp_handle_t" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == phMetricDecoder`" + ] + } + ], + "type": "function", + "version": "1.10" + }, + { + "class": "$tMetricDecoder", + "desc": "Return the list of the decodable metrics from the decoder.", + "details": [ + "The decodable metrics handles returned by this API are defined by the metric groups in the tracer on which the decoder was created.", + "The decodable metrics handles returned by this API are only valid to decode metrics raw data with $tMetricTracerDecodeExp(). Decodable metric handles are not valid to compare with metrics handles included in metric groups." + ], + "hash": "3d1ac19733022f5c93c944a43f72fd41b0c9fbe93bce83ba5063fd16d7cb6dcf", + "name": "GetDecodableMetricsExp", + "params": [ + { + "desc": "[in] handle of the metric decoder object", + "name": "hMetricDecoder", + "type": "$t_metric_decoder_exp_handle_t" + }, + { + "desc": "[in,out] pointer to number of decodable metric in the hMetricDecoder handle. If count is zero, then the driver shall \nupdate the value with the total number of decodable metrics available in the decoder. if count is greater than zero \nbut less than the total number of decodable metrics available in the decoder, then only that number will be returned. \nif count is greater than the number of decodable metrics available in the decoder, then the driver shall update the \nvalue with the actual number of decodable metrics available. \n", + "name": "pCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out] [range(0, *pCount)] array of handles of decodable metrics in the hMetricDecoder handle provided.", + "name": "phMetrics", + "type": "$t_metric_handle_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricDecoder`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCount`", + "`nullptr == phMetrics`" + ] + } + ], + "type": "function", + "version": "1.10" + }, + { + "class": "$tMetricTracer", + "desc": "Decode raw events collected from a tracer.", + "hash": "07e0bc42a335a52149afacfd2297ba845ca79452fc78671bc2d3e06299c2aca1", + "name": "DecodeExp", + "params": [ + { + "desc": "[in] handle of the metric decoder object", + "name": "phMetricDecoder", + "type": "$t_metric_decoder_exp_handle_t" + }, + { + "desc": "[in,out] size in bytes of raw data buffer. If pMetricEntriesCount is greater than zero but less than total number of \ndecodable metrics available in the raw data buffer, then driver shall update this value with actual number of raw \ndata bytes processed.\n", + "name": "pRawDataSize", + "type": "size_t*" + }, + { + "desc": "[in,out][optional][range(0, *pRawDataSize)] buffer containing tracer data in raw format", + "name": "pRawData", + "type": "uint8_t*" + }, + { + "desc": "[in] number of decodable metrics in the tracer for which the hMetricDecoder handle was provided. See \n$tMetricDecoderGetDecodableMetricsExp(). If metricCount is greater than zero but less than the number decodable \nmetrics available in the raw data buffer, then driver shall only decode those.\n", + "name": "metricsCount", + "type": "uint32_t" + }, + { + "desc": "[in] [range(0, metricsCount)] array of handles of decodable metrics in the decoder for which the hMetricDecoder handle was \nprovided. Metrics handles are expected to be for decodable metrics, see $tMetricDecoderGetDecodableMetrics() \n", + "name": "phMetrics", + "type": "$t_metric_handle_t*" + }, + { + "desc": "[in,out] pointer to number of metric sets. If count is zero, then the driver shall update the value with the total\nnumber of metric sets to be decoded. If count is greater than the number available in the raw data buffer, then the\ndriver shall update the value with the actual number of metric sets to be decoded. There is a 1:1 relation between\nthe number of sets and sub-devices returned in the decoded entries.\n", + "name": "pSetCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pSetCount)] buffer of metric entries counts per metric set, one value per set.\n", + "name": "pMetricEntriesCountPerSet", + "type": "uint32_t*" + }, + { + "desc": "[in,out] pointer to the total number of metric entries decoded, for all metric sets. If count is zero, then the\ndriver shall update the value with the total number of metric entries to be decoded. If count is greater than zero\nbut less than the total number of metric entries available in the raw data, then user provided number will be decoded.\nIf count is greater than the number available in the raw data buffer, then the driver shall update the value with\nthe actual number of decodable metric entries decoded. If set to null, then driver will only update the value of\npSetCount.\n", + "name": "pMetricEntriesCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pMetricEntriesCount)] buffer containing decoded metric entries", + "name": "pMetricEntries", + "type": "$t_metric_entry_exp_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == phMetricDecoder`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pRawDataSize`", + "`nullptr == phMetrics`", + "`nullptr == pSetCount`", + "`nullptr == pMetricEntriesCount`" + ] + } + ], + "type": "function", + "version": "1.10" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Tool Experimental Extension for Metrics/Metric Groups which export Memory", + "ordinal": 1110, + "type": "header", + "version": "1.11" + }, + "name": "metricExportMemory", + "objects": [ + { + "class": "$tMetricGroup", + "desc": "Metric group type", + "etors": [ + { + "desc": "Metric group and metrics exports memory using linux dma-buf, which could be imported/mapped to the host process. Properties of the dma_buf could be queried using $t_export_dma_buf_exp_properties_t.", + "name": "$T_METRIC_GROUP_TYPE_EXP_FLAG_EXPORT_DMA_BUF", + "value": "$X_BIT(0)" + }, + { + "desc": "Metric group created using $tMetricGroupCreateExp", + "name": "$T_METRIC_GROUP_TYPE_EXP_FLAG_USER_CREATED", + "value": "$X_BIT(1)" + }, + { + "desc": "Metric group which has a collection of metrics", + "name": "$T_METRIC_GROUP_TYPE_EXP_FLAG_OTHER", + "value": "$X_BIT(2)" + } + ], + "name": "$t_metric_group_type_exp_flags_t", + "type": "enum" + }, + { + "base": "$t_base_properties_t", + "class": "$tMetricGroup", + "desc": "Query the metric group type using `pNext` of $t_metric_group_properties_t", + "members": [ + { + "desc": "[in] type of this structure", + "init": "$T_STRUCTURE_TYPE_METRIC_GROUP_TYPE_EXP", + "name": "stype", + "type": "$t_structure_type_t" + }, + { + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" + }, + { + "desc": "[out] metric group type.\nreturns a combination of $t_metric_group_type_exp_flags_t.\n", + "name": "type", + "type": "$t_metric_group_type_exp_flags_t" + } + ], + "name": "$t_metric_group_type_exp_t", + "type": "struct" + }, + { + "base": "$t_base_properties_t", + "class": "$tMetric", + "desc": "Exported dma_buf properties queried using `pNext` of $t_metric_group_properties_t or $t_metric_properties_t", + "members": [ + { + "desc": "[in] type of this structure", + "init": "$T_STRUCTURE_TYPE_EXPORT_DMA_BUF_EXP_PROPERTIES", + "name": "stype", + "type": "$t_structure_type_t" + }, + { + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" + }, + { + "desc": "[out] the file descriptor handle that could be used to import the memory by the host process.", + "name": "fd", + "type": "int" + }, + { + "desc": "[out] size in bytes of the dma_buf", + "name": "size", + "type": "size_t" + } + ], + "name": "$t_export_dma_buf_exp_properties_t", + "type": "struct" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Tool Experimental Extension for Calculating Multiple Metrics", + "ordinal": 1200, + "type": "header", + "version": "1.2" + }, + "name": "multiMetricValues", + "objects": [ + { + "desc": "Calculating Multiple Metrics Experimental Extension Name", + "name": "$T_MULTI_METRICS_EXP_NAME", + "type": "macro", + "value": "\"$XT_experimental_calculate_multiple_metrics\"", + "version": "1.2" + }, + { + "desc": "Calculating Multiple Metrics Experimental Extension Version(s)", + "etors": [ + { + "desc": "version 1.0", + "name": "$X_CALCULATE_MULTIPLE_METRICS_EXP_VERSION_1_0", + "value": "$X_MAKE_VERSION( 1, 0 )" + }, + { + "desc": "latest known version", + "name": "$X_CALCULATE_MULTIPLE_METRICS_EXP_VERSION_CURRENT", + "value": "$X_MAKE_VERSION( 1, 0 )" + } + ], + "name": "$x_calculate_multiple_metrics_exp_version_t", + "type": "enum", + "version": "1.2" + }, + { + "class": "$tMetricGroup", + "decl": "static", + "desc": "Calculate one or more sets of metric values from raw data.", + "details": [ + "This function is similar to $tMetricGroupCalculateMetricValues except it may calculate more than one set of metric values from a single data buffer. There may be one set of metric values for each sub-device, for example.", + "Each set of metric values may consist of a different number of metric values, returned as the metric value count.", + "All metric values are calculated into a single buffer; use the metric counts to determine which metric values belong to which set.", + "The application may call this function from simultaneous threads." + ], + "hash": "e2074d5e3c7ddbf7f7bd4a5a71cdb32afce7fdf407b420ee8e22d44c84e0bb83", + "name": "CalculateMultipleMetricValuesExp", + "params": [ + { + "desc": "[in] handle of the metric group", + "name": "hMetricGroup", + "type": "$t_metric_group_handle_t" + }, + { + "desc": "[in] calculation type to be applied on raw data", + "name": "type", + "type": "$t_metric_group_calculation_type_t" + }, + { + "desc": "[in] size in bytes of raw data buffer", + "name": "rawDataSize", + "type": "size_t" + }, + { + "desc": "[in][range(0, rawDataSize)] buffer of raw data to calculate", + "name": "pRawData", + "type": "const uint8_t*" + }, + { + "desc": "[in,out] pointer to number of metric sets.\nif count is zero, then the driver shall update the value with the total number of metric sets to be calculated.\nif count is greater than the number available in the raw data buffer, then the driver shall update the value with the actual number of metric sets to be calculated.\n", + "name": "pSetCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out] pointer to number of the total number of metric values calculated, for all metric sets.\nif count is zero, then the driver shall update the value with the total number of metric values to be calculated.\nif count is greater than the number available in the raw data buffer, then the driver shall update the value with the actual number of metric values to be calculated.\n", + "name": "pTotalMetricValueCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pSetCount)] buffer of metric counts per metric set.\n", + "name": "pMetricCounts", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pTotalMetricValueCount)] buffer of calculated metrics.\nif count is less than the number available in the raw data buffer, then driver shall only calculate that number of metric values.\n", + "name": "pMetricValues", + "type": "$t_typed_value_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricGroup`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_ENUMERATION": [ + "`$T_METRIC_GROUP_CALCULATION_TYPE_MAX_METRIC_VALUES < type`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pRawData`", + "`nullptr == pSetCount`", + "`nullptr == pTotalMetricValueCount`" + ] + } + ], + "type": "function", + "version": "1.2" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Tool Experimental Extension for Global Metric Timestamps", + "ordinal": 1500, + "type": "header", + "version": "1.5" + }, + "name": "GlobalTimestamps", + "objects": [ + { + "desc": "Global Metric Timestamps Experimental Extension Name", + "name": "$T_GLOBAL_METRICS_TIMESTAMPS_EXP_NAME", + "type": "macro", + "value": "\"$XT_experimental_global_metric_timestamps\"", + "version": "1.5" + }, + { + "desc": "Global Metric Timestamps Experimental Extension Version(s)", + "etors": [ + { + "desc": "version 1.0", + "name": "$X_METRIC_GLOBAL_TIMESTAMPS_EXP_VERSION_1_0", + "value": "$X_MAKE_VERSION( 1, 0 )" + }, + { + "desc": "latest known version", + "name": "$X_METRIC_GLOBAL_TIMESTAMPS_EXP_VERSION_CURRENT", + "value": "$X_MAKE_VERSION( 1, 0 )" + } + ], + "name": "$x_metric_global_timestamps_exp_version_t", + "type": "enum", + "version": "1.5" + }, + { + "base": "$t_base_desc_t", + "class": "$tMetric", + "desc": "Metric timestamps resolution", + "details": [ + "This structure may be returned from $tMetricGroupGetProperties via the `pNext` member of $t_metric_group_properties_t.", + "Used for mapping metric timestamps to other timers." + ], + "members": [ + { + "desc": "[in] type of this structure", + "init": "$T_STRUCTURE_TYPE_METRIC_GLOBAL_TIMESTAMPS_RESOLUTION_EXP", + "name": "stype", + "type": "$t_structure_type_t" + }, + { + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, + { + "desc": "[out] Returns the resolution of metrics timer (used for timestamps) in cycles/sec.", + "name": "timerResolution", + "type": "uint64_t" + }, + { + "desc": "[out] Returns the number of valid bits in the timestamp value.", + "name": "timestampValidBits", + "type": "uint64_t" + } + ], + "name": "$t_metric_global_timestamps_resolution_exp_t", + "type": "struct", + "version": "1.5" + }, + { + "class": "$tMetricGroup", + "decl": "static", + "desc": "Returns metric timestamps synchronized with global device timestamps, optionally synchronized with host", + "details": [ + "The application may call this function from simultaneous threads.", + "By default, the global and metrics timestamps are synchronized to the device." + ], + "hash": "223592fae768685fbaf678e7be2615d9d155a4f4c8d4e984da32b75707c71394", + "name": "GetGlobalTimestampsExp", + "params": [ + { + "desc": "[in] handle of the metric group", + "name": "hMetricGroup", + "type": "$t_metric_group_handle_t" + }, + { + "desc": "[in] Returns the timestamps synchronized to the host or the device.", + "init": "false", + "name": "synchronizedWithHost", + "type": "$x_bool_t" + }, + { + "desc": "[out] Device timestamp.\n", + "name": "globalTimestamp", + "type": "uint64_t*" + }, + { + "desc": "[out] Metric timestamp.\n", + "name": "metricTimestamp", + "type": "uint64_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricGroup`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == globalTimestamp`", + "`nullptr == metricTimestamp`" + ] + } + ], + "type": "function", + "version": "1.5" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Tool Experimental Extension for Exporting Metrics Data", + "ordinal": 1600, + "type": "header", + "version": "1.6" + }, + "name": "metricExportData", + "objects": [ + { + "desc": "Exporting Metrics Data Experimental Extension Name", + "name": "$T_EXPORT_METRICS_DATA_EXP_NAME", + "type": "macro", + "value": "\"$XT_experimental_metric_export_data\"", + "version": "1.6" + }, + { + "desc": "Exporting Metrics Data Experimental Extension Version(s)", + "etors": [ + { + "desc": "version 1.0", + "name": "$T_EXPORT_METRIC_DATA_EXP_VERSION_1_0", + "value": "$X_MAKE_VERSION( 1, 0 )" + }, + { + "desc": "latest known version", + "name": "$T_EXPORT_METRIC_DATA_EXP_VERSION_CURRENT", + "value": "$X_MAKE_VERSION( 1, 0 )" + } + ], + "name": "$t_export_metric_data_exp_version_t", + "type": "enum", + "version": "1.6" + }, + { + "desc": "Maximum count of characters in export data element name", + "name": "$T_MAX_METRIC_EXPORT_DATA_ELEMENT_NAME_EXP", + "type": "macro", + "value": "256", + "version": "1.6" + }, + { + "desc": "Maximum export data element description string size", + "name": "$T_MAX_METRIC_EXPORT_DATA_ELEMENT_DESCRIPTION_EXP", + "type": "macro", + "value": "256", + "version": "1.6" + }, + { + "base": "$t_base_desc_t", + "class": "$tMetric", + "desc": "Metrics calculation descriptor", + "members": [ + { + "desc": "[in] type of this structure", + "init": "$T_STRUCTURE_TYPE_METRIC_CALCULATE_EXP_DESC", + "name": "stype", + "type": "$t_structure_type_t" + }, + { + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, + { + "desc": "[in] number of reports to skip during calculation", + "name": "rawReportSkipCount", + "type": "uint32_t" + } + ], + "name": "$t_metric_calculate_exp_desc_t", + "type": "struct", + "version": "1.6" + }, + { + "class": "$tMetricGroup", + "decl": "static", + "desc": "Export Metrics Data for system independent calculation.", + "details": [ + "This function exports raw data and necessary information to perform metrics calculation of collected data in a different system than where data was collected, which may or may not have accelerators.", + "Implementations can choose to describe the data arrangement of the exported data, using any mechanism which allows users to read and process them.", + "The application may call this function from simultaneous threads." + ], + "hash": "499db6354496cf5b11624cc913efa9de29684492f7c073d1b6a55a7015e2e9c5", + "name": "GetExportDataExp", + "params": [ + { + "desc": "[in] handle of the metric group", + "name": "hMetricGroup", + "type": "$t_metric_group_handle_t" + }, + { + "desc": "[in] buffer of raw data", + "name": "pRawData", + "type": "const uint8_t*" + }, + { + "desc": "[in] size in bytes of raw data buffer", + "name": "rawDataSize", + "type": "size_t" + }, + { + "desc": "[in,out] size in bytes of export data buffer\nif size is zero, then the driver shall update the value with the number of bytes necessary to store the exported data.\nif size is greater than required, then the driver shall update the value with the actual number of bytes necessary to store the exported data.\n", + "name": "pExportDataSize", + "type": "size_t*" + }, + { + "desc": "[in,out][optional][range(0, *pExportDataSize)] buffer of exported data.\n", + "name": "pExportData", + "type": "uint8_t *" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricGroup`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pRawData`", + "`nullptr == pExportDataSize`" + ] + } + ], + "type": "function", + "version": "1.6" + }, + { + "class": "$tMetricGroup", + "decl": "static", + "desc": "Calculate one or more sets of metric values from exported raw data.", + "details": [ + "Calculate metrics values using exported data returned by $tMetricGroupGetExportDataExp.", + "This function is similar to $tMetricGroupCalculateMultipleMetricValuesExp except it would calculate from exported metric data.", + "This function could be used to calculate metrics on a system different from where the metric raw data was collected.", + "The application may call this function from simultaneous threads." + ], + "hash": "45b7016f0a5f68adeb96524bb980cfdbf317c31a6a579e8be8dff30f93df6085", + "name": "CalculateMetricExportDataExp", + "params": [ + { + "desc": "[in] handle of the driver instance", + "name": "hDriver", + "type": "$x_driver_handle_t" + }, + { + "desc": "[in] calculation type to be applied on raw data", + "name": "type", + "type": "$t_metric_group_calculation_type_t" + }, + { + "desc": "[in] size in bytes of exported data buffer", + "name": "exportDataSize", + "type": "size_t" + }, + { + "desc": "[in][range(0, exportDataSize)] buffer of exported data to calculate", + "name": "pExportData", + "type": "const uint8_t*" + }, + { + "desc": "[in] descriptor specifying calculation specific parameters", + "name": "pCalculateDescriptor", + "type": "$t_metric_calculate_exp_desc_t*" + }, + { + "desc": "[in,out] pointer to number of metric sets.\nif count is zero, then the driver shall update the value with the total number of metric sets to be calculated.\nif count is greater than the number available in the raw data buffer, then the driver shall update the value with the actual number of metric sets to be calculated.\n", + "name": "pSetCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out] pointer to number of the total number of metric values calculated, for all metric sets.\nif count is zero, then the driver shall update the value with the total number of metric values to be calculated.\nif count is greater than the number available in the raw data buffer, then the driver shall update the value with the actual number of metric values to be calculated.\n", + "name": "pTotalMetricValueCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pSetCount)] buffer of metric counts per metric set.\n", + "name": "pMetricCounts", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pTotalMetricValueCount)] buffer of calculated metrics.\nif count is less than the number available in the raw data buffer, then driver shall only calculate that number of metric values.\n", + "name": "pMetricValues", + "type": "$t_typed_value_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDriver`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_ENUMERATION": [ + "`$T_METRIC_GROUP_CALCULATION_TYPE_MAX_METRIC_VALUES < type`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pExportData`", + "`nullptr == pCalculateDescriptor`", + "`nullptr == pSetCount`", + "`nullptr == pTotalMetricValueCount`" + ] + } + ], + "type": "function", + "version": "1.6" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Tool Experimental Extension for Programmable Metrics", + "ordinal": 1900, + "type": "header", + "version": "1.9" + }, + "name": "metricProgrammable", + "objects": [ + { + "desc": "Programmable Metrics Experimental Extension Name", + "name": "$T_PROGRAMMABLE_METRICS_EXP_NAME", + "type": "macro", + "value": "\"$XT_experimental_programmable_metrics\"", + "version": "1.9" + }, + { + "desc": "Programmable Metrics Experimental Extension Version(s)", + "etors": [ + { + "desc": "version 1.1", + "name": "$T_METRIC_PROGRAMMABLE_EXP_VERSION_1_1", + "value": "$X_MAKE_VERSION( 1, 1 )" + }, + { + "desc": "latest known version", + "name": "$T_METRIC_PROGRAMMABLE_EXP_VERSION_CURRENT", + "value": "$X_MAKE_VERSION( 1, 1 )" + } + ], + "name": "$t_metric_programmable_exp_version_t", + "type": "enum", + "version": "1.9" + }, + { + "desc": "Maximum count of characters in export data element name", + "name": "$T_MAX_PROGRAMMABLE_METRICS_ELEMENT_NAME_EXP", + "type": "macro", + "value": "256", + "version": "1.9" + }, + { + "desc": "Maximum export data element description string size", + "name": "$T_MAX_PROGRAMMABLE_METRICS_ELEMENT_DESCRIPTION_EXP", + "type": "macro", + "value": "256", + "version": "1.9" + }, + { + "desc": "Maximum metric programmable name string size", + "name": "$T_MAX_METRIC_PROGRAMMABLE_NAME_EXP", + "type": "macro", + "value": "128", + "version": "1.9" + }, + { + "desc": "Maximum metric programmable description string size", + "name": "$T_MAX_METRIC_PROGRAMMABLE_DESCRIPTION_EXP", + "type": "macro", + "value": "128", + "version": "1.9" + }, + { + "desc": "Maximum metric programmable component string size", + "name": "$T_MAX_METRIC_PROGRAMMABLE_COMPONENT_EXP", + "type": "macro", + "value": "128", + "version": "1.9" + }, + { + "desc": "Maximum metric programmable parameter string size", + "name": "$T_MAX_METRIC_PROGRAMMABLE_PARAMETER_NAME_EXP", + "type": "macro", + "value": "128", + "version": "1.9" + }, + { + "desc": "Maximum value for programmable value description", + "name": "$T_MAX_METRIC_PROGRAMMABLE_VALUE_DESCRIPTION_EXP", + "type": "macro", + "value": "128", + "version": "1.9" + }, + { + "desc": "Maximum value metric group name prefix", + "name": "$X_MAX_METRIC_GROUP_NAME_PREFIX", + "type": "macro", + "value": "64", + "version": "1.10" + }, + { + "class": "$tMetricProgrammable", + "desc": "Handle of metric programmable's object", + "name": "$t_metric_programmable_exp_handle_t", + "type": "handle", + "version": "1.9" + }, + { + "base": "$t_base_properties_t", + "class": "$tMetricProgrammable", + "desc": "Metric Programmable properties queried using $tMetricProgrammableGetPropertiesExp", + "members": [ + { + "desc": "[in] type of this structure", + "init": "$T_STRUCTURE_TYPE_METRIC_PROGRAMMABLE_EXP_PROPERTIES", + "name": "stype", + "type": "$t_structure_type_t" + }, + { + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" + }, + { + "desc": "[out] metric programmable name", + "name": "name[$T_MAX_METRIC_PROGRAMMABLE_NAME_EXP]", + "type": "char" + }, + { + "desc": "[out] metric programmable description", + "name": "description[$T_MAX_METRIC_PROGRAMMABLE_DESCRIPTION_EXP]", + "type": "char" + }, + { + "desc": "[out] metric programmable component", + "name": "component[$T_MAX_METRIC_PROGRAMMABLE_COMPONENT_EXP]", + "type": "char" + }, + { + "desc": "[out] tier number", + "name": "tierNumber", + "type": "uint32_t" + }, + { + "desc": "[out] metric domain number.", + "name": "domain", + "type": "uint32_t" + }, + { + "desc": "[out] number of parameters in the programmable", + "name": "parameterCount", + "type": "uint32_t" + }, + { + "desc": "[out] metric sampling type.\nreturns a combination of $t_metric_group_sampling_type_flag_t.\n", + "name": "samplingType", + "type": "$t_metric_group_sampling_type_flags_t" + }, + { + "desc": "[out] unique metric source identifier(within platform)to identify the HW block where the metric is collected.", + "name": "sourceId", + "type": "uint32_t" + } + ], + "name": "$t_metric_programmable_exp_properties_t", + "type": "struct", + "version": "1.9" + }, + { + "class": "$tMetricProgrammable", + "desc": "Metric Programmable Parameter types", + "etors": [ + { + "desc": "Metric is disaggregated.", + "name": "$T_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_DISAGGREGATION", + "value": "0" + }, + { + "desc": "Metric for latency measurement.", + "name": "$T_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_LATENCY", + "value": "1" + }, + { + "desc": "Produces normalization in percent using raw_metric * 100 / cycles / HW instance_count.", + "name": "$T_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_NORMALIZATION_UTILIZATION", + "value": "2" + }, + { + "desc": "Produces normalization using raw_metric / HW instance_count.", + "name": "$T_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_NORMALIZATION_AVERAGE", + "value": "3" + }, + { + "desc": "Produces normalization average using raw_metric / timestamp.", + "name": "$T_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_NORMALIZATION_RATE", + "value": "4" + }, + { + "desc": "Produces normalization average using raw_metric * n bytes.", + "name": "$T_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_NORMALIZATION_BYTES", + "value": "5", + "version": "1.10" + } + ], + "name": "$t_metric_programmable_param_type_exp_t", + "type": "enum", + "version": "1.9" + }, + { + "desc": "Supported value info types", + "etors": [ + { + "desc": "32-bit unsigned-integer", + "name": "$T_VALUE_INFO_TYPE_EXP_UINT32", + "value": "0" + }, + { + "desc": "64-bit unsigned-integer", + "name": "$T_VALUE_INFO_TYPE_EXP_UINT64", + "value": "1" + }, + { + "desc": "32-bit floating-point", + "name": "$T_VALUE_INFO_TYPE_EXP_FLOAT32", + "value": "2" + }, + { + "desc": "64-bit floating-point", + "name": "$T_VALUE_INFO_TYPE_EXP_FLOAT64", + "value": "3" + }, + { + "desc": "8-bit boolean", + "name": "$T_VALUE_INFO_TYPE_EXP_BOOL8", + "value": "4" + }, + { + "desc": "8-bit unsigned-integer", + "name": "$T_VALUE_INFO_TYPE_EXP_UINT8", + "value": "5" + }, + { + "desc": "16-bit unsigned-integer", + "name": "$T_VALUE_INFO_TYPE_EXP_UINT16", + "value": "6" + }, + { + "desc": "64-bit unsigned-integer range (minimum and maximum)", + "name": "$T_VALUE_INFO_TYPE_EXP_UINT64_RANGE", + "value": "7" + }, + { + "desc": "64-bit floating point range (minimum and maximum)", + "name": "$T_VALUE_INFO_TYPE_EXP_FLOAT64_RANGE", + "value": "8", + "version": "1.10" + } + ], + "name": "$t_value_info_type_exp_t", + "type": "enum", + "version": "1.9" + }, + { + "desc": "Value info of type uint64_t range", + "members": [ + { + "desc": "[out] minimum value of the range", + "name": "ui64Min", + "type": "uint64_t" + }, + { + "desc": "[out] maximum value of the range", + "name": "ui64Max", + "type": "uint64_t" + } + ], + "name": "$t_value_uint64_range_exp_t", + "type": "struct", + "version": "1.9" + }, + { + "desc": "Value info of type float64 range", + "members": [ + { + "desc": "[out] minimum value of the range", + "name": "fp64Min", + "type": "double" + }, + { + "desc": "[out] maximum value of the range", + "name": "fp64Max", + "type": "double" + } + ], + "name": "$t_value_fp64_range_exp_t", + "type": "struct", + "version": "1.10" + }, + { + "desc": "Union of value information", + "members": [ + { + "desc": "[out] 32-bit unsigned-integer", + "name": "ui32", + "type": "uint32_t" + }, + { + "desc": "[out] 64-bit unsigned-integer", + "name": "ui64", + "type": "uint64_t" + }, + { + "desc": "[out] 32-bit floating-point", + "name": "fp32", + "type": "float" + }, + { + "desc": "[out] 64-bit floating-point", + "name": "fp64", + "type": "double" + }, + { + "desc": "[out] 8-bit boolean", + "name": "b8", + "type": "$x_bool_t" + }, + { + "desc": "[out] 8-bit unsigned integer", + "name": "ui8", + "type": "uint8_t" + }, + { + "desc": "[out] 16-bit unsigned integer", + "name": "ui16", + "type": "uint16_t" + }, + { + "desc": "[out] minimum and maximum value of the range", + "name": "ui64Range", + "type": "$t_value_uint64_range_exp_t" + }, + { + "desc": "[out] minimum and maximum value of the range", + "name": "fp64Range", + "type": "$t_value_fp64_range_exp_t", + "version": "1.10" + } + ], + "name": "$t_value_info_exp_t", + "type": "union", + "version": "1.9" + }, + { + "base": "$t_base_properties_t", + "class": "$tMetricProgrammable", + "desc": "Metric Programmable parameter information", + "members": [ + { + "desc": "[in] type of this structure", + "init": "$T_STRUCTURE_TYPE_METRIC_PROGRAMMABLE_PARAM_INFO_EXP", + "name": "stype", + "type": "$t_structure_type_t" + }, + { + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" + }, + { + "desc": "[out] programmable parameter type", + "name": "type", + "type": "$t_metric_programmable_param_type_exp_t" + }, + { + "desc": "[out] metric programmable parameter name", + "name": "name[$T_MAX_METRIC_PROGRAMMABLE_PARAMETER_NAME_EXP]", + "type": "char" + }, + { + "desc": "[out] value info type", + "name": "valueInfoType", + "type": "$t_value_info_type_exp_t" + }, + { + "desc": "[out] default value for the parameter", + "name": "defaultValue", + "type": "$t_value_t" + }, + { + "desc": "[out] count of $t_metric_programmable_param_value_info_exp_t", + "name": "valueInfoCount", + "type": "uint32_t" + } + ], + "name": "$t_metric_programmable_param_info_exp_t", + "type": "struct", + "version": "1.9" + }, + { + "base": "$t_base_properties_t", + "class": "$tMetricProgrammable", + "desc": "Metric Programmable parameter value information", + "members": [ + { + "desc": "[in] type of this structure", + "init": "$T_STRUCTURE_TYPE_METRIC_PROGRAMMABLE_PARAM_VALUE_INFO_EXP", + "name": "stype", + "type": "$t_structure_type_t" + }, + { + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" + }, + { + "desc": "[out] information about the parameter value", + "name": "valueInfo", + "type": "$t_value_info_exp_t" + }, + { + "desc": "[out] description about the value", + "name": "description[$T_MAX_METRIC_PROGRAMMABLE_VALUE_DESCRIPTION_EXP]", + "type": "char" + } + ], + "name": "$t_metric_programmable_param_value_info_exp_t", + "type": "struct", + "version": "1.9" + }, + { + "class": "$tMetricProgrammable", + "desc": "Metric Programmable parameter value", + "members": [ + { + "desc": "[in] parameter value", + "name": "value", + "type": "$t_value_t" + } + ], + "name": "$t_metric_programmable_param_value_exp_t", + "type": "struct", + "version": "1.9" + }, + { + "class": "$tMetricProgrammable", + "decl": "static", + "desc": "Query and get the available metric programmable handles.", + "details": [ + "Query the available programmable handles using *pCount = 0.", + "Returns all programmable metric handles available in the device.", + "The application may call this function from simultaneous threads." + ], + "hash": "ccc0dd6c7a4ed0f7160b301fdbfe0382c093f26bded09a2577f66e276d5c3336", + "name": "GetExp", + "params": [ + { + "desc": "[in] handle of the device", + "name": "hDevice", + "type": "$t_device_handle_t" + }, + { + "desc": "[in,out] pointer to the number of metric programmable handles.\nif count is zero, then the driver shall update the value with the total number of metric programmable handles available.\nif count is greater than the number of metric programmable handles available, then the driver shall update the value with the correct number of metric programmable handles available.\n", + "name": "pCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pCount)] array of handle of metric programmables.\nif count is less than the number of metric programmables available, then driver shall only retrieve that number of metric programmables.\n", + "name": "phMetricProgrammables", + "type": "$t_metric_programmable_exp_handle_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDevice`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCount`" + ] + } + ], + "type": "function", + "version": "1.9" + }, + { + "class": "$tMetricProgrammable", + "decl": "static", + "desc": "Get the properties of the metric programmable.", + "details": [ + "Returns the properties of the metric programmable." + ], + "hash": "f3d786fa9ed476cde98243d2f15cbb74d893e0f478af2773f52e52bd77e9d7f0", + "name": "GetPropertiesExp", + "params": [ + { + "desc": "[in] handle of the metric programmable", + "name": "hMetricProgrammable", + "type": "$t_metric_programmable_exp_handle_t" + }, + { + "desc": "[in,out] properties of the metric programmable", + "name": "pProperties", + "type": "$t_metric_programmable_exp_properties_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricProgrammable`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pProperties`" + ] + } + ], + "type": "function", + "version": "1.9" + }, + { + "class": "$tMetricProgrammable", + "decl": "static", + "desc": "Get the information about the parameters of the metric programmable.", + "details": [ + "Returns information about the parameters of the metric programmable handle." + ], + "hash": "2dba3c29b34868dc86f76c5bc9d0f483e4538e6bd784e228ee342dc9f3b30769", + "name": "GetParamInfoExp", + "params": [ + { + "desc": "[in] handle of the metric programmable", + "name": "hMetricProgrammable", + "type": "$t_metric_programmable_exp_handle_t" + }, + { + "desc": "[in,out] count of the parameters to retrieve parameter info.\nif value pParameterCount is greater than count of parameters available, then pParameterCount will be updated with count of parameters available.\nThe count of parameters available can be queried using $tMetricProgrammableGetPropertiesExp.\n", + "name": "pParameterCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][range(1, *pParameterCount)] array of parameter info.\nif parameterCount is less than the number of parameters available, then driver shall only retrieve that number of parameter info.\n", + "name": "pParameterInfo", + "type": "$t_metric_programmable_param_info_exp_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricProgrammable`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pParameterCount`", + "`nullptr == pParameterInfo`" + ] + } + ], + "type": "function", + "version": "1.9" + }, + { + "class": "$tMetricProgrammable", + "decl": "static", + "desc": "Get the information about the parameter value of the metric programmable.", + "details": [ + "Returns the value-information about the parameter at the specific ordinal of the metric programmable handle." + ], + "hash": "a8bbacea8ada7ba67f03ef7e159d10bc7e9f5cdd98d334eb2f0c0c88b8debe78", + "name": "GetParamValueInfoExp", + "params": [ + { + "desc": "[in] handle of the metric programmable", + "name": "hMetricProgrammable", + "type": "$t_metric_programmable_exp_handle_t" + }, + { + "desc": "[in] ordinal of the parameter in the metric programmable", + "name": "parameterOrdinal", + "type": "uint32_t" + }, + { + "desc": "[in,out] count of parameter value information to retrieve.\nif value at pValueInfoCount is greater than count of value info available, then pValueInfoCount will be updated with count of value info available.\nThe count of parameter value info available can be queried using $tMetricProgrammableGetParamInfoExp.\n", + "name": "pValueInfoCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][range(1, *pValueInfoCount)] array of parameter value info.\nif pValueInfoCount is less than the number of value info available, then driver shall only retrieve that number of value info.\n", + "name": "pValueInfo", + "type": "$t_metric_programmable_param_value_info_exp_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricProgrammable`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pValueInfoCount`", + "`nullptr == pValueInfo`" + ] + } + ], + "type": "function", + "version": "1.9" + }, + { + "class": "$tMetric", + "decl": "static", + "desc": "Create metric handles by applying parameter values on the metric programmable handle.", + "details": [ + "Multiple parameter values could be used to prepare a metric.", + "If parameterCount = 0, the default value of the metric programmable would be used for all parameters.", + "The implementation can post-fix a C string to the metric name and description, based on the parameter values chosen.", + "$tMetricProgrammableGetParamInfoExp() returns a list of parameters in a defined order.", + "Therefore, the list of values passed in to the API should respect the same order such that the desired parameter is set with expected value" + ], + "hash": "dbb77dc5d0fa8c02a2fdb02c1bc1418b8cd656185111e57b2c76fe53f5b528c2", + "name": "CreateFromProgrammableExp2", + "params": [ + { + "desc": "[in] handle of the metric programmable", + "name": "hMetricProgrammable", + "type": "$t_metric_programmable_exp_handle_t" + }, + { + "desc": "[in] Count of parameters to set.", + "name": "parameterCount", + "type": "uint32_t" + }, + { + "desc": "[in] list of parameter values to be set.", + "name": "pParameterValues", + "type": "$t_metric_programmable_param_value_exp_t*" + }, + { + "desc": "[in] pointer to metric name to be used. Must point to a null-terminated character array no longer than $T_MAX_METRIC_NAME.", + "name": "pName", + "type": "const char*" + }, + { + "desc": "[in] pointer to metric description to be used. Must point to a null-terminated character array no longer than $T_MAX_METRIC_DESCRIPTION.", + "name": "pDescription", + "type": "const char*" + }, + { + "desc": "[in,out] Pointer to the number of metric handles.\nif count is zero, then the driver shall update the value with the number of metric handles available for this programmable.\nif count is greater than the number of metric handles available, then the driver shall update the value with the correct number of metric handles available.\n", + "name": "pMetricHandleCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0,*pMetricHandleCount)] array of handle of metrics.\nif count is less than the number of metrics available, then driver shall only retrieve that number of metric handles.\n", + "name": "phMetricHandles", + "type": "$t_metric_handle_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricProgrammable`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pParameterValues`", + "`nullptr == pName`", + "`nullptr == pDescription`", + "`nullptr == pMetricHandleCount`" + ] + } + ], + "type": "function", + "version": "1.11" + }, + { + "class": "$tMetric", + "decl": "static", + "desc": "Create metric handles by applying parameter values on the metric programmable handle.", + "details": [ + "This API is deprecated. Please use $tMetricCreateFromProgrammableExp2()" + ], + "hash": "1f79d41fa245802ffbdb926fdf47717e4073e63661216306b543d0d93e079c0f", + "name": "CreateFromProgrammableExp", + "params": [ + { + "desc": "[in] handle of the metric programmable", + "name": "hMetricProgrammable", + "type": "$t_metric_programmable_exp_handle_t" + }, + { + "desc": "[in] list of parameter values to be set.", + "name": "pParameterValues", + "type": "$t_metric_programmable_param_value_exp_t*" + }, + { + "desc": "[in] Count of parameters to set.", + "name": "parameterCount", + "type": "uint32_t" + }, + { + "desc": "[in] pointer to metric name to be used. Must point to a null-terminated character array no longer than $T_MAX_METRIC_NAME.", + "name": "pName", + "type": "const char*" + }, + { + "desc": "[in] pointer to metric description to be used. Must point to a null-terminated character array no longer than $T_MAX_METRIC_DESCRIPTION.", + "name": "pDescription", + "type": "const char*" + }, + { + "desc": "[in,out] Pointer to the number of metric handles.\nif count is zero, then the driver shall update the value with the number of metric handles available for this programmable.\nif count is greater than the number of metric handles available, then the driver shall update the value with the correct number of metric handles available.\n", + "name": "pMetricHandleCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0,*pMetricHandleCount)] array of handle of metrics.\nif count is less than the number of metrics available, then driver shall only retrieve that number of metric handles.\n", + "name": "phMetricHandles", + "type": "$t_metric_handle_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricProgrammable`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pParameterValues`", + "`nullptr == pName`", + "`nullptr == pDescription`", + "`nullptr == pMetricHandleCount`" + ] + } + ], + "type": "function", + "version": "1.9" + }, + { + "class": "$tDevice", + "decl": "static", + "desc": "Create multiple metric group handles from metric handles.", + "details": [ + "Creates multiple metric groups from metrics which were created using $tMetricCreateFromProgrammableExp2().", + "Metrics whose Hardware resources do not overlap are added to same metric group.", + "The metric groups created using this API are managed by the application and cannot be retrieved using $tMetricGroupGet().", + "The created metric groups are ready for activation and collection." + ], + "hash": "ee04ae2896c387da5871785e7599c03a4d78d896df59a843f7776ff538f754ec", + "name": "CreateMetricGroupsFromMetricsExp", + "params": [ + { + "desc": "[in] handle of the device.", + "name": "hDevice", + "type": "$t_device_handle_t" + }, + { + "desc": "[in] number of metric handles.", + "name": "metricCount", + "type": "uint32_t" + }, + { + "desc": "[in] metric handles to be added to the metric groups.", + "name": "phMetrics", + "type": "zet_metric_handle_t *" + }, + { + "desc": "[in] prefix to the name created for the metric groups. Must point to a null-terminated character array no longer than ZEX_MAX_METRIC_GROUP_NAME_PREFIX.", + "name": "pMetricGroupNamePrefix", + "type": "const char *" + }, + { + "desc": "[in] pointer to description of the metric groups. Must point to a null-terminated character array no longer than $T_MAX_METRIC_GROUP_DESCRIPTION.", + "name": "pDescription", + "type": "const char *" + }, + { + "desc": "[in,out] pointer to the number of metric group handles to be created.\nif pMetricGroupCount is zero, then the driver shall update the value with the maximum possible number of metric group handles that could be created.\nif pMetricGroupCount is greater than the number of metric group handles that could be created, then the driver shall update the value with the correct number of metric group handles generated.\nif pMetricGroupCount is lesser than the number of metric group handles that could be created, then $X_RESULT_ERROR_INVALID_ARGUMENT is returned.\n", + "name": "pMetricGroupCount", + "type": "uint32_t *" }, { - "desc": "[out] device-specific register set type", - "name": "type", - "type": "uint32_t" + "desc": "[in,out][optional][range(0, *pMetricGroupCount)] array of handle of metric group handles.\nCreated Metric group handles.\n", + "name": "phMetricGroup", + "type": "$t_metric_group_handle_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] }, { - "desc": "[out] device-specific version of this register set", - "name": "version", - "type": "uint32_t" + "$X_RESULT_ERROR_UNINITIALIZED": [] }, { - "desc": "[out] general register set flags", - "name": "generalFlags", - "type": "$t_debug_regset_flags_t" + "$X_RESULT_ERROR_DEVICE_LOST": [] }, { - "desc": "[out] device-specific register set flags", - "name": "deviceFlags", - "type": "uint32_t" + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] }, { - "desc": "[out] number of registers in the set", - "name": "count", - "type": "uint32_t" + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] }, { - "desc": "[out] the size of a register in bits", - "name": "bitSize", - "type": "uint32_t" + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDevice`", + "`nullptr == phMetrics`" + ] }, { - "desc": "[out] the size required for reading or writing a register in bytes", - "name": "byteSize", - "type": "uint32_t" + "$X_RESULT_ERROR_INVALID_ARGUMENT": [ + "metricGroupCount is lesser than the number of metric group handles that could be created." + ] } ], - "name": "$t_debug_regset_properties_t", - "type": "struct" + "type": "function", + "version": "1.10" }, { - "class": "$tDebug", + "class": "$tMetricGroup", "decl": "static", - "desc": "Retrieves debug register set properties.", - "hash": "66c8f10d019ad513b3749bc9486eacb1dbc5934eb24fdd59ce915c1de01f6fa9", - "name": "GetRegisterSetProperties", + "desc": "Create metric group handle.", + "details": [ + "This API is deprecated. Please use $tCreateMetricGroupsFromMetricsExp() " + ], + "hash": "911fc9ce16d58fd7864f8c461aa27bf5b547abd68657eb09965799166f83c882", + "name": "CreateExp", "params": [ { - "desc": "[in] device handle", + "desc": "[in] handle of the device", "name": "hDevice", "type": "$t_device_handle_t" }, { - "desc": "[in,out] pointer to the number of register set properties.\nif count is zero, then the driver shall update the value with the total number of register set properties available.\nif count is greater than the number of register set properties available, then the driver shall update the value with the correct number of registry set properties available.\n", - "name": "pCount", - "type": "uint32_t*" + "desc": "[in] pointer to metric group name. Must point to a null-terminated character array no longer than $T_MAX_METRIC_GROUP_NAME.", + "name": "pName", + "type": "const char*" }, { - "desc": "[in,out][optional][range(0, *pCount)] array of query results for register set properties.\nif count is less than the number of register set properties available, then driver shall only retrieve that number of register set properties.\n", - "name": "pRegisterSetProperties", - "type": "$t_debug_regset_properties_t*" + "desc": "[in] pointer to metric group description. Must point to a null-terminated character array no longer than $T_MAX_METRIC_GROUP_DESCRIPTION.", + "name": "pDescription", + "type": "const char*" + }, + { + "desc": "[in] Sampling type for the metric group.", + "name": "samplingType", + "type": "$t_metric_group_sampling_type_flags_t" + }, + { + "desc": "[in,out] Created Metric group handle", + "name": "phMetricGroup", + "type": "$t_metric_group_handle_t*" } ], "returns": [ @@ -64868,38 +79368,52 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pCount`" + "`nullptr == pName`", + "`nullptr == pDescription`", + "`nullptr == phMetricGroup`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_ENUMERATION": [ + "`0x7 < samplingType`" ] } ], - "type": "function" + "type": "function", + "version": "1.9" }, { - "class": "$tDebug", + "class": "$tMetricGroup", "decl": "static", - "desc": "Retrieves debug register set properties for a given thread.", - "hash": "96f5ab4fe190013dfe748f26ae4db3b9d95a62f88dcb7a7e9468b00d94945169", - "name": "GetThreadRegisterSetProperties", + "desc": "Add a metric handle to the metric group handle created using $tMetricGroupCreateExp.", + "details": [ + "Reasons for failing to add the metric could be queried using pErrorString", + "Multiple additions of same metric would add the metric only once to the hMetricGroup", + "Metric handles from multiple domains may be used in a single metric group.", + "Metric handles from different sourceIds (refer $t_metric_programmable_exp_properties_t) are not allowed in a single metric group." + ], + "hash": "d1255facd6f043c17b1ba82228f5f8512c857c19455fa60dc9b52a534b907652", + "name": "AddMetricExp", "params": [ { - "desc": "[in] debug session handle", - "name": "hDebug", - "type": "$t_debug_session_handle_t" + "desc": "[in] Handle of the metric group", + "name": "hMetricGroup", + "type": "$t_metric_group_handle_t" }, { - "desc": "[in] the thread identifier specifying a single stopped thread", - "name": "thread", - "type": "$x_device_thread_t" + "desc": "[in] Metric to be added to the group.", + "name": "hMetric", + "type": "$t_metric_handle_t" }, { - "desc": "[in,out] pointer to the number of register set properties.\nif count is zero, then the driver shall update the value with the total number of register set properties available.\nif count is greater than the number of register set properties available, then the driver shall update the value with the correct number of registry set properties available.\n", - "name": "pCount", - "type": "uint32_t*" + "desc": "[in,out][optional] Size of the error string to query, if an error was reported during adding the metric handle.\nif *pErrorStringSize is zero, then the driver shall update the value with the size of the error string in bytes.\n", + "name": "pErrorStringSize", + "type": "size_t *" }, { - "desc": "[in,out][optional][range(0, *pCount)] array of query results for register set properties.\nif count is less than the number of register set properties available, then driver shall only retrieve that number of register set properties.\n", - "name": "pRegisterSetProperties", - "type": "$t_debug_regset_properties_t*" + "desc": "[in,out][optional][range(0, *pErrorStringSize)] Error string.\nif *pErrorStringSize is less than the length of the error string available, then driver shall only retrieve that length of error string.\n", + "name": "pErrorString", + "type": "char*" } ], "returns": [ @@ -64920,63 +79434,100 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDebug`" - ] - }, - { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pCount`" + "`nullptr == hMetricGroup`", + "`nullptr == hMetric`" ] }, { - "$X_RESULT_ERROR_NOT_AVAILABLE": [ - "the thread is running or unavailable" + "$X_RESULT_ERROR_INVALID_ARGUMENT": [ + "If a Metric handle from a pre-defined metric group is requested to be added." ] }, { - "$X_RESULT_ERROR_INVALID_ARGUMENT": [ - "the thread argument specifies more than one or a non-existant thread" + "$X_RESULT_ERROR_HANDLE_OBJECT_IN_USE": [ + "If the metric group is currently activated." ] } ], "type": "function", - "version": "1.5" + "version": "1.9" }, { - "class": "$tDebug", - "desc": "Read register state.", - "hash": "4971ff5ff86f5c20fda571c8540832b90f68b99ff6b2c72527ae590fb92ecd13", - "name": "ReadRegisters", + "class": "$tMetricGroup", + "decl": "static", + "desc": "Remove a metric from the metric group handle created using $tMetricGroupCreateExp.", + "details": [ + "Remove an already added metric handle from the metric group." + ], + "hash": "435763728c9824dcd58b6bfaef35731211e78fd3d83b41b602bb2aedc2c1e79d", + "name": "RemoveMetricExp", "params": [ { - "desc": "[in] debug session handle", - "name": "hDebug", - "type": "$t_debug_session_handle_t" + "desc": "[in] Handle of the metric group", + "name": "hMetricGroup", + "type": "$t_metric_group_handle_t" }, { - "desc": "[in] the thread identifier", - "name": "thread", - "type": "$x_device_thread_t" + "desc": "[in] Metric handle to be removed from the metric group.", + "name": "hMetric", + "type": "$t_metric_handle_t" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] }, { - "desc": "[in] register set type", - "name": "type", - "type": "uint32_t" + "$X_RESULT_ERROR_UNINITIALIZED": [] }, { - "desc": "[in] the starting offset into the register state area; must be less than the `count` member of $t_debug_regset_properties_t for the type", - "name": "start", - "type": "uint32_t" + "$X_RESULT_ERROR_DEVICE_LOST": [] }, { - "desc": "[in] the number of registers to read; start+count must be less than or equal to the `count` member of $t_debug_register_group_properties_t for the type", - "name": "count", - "type": "uint32_t" + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] }, { - "desc": "[in,out][optional][range(0, count)] buffer of register values", - "name": "pRegisterValues", - "type": "void*" + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricGroup`", + "`nullptr == hMetric`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_ARGUMENT": [ + "If trying to remove a metric not previously added to the metric group", + "If the input metric group is a pre-defined metric group" + ] + }, + { + "$X_RESULT_ERROR_HANDLE_OBJECT_IN_USE": [ + "If the metric group is currently activated" + ] + } + ], + "type": "function", + "version": "1.9" + }, + { + "class": "$tMetricGroup", + "decl": "static", + "desc": "Closes a created metric group using $tMetricGroupCreateExp, so that it can be activated.", + "details": [ + "Finalizes the $tMetricGroupAddMetricExp and $tMetricGroupRemoveMetricExp operations on the metric group.", + "This is a necessary step before activation of the created metric group.", + "Add / Remove of metrics is possible after $tMetricGroupCloseExp. However, a call to $tMetricGroupCloseExp is necessary after modifying the metric group.", + "Implementations could choose to add new metrics to the group during $tMetricGroupCloseExp, which are related and might add value to the metrics already added by the application", + "Applications can query the list of metrics in the metric group using $tMetricGet" + ], + "hash": "c943d1cdc0583f994fba50ef3d22b20a6df1b03df8a87b03a59bbcdb79fc85a4", + "name": "CloseExp", + "params": [ + { + "desc": "[in] Handle of the metric group", + "name": "hMetricGroup", + "type": "$t_metric_group_handle_t" } ], "returns": [ @@ -64997,52 +79548,89 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDebug`" + "`nullptr == hMetricGroup`" ] }, { - "$X_RESULT_ERROR_NOT_AVAILABLE": [ - "the thread is running or unavailable" + "$X_RESULT_ERROR_INVALID_ARGUMENT": [ + "If the input metric group is a pre-defined metric group" + ] + }, + { + "$X_RESULT_ERROR_HANDLE_OBJECT_IN_USE": [ + "If the metric group is currently activated" ] } ], - "type": "function" + "type": "function", + "version": "1.9" }, { - "class": "$tDebug", - "desc": "Write register state.", - "hash": "a7e5e8a068e13a51cbe0643ad035cb7b9c043f5a050593e66978ede75b49023c", - "name": "WriteRegisters", + "class": "$tMetricGroup", + "decl": "static", + "desc": "Destroy a metric group created using $tMetricGroupCreateExp.", + "details": [ + "Metric handles created using $tMetricCreateFromProgrammableExp2 and are part of the metricGroup are not destroyed.", + "It is necessary to call $tMetricDestroyExp for each of the metric handles (created from $tMetricCreateFromProgrammableExp2) to destroy them." + ], + "hash": "d96013a8866f2fd6989dcabcdd110ae2a8abff9994268d07abdcc0cc2df32e9c", + "name": "DestroyExp", "params": [ { - "desc": "[in] debug session handle", - "name": "hDebug", - "type": "$t_debug_session_handle_t" + "desc": "[in] Handle of the metric group to destroy", + "name": "hMetricGroup", + "type": "$t_metric_group_handle_t" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] }, { - "desc": "[in] the thread identifier", - "name": "thread", - "type": "$x_device_thread_t" + "$X_RESULT_ERROR_UNINITIALIZED": [] }, { - "desc": "[in] register set type", - "name": "type", - "type": "uint32_t" + "$X_RESULT_ERROR_DEVICE_LOST": [] }, { - "desc": "[in] the starting offset into the register state area; must be less than the `count` member of $t_debug_regset_properties_t for the type", - "name": "start", - "type": "uint32_t" + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] }, { - "desc": "[in] the number of registers to write; start+count must be less than or equal to the `count` member of $t_debug_register_group_properties_t for the type", - "name": "count", - "type": "uint32_t" + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] }, { - "desc": "[in,out][optional][range(0, count)] buffer of register values", - "name": "pRegisterValues", - "type": "void*" + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hMetricGroup`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_ARGUMENT": [ + "If trying to destroy a pre-defined metric group" + ] + }, + { + "$X_RESULT_ERROR_HANDLE_OBJECT_IN_USE": [ + "If trying to destroy an activated metric group" + ] + } + ], + "type": "function", + "version": "1.9" + }, + { + "class": "$tMetric", + "decl": "static", + "desc": "Destroy a metric created using $tMetricCreateFromProgrammableExp2.", + "details": [ + "If a metric is added to a metric group, the metric has to be removed using $tMetricGroupRemoveMetricExp before it can be destroyed." + ], + "hash": "2ba0a66809e327a7e1946aefe3ac00b4df3c601551e7677b92e2ee03ebe5d195", + "name": "DestroyExp", + "params": [ + { + "desc": "[in] Handle of the metric to destroy", + "name": "hMetric", + "type": "$t_metric_handle_t" } ], "returns": [ @@ -65063,396 +79651,598 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDebug`" + "`nullptr == hMetric`" ] }, { - "$X_RESULT_ERROR_NOT_AVAILABLE": [ - "the thread is running or unavailable" + "$X_RESULT_ERROR_INVALID_ARGUMENT": [ + "If trying to destroy a metric from pre-defined metric group" ] - } - ], - "type": "function" - }, - { - "desc": "C++ wrapper for Debug API", - "members": [ + }, { - "desc": "[in] debug session handle", - "name": "handle", - "type": "$t_debug_session_handle_t" + "$X_RESULT_ERROR_HANDLE_OBJECT_IN_USE": [ + "If trying to destroy a metric currently added to a metric group" + ] } ], - "name": "$tDebug", - "type": "class" + "type": "function", + "version": "1.9" } ] - }, + } + ], + [ { "header": { - "desc": "Intel $OneApi Level-Zero Tool APIs for Metric", - "ordinal": 1000, + "desc": "Intel $OneApi Level-Zero Sysman API common types", + "ordinal": 0, "type": "header" }, - "name": "metric", + "name": "common", "objects": [ { - "class": "$tMetricGroup", - "decl": "static", - "desc": "Retrieves metric group for a device.", - "details": [ - "The application may call this function from simultaneous threads." - ], - "hash": "3c1168f00cd21001f959d5f66f20559a4bf5e396bb1cb1d34116e7729a4f4fc8", - "name": "Get", - "params": [ + "alias": "$x_driver_handle_t", + "class": "$sDriver", + "desc": "Handle to a driver instance", + "name": "$s_driver_handle_t", + "type": "handle" + }, + { + "alias": "$x_device_handle_t", + "class": "$sDevice", + "desc": "Handle of device object", + "name": "$s_device_handle_t", + "type": "handle" + }, + { + "class": "$sScheduler", + "desc": "Handle for a Sysman device scheduler queue", + "name": "$s_sched_handle_t", + "type": "handle" + }, + { + "class": "$sPerformanceFactor", + "desc": "Handle for a Sysman device performance factors", + "name": "$s_perf_handle_t", + "type": "handle" + }, + { + "class": "$sPower", + "desc": "Handle for a Sysman device power domain", + "name": "$s_pwr_handle_t", + "type": "handle" + }, + { + "class": "$sFrequency", + "desc": "Handle for a Sysman device frequency domain", + "name": "$s_freq_handle_t", + "type": "handle" + }, + { + "class": "$sEngine", + "desc": "Handle for a Sysman device engine group", + "name": "$s_engine_handle_t", + "type": "handle" + }, + { + "class": "$sStandby", + "desc": "Handle for a Sysman device standby control", + "name": "$s_standby_handle_t", + "type": "handle" + }, + { + "class": "$sFirmware", + "desc": "Handle for a Sysman device firmware", + "name": "$s_firmware_handle_t", + "type": "handle" + }, + { + "class": "$sMemory", + "desc": "Handle for a Sysman device memory module", + "name": "$s_mem_handle_t", + "type": "handle" + }, + { + "class": "$sFabricPort", + "desc": "Handle for a Sysman fabric port", + "name": "$s_fabric_port_handle_t", + "type": "handle" + }, + { + "class": "$sTemperature", + "desc": "Handle for a Sysman device temperature sensor", + "name": "$s_temp_handle_t", + "type": "handle" + }, + { + "class": "$sPsu", + "desc": "Handle for a Sysman device power supply", + "name": "$s_psu_handle_t", + "type": "handle" + }, + { + "class": "$sFan", + "desc": "Handle for a Sysman device fan", + "name": "$s_fan_handle_t", + "type": "handle" + }, + { + "class": "$sLed", + "desc": "Handle for a Sysman device LED", + "name": "$s_led_handle_t", + "type": "handle" + }, + { + "class": "$sRas", + "desc": "Handle for a Sysman device RAS error set", + "name": "$s_ras_handle_t", + "type": "handle" + }, + { + "class": "$sDiagnostics", + "desc": "Handle for a Sysman device diagnostics test suite", + "name": "$s_diag_handle_t", + "type": "handle" + }, + { + "class": "$sOverclock", + "desc": "Handle for a Sysman device overclock domain", + "name": "$s_overclock_handle_t", + "type": "handle", + "version": "1.5" + }, + { + "class": "$sVFManagement", + "desc": "Handle for a Sysman virtual function management domain", + "name": "$s_vf_handle_t", + "type": "handle", + "version": "1.9" + }, + { + "desc": "Defines structure types", + "etors": [ { - "desc": "[in] handle of the device", - "name": "hDevice", - "type": "$t_device_handle_t" + "desc": "$s_device_properties_t", + "name": "$S_STRUCTURE_TYPE_DEVICE_PROPERTIES", + "value": "0x1" }, { - "desc": "[in,out] pointer to the number of metric groups.\nif count is zero, then the driver shall update the value with the total number of metric groups available.\nif count is greater than the number of metric groups available, then the driver shall update the value with the correct number of metric groups available.\n", - "name": "pCount", - "type": "uint32_t*" + "desc": "$s_pci_properties_t", + "name": "$S_STRUCTURE_TYPE_PCI_PROPERTIES", + "value": "0x2" }, { - "desc": "[in,out][optional][range(0, *pCount)] array of handle of metric groups.\nif count is less than the number of metric groups available, then driver shall only retrieve that number of metric groups.\n", - "name": "phMetricGroups", - "type": "$t_metric_group_handle_t*" - } - ], - "returns": [ + "desc": "$s_pci_bar_properties_t", + "name": "$S_STRUCTURE_TYPE_PCI_BAR_PROPERTIES", + "value": "0x3" + }, + { + "desc": "$s_diag_properties_t", + "name": "$S_STRUCTURE_TYPE_DIAG_PROPERTIES", + "value": "0x4" + }, + { + "desc": "$s_engine_properties_t", + "name": "$S_STRUCTURE_TYPE_ENGINE_PROPERTIES", + "value": "0x5" + }, + { + "desc": "$s_fabric_port_properties_t", + "name": "$S_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES", + "value": "0x6" + }, + { + "desc": "$s_fan_properties_t", + "name": "$S_STRUCTURE_TYPE_FAN_PROPERTIES", + "value": "0x7" + }, + { + "desc": "$s_firmware_properties_t", + "name": "$S_STRUCTURE_TYPE_FIRMWARE_PROPERTIES", + "value": "0x8" + }, + { + "desc": "$s_freq_properties_t", + "name": "$S_STRUCTURE_TYPE_FREQ_PROPERTIES", + "value": "0x9" + }, + { + "desc": "$s_led_properties_t", + "name": "$S_STRUCTURE_TYPE_LED_PROPERTIES", + "value": "0xa" + }, + { + "desc": "$s_mem_properties_t", + "name": "$S_STRUCTURE_TYPE_MEM_PROPERTIES", + "value": "0xb" + }, + { + "desc": "$s_perf_properties_t", + "name": "$S_STRUCTURE_TYPE_PERF_PROPERTIES", + "value": "0xc" + }, + { + "desc": "$s_power_properties_t", + "name": "$S_STRUCTURE_TYPE_POWER_PROPERTIES", + "value": "0xd" + }, + { + "desc": "$s_psu_properties_t", + "name": "$S_STRUCTURE_TYPE_PSU_PROPERTIES", + "value": "0xe" + }, + { + "desc": "$s_ras_properties_t", + "name": "$S_STRUCTURE_TYPE_RAS_PROPERTIES", + "value": "0xf" + }, + { + "desc": "$s_sched_properties_t", + "name": "$S_STRUCTURE_TYPE_SCHED_PROPERTIES", + "value": "0x10" + }, + { + "desc": "$s_sched_timeout_properties_t", + "name": "$S_STRUCTURE_TYPE_SCHED_TIMEOUT_PROPERTIES", + "value": "0x11" + }, + { + "desc": "$s_sched_timeslice_properties_t", + "name": "$S_STRUCTURE_TYPE_SCHED_TIMESLICE_PROPERTIES", + "value": "0x12" + }, + { + "desc": "$s_standby_properties_t", + "name": "$S_STRUCTURE_TYPE_STANDBY_PROPERTIES", + "value": "0x13" + }, + { + "desc": "$s_temp_properties_t", + "name": "$S_STRUCTURE_TYPE_TEMP_PROPERTIES", + "value": "0x14" + }, { - "$X_RESULT_SUCCESS": [] + "desc": "$s_device_state_t", + "name": "$S_STRUCTURE_TYPE_DEVICE_STATE", + "value": "0x15" }, { - "$X_RESULT_ERROR_UNINITIALIZED": [] + "desc": "$s_process_state_t", + "name": "$S_STRUCTURE_TYPE_PROCESS_STATE", + "value": "0x16" }, { - "$X_RESULT_ERROR_DEVICE_LOST": [] + "desc": "$s_pci_state_t", + "name": "$S_STRUCTURE_TYPE_PCI_STATE", + "value": "0x17" }, { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "desc": "$s_fabric_port_config_t", + "name": "$S_STRUCTURE_TYPE_FABRIC_PORT_CONFIG", + "value": "0x18" }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + "desc": "$s_fabric_port_state_t", + "name": "$S_STRUCTURE_TYPE_FABRIC_PORT_STATE", + "value": "0x19" }, { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDevice`" - ] + "desc": "$s_fan_config_t", + "name": "$S_STRUCTURE_TYPE_FAN_CONFIG", + "value": "0x1a" }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pCount`" - ] - } - ], - "type": "function" - }, - { - "desc": "Maximum metric group name string size", - "name": "$T_MAX_METRIC_GROUP_NAME", - "type": "macro", - "value": "256" - }, - { - "desc": "Maximum metric group description string size", - "name": "$T_MAX_METRIC_GROUP_DESCRIPTION", - "type": "macro", - "value": "256" - }, - { - "class": "$tMetricGroup", - "desc": "Metric group sampling type", - "etors": [ + "desc": "$s_freq_state_t", + "name": "$S_STRUCTURE_TYPE_FREQ_STATE", + "value": "0x1b" + }, { - "desc": "Event based sampling", - "name": "$T_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED", - "value": "$X_BIT(0)" + "desc": "$s_oc_capabilities_t", + "name": "$S_STRUCTURE_TYPE_OC_CAPABILITIES", + "value": "0x1c" }, { - "desc": "Time based sampling", - "name": "$T_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED", - "value": "$X_BIT(1)" - } - ], - "name": "$t_metric_group_sampling_type_flags_t", - "type": "enum" - }, - { - "base": "$t_base_properties_t", - "class": "$tMetricGroup", - "desc": "Metric group properties queried using $tMetricGroupGetProperties", - "members": [ + "desc": "$s_led_state_t", + "name": "$S_STRUCTURE_TYPE_LED_STATE", + "value": "0x1d" + }, { - "desc": "[in] type of this structure", - "init": "$T_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES", - "name": "stype", - "type": "$t_structure_type_t" + "desc": "$s_mem_state_t", + "name": "$S_STRUCTURE_TYPE_MEM_STATE", + "value": "0x1e" }, { - "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "void*" + "desc": "$s_psu_state_t", + "name": "$S_STRUCTURE_TYPE_PSU_STATE", + "value": "0x1f" }, { - "desc": "[out] metric group name", - "name": "name[$T_MAX_METRIC_GROUP_NAME]", - "type": "char" + "desc": "$s_base_state_t", + "name": "$S_STRUCTURE_TYPE_BASE_STATE", + "value": "0x20" }, { - "desc": "[out] metric group description", - "name": "description[$T_MAX_METRIC_GROUP_DESCRIPTION]", - "type": "char" + "desc": "$s_ras_config_t", + "name": "$S_STRUCTURE_TYPE_RAS_CONFIG", + "value": "0x21" }, { - "desc": "[out] metric group sampling type.\nreturns a combination of $t_metric_group_sampling_type_flag_t.\n", - "name": "samplingType", - "type": "$t_metric_group_sampling_type_flags_t" + "desc": "$s_ras_state_t", + "name": "$S_STRUCTURE_TYPE_RAS_STATE", + "value": "0x22" }, { - "desc": "[out] metric group domain number. Cannot use multiple, simultaneous metric groups from the same domain.", - "name": "domain", - "type": "uint32_t" + "desc": "$s_temp_config_t", + "name": "$S_STRUCTURE_TYPE_TEMP_CONFIG", + "value": "0x23" }, { - "desc": "[out] metric count belonging to this group", - "name": "metricCount", - "type": "uint32_t" - } - ], - "name": "$t_metric_group_properties_t", - "type": "struct" - }, - { - "class": "$tMetricGroup", - "desc": "Retrieves attributes of a metric group.", - "details": [ - "The application may call this function from simultaneous threads." - ], - "hash": "78240eaf21bff68383fe29f14362cb160f3ebbb609b183920ba33af1d0792bb9", - "name": "GetProperties", - "params": [ + "desc": "$s_pci_bar_properties_1_2_t", + "name": "$S_STRUCTURE_TYPE_PCI_BAR_PROPERTIES_1_2", + "value": "0x24", + "version": "1.2" + }, { - "desc": "[in] handle of the metric group", - "name": "hMetricGroup", - "type": "$t_metric_group_handle_t" + "desc": "$s_device_ecc_desc_t", + "name": "$S_STRUCTURE_TYPE_DEVICE_ECC_DESC", + "value": "0x25", + "version": "1.4" }, { - "desc": "[in,out] metric group properties", - "name": "pProperties", - "type": "$t_metric_group_properties_t*" - } - ], - "returns": [ + "desc": "$s_device_ecc_properties_t", + "name": "$S_STRUCTURE_TYPE_DEVICE_ECC_PROPERTIES", + "value": "0x26", + "version": "1.4" + }, { - "$X_RESULT_SUCCESS": [] + "desc": "$s_power_limit_ext_desc_t", + "name": "$S_STRUCTURE_TYPE_POWER_LIMIT_EXT_DESC", + "value": "0x27", + "version": "1.4" }, { - "$X_RESULT_ERROR_UNINITIALIZED": [] + "desc": "$s_power_ext_properties_t", + "name": "$S_STRUCTURE_TYPE_POWER_EXT_PROPERTIES", + "value": "0x28", + "version": "1.4" }, { - "$X_RESULT_ERROR_DEVICE_LOST": [] + "desc": "$s_overclock_properties_t", + "name": "$S_STRUCTURE_TYPE_OVERCLOCK_PROPERTIES", + "value": "0x29", + "version": "1.5" }, { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "desc": "$s_fabric_port_error_counters_t", + "name": "$S_STRUCTURE_TYPE_FABRIC_PORT_ERROR_COUNTERS", + "value": "0x2a", + "version": "1.7" }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + "desc": "$s_engine_ext_properties_t", + "name": "$S_STRUCTURE_TYPE_ENGINE_EXT_PROPERTIES", + "value": "0x2b", + "version": "1.7" }, { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hMetricGroup`" - ] + "desc": "$s_reset_properties_t", + "name": "$S_STRUCTURE_TYPE_RESET_PROPERTIES", + "value": "0x2c", + "version": "1.7" }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pProperties`" - ] - } - ], - "type": "function" - }, - { - "class": "$tMetric", - "desc": "Metric types", - "etors": [ + "desc": "$s_device_ext_properties_t", + "name": "$S_STRUCTURE_TYPE_DEVICE_EXT_PROPERTIES", + "value": "0x2d", + "version": "1.7" + }, { - "desc": "Metric type: duration", - "name": "$T_METRIC_TYPE_DURATION", - "value": "0" + "desc": "$s_uuid_t", + "name": "$S_STRUCTURE_TYPE_DEVICE_UUID", + "value": "0x2e", + "version": "1.7" }, { - "desc": "Metric type: event", - "name": "$T_METRIC_TYPE_EVENT", - "value": "1" + "desc": "$s_power_domain_exp_properties_t", + "name": "$S_STRUCTURE_TYPE_POWER_DOMAIN_EXP_PROPERTIES", + "value": "0x00020001", + "version": "1.8" }, { - "desc": "Metric type: event with range", - "name": "$T_METRIC_TYPE_EVENT_WITH_RANGE", - "value": "2" + "desc": "$s_mem_bandwidth_counter_bits_exp_properties_t", + "name": "$S_STRUCTURE_TYPE_MEM_BANDWIDTH_COUNTER_BITS_EXP_PROPERTIES", + "value": "0x00020002", + "version": "1.8" }, { - "desc": "Metric type: throughput", - "name": "$T_METRIC_TYPE_THROUGHPUT", - "value": "3" + "desc": "$s_mem_page_offline_state_exp_t", + "name": "$S_STRUCTURE_TYPE_MEMORY_PAGE_OFFLINE_STATE_EXP", + "value": "0x00020003", + "version": "1.8" }, { - "desc": "Metric type: timestamp", - "name": "$T_METRIC_TYPE_TIMESTAMP", - "value": "4" + "desc": "$s_subdevice_exp_properties_t", + "name": "$S_STRUCTURE_TYPE_SUBDEVICE_EXP_PROPERTIES", + "value": "0x00020004", + "version": "1.9" }, { - "desc": "Metric type: flag", - "name": "$T_METRIC_TYPE_FLAG", - "value": "5" + "desc": "$s_vf_exp_properties_t", + "name": "$S_STRUCTURE_TYPE_VF_EXP_PROPERTIES", + "value": "0x00020005", + "version": "1.10" }, { - "desc": "Metric type: ratio", - "name": "$T_METRIC_TYPE_RATIO", - "value": "6" + "desc": "$s_vf_util_mem_exp_t", + "name": "$S_STRUCTURE_TYPE_VF_UTIL_MEM_EXP", + "value": "0x00020006", + "version": "1.9" }, { - "desc": "Metric type: raw", - "name": "$T_METRIC_TYPE_RAW", - "value": "7" + "desc": "$s_vf_util_engine_exp_t", + "name": "$S_STRUCTURE_TYPE_VF_UTIL_ENGINE_EXP", + "value": "0x00020007", + "version": "1.9" }, { - "desc": "Metric type: instruction pointer. Deprecated, use $T_METRIC_TYPE_IP.", - "name": "$T_METRIC_TYPE_IP_EXP", - "value": "0x7ffffffe" + "desc": "$s_vf_exp_capabilities_t", + "name": "$S_STRUCTURE_TYPE_VF_EXP_CAPABILITIES", + "value": "0x00020008", + "version": "1.10" }, { - "desc": "Metric type: instruction pointer", - "name": "$T_METRIC_TYPE_IP", - "value": "0x7ffffffe", - "version": "1.7" + "desc": "$s_vf_util_mem_exp2_t", + "name": "$S_STRUCTURE_TYPE_VF_UTIL_MEM_EXP2", + "value": "0x00020009", + "version": "1.10" + }, + { + "desc": "$s_vf_util_engine_exp2_t", + "name": "$S_STRUCTURE_TYPE_VF_UTIL_ENGINE_EXP2", + "value": "0x00020010", + "version": "1.10" } ], - "name": "$t_metric_type_t", + "name": "$s_structure_type_t", "type": "enum" }, { - "class": "$tMetricGroup", - "desc": "Metric group calculation type", - "etors": [ + "desc": "Base for all properties types", + "members": [ { - "desc": "Calculated metric values from raw data.", - "name": "$T_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES", - "value": "0" + "desc": "[in] type of this structure", + "name": "stype", + "type": "$s_structure_type_t" }, { - "desc": "Maximum metric values.", - "name": "$T_METRIC_GROUP_CALCULATION_TYPE_MAX_METRIC_VALUES", - "value": "1" + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" } ], - "name": "$t_metric_group_calculation_type_t", - "type": "enum" + "name": "$s_base_properties_t", + "type": "struct" }, { - "class": "$tMetricGroup", - "decl": "static", - "desc": "Calculates metric values from raw data.", - "details": [ - "The application may call this function from simultaneous threads." - ], - "hash": "cb6e20cd2535530f4def46834390547217f8eba6eeba1dc0a902555c40af9028", - "name": "CalculateMetricValues", - "params": [ - { - "desc": "[in] handle of the metric group", - "name": "hMetricGroup", - "type": "$t_metric_group_handle_t" - }, - { - "desc": "[in] calculation type to be applied on raw data", - "name": "type", - "type": "$t_metric_group_calculation_type_t" - }, - { - "desc": "[in] size in bytes of raw data buffer", - "name": "rawDataSize", - "type": "size_t" - }, - { - "desc": "[in][range(0, rawDataSize)] buffer of raw data to calculate", - "name": "pRawData", - "type": "const uint8_t*" - }, + "desc": "Base for all descriptor types", + "members": [ { - "desc": "[in,out] pointer to number of metric values calculated.\nif count is zero, then the driver shall update the value with the total number of metric values to be calculated.\nif count is greater than the number available in the raw data buffer, then the driver shall update the value with the actual number of metric values to be calculated.\n", - "name": "pMetricValueCount", - "type": "uint32_t*" + "desc": "[in] type of this structure", + "name": "stype", + "type": "$s_structure_type_t" }, { - "desc": "[in,out][optional][range(0, *pMetricValueCount)] buffer of calculated metrics.\nif count is less than the number available in the raw data buffer, then driver shall only calculate that number of metric values.\n", - "name": "pMetricValues", - "type": "$t_typed_value_t*" + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" } ], - "returns": [ - { - "$X_RESULT_SUCCESS": [] - }, + "name": "$s_base_desc_t", + "type": "struct" + }, + { + "desc": "Base for all state types", + "members": [ { - "$X_RESULT_ERROR_UNINITIALIZED": [] + "desc": "[in] type of this structure", + "name": "stype", + "type": "$s_structure_type_t" }, { - "$X_RESULT_ERROR_DEVICE_LOST": [] - }, + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + } + ], + "name": "$s_base_state_t", + "type": "struct" + }, + { + "desc": "Base for all config types", + "members": [ { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "desc": "[in] type of this structure", + "name": "stype", + "type": "$s_structure_type_t" }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] - }, + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + } + ], + "name": "$s_base_config_t", + "type": "struct" + }, + { + "desc": "Base for all capability types", + "members": [ { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hMetricGroup`" - ] + "desc": "[in] type of this structure", + "name": "stype", + "type": "$s_structure_type_t" }, { - "$X_RESULT_ERROR_INVALID_ENUMERATION": [ - "`$T_METRIC_GROUP_CALCULATION_TYPE_MAX_METRIC_VALUES < type`" - ] - }, + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + } + ], + "name": "$s_base_capability_t", + "type": "struct" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman)", + "ordinal": 1, + "type": "header" + }, + "name": "driver", + "objects": [ + { + "class": "$s", + "desc": "Supported sysman initialization flags", + "etors": [ { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pRawData`", - "`nullptr == pMetricValueCount`" - ] + "desc": "placeholder for future use", + "name": "$S_INIT_FLAG_PLACEHOLDER", + "value": "$X_BIT(0)" } ], - "type": "function" + "name": "$s_init_flags_t", + "type": "enum", + "version": "1.5" }, { - "class": "$tMetric", + "class": "$s", "decl": "static", - "desc": "Retrieves metric from a metric group.", + "desc": "Initialize $OneApi System Resource Management (sysman)", "details": [ - "The application may call this function from simultaneous threads." + "The application must call this function or $xInit with the $S_ENABLE_SYSMAN environment variable set before calling any other sysman function.", + "If this function is not called then all other sysman functions will return $X_RESULT_ERROR_UNINITIALIZED.", + "This function will only initialize sysman. To initialize other functions, call $xInit.", + "There is no requirement to call this function before or after $xInit.", + "Only one instance of sysman will be initialized per process.", + "The application must call this function after forking new processes. Each forked process must call this function.", + "The application may call this function from simultaneous threads.", + "The implementation of this function must be thread-safe for scenarios where multiple libraries may initialize sysman simultaneously." ], - "hash": "23f30faaba53d0a7e0aae5ccd4a7f28d12c9e6c4cdccce6dfa8f8d6b3bc606df", - "name": "Get", + "hash": "1bbd5be40cc583c65df6085755af48c663f466a9fc324f6a5c43a9f9c4cb3b97", + "name": "Init", + "ordinal": "0", "params": [ { - "desc": "[in] handle of the metric group", - "name": "hMetricGroup", - "type": "$t_metric_group_handle_t" - }, - { - "desc": "[in,out] pointer to the number of metrics.\nif count is zero, then the driver shall update the value with the total number of metrics available.\nif count is greater than the number of metrics available, then the driver shall update the value with the correct number of metrics available.\n", - "name": "pCount", - "type": "uint32_t*" - }, - { - "desc": "[in,out][optional][range(0, *pCount)] array of handle of metrics.\nif count is less than the number of metrics available, then driver shall only retrieve that number of metrics.\n", - "name": "phMetrics", - "type": "$t_metric_handle_t*" + "desc": "[in] initialization flags.\ncurrently unused, must be 0 (default).\n", + "init": "0", + "name": "flags", + "type": "$s_init_flags_t" } ], "returns": [ @@ -65472,116 +80262,118 @@ "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] }, { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hMetricGroup`" + "$X_RESULT_ERROR_INVALID_ENUMERATION": [ + "`0x1 < flags`" ] }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pCount`" - ] + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] } ], - "type": "function" - }, - { - "desc": "Maximum metric name string size", - "name": "$T_MAX_METRIC_NAME", - "type": "macro", - "value": "256" - }, - { - "desc": "Maximum metric description string size", - "name": "$T_MAX_METRIC_DESCRIPTION", - "type": "macro", - "value": "256" - }, - { - "desc": "Maximum metric component string size", - "name": "$T_MAX_METRIC_COMPONENT", - "type": "macro", - "value": "256" - }, - { - "desc": "Maximum metric result units string size", - "name": "$T_MAX_METRIC_RESULT_UNITS", - "type": "macro", - "value": "256" + "type": "function", + "version": "1.5" }, { - "base": "$t_base_properties_t", - "class": "$tMetric", - "desc": "Metric properties queried using $tMetricGetProperties", - "members": [ + "class": "$sDriver", + "decl": "static", + "desc": "Retrieves sysman driver instances", + "details": [ + "A sysman driver represents a collection of physical devices.", + "Multiple calls to this function will return identical sysman driver handles, in the same order.", + "The application may pass nullptr for pDrivers when only querying the number of sysman drivers.", + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "25a93e8621b2de9d5cdea1eb8414add47e38defc9e270b7c6759ed52b55ec6d0", + "name": "Get", + "ordinal": "0", + "params": [ { - "desc": "[in] type of this structure", - "init": "$T_STRUCTURE_TYPE_METRIC_PROPERTIES", - "name": "stype", - "type": "$t_structure_type_t" + "desc": "[in,out] pointer to the number of sysman driver instances.\nif count is zero, then the loader shall update the value with the total number of sysman drivers available.\nif count is greater than the number of sysman drivers available, then the loader shall update the value with the correct number of sysman drivers available.\n", + "name": "pCount", + "type": "uint32_t*" }, { - "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "void*" - }, + "desc": "[in,out][optional][range(0, *pCount)] array of sysman driver instance handles.\nif count is less than the number of sysman drivers available, then the loader shall only retrieve that number of sysman drivers.\n", + "name": "phDrivers", + "type": "$s_driver_handle_t*" + } + ], + "returns": [ { - "desc": "[out] metric name", - "name": "name[$T_MAX_METRIC_NAME]", - "type": "char" + "$X_RESULT_SUCCESS": [] }, { - "desc": "[out] metric description", - "name": "description[$T_MAX_METRIC_DESCRIPTION]", - "type": "char" + "$X_RESULT_ERROR_UNINITIALIZED": [] }, { - "desc": "[out] metric component", - "name": "component[$T_MAX_METRIC_COMPONENT]", - "type": "char" + "$X_RESULT_ERROR_DEVICE_LOST": [] }, { - "desc": "[out] number of tier", - "name": "tierNumber", - "type": "uint32_t" + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] }, { - "desc": "[out] metric type", - "name": "metricType", - "type": "$t_metric_type_t" + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] }, { - "desc": "[out] metric result type", - "name": "resultType", - "type": "$t_value_type_t" - }, + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCount`" + ] + } + ], + "type": "function", + "version": "1.5" + }, + { + "desc": "Maximum extension name string size", + "name": "$S_MAX_EXTENSION_NAME", + "type": "macro", + "value": "256", + "version": "1.8" + }, + { + "class": "$sDriver", + "desc": "Extension properties queried using $sDriverGetExtensionProperties", + "members": [ { - "desc": "[out] metric result units", - "name": "resultUnits[$T_MAX_METRIC_RESULT_UNITS]", + "desc": "[out] extension name", + "name": "name[$S_MAX_EXTENSION_NAME]", "type": "char" + }, + { + "desc": "[out] extension version using $X_MAKE_VERSION", + "name": "version", + "type": "uint32_t" } ], - "name": "$t_metric_properties_t", - "type": "struct" + "name": "$s_driver_extension_properties_t", + "type": "struct", + "version": "1.8" }, { - "class": "$tMetric", - "desc": "Retrieves attributes of a metric.", + "class": "$sDriver", + "desc": "Retrieves extension properties", "details": [ - "The application may call this function from simultaneous threads." + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." ], - "hash": "aef6333271f2a5fdf7ab89c275d95405139496cb21c67904139bad5bc9dd0730", - "name": "GetProperties", + "hash": "dff8b1c749c24800e4522d72ec77d0d2f80e86dcd753f1f4131dfd642cffd285", + "name": "GetExtensionProperties", "params": [ { - "desc": "[in] handle of the metric", - "name": "hMetric", - "type": "$t_metric_handle_t" + "desc": "[in] handle of the driver instance", + "name": "hDriver", + "type": "$s_driver_handle_t" }, { - "desc": "[in,out] metric properties", - "name": "pProperties", - "type": "$t_metric_properties_t*" + "desc": "[in,out] pointer to the number of extension properties.\nif count is zero, then the driver shall update the value with the total number of extension properties available.\nif count is greater than the number of extension properties available, then the driver shall update the value with the correct number of extension properties available.\n", + "name": "pCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pCount)] array of query results for extension properties.\nif count is less than the number of extension properties available, then driver shall only retrieve that number of extension properties.\n", + "name": "pExtensionProperties", + "type": "$s_driver_extension_properties_t*" } ], "returns": [ @@ -65602,49 +80394,42 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hMetric`" + "`nullptr == hDriver`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pProperties`" + "`nullptr == pCount`" ] } ], - "type": "function" + "type": "function", + "version": "1.8" }, { - "class": "$tContext", - "desc": "Activates metric groups.", + "class": "$sDriver", + "desc": "Retrieves function pointer for vendor-specific or experimental extensions", "details": [ - "Immediately reconfigures the device to activate only those metric groups provided.", - "Any metric groups previously activated but not provided will be deactivated.", - "Deactivating metric groups that are still in-use will result in undefined behavior.", - "All metric groups must have different domains, see $t_metric_group_properties_t.", - "The application must **not** call this function from simultaneous threads with the same device handle." + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." ], - "hash": "34c932ade11f77be736543eb44b6cf7cebfde09ac71f5b67362519b27f763e96", - "name": "ActivateMetricGroups", + "hash": "f9e53cbf6dd9fb646d04ca02d88d69da064b659dcd4e935e0a8a799656259ffc", + "name": "GetExtensionFunctionAddress", "params": [ { - "desc": "[in] handle of the context object", - "name": "hContext", - "type": "$t_context_handle_t" - }, - { - "desc": "[in] handle of the device", - "name": "hDevice", - "type": "$t_device_handle_t" + "desc": "[in] handle of the driver instance", + "name": "hDriver", + "type": "$s_driver_handle_t" }, { - "desc": "[in] metric group count to activate; must be 0 if `nullptr == phMetricGroups`", - "name": "count", - "type": "uint32_t" + "desc": "[in] extension function name", + "name": "name", + "type": "const char*" }, { - "desc": "[in][optional][range(0, count)] handles of the metric groups to activate.\nnullptr deactivates all previously used metric groups.\nall metrics groups must come from a different domains.\nmetric query and metric stream must use activated metric groups.\n", - "name": "phMetricGroups", - "type": "$t_metric_group_handle_t*" + "desc": "[out] pointer to function pointer", + "name": "ppFunctionAddress", + "type": "void**" } ], "returns": [ @@ -65665,95 +80450,57 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hContext`", - "`nullptr == hDevice`" - ] - }, - { - "$X_RESULT_ERROR_INVALID_SIZE": [ - "`(nullptr == phMetricGroups) && (0 < count)`" + "`nullptr == hDriver`" ] }, { - "$X_RESULT_ERROR_INVALID_ARGUMENT": [ - "Multiple metric groups share the same domain" + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == name`", + "`nullptr == ppFunctionAddress`" ] } ], - "type": "function" - }, - { - "base": "$t_base_desc_t", - "class": "$tMetricStreamer", - "desc": "Metric streamer descriptor", - "members": [ - { - "desc": "[in] type of this structure", - "init": "$T_STRUCTURE_TYPE_METRIC_STREAMER_DESC", - "name": "stype", - "type": "$t_structure_type_t" - }, - { - "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "const void*" - }, - { - "desc": "[in,out] number of collected reports after which notification event will be signaled. If the requested value is not supported exactly, then the driver may use a value that is the closest supported approximation and shall update this member during $tMetricStreamerOpen.\n", - "name": "notifyEveryNReports", - "type": "uint32_t" - }, - { - "desc": "[in,out] streamer sampling period in nanoseconds. If the requested value is not supported exactly, then the driver may use a value that is the closest supported approximation and shall update this member during $tMetricStreamerOpen.\n", - "name": "samplingPeriod", - "type": "uint32_t" - } - ], - "name": "$t_metric_streamer_desc_t", - "type": "struct" - }, + "type": "function", + "version": "1.8" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - Device management", + "ordinal": 2, + "type": "header" + }, + "name": "device", + "objects": [ { - "class": "$tMetricStreamer", + "class": "$sDevice", "decl": "static", - "desc": "Opens metric streamer for a device.", + "desc": "Retrieves sysman devices within a sysman driver", "details": [ - "The notification event must have been created from an event pool that was created using $X_EVENT_POOL_FLAG_HOST_VISIBLE flag.", - "The duration of the signal event created from an event pool that was created using $X_EVENT_POOL_FLAG_KERNEL_TIMESTAMP flag is undefined. However, for consistency and orthogonality the event will report correctly as signaled when used by other event API functionality.", - "The application must **not** call this function from simultaneous threads with the same device handle." + "Multiple calls to this function will return identical sysman device handles, in the same order.", + "The number and order of handles returned from this function is NOT affected by the $X_AFFINITY_MASK, $X_ENABLE_PCI_ID_DEVICE_ORDER, or $X_FLAT_DEVICE_HIERARCHY environment variables.", + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." ], - "hash": "fd476dcac868ee20bbfeaa63a804477465714e4b754e0d863151f3f5f39ffc23", - "name": "Open", + "hash": "39d581ecb601676e1aeb2d414243171941d470b923f87b7356eaa9b784c14cfa", + "name": "Get", + "ordinal": "0", "params": [ { - "desc": "[in] handle of the context object", - "name": "hContext", - "type": "$t_context_handle_t" - }, - { - "desc": "[in] handle of the device", - "name": "hDevice", - "type": "$t_device_handle_t" - }, - { - "desc": "[in] handle of the metric group", - "name": "hMetricGroup", - "type": "$t_metric_group_handle_t" - }, - { - "desc": "[in,out] metric streamer descriptor", - "name": "desc", - "type": "$t_metric_streamer_desc_t*" + "desc": "[in] handle of the sysman driver instance", + "name": "hDriver", + "type": "$s_driver_handle_t" }, { - "desc": "[in][optional] event used for report availability notification", - "name": "hNotificationEvent", - "type": "$x_event_handle_t" + "desc": "[in,out] pointer to the number of sysman devices.\nif count is zero, then the driver shall update the value with the total number of sysman devices available.\nif count is greater than the number of sysman devices available, then the driver shall update the value with the correct number of sysman devices available.\n", + "name": "pCount", + "type": "uint32_t*" }, { - "desc": "[out] handle of metric streamer", - "name": "phMetricStreamer", - "type": "$t_metric_streamer_handle_t*" + "desc": "[in,out][optional][range(0, *pCount)] array of handle of sysman devices.\nif count is less than the number of sysman devices available, then driver shall only retrieve that number of sysman devices.\n", + "name": "phDevices", + "type": "$s_device_handle_t*" } ], "returns": [ @@ -65774,264 +80521,390 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hContext`", - "`nullptr == hDevice`", - "`nullptr == hMetricGroup`" + "`nullptr == hDriver`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == desc`", - "`nullptr == phMetricStreamer`" + "`nullptr == pCount`" ] + } + ], + "type": "function", + "version": "1.5" + }, + { + "desc": "Maximum number of characters in string properties.", + "name": "$S_STRING_PROPERTY_SIZE", + "type": "macro", + "value": "64" + }, + { + "desc": "Maximum device universal unique id (UUID) size in bytes.", + "name": "$S_MAX_UUID_SIZE", + "type": "macro", + "value": "16" + }, + { + "class": "$sDevice", + "desc": "Types of accelerator engines", + "etors": [ + { + "desc": "Undefined types of accelerators.", + "name": "$S_ENGINE_TYPE_FLAG_OTHER", + "value": "$X_BIT(0)" }, { - "$X_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT": [] + "desc": "Engines that process compute kernels only (no 3D content).", + "name": "$S_ENGINE_TYPE_FLAG_COMPUTE", + "value": "$X_BIT(1)" + }, + { + "desc": "Engines that process 3D content only (no compute kernels).", + "name": "$S_ENGINE_TYPE_FLAG_3D", + "value": "$X_BIT(2)" + }, + { + "desc": "Engines that process media workloads.", + "name": "$S_ENGINE_TYPE_FLAG_MEDIA", + "value": "$X_BIT(3)" + }, + { + "desc": "Engines that copy blocks of data.", + "name": "$S_ENGINE_TYPE_FLAG_DMA", + "value": "$X_BIT(4)" + }, + { + "desc": "Engines that can process both 3D content and compute kernels.", + "name": "$S_ENGINE_TYPE_FLAG_RENDER", + "value": "$X_BIT(5)" } ], - "type": "function" + "name": "$s_engine_type_flags_t", + "type": "enum" }, { - "class": "$tCommandList", - "desc": "Append metric streamer marker into a command list.", - "details": [ - "The application must ensure the metric streamer is accessible by the device on which the command list was created.", - "The application must ensure the command list and metric streamer were created on the same context.", - "The application must **not** call this function from simultaneous threads with the same command list handle.", - "Allow to associate metric stream time based metrics with executed workload." - ], - "hash": "442249fcbae3e728493309e244e058e9b58dbcd35d8a6e08a27fc30e787152fa", - "name": "AppendMetricStreamerMarker", - "params": [ + "class": "$sDevice", + "desc": "Device repair status", + "etors": [ { - "desc": "[in] handle of the command list", - "name": "hCommandList", - "type": "$t_command_list_handle_t" + "desc": "The device does not support in-field repairs.", + "name": "$S_REPAIR_STATUS_UNSUPPORTED", + "value": "0" }, { - "desc": "[in] handle of the metric streamer", - "name": "hMetricStreamer", - "type": "$t_metric_streamer_handle_t" + "desc": "The device has never been repaired.", + "name": "$S_REPAIR_STATUS_NOT_PERFORMED", + "value": "1" }, { - "desc": "[in] streamer marker value", - "name": "value", - "type": "uint32_t" + "desc": "The device has been repaired.", + "name": "$S_REPAIR_STATUS_PERFORMED", + "value": "2" } ], - "returns": [ + "name": "$s_repair_status_t", + "type": "enum" + }, + { + "class": "$sDevice", + "desc": "Device reset reasons", + "etors": [ { - "$X_RESULT_SUCCESS": [] + "desc": "The device needs to be reset because one or more parts of the hardware is wedged", + "name": "$S_RESET_REASON_FLAG_WEDGED", + "value": "$X_BIT(0)" }, { - "$X_RESULT_ERROR_UNINITIALIZED": [] + "desc": "The device needs to be reset in order to complete in-field repairs", + "name": "$S_RESET_REASON_FLAG_REPAIR", + "value": "$X_BIT(1)" + } + ], + "name": "$s_reset_reason_flags_t", + "type": "enum" + }, + { + "class": "$sDevice", + "desc": "Device reset type", + "etors": [ + { + "desc": "Apply warm reset", + "name": "$S_RESET_TYPE_WARM", + "value": "0" }, { - "$X_RESULT_ERROR_DEVICE_LOST": [] + "desc": "Apply cold reset", + "name": "$S_RESET_TYPE_COLD", + "value": "1" }, { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "desc": "Apply FLR reset", + "name": "$S_RESET_TYPE_FLR", + "value": "2" + } + ], + "name": "$s_reset_type_t", + "type": "enum", + "version": "1.7" + }, + { + "base": "$s_base_state_t", + "class": "$sDevice", + "desc": "Device state", + "members": [ + { + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_DEVICE_STATE", + "name": "stype", + "type": "$s_structure_type_t" }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" }, { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hCommandList`", - "`nullptr == hMetricStreamer`" - ] + "desc": "[out] Indicates if the device needs to be reset and for what reasons.\nreturns 0 (none) or combination of $s_reset_reason_flag_t\n", + "name": "reset", + "type": "$s_reset_reason_flags_t" + }, + { + "desc": "[out] Indicates if the device has been repaired", + "name": "repaired", + "type": "$s_repair_status_t" } ], - "type": "function" + "name": "$s_device_state_t", + "type": "struct" }, { - "class": "$tMetricStreamer", - "desc": "Closes metric streamer.", - "details": [ - "The application must **not** call this function from simultaneous threads with the same metric streamer handle." - ], - "hash": "f4cbb10d86bc48d25d8daf58501a6a5f561fad25962e1174cdbe30f1a912e97a", - "name": "Close", - "params": [ + "base": "$s_base_properties_t", + "class": "$sDevice", + "desc": "Device reset properties", + "members": [ { - "desc": "[in][release] handle of the metric streamer", - "name": "hMetricStreamer", - "type": "$t_metric_streamer_handle_t" + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_RESET_PROPERTIES", + "name": "stype", + "type": "$s_structure_type_t" + }, + { + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" + }, + { + "desc": "[in] If set to true, all applications that are currently using the device will be forcibly killed.\n", + "name": "force", + "type": "ze_bool_t" + }, + { + "desc": "[in] Type of reset needs to be performed", + "name": "resetType", + "type": "$s_reset_type_t" } ], - "returns": [ + "name": "$s_reset_properties_t", + "type": "struct", + "version": "1.7" + }, + { + "class": "$sDevice", + "desc": "Device universal unique id (UUID)", + "members": [ { - "$X_RESULT_SUCCESS": [] - }, + "desc": "[out] opaque data representing a device UUID", + "name": "id[$S_MAX_UUID_SIZE]", + "type": "uint8_t" + } + ], + "name": "$s_uuid_t", + "type": "struct", + "version": "1.7" + }, + { + "class": "$sDevice", + "desc": "Supported device types", + "etors": [ { - "$X_RESULT_ERROR_UNINITIALIZED": [] + "desc": "Graphics Processing Unit", + "name": "$S_DEVICE_TYPE_GPU", + "value": "1" }, { - "$X_RESULT_ERROR_DEVICE_LOST": [] + "desc": "Central Processing Unit", + "name": "$S_DEVICE_TYPE_CPU", + "value": "2" }, { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "desc": "Field Programmable Gate Array", + "name": "$S_DEVICE_TYPE_FPGA", + "value": "3" }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + "desc": "Memory Copy Accelerator", + "name": "$S_DEVICE_TYPE_MCA", + "value": "4" }, { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hMetricStreamer`" - ] + "desc": "Vision Processing Unit", + "name": "$S_DEVICE_TYPE_VPU", + "value": "5" } ], - "type": "function" + "name": "$s_device_type_t", + "type": "enum", + "version": "1.7" }, { - "class": "$tMetricStreamer", - "desc": "Reads data from metric streamer.", - "details": [ - "The application may call this function from simultaneous threads." - ], - "hash": "46f3a51dca41a6993577fdad58dc258e362bc98c7ffac1bdc6f6000b327acd2b", - "name": "ReadData", - "params": [ + "class": "$sDevice", + "desc": "Supported device property flags", + "etors": [ { - "desc": "[in] handle of the metric streamer", - "name": "hMetricStreamer", - "type": "$t_metric_streamer_handle_t" + "desc": "Device is integrated with the Host.", + "name": "$S_DEVICE_PROPERTY_FLAG_INTEGRATED", + "value": "$X_BIT(0)" }, { - "desc": "[in] the maximum number of reports the application wants to receive.\nif `UINT32_MAX`, then function will retrieve all reports available\n", - "name": "maxReportCount", - "type": "uint32_t" + "desc": "Device handle used for query represents a sub-device.", + "name": "$S_DEVICE_PROPERTY_FLAG_SUBDEVICE", + "value": "$X_BIT(1)" }, { - "desc": "[in,out] pointer to size in bytes of raw data requested to read.\nif size is zero, then the driver will update the value with the total size in bytes needed for all reports available.\nif size is non-zero, then driver will only retrieve the number of reports that fit into the buffer.\nif size is larger than size needed for all reports, then driver will update the value with the actual size needed.\n", - "name": "pRawDataSize", - "type": "size_t*" + "desc": "Device supports error correction memory access.", + "name": "$S_DEVICE_PROPERTY_FLAG_ECC", + "value": "$X_BIT(2)" }, { - "desc": "[in,out][optional][range(0, *pRawDataSize)] buffer containing streamer reports in raw format", - "name": "pRawData", - "type": "uint8_t*" + "desc": "Device supports on-demand page-faulting.", + "name": "$S_DEVICE_PROPERTY_FLAG_ONDEMANDPAGING", + "value": "$X_BIT(3)" } ], - "returns": [ + "name": "$s_device_property_flags_t", + "type": "enum", + "version": "1.7" + }, + { + "base": "$s_base_properties_t", + "class": "$sDevice", + "desc": "Device properties", + "members": [ { - "$X_RESULT_SUCCESS": [] + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_DEVICE_PROPERTIES", + "name": "stype", + "type": "$s_structure_type_t" }, { - "$X_RESULT_ERROR_UNINITIALIZED": [] + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" }, { - "$X_RESULT_ERROR_DEVICE_LOST": [] + "desc": "[out] (Deprecated, use $s_uuid_t in the extended structure) Core device properties", + "name": "core", + "type": "$x_device_properties_t" }, { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "desc": "[out] Number of sub-devices. A value of 0 indicates that this device doesn't have sub-devices.", + "name": "numSubdevices", + "type": "uint32_t" }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + "desc": "[out] Manufacturing serial number (NULL terminated string value). This value is intended to reflect the Part ID/SoC ID assigned by manufacturer that is unique for a SoC. Will be set to the string \"unknown\" if this cannot be determined for the device.", + "name": "serialNumber[$S_STRING_PROPERTY_SIZE]", + "type": "char" }, { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hMetricStreamer`" - ] + "desc": "[out] Manufacturing board number (NULL terminated string value). Alternatively \"boardSerialNumber\", this value is intended to reflect the string printed on board label by manufacturer. Will be set to the string \"unknown\" if this cannot be determined for the device.", + "name": "boardNumber[$S_STRING_PROPERTY_SIZE]", + "type": "char" }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pRawDataSize`" - ] + "desc": "[out] Brand name of the device (NULL terminated string value). Will be set to the string \"unknown\" if this cannot be determined for the device.", + "name": "brandName[$S_STRING_PROPERTY_SIZE]", + "type": "char" }, { - "$X_RESULT_WARNING_DROPPED_DATA": [ - "Metric streamer data may have been dropped. Reduce sampling period." - ] - } - ], - "type": "function" - }, - { - "class": "$tMetricQueryPool", - "desc": "Metric query pool types", - "etors": [ + "desc": "[out] Model name of the device (NULL terminated string value). Will be set to the string \"unknown\" if this cannot be determined for the device.", + "name": "modelName[$S_STRING_PROPERTY_SIZE]", + "type": "char" + }, { - "desc": "Performance metric query pool.", - "name": "$T_METRIC_QUERY_POOL_TYPE_PERFORMANCE", - "value": "0" + "desc": "[out] Vendor name of the device (NULL terminated string value). Will be set to the string \"unknown\" if this cannot be determined for the device.", + "name": "vendorName[$S_STRING_PROPERTY_SIZE]", + "type": "char" }, { - "desc": "Skips workload execution between begin/end calls.", - "name": "$T_METRIC_QUERY_POOL_TYPE_EXECUTION", - "value": "1" + "desc": "[out] Installed driver version (NULL terminated string value). Will be set to the string \"unknown\" if this cannot be determined for the device.", + "name": "driverVersion[$S_STRING_PROPERTY_SIZE]", + "type": "char" } ], - "name": "$t_metric_query_pool_type_t", - "type": "enum" + "name": "$s_device_properties_t", + "type": "struct" }, { - "base": "$t_base_desc_t", - "class": "$tMetricQueryPool", - "desc": "Metric query pool description", + "base": "$s_base_properties_t", + "class": "$sDevice", + "desc": "Device properties", "members": [ { "desc": "[in] type of this structure", - "init": "$T_STRUCTURE_TYPE_METRIC_QUERY_POOL_DESC", + "init": "$S_STRUCTURE_TYPE_DEVICE_EXT_PROPERTIES", "name": "stype", - "type": "$t_structure_type_t" + "type": "$s_structure_type_t" }, { - "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", "init": "nullptr", "name": "pNext", - "type": "const void*" + "type": "void*" }, { - "desc": "[in] Query pool type.", - "init": "$T_METRIC_QUERY_POOL_TYPE_PERFORMANCE", + "desc": "[out] universal unique identifier. Note: uuid obtained from Sysman API is the same as from core API. Subdevices will have their own uuid.", + "name": "uuid", + "type": "$s_uuid_t" + }, + { + "desc": "[out] generic device type", "name": "type", - "type": "$t_metric_query_pool_type_t" + "type": "$s_device_type_t" }, { - "desc": "[in] Internal slots count within query pool object.", - "name": "count", - "type": "uint32_t" + "desc": "[out] 0 (none) or a valid combination of $s_device_property_flag_t", + "name": "flags", + "type": "$s_device_property_flags_t" } ], - "name": "$t_metric_query_pool_desc_t", - "type": "struct" + "name": "$s_device_ext_properties_t", + "type": "struct", + "version": "1.7" }, { - "class": "$tMetricQueryPool", - "decl": "static", - "desc": "Creates a pool of metric queries on the context.", + "class": "$sDevice", + "desc": "Get properties about the device", "details": [ "The application may call this function from simultaneous threads.", - "The implementation of this function must be thread-safe." + "The implementation of this function should be lock-free." ], - "hash": "9727a2898e91512de28ffbf2c09ad780be377d517d6dfe36cf34e27eaa723885", - "name": "Create", + "hash": "c558d1b867032600d877bf98f17dfab339d27cf77a33bb46c846981ac08d0fd0", + "name": "GetProperties", "params": [ { - "desc": "[in] handle of the context object", - "name": "hContext", - "type": "$t_context_handle_t" - }, - { - "desc": "[in] handle of the device", + "desc": "[in] Sysman handle of the device.", "name": "hDevice", - "type": "$t_device_handle_t" - }, - { - "desc": "[in] metric group associated with the query object.", - "name": "hMetricGroup", - "type": "$t_metric_group_handle_t" - }, - { - "desc": "[in] metric query pool descriptor", - "name": "desc", - "type": "const $t_metric_query_pool_desc_t*" + "type": "$s_device_handle_t" }, { - "desc": "[out] handle of metric query pool", - "name": "phMetricQueryPool", - "type": "$t_metric_query_pool_handle_t*" + "desc": "[in,out] Structure that will contain information about the device.", + "name": "pProperties", + "type": "$s_device_properties_t*" } ], "returns": [ @@ -66052,42 +80925,36 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hContext`", - "`nullptr == hDevice`", - "`nullptr == hMetricGroup`" + "`nullptr == hDevice`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == desc`", - "`nullptr == phMetricQueryPool`" - ] - }, - { - "$X_RESULT_ERROR_INVALID_ENUMERATION": [ - "`$T_METRIC_QUERY_POOL_TYPE_EXECUTION < desc->type`" + "`nullptr == pProperties`" ] } ], "type": "function" }, { - "class": "$tMetricQueryPool", - "decl": "static", - "desc": "Deletes a query pool object.", + "class": "$sDevice", + "desc": "Get information about the state of the device - if a reset is required, reasons for the reset and if the device has been repaired", "details": [ - "The application must destroy all query handles created from the pool before destroying the pool itself.", - "The application must ensure the device is not currently referencing the any query within the pool before it is deleted.", - "The application must **not** call this function from simultaneous threads with the same query pool handle.", - "The implementation of this function must be thread-safe." + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." ], - "hash": "b26d02c53519d670c87cb7b785b5df2a25f8a4fcbe931f5ecd168e5730641c6e", - "name": "Destroy", + "hash": "28bd626c19e2bd6d9240511ec845060f705570df8951af52c71be55b50515edd", + "name": "GetState", "params": [ { - "desc": "[in][release] handle of the metric query pool", - "name": "hMetricQueryPool", - "type": "$t_metric_query_pool_handle_t" + "desc": "[in] Sysman handle of the device.", + "name": "hDevice", + "type": "$s_device_handle_t" + }, + { + "desc": "[in,out] Structure that will contain information about the device.", + "name": "pState", + "type": "$s_device_state_t*" } ], "returns": [ @@ -66108,40 +80975,38 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hMetricQueryPool`" + "`nullptr == hDevice`" ] }, { - "$X_RESULT_ERROR_HANDLE_OBJECT_IN_USE": [] + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pState`" + ] } ], "type": "function" }, { - "class": "$tMetricQuery", - "decl": "static", - "desc": "Creates metric query from the pool.", + "class": "$sDevice", + "desc": "Reset device", "details": [ - "The application may call this function from simultaneous threads.", - "The implementation of this function must be thread-safe." + "Performs a PCI bus reset of the device. This will result in all current device state being lost.", + "All applications using the device should be stopped before calling this function.", + "If the force argument is specified, all applications using the device will be forcibly killed.", + "The function will block until the device has restarted or an implementation defined timeout occurred waiting for the reset to complete." ], - "hash": "8644abb74b401f86e5b41611bb4a50a1514db5c88349292c1713315229a8ab50", - "name": "Create", + "hash": "67b1841611f9320f42b40fbca89a7d36fe40df9eb3f266d1eaa2b10d345bf9dd", + "name": "Reset", "params": [ { - "desc": "[in] handle of the metric query pool", - "name": "hMetricQueryPool", - "type": "$t_metric_query_pool_handle_t" - }, - { - "desc": "[in] index of the query within the pool", - "name": "index", - "type": "uint32_t" + "desc": "[in] Sysman handle for the device", + "name": "hDevice", + "type": "$s_device_handle_t" }, { - "desc": "[out] handle of metric query", - "name": "phMetricQuery", - "type": "$t_metric_query_handle_t*" + "desc": "[in] If set to true, all applications that are currently using the device will be forcibly killed.", + "name": "force", + "type": "$x_bool_t" } ], "returns": [ @@ -66162,33 +81027,48 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hMetricQueryPool`" + "`nullptr == hDevice`" ] }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == phMetricQuery`" + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "User does not have permissions to perform this operation." + ] + }, + { + "$X_RESULT_ERROR_HANDLE_OBJECT_IN_USE": [ + "Reset cannot be performed because applications are using this device." + ] + }, + { + "$X_RESULT_ERROR_UNKNOWN": [ + "There were problems unloading the device driver, performing a bus reset or reloading the device driver." ] } ], "type": "function" }, { - "class": "$tMetricQuery", - "decl": "static", - "desc": "Deletes a metric query object.", + "class": "$sDevice", + "desc": "Reset device extension", "details": [ - "The application must ensure the device is not currently referencing the query before it is deleted.", - "The application must **not** call this function from simultaneous threads with the same query handle.", - "The implementation of this function must be thread-safe." + "Performs a PCI bus reset of the device. This will result in all current device state being lost.", + "Prior to calling this function, user is responsible for closing applications using the device unless force argument is specified.", + "If the force argument is specified, all applications using the device will be forcibly killed.", + "The function will block until the device has restarted or a implementation specific timeout occurred waiting for the reset to complete." ], - "hash": "e383c2dd1db9330485352b7dc38681e70be0e44436e2872d7681c5727576c407", - "name": "Destroy", + "hash": "483a18c10d33993940d82a433a1d1315e607f86845f02ea1cb32d9f41b225fb3", + "name": "ResetExt", "params": [ { - "desc": "[in][release] handle of metric query", - "name": "hMetricQuery", - "type": "$t_metric_query_handle_t" + "desc": "[in] Sysman handle for the device", + "name": "hDevice", + "type": "$s_device_handle_t" + }, + { + "desc": "[in] Device reset properties to apply", + "name": "pProperties", + "type": "$s_reset_properties_t*" } ], "returns": [ @@ -66209,142 +81089,102 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hMetricQuery`" + "`nullptr == hDevice`" ] }, { - "$X_RESULT_ERROR_HANDLE_OBJECT_IN_USE": [] - } - ], - "type": "function" - }, - { - "class": "$tMetricQuery", - "desc": "Resets a metric query object back to initial state.", - "details": [ - "The application must ensure the device is not currently referencing the query before it is reset", - "The application must **not** call this function from simultaneous threads with the same query handle." - ], - "hash": "bd549c068b921a3b4d5be8147c1668f747c8b30d5794d06e24821c0531a38cb6", - "name": "Reset", - "params": [ - { - "desc": "[in] handle of metric query", - "name": "hMetricQuery", - "type": "$t_metric_query_handle_t" - } - ], - "returns": [ - { - "$X_RESULT_SUCCESS": [] - }, - { - "$X_RESULT_ERROR_UNINITIALIZED": [] - }, - { - "$X_RESULT_ERROR_DEVICE_LOST": [] + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pProperties`" + ] }, { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "User does not have permissions to perform this operation." + ] }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + "$X_RESULT_ERROR_HANDLE_OBJECT_IN_USE": [ + "Reset cannot be performed because applications are using this device." + ] }, { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hMetricQuery`" + "$X_RESULT_ERROR_UNKNOWN": [ + "There were problems unloading the device driver, performing a bus reset or reloading the device driver." ] } ], - "type": "function" + "type": "function", + "version": "1.7" }, { - "class": "$tCommandList", - "desc": "Appends metric query begin into a command list.", + "base": "$s_base_state_t", + "class": "$sDevice", + "desc": "Contains information about a process that has an open connection with this device", "details": [ - "The application must ensure the metric query is accessible by the device on which the command list was created.", - "The application must ensure the command list and metric query were created on the same context.", - "This command blocks all following commands from beginning until the execution of the query completes.", - "The application must **not** call this function from simultaneous threads with the same command list handle." - ], - "hash": "84fe1ebe23db5e8ef6eea4d147307ac6af09f6df489af8613329efb938d59e2e", - "name": "AppendMetricQueryBegin", - "params": [ - { - "desc": "[in] handle of the command list", - "name": "hCommandList", - "type": "$t_command_list_handle_t" - }, - { - "desc": "[in] handle of the metric query", - "name": "hMetricQuery", - "type": "$t_metric_query_handle_t" - } + "The application can use the process ID to query the OS for the owner and the path to the executable." ], - "returns": [ + "members": [ { - "$X_RESULT_SUCCESS": [] + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_PROCESS_STATE", + "name": "stype", + "type": "$s_structure_type_t" }, { - "$X_RESULT_ERROR_UNINITIALIZED": [] + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" }, { - "$X_RESULT_ERROR_DEVICE_LOST": [] + "desc": "[out] Host OS process ID.", + "name": "processId", + "type": "uint32_t" }, { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "desc": "[out] Device memory size in bytes allocated by this process (may not necessarily be resident on the device at the time of reading).", + "name": "memSize", + "type": "uint64_t" }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + "desc": "[out] The size of shared device memory mapped into this process (may not necessarily be resident on the device at the time of reading).", + "name": "sharedSize", + "type": "uint64_t" }, { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hCommandList`", - "`nullptr == hMetricQuery`" - ] + "desc": "[out] Bitfield of accelerator engine types being used by this process.", + "name": "engines", + "type": "$s_engine_type_flags_t" } ], - "type": "function" + "name": "$s_process_state_t", + "type": "struct" }, { - "class": "$tCommandList", - "desc": "Appends metric query end into a command list.", + "class": "$sDevice", + "desc": "Get information about host processes using the device", "details": [ - "The application must ensure the metric query and events are accessible by the device on which the command list was created.", - "The application must ensure the command list, events and metric query were created on the same context.", - "The duration of the signal event created from an event pool that was created using $X_EVENT_POOL_FLAG_KERNEL_TIMESTAMP flag is undefined. However, for consistency and orthogonality the event will report correctly as signaled when used by other event API functionality.", - "If numWaitEvents is zero, then all previous commands are completed prior to the execution of the query.", - "If numWaitEvents is non-zero, then all phWaitEvents must be signaled prior to the execution of the query.", - "This command blocks all following commands from beginning until the execution of the query completes.", - "The application must **not** call this function from simultaneous threads with the same command list handle." + "The number of processes connected to the device is dynamic. This means that between a call to determine the value of pCount and the subsequent call, the number of processes may have increased or decreased. It is recommended that a large array be passed in so as to avoid receiving the error $X_RESULT_ERROR_INVALID_SIZE. Also, always check the returned value in pCount since it may be less than the earlier call to get the required array size.", + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." ], - "hash": "20793bcbc2a57cd3cd64765ed31236e03d78c596d549679ccb5733f2829ff01e", - "name": "AppendMetricQueryEnd", + "hash": "e0532e5c68d72d06053786f30f98e8586a9f97e4123742ec00b31bd1190d67b0", + "name": "ProcessesGetState", "params": [ { - "desc": "[in] handle of the command list", - "name": "hCommandList", - "type": "$t_command_list_handle_t" - }, - { - "desc": "[in] handle of the metric query", - "name": "hMetricQuery", - "type": "$t_metric_query_handle_t" - }, - { - "desc": "[in][optional] handle of the event to signal on completion", - "name": "hSignalEvent", - "type": "$x_event_handle_t" + "desc": "[in] Sysman handle for the device", + "name": "hDevice", + "type": "$s_device_handle_t" }, { - "desc": "[in] must be zero", - "name": "numWaitEvents", - "type": "uint32_t" + "desc": "[in,out] pointer to the number of processes.\nif count is zero, then the driver shall update the value with the total number of processes currently attached to the device.\nif count is greater than the number of processes currently attached to the device, then the driver shall update the value with the correct number of processes.\n", + "name": "pCount", + "type": "uint32_t*" }, { - "desc": "[in][mbz] must be nullptr", - "name": "phWaitEvents", - "type": "$x_event_handle_t*" + "desc": "[in,out][optional][range(0, *pCount)] array of process information.\nif count is less than the number of processes currently attached to the device, then the driver shall only retrieve information about that number of processes. In this case, the return code will $X_RESULT_ERROR_INVALID_SIZE.\n", + "name": "pProcesses", + "type": "$s_process_state_t*" } ], "returns": [ @@ -66365,255 +81205,252 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hCommandList`", - "`nullptr == hMetricQuery`" + "`nullptr == hDevice`" ] }, { - "$X_RESULT_ERROR_INVALID_SYNCHRONIZATION_OBJECT": [] + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCount`" + ] }, { "$X_RESULT_ERROR_INVALID_SIZE": [ - "`(nullptr == phWaitEvents) && (0 < numWaitEvents)`" + "The provided value of pCount is not big enough to store information about all the processes currently attached to the device." ] } ], "type": "function" }, { - "class": "$tCommandList", - "desc": "Appends metric query commands to flush all caches.", - "details": [ - "The application must **not** call this function from simultaneous threads with the same command list handle." - ], - "hash": "9f3cba9f6f40a91263c007a1f597465b2b96639756498cbd3a1f6a034e4b6f3a", - "name": "AppendMetricMemoryBarrier", - "params": [ - { - "desc": "[in] handle of the command list", - "name": "hCommandList", - "type": "$t_command_list_handle_t" - } - ], - "returns": [ - { - "$X_RESULT_SUCCESS": [] - }, - { - "$X_RESULT_ERROR_UNINITIALIZED": [] - }, + "class": "$sDevice", + "desc": "PCI address", + "members": [ { - "$X_RESULT_ERROR_DEVICE_LOST": [] + "desc": "[out] BDF domain", + "name": "domain", + "type": "uint32_t" }, { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "desc": "[out] BDF bus", + "name": "bus", + "type": "uint32_t" }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + "desc": "[out] BDF device", + "name": "device", + "type": "uint32_t" }, { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hCommandList`" - ] + "desc": "[out] BDF function", + "name": "function", + "type": "uint32_t" } ], - "type": "function" + "name": "$s_pci_address_t", + "type": "struct" }, { - "class": "$tMetricQuery", - "desc": "Retrieves raw data for a given metric query.", - "details": [ - "The application may call this function from simultaneous threads." - ], - "hash": "80cdaba4fc2a26a2427d93307cd9bf45b900a795ffb6f1f21eb0c74ccfd23ba6", - "name": "GetData", - "params": [ + "class": "$sDevice", + "desc": "PCI speed", + "members": [ { - "desc": "[in] handle of the metric query", - "name": "hMetricQuery", - "type": "$t_metric_query_handle_t" + "desc": "[out] The link generation. A value of -1 means that this property is unknown.", + "name": "gen", + "type": "int32_t" }, { - "desc": "[in,out] pointer to size in bytes of raw data requested to read.\nif size is zero, then the driver will update the value with the total size in bytes needed for all reports available.\nif size is non-zero, then driver will only retrieve the number of reports that fit into the buffer.\nif size is larger than size needed for all reports, then driver will update the value with the actual size needed.\n", - "name": "pRawDataSize", - "type": "size_t*" + "desc": "[out] The number of lanes. A value of -1 means that this property is unknown.", + "name": "width", + "type": "int32_t" }, { - "desc": "[in,out][optional][range(0, *pRawDataSize)] buffer containing query reports in raw format", - "name": "pRawData", - "type": "uint8_t*" + "desc": "[out] The maximum bandwidth in bytes/sec (sum of all lanes). A value of -1 means that this property is unknown.", + "name": "maxBandwidth", + "type": "int64_t" } ], - "returns": [ + "name": "$s_pci_speed_t", + "type": "struct" + }, + { + "base": "$s_base_properties_t", + "class": "$sDevice", + "desc": "Static PCI properties", + "members": [ { - "$X_RESULT_SUCCESS": [] + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_PCI_PROPERTIES", + "name": "stype", + "type": "$s_structure_type_t" }, { - "$X_RESULT_ERROR_UNINITIALIZED": [] + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" }, { - "$X_RESULT_ERROR_DEVICE_LOST": [] + "desc": "[out] The BDF address", + "name": "address", + "type": "$s_pci_address_t" }, { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "desc": "[out] Fastest port configuration supported by the device (sum of all lanes)", + "name": "maxSpeed", + "type": "$s_pci_speed_t" }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + "desc": "[out] Indicates whether the `rxCounter` and `txCounter` members of $s_pci_stats_t will have valid values", + "name": "haveBandwidthCounters", + "type": "$x_bool_t" }, { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hMetricQuery`" - ] + "desc": "[out] Indicates whether the `packetCounter` member of $s_pci_stats_t will have a valid value", + "name": "havePacketCounters", + "type": "$x_bool_t" }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pRawDataSize`" - ] + "desc": "[out] Indicates whether the `replayCounter` member of $s_pci_stats_t will have a valid value", + "name": "haveReplayCounters", + "type": "$x_bool_t" } ], - "type": "function" + "name": "$s_pci_properties_t", + "type": "struct" }, { - "attribute": "singleton", - "desc": "C++ wrapper for metric group", - "members": [ + "class": "$sDevice", + "desc": "PCI link status", + "etors": [ { - "desc": "[in] handle of metric group object", - "init": "nullptr", - "name": "handle", - "type": "$t_metric_group_handle_t" + "desc": "The link status could not be determined", + "name": "$S_PCI_LINK_STATUS_UNKNOWN", + "value": "0" }, { - "desc": "[in] pointer to owner object", - "name": "pDevice", - "type": "$tDevice*" + "desc": "The link is up and operating as expected", + "name": "$S_PCI_LINK_STATUS_GOOD", + "value": "1" + }, + { + "desc": "The link is up but has quality and/or bandwidth degradation", + "name": "$S_PCI_LINK_STATUS_QUALITY_ISSUES", + "value": "2" + }, + { + "desc": "The link has stability issues and preventing workloads making forward progress", + "name": "$S_PCI_LINK_STATUS_STABILITY_ISSUES", + "value": "3" } ], - "name": "$tMetricGroup", - "owner": "$tDevice", - "type": "class" + "name": "$s_pci_link_status_t", + "type": "enum" }, { - "attribute": "singleton", - "desc": "C++ wrapper for metric", - "members": [ + "class": "$sDevice", + "desc": "PCI link quality degradation reasons", + "etors": [ { - "desc": "[in] handle of metric object", - "name": "handle", - "type": "$t_metric_handle_t" + "desc": "A significant number of replays are occurring", + "name": "$S_PCI_LINK_QUAL_ISSUE_FLAG_REPLAYS", + "value": "$X_BIT(0)" }, { - "desc": "[in] pointer to owner object", - "name": "pMetricGroup", - "type": "$tMetricGroup*" + "desc": "There is a degradation in the maximum bandwidth of the link", + "name": "$S_PCI_LINK_QUAL_ISSUE_FLAG_SPEED", + "value": "$X_BIT(1)" } ], - "name": "$tMetric", - "owner": "$tMetricGroup", - "type": "class" + "name": "$s_pci_link_qual_issue_flags_t", + "type": "enum" }, { - "desc": "C++ wrapper for metric streamer", - "members": [ - { - "desc": "[in] handle of metric streamer object", - "name": "handle", - "type": "$t_metric_streamer_handle_t" - }, - { - "desc": "[in] pointer to owner object", - "name": "pDevice", - "type": "$tDevice*" - }, + "class": "$sDevice", + "desc": "PCI link stability issues", + "etors": [ { - "desc": "[in] descriptor of the metric streamer", - "name": "desc", - "type": "$t_metric_streamer_desc_t" + "desc": "Link retraining has occurred to deal with quality issues", + "name": "$S_PCI_LINK_STAB_ISSUE_FLAG_RETRAINING", + "value": "$X_BIT(0)" } ], - "name": "$tMetricStreamer", - "owner": "$tDevice", - "type": "class" + "name": "$s_pci_link_stab_issue_flags_t", + "type": "enum" }, { - "desc": "C++ wrapper for metric query pool", + "base": "$s_base_state_t", + "class": "$sDevice", + "desc": "Dynamic PCI state", "members": [ { - "desc": "[in] handle of metric query pool object", - "name": "handle", - "type": "$t_metric_query_pool_handle_t" + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_PCI_STATE", + "name": "stype", + "type": "$s_structure_type_t" }, { - "desc": "[in] pointer to owner object", - "name": "pDevice", - "type": "$tDevice*" + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" }, { - "desc": "[in] descriptor of the metric query pool", - "name": "desc", - "type": "$t_metric_query_pool_desc_t" - } - ], - "name": "$tMetricQueryPool", - "owner": "$tDevice", - "type": "class" - }, - { - "desc": "C++ wrapper for metric query", - "members": [ + "desc": "[out] The current status of the port", + "name": "status", + "type": "$s_pci_link_status_t" + }, { - "desc": "[in] handle of metric query object", - "name": "handle", - "type": "$t_metric_query_handle_t" + "desc": "[out] If status is $S_PCI_LINK_STATUS_QUALITY_ISSUES, \nthen this gives a combination of $s_pci_link_qual_issue_flag_t for quality issues that have been detected;\notherwise, 0 indicates there are no quality issues with the link at this time.\"\n", + "name": "qualityIssues", + "type": "$s_pci_link_qual_issue_flags_t" }, { - "desc": "[in] pointer to owner object", - "name": "pDevice", - "type": "$tDevice*" + "desc": "[out] If status is $S_PCI_LINK_STATUS_STABILITY_ISSUES, \nthen this gives a combination of $s_pci_link_stab_issue_flag_t for reasons for the connection instability;\notherwise, 0 indicates there are no connection stability issues at this time.\"\n", + "name": "stabilityIssues", + "type": "$s_pci_link_stab_issue_flags_t" + }, + { + "desc": "[out] The current port configure speed", + "name": "speed", + "type": "$s_pci_speed_t" } ], - "name": "$tMetricQuery", - "owner": "$tDevice", - "type": "class" - } - ] - }, - { - "header": { - "desc": "Intel $OneApi Level-Zero Tool APIs for Program Instrumentation (PIN)", - "ordinal": 1000, - "type": "header" - }, - "name": "pin", - "objects": [ + "name": "$s_pci_state_t", + "type": "struct" + }, { - "class": "$tKernel", - "desc": "Supportted profile features", + "class": "$sDevice", + "desc": "PCI bar types", "etors": [ { - "desc": "request the compiler attempt to minimize register usage as much as possible to allow for instrumentation", - "name": "$T_PROFILE_FLAG_REGISTER_REALLOCATION", - "value": "$X_BIT(0)" + "desc": "MMIO registers", + "name": "$S_PCI_BAR_TYPE_MMIO", + "value": "0" }, { - "desc": "request the compiler generate free register info", - "name": "$T_PROFILE_FLAG_FREE_REGISTER_INFO", - "value": "$X_BIT(1)" + "desc": "ROM aperture", + "name": "$S_PCI_BAR_TYPE_ROM", + "value": "1" + }, + { + "desc": "Device memory", + "name": "$S_PCI_BAR_TYPE_MEM", + "value": "2" } ], - "name": "$t_profile_flags_t", + "name": "$s_pci_bar_type_t", "type": "enum" }, { - "base": "$t_base_properties_t", - "class": "$tKernel", - "desc": "Profiling meta-data for instrumentation", + "base": "$s_base_properties_t", + "class": "$sDevice", + "desc": "Properties of a pci bar", "members": [ { "desc": "[in] type of this structure", - "init": "$T_STRUCTURE_TYPE_PROFILE_PROPERTIES", + "init": "$S_STRUCTURE_TYPE_PCI_BAR_PROPERTIES", "name": "stype", - "type": "$t_structure_type_t" + "type": "$s_structure_type_t" }, { "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", @@ -66622,98 +81459,142 @@ "type": "void*" }, { - "desc": "[out] indicates which flags were enabled during compilation.\nreturns 0 (none) or a combination of $t_profile_flag_t\n", - "name": "flags", - "type": "$t_profile_flags_t" + "desc": "[out] The type of bar", + "name": "type", + "type": "$s_pci_bar_type_t" }, { - "desc": "[out] number of tokens immediately following this structure", - "name": "numTokens", + "desc": "[out] The index of the bar", + "name": "index", "type": "uint32_t" - } - ], - "name": "$t_profile_properties_t", - "type": "struct" - }, - { - "class": "$tKernel", - "desc": "Supported profile token types", - "etors": [ + }, { - "desc": "GRF info", - "name": "$T_PROFILE_TOKEN_TYPE_FREE_REGISTER", - "value": "0" + "desc": "[out] Base address of the bar.", + "name": "base", + "type": "uint64_t" + }, + { + "desc": "[out] Size of the bar.", + "name": "size", + "type": "uint64_t" } ], - "name": "$t_profile_token_type_t", - "type": "enum" + "name": "$s_pci_bar_properties_t", + "type": "struct" }, { - "class": "$tKernel", - "desc": "Profile free register token detailing unused registers in the current function", + "base": "$s_base_properties_t", + "class": "$sDevice", + "desc": "Properties of a pci bar, including the resizable bar.", "members": [ { - "desc": "[out] type of token", + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_PCI_BAR_PROPERTIES_1_2", + "name": "stype", + "type": "$s_structure_type_t" + }, + { + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" + }, + { + "desc": "[out] The type of bar", "name": "type", - "type": "$t_profile_token_type_t" + "type": "$s_pci_bar_type_t" }, { - "desc": "[out] total size of the token, in bytes", - "name": "size", + "desc": "[out] The index of the bar", + "name": "index", "type": "uint32_t" }, { - "desc": "[out] number of register sequences immediately following this structure", - "name": "count", - "type": "uint32_t" + "desc": "[out] Base address of the bar.", + "name": "base", + "type": "uint64_t" + }, + { + "desc": "[out] Size of the bar.", + "name": "size", + "type": "uint64_t" + }, + { + "desc": "[out] Support for Resizable Bar on this device.", + "name": "resizableBarSupported", + "type": "$x_bool_t" + }, + { + "desc": "[out] Resizable Bar enabled on this device", + "name": "resizableBarEnabled", + "type": "$x_bool_t" } ], - "name": "$t_profile_free_register_token_t", - "type": "struct" + "name": "$s_pci_bar_properties_1_2_t", + "type": "struct", + "version": "1.2" }, { - "class": "$tKernel", - "desc": "Profile register sequence detailing consecutive bytes, all of which are unused", + "class": "$sDevice", + "desc": "PCI stats counters", + "details": [ + "Percent replays is calculated by taking two snapshots (s1, s2) and using the equation: %replay = 10^6 * (s2.replayCounter - s1.replayCounter) / (s2.maxBandwidth * (s2.timestamp - s1.timestamp))", + "Percent throughput is calculated by taking two snapshots (s1, s2) and using the equation: %bw = 10^6 * ((s2.rxCounter - s1.rxCounter) + (s2.txCounter - s1.txCounter)) / (s2.maxBandwidth * (s2.timestamp - s1.timestamp))" + ], "members": [ { - "desc": "[out] starting byte in the register table, representing the start of unused bytes in the current function", - "name": "start", - "type": "uint32_t" + "desc": "[out] Monotonic timestamp counter in microseconds when the measurement was made.\nThis timestamp should only be used to calculate delta time between snapshots of this structure.\nNever take the delta of this timestamp with the timestamp from a different structure since they are not guaranteed to have the same base.\nThe absolute value of the timestamp is only valid during within the application and may be different on the next execution.\n", + "name": "timestamp", + "type": "uint64_t" }, { - "desc": "[out] number of consecutive bytes in the sequence, starting from start", - "name": "count", - "type": "uint32_t" + "desc": "[out] Monotonic counter for the number of replay packets (sum of all lanes). Will always be 0 when the `haveReplayCounters` member of $s_pci_properties_t is FALSE.", + "name": "replayCounter", + "type": "uint64_t" + }, + { + "desc": "[out] Monotonic counter for the number of packets (sum of all lanes). Will always be 0 when the `havePacketCounters` member of $s_pci_properties_t is FALSE.", + "name": "packetCounter", + "type": "uint64_t" + }, + { + "desc": "[out] Monotonic counter for the number of bytes received (sum of all lanes). Will always be 0 when the `haveBandwidthCounters` member of $s_pci_properties_t is FALSE.", + "name": "rxCounter", + "type": "uint64_t" + }, + { + "desc": "[out] Monotonic counter for the number of bytes transmitted (including replays) (sum of all lanes). Will always be 0 when the `haveBandwidthCounters` member of $s_pci_properties_t is FALSE.", + "name": "txCounter", + "type": "uint64_t" + }, + { + "desc": "[out] The current speed of the link (sum of all lanes)", + "name": "speed", + "type": "$s_pci_speed_t" } ], - "name": "$t_profile_register_sequence_t", + "name": "$s_pci_stats_t", "type": "struct" }, { - "class": "$tKernel", - "desc": "Retrieve profiling information generated for the kernel.", + "class": "$sDevice", + "desc": "Get PCI properties - address, max speed", "details": [ - { - "Module must be created using the following build option:": [ - "\"-$t-profile-flags \" - enable generation of profile information", - "\"\" must be a combination of $t_profile_flag_t, in hex" - ] - }, "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "daba304e8f1cfd945f7fcfe506ff1f93db38b2e14d5ec6326ce09a0180dbff9d", - "name": "GetProfileInfo", + "hash": "e87d7976293d00d44adf69bd42f1430f154f7bf820abeda534a7330211550eec", + "name": "PciGetProperties", "params": [ { - "desc": "[in] handle to kernel", - "name": "hKernel", - "type": "$t_kernel_handle_t" + "desc": "[in] Sysman handle of the device.", + "name": "hDevice", + "type": "$s_device_handle_t" }, { - "desc": "[out] pointer to profile properties", - "name": "pProfileProperties", - "type": "$t_profile_properties_t*" + "desc": "[in,out] Will contain the PCI properties.", + "name": "pProperties", + "type": "$s_pci_properties_t*" } ], "returns": [ @@ -66734,111 +81615,36 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hKernel`" + "`nullptr == hDevice`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pProfileProperties`" + "`nullptr == pProperties`" ] } ], "type": "function" - } - ] - }, - { - "header": { - "desc": "Intel $OneApi Level-Zero Tool Experimental Extension APIs for API Tracing", - "ordinal": 1000, - "type": "header" - }, - "name": "tracing", - "objects": [ - { - "desc": "API Tracing Experimental Extension Name", - "name": "$T_API_TRACING_EXP_NAME", - "type": "macro", - "value": "\"$XT_experimental_api_tracing\"" - }, - { - "desc": "API Tracing Experimental Extension Version(s)", - "etors": [ - { - "desc": "version 1.0", - "name": "$T_API_TRACING_EXP_VERSION_1_0", - "value": "$X_MAKE_VERSION( 1, 0 )" - }, - { - "desc": "latest known version", - "name": "$T_API_TRACING_EXP_VERSION_CURRENT", - "value": "$X_MAKE_VERSION( 1, 0 )" - } - ], - "name": "$t_api_tracing_exp_version_t", - "type": "enum" - }, - { - "class": "$tTracerExp", - "desc": "Alias the existing callbacks definition for 'core' callbacks", - "name": "$t_core_callbacks_t", - "type": "typedef", - "value": "$x_callbacks_t" - }, - { - "base": "$t_base_desc_t", - "class": "$tTracerExp", - "desc": "Tracer descriptor", - "members": [ - { - "desc": "[in] type of this structure", - "init": "$T_STRUCTURE_TYPE_TRACER_EXP_DESC", - "name": "stype", - "type": "$t_structure_type_t" - }, - { - "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "const void*" - }, - { - "desc": "[in] pointer passed to every tracer's callbacks", - "name": "pUserData", - "type": "void*" - } - ], - "name": "$t_tracer_exp_desc_t", - "type": "struct" }, { - "class": "$tTracerExp", - "decl": "static", - "desc": "Creates a tracer on the context.", + "class": "$sDevice", + "desc": "Get current PCI state - current speed", "details": [ - "The application must only use the tracer for the context which was provided during creation.", - "The tracer is created in the disabled state.", "The application may call this function from simultaneous threads.", - "The implementation of this function must be thread-safe." + "The implementation of this function should be lock-free." ], - "hash": "99654d158628fa6f80a407f4c6dd5fc582fec9bef666d5e4e841639ff3ddf90b", - "name": "Create", - "ordinal": "0", + "hash": "84dc8436ca5d1cfcdace8795f05b6fff03f037f9e33c0871a68a7df0c4919ac9", + "name": "PciGetState", "params": [ { - "desc": "[in] handle of the context object", - "name": "hContext", - "type": "$t_context_handle_t" - }, - { - "desc": "[in] pointer to tracer descriptor", - "name": "desc", - "type": "const $t_tracer_exp_desc_t*" + "desc": "[in] Sysman handle of the device.", + "name": "hDevice", + "type": "$s_device_handle_t" }, { - "desc": "[out] pointer to handle of tracer object created", - "name": "phTracer", - "type": "$t_tracer_exp_handle_t*" + "desc": "[in,out] Will contain the PCI properties.", + "name": "pState", + "type": "$s_pci_state_t*" } ], "returns": [ @@ -66859,36 +81665,41 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hContext`" + "`nullptr == hDevice`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == desc`", - "`nullptr == desc->pUserData`", - "`nullptr == phTracer`" + "`nullptr == pState`" ] } ], "type": "function" }, { - "class": "$tTracerExp", - "decl": "static", - "desc": "Destroys a tracer.", + "class": "$sDevice", + "desc": "Get information about each configured bar", "details": [ - "The application must **not** call this function from simultaneous threads with the same tracer handle.", - "The implementation of this function must be thread-safe.", - "The implementation of this function will stall and wait on any outstanding threads executing callbacks before freeing any Host allocations associated with this tracer." + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." ], - "hash": "93988865d3b59785a30efbb5b38fea9024972b775e1ec2b82b52cfcd53e0fac2", - "name": "Destroy", - "ordinal": "0", + "hash": "88ba4b62a295f7ab057dac57aabd8ab6e46cd95e29f99e9c4c094d837c6d141d", + "name": "PciGetBars", "params": [ { - "desc": "[in][release] handle of tracer object to destroy", - "name": "hTracer", - "type": "$t_tracer_exp_handle_t" + "desc": "[in] Sysman handle of the device.", + "name": "hDevice", + "type": "$s_device_handle_t" + }, + { + "desc": "[in,out] pointer to the number of PCI bars.\nif count is zero, then the driver shall update the value with the total number of PCI bars that are setup.\nif count is greater than the number of PCI bars that are setup, then the driver shall update the value with the correct number of PCI bars.\n", + "name": "pCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pCount)] array of information about setup PCI bars.\nif count is less than the number of PCI bars that are setup, then the driver shall only retrieve information about that number of PCI bars.\n", + "name": "pProperties", + "type": "$s_pci_bar_properties_t*" } ], "returns": [ @@ -66909,35 +81720,36 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hTracer`" + "`nullptr == hDevice`" ] }, { - "$X_RESULT_ERROR_HANDLE_OBJECT_IN_USE": [] + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCount`" + ] } ], "type": "function" }, { - "class": "$tTracerExp", - "desc": "Sets the collection of callbacks to be executed **before** driver execution.", + "class": "$sDevice", + "desc": "Get PCI stats - bandwidth, number of packets, number of replays", "details": [ - "The application only needs to set the function pointers it is interested in receiving; all others should be 'nullptr'", - "The application must ensure that no other threads are executing functions for which the tracing functions are changing.", - "The application must **not** call this function from simultaneous threads with the same tracer handle." + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." ], - "hash": "3757c0ce726200f3b8edc93579a5460a058c240b7c52a06ff74e4756ebfc3eb0", - "name": "SetPrologues", + "hash": "a4510a9789e8a79b17f288aee861954692b2662324b154bcb479f977c08e0e08", + "name": "PciGetStats", "params": [ { - "desc": "[in] handle of the tracer", - "name": "hTracer", - "type": "$t_tracer_exp_handle_t" + "desc": "[in] Sysman handle of the device.", + "name": "hDevice", + "type": "$s_device_handle_t" }, { - "desc": "[in] pointer to table of 'core' callback function pointers", - "name": "pCoreCbs", - "type": "$t_core_callbacks_t*" + "desc": "[in,out] Will contain a snapshot of the latest stats.", + "name": "pStats", + "type": "$s_pci_stats_t*" } ], "returns": [ @@ -66958,365 +81770,461 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hTracer`" + "`nullptr == hDevice`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pCoreCbs`" + "`nullptr == pStats`" + ] + }, + { + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "User does not have permissions to query this telemetry." ] } ], "type": "function" }, { - "class": "$tTracerExp", - "desc": "Sets the collection of callbacks to be executed **after** driver execution.", - "details": [ - "The application only needs to set the function pointers it is interested in receiving; all others should be 'nullptr'", - "The application must ensure that no other threads are executing functions for which the tracing functions are changing.", - "The application must **not** call this function from simultaneous threads with the same tracer handle." - ], - "hash": "fe64ecc4c3782cee737bb511673becc83b0a86f22604887853b751fe9ce897df", - "name": "SetEpilogues", - "params": [ + "base": "$xDriver", + "desc": "C++ wrapper for driver instance", + "members": [], + "name": "$sDriver", + "type": "class" + }, + { + "base": "$xDevice", + "desc": "C++ wrapper for device", + "members": [], + "name": "$sDevice", + "type": "class" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - Overclock controls, VF curve manipulation", + "ordinal": 1000, + "type": "header" + }, + "name": "Overclock", + "objects": [ + { + "class": "$sDevice", + "desc": "Overclock domains.", + "etors": [ { - "desc": "[in] handle of the tracer", - "name": "hTracer", - "type": "$t_tracer_exp_handle_t" + "desc": "Overclocking card level properties such as temperature limits.", + "name": "$S_OVERCLOCK_DOMAIN_CARD", + "value": "1" }, { - "desc": "[in] pointer to table of 'core' callback function pointers", - "name": "pCoreCbs", - "type": "$t_core_callbacks_t*" - } - ], - "returns": [ + "desc": "Overclocking package level properties such as power limits.", + "name": "$S_OVERCLOCK_DOMAIN_PACKAGE", + "value": "2" + }, { - "$X_RESULT_SUCCESS": [] + "desc": "Overclocking a GPU that has all accelerator assets on the same PLL/VR.", + "name": "$S_OVERCLOCK_DOMAIN_GPU_ALL", + "value": "4" }, { - "$X_RESULT_ERROR_UNINITIALIZED": [] + "desc": "Overclocking a GPU with render and compute assets on the same PLL/VR.", + "name": "$S_OVERCLOCK_DOMAIN_GPU_RENDER_COMPUTE", + "value": "8" }, { - "$X_RESULT_ERROR_DEVICE_LOST": [] + "desc": "Overclocking a GPU with render assets on its own PLL/VR.", + "name": "$S_OVERCLOCK_DOMAIN_GPU_RENDER", + "value": "16" }, { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "desc": "Overclocking a GPU with compute assets on its own PLL/VR.", + "name": "$S_OVERCLOCK_DOMAIN_GPU_COMPUTE", + "value": "32" }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + "desc": "Overclocking a GPU with media assets on its own PLL/VR.", + "name": "$S_OVERCLOCK_DOMAIN_GPU_MEDIA", + "value": "64" }, { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hTracer`" - ] + "desc": "Overclocking device local memory.", + "name": "$S_OVERCLOCK_DOMAIN_VRAM", + "value": "128" }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pCoreCbs`" - ] + "desc": "Overclocking LLC/L4 cache.", + "name": "$S_OVERCLOCK_DOMAIN_ADM", + "value": "256" } ], - "type": "function" + "name": "$s_overclock_domain_t", + "type": "enum", + "version": "1.5" }, { - "class": "$tTracerExp", - "desc": "Enables (or disables) the tracer", - "details": [ - "The application must **not** call this function from simultaneous threads with the same tracer handle." - ], - "hash": "60691e67f575e8b84d93b29f94642fafd9b9a302bc05b5f0d45340e335804de9", - "name": "SetEnabled", - "params": [ + "class": "$sOverclock", + "desc": "Overclock controls.", + "etors": [ { - "desc": "[in] handle of the tracer", - "name": "hTracer", - "type": "$t_tracer_exp_handle_t" + "desc": "This control permits setting a custom V-F curve.", + "name": "$S_OVERCLOCK_CONTROL_VF", + "value": "1" }, { - "desc": "[in] enable the tracer if true; disable if false", - "name": "enable", - "type": "$x_bool_t" - } - ], - "returns": [ + "desc": "The V-F curve of the overclock domain can be shifted up or down using this control.", + "name": "$S_OVERCLOCK_CONTROL_FREQ_OFFSET", + "value": "2" + }, { - "$X_RESULT_SUCCESS": [] + "desc": "This control is used to increase the permitted voltage above the shipped voltage maximum.", + "name": "$S_OVERCLOCK_CONTROL_VMAX_OFFSET", + "value": "4" }, { - "$X_RESULT_ERROR_UNINITIALIZED": [] + "desc": "This control permits direct changes to the operating frequency.", + "name": "$S_OVERCLOCK_CONTROL_FREQ", + "value": "8" }, { - "$X_RESULT_ERROR_DEVICE_LOST": [] + "desc": "This control prevents frequencies that would push the voltage above this value, typically used by V-F scanners.", + "name": "$S_OVERCLOCK_CONTROL_VOLT_LIMIT", + "value": "16" }, { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "desc": "This control changes the sustained power limit (PL1).", + "name": "$S_OVERCLOCK_CONTROL_POWER_SUSTAINED_LIMIT", + "value": "32" }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + "desc": "This control changes the burst power limit (PL2).", + "name": "$S_OVERCLOCK_CONTROL_POWER_BURST_LIMIT", + "value": "64" }, { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hTracer`" - ] + "desc": "his control changes the peak power limit (PL4).", + "name": "$S_OVERCLOCK_CONTROL_POWER_PEAK_LIMIT", + "value": "128" + }, + { + "desc": "This control changes the value of IccMax..", + "name": "$S_OVERCLOCK_CONTROL_ICCMAX_LIMIT", + "value": "256" + }, + { + "desc": "This control changes the value of TjMax.", + "name": "$S_OVERCLOCK_CONTROL_TEMP_LIMIT", + "value": "512" + }, + { + "desc": "This control permits disabling the adaptive voltage feature ITD", + "name": "$S_OVERCLOCK_CONTROL_ITD_DISABLE", + "value": "1024" + }, + { + "desc": "This control permits disabling the adaptive voltage feature ACM.", + "name": "$S_OVERCLOCK_CONTROL_ACM_DISABLE", + "value": "2048" } ], - "type": "function" + "name": "$s_overclock_control_t", + "type": "enum", + "version": "1.5" }, { - "desc": "C++ wrapper for tracer", - "members": [ + "class": "$sOverclock", + "desc": "Overclock modes.", + "etors": [ { - "desc": "[in] handle of tracer object", - "name": "handle", - "type": "$t_tracer_exp_handle_t" + "desc": "Overclock mode is off", + "name": "$S_OVERCLOCK_MODE_MODE_OFF", + "value": "0" }, { - "desc": "[in] pointer to owner object", - "name": "pDriver", - "type": "$tDriver*" + "desc": "Stock (manufacturing settings) are being used.", + "name": "$S_OVERCLOCK_MODE_MODE_STOCK", + "value": "2" }, { - "desc": "[in] descriptor of the tracer object", - "name": "desc", - "type": "$t_tracer_exp_desc_t" + "desc": "Overclock mode is on.", + "name": "$S_OVERCLOCK_MODE_MODE_ON", + "value": "3" + }, + { + "desc": "Overclocking is unavailable at this time since the system is running on battery.", + "name": "$S_OVERCLOCK_MODE_MODE_UNAVAILABLE", + "value": "4" + }, + { + "desc": "Overclock mode is disabled.", + "name": "$S_OVERCLOCK_MODE_MODE_DISABLED", + "value": "5" } ], - "name": "$tTracerExp", - "owner": "$tDriver", - "type": "class" - } - ] - }, - { - "header": { - "desc": "Intel $OneApi Level-Zero Tool Experimental Extension for Calculating Multiple Metrics", - "ordinal": 1200, - "type": "header", - "version": "1.2" - }, - "name": "multiMetricValues", - "objects": [ - { - "desc": "Calculating Multiple Metrics Experimental Extension Name", - "name": "$T_MULTI_METRICS_EXP_NAME", - "type": "macro", - "value": "\"$XT_experimental_calculate_multiple_metrics\"", - "version": "1.2" + "name": "$s_overclock_mode_t", + "type": "enum", + "version": "1.5" }, { - "desc": "Calculating Multiple Metrics Experimental Extension Version(s)", + "class": "$sOverclock", + "desc": "Overclock control states.", "etors": [ { - "desc": "version 1.0", - "name": "$X_CALCULATE_MULTIPLE_METRICS_EXP_VERSION_1_0", - "value": "$X_MAKE_VERSION( 1, 0 )" + "desc": "No overclock control has not been changed by the driver since the last boot/reset.", + "name": "$S_CONTROL_STATE_STATE_UNSET", + "value": "0" }, { - "desc": "latest known version", - "name": "$X_CALCULATE_MULTIPLE_METRICS_EXP_VERSION_CURRENT", - "value": "$X_MAKE_VERSION( 1, 0 )" + "desc": "The overclock control has been set and it is active.", + "name": "$S_CONTROL_STATE_STATE_ACTIVE", + "value": "2" + }, + { + "desc": "The overclock control value has been disabled due to the current power configuration (typically when running on DC).", + "name": "$S_CONTROL_STATE_STATE_DISABLED", + "value": "3" } ], - "name": "$x_calculate_multiple_metrics_exp_version_t", + "name": "$s_control_state_t", "type": "enum", - "version": "1.2" + "version": "1.5" }, { - "class": "$tMetricGroup", - "decl": "static", - "desc": "Calculate one or more sets of metric values from raw data.", - "details": [ - "This function is similar to $tMetricGroupCalculateMetricValues except it may calculate more than one set of metric values from a single data buffer. There may be one set of metric values for each sub-device, for example.", - "Each set of metric values may consist of a different number of metric values, returned as the metric value count.", - "All metric values are calculated into a single buffer; use the metric counts to determine which metric values belong to which set.", - "The application may call this function from simultaneous threads." - ], - "hash": "e2074d5e3c7ddbf7f7bd4a5a71cdb32afce7fdf407b420ee8e22d44c84e0bb83", - "name": "CalculateMultipleMetricValuesExp", - "params": [ + "class": "$sOverclock", + "desc": "Overclock pending actions.", + "etors": [ { - "desc": "[in] handle of the metric group", - "name": "hMetricGroup", - "type": "$t_metric_group_handle_t" + "desc": "There no pending actions. .", + "name": "$S_PENDING_ACTION_PENDING_NONE", + "value": "0" }, { - "desc": "[in] calculation type to be applied on raw data", - "name": "type", - "type": "$t_metric_group_calculation_type_t" + "desc": "The requested change is in progress and should complete soon.", + "name": "$S_PENDING_ACTION_PENDING_IMMINENT", + "value": "1" }, { - "desc": "[in] size in bytes of raw data buffer", - "name": "rawDataSize", - "type": "size_t" + "desc": "The requested change requires a device cold reset (hotplug, system boot).", + "name": "$S_PENDING_ACTION_PENDING_COLD_RESET", + "value": "2" }, { - "desc": "[in][range(0, rawDataSize)] buffer of raw data to calculate", - "name": "pRawData", - "type": "const uint8_t*" - }, + "desc": "The requested change requires a device warm reset (PCIe FLR).", + "name": "$S_PENDING_ACTION_PENDING_WARM_RESET", + "value": "3" + } + ], + "name": "$s_pending_action_t", + "type": "enum", + "version": "1.5" + }, + { + "class": "$sOverclock", + "desc": "Overclock V-F curve programing.", + "etors": [ { - "desc": "[in,out] pointer to number of metric sets.\nif count is zero, then the driver shall update the value with the total number of metric sets to be calculated.\nif count is greater than the number available in the raw data buffer, then the driver shall update the value with the actual number of metric sets to be calculated.\n", - "name": "pSetCount", - "type": "uint32_t*" + "desc": "Can program an arbitrary number of V-F points up to the maximum number and each point can have arbitrary voltage and frequency values within the min/max/step limits", + "name": "$S_VF_PROGRAM_TYPE_VF_ARBITRARY", + "value": "0" }, { - "desc": "[in,out] pointer to number of the total number of metric values calculated, for all metric sets.\nif count is zero, then the driver shall update the value with the total number of metric values to be calculated.\nif count is greater than the number available in the raw data buffer, then the driver shall update the value with the actual number of metric values to be calculated.\n", - "name": "pTotalMetricValueCount", - "type": "uint32_t*" + "desc": "Can only program the voltage for the V-F points that it reads back - the frequency of those points cannot be changed", + "name": "$S_VF_PROGRAM_TYPE_VF_FREQ_FIXED", + "value": "1" }, { - "desc": "[in,out][optional][range(0, *pSetCount)] buffer of metric counts per metric set.\n", - "name": "pMetricCounts", - "type": "uint32_t*" + "desc": "Can only program the frequency for the V-F points that is reads back - the voltage of each point cannot be changed.", + "name": "$S_VF_PROGRAM_TYPE_VF_VOLT_FIXED", + "value": "2" + } + ], + "name": "$s_vf_program_type_t", + "type": "enum", + "version": "1.5" + }, + { + "class": "$sOverclock", + "desc": "VF type", + "etors": [ + { + "desc": "VF Voltage point", + "name": "$S_VF_TYPE_VOLT", + "value": "0" }, { - "desc": "[in,out][optional][range(0, *pTotalMetricValueCount)] buffer of calculated metrics.\nif count is less than the number available in the raw data buffer, then driver shall only calculate that number of metric values.\n", - "name": "pMetricValues", - "type": "$t_typed_value_t*" + "desc": "VF Frequency point", + "name": "$S_VF_TYPE_FREQ", + "value": "1" } ], - "returns": [ + "name": "$s_vf_type_t", + "type": "enum", + "version": "1.5" + }, + { + "class": "$sOverclock", + "desc": "VF type", + "etors": [ { - "$X_RESULT_SUCCESS": [] + "desc": "User V-F array", + "name": "$S_VF_ARRAY_TYPE_USER_VF_ARRAY", + "value": "0" }, { - "$X_RESULT_ERROR_UNINITIALIZED": [] + "desc": "Default V-F array", + "name": "$S_VF_ARRAY_TYPE_DEFAULT_VF_ARRAY", + "value": "1" }, { - "$X_RESULT_ERROR_DEVICE_LOST": [] + "desc": "Live V-F array", + "name": "$S_VF_ARRAY_TYPE_LIVE_VF_ARRAY", + "value": "2" + } + ], + "name": "$s_vf_array_type_t", + "type": "enum", + "version": "1.5" + }, + { + "base": "$s_base_properties_t", + "class": "$sOverclock", + "desc": "Overclock properties", + "details": [ + "Information on the overclock domain type and all the contols that are part of the domain." + ], + "members": [ + { + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_OVERCLOCK_PROPERTIES", + "name": "stype", + "type": "$s_structure_type_t" }, { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + "desc": "[out] The hardware block that this overclock domain controls (GPU, VRAM, ...)", + "name": "domainType", + "type": "$s_overclock_domain_t" }, { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hMetricGroup`" - ] + "desc": "[out] Returns the overclock controls that are supported (a bit for each of enum $s_overclock_control_t). If no bits are set, the domain doesn't support overclocking.", + "name": "AvailableControls", + "type": "uint32_t" }, { - "$X_RESULT_ERROR_INVALID_ENUMERATION": [ - "`$T_METRIC_GROUP_CALCULATION_TYPE_MAX_METRIC_VALUES < type`" - ] + "desc": "[out] Type of V-F curve programming that is permitted:.", + "name": "VFProgramType", + "type": "$s_vf_program_type_t" }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pRawData`", - "`nullptr == pSetCount`", - "`nullptr == pTotalMetricValueCount`" - ] + "desc": "[out] Number of VF points that can be programmed - max_num_points", + "name": "NumberOfVFPoints", + "type": "uint32_t" } ], - "type": "function", - "version": "1.2" - } - ] - }, - { - "header": { - "desc": "Intel $OneApi Level-Zero Tool Experimental Extension for Global Metric Timestamps", - "ordinal": 1500, - "type": "header", - "version": "1.5" - }, - "name": "GlobalTimestamps", - "objects": [ - { - "desc": "Global Metric Timestamps Experimental Extension Name", - "name": "$T_GLOBAL_METRICS_TIMESTAMPS_EXP_NAME", - "type": "macro", - "value": "\"$XT_experimental_global_metric_timestamps\"", + "name": "$s_overclock_properties_t", + "type": "struct", "version": "1.5" }, { - "desc": "Global Metric Timestamps Experimental Extension Version(s)", - "etors": [ + "class": "$sOverclock", + "desc": "Overclock Control properties", + "details": [ + "Provides all the control capabilities supported by the device for the overclock domain." + ], + "members": [ { - "desc": "version 1.0", - "name": "$X_METRIC_GLOBAL_TIMESTAMPS_EXP_VERSION_1_0", - "value": "$X_MAKE_VERSION( 1, 0 )" + "desc": "[out] This provides information about the limits of the control value so that the driver can calculate the set of valid values.", + "name": "MinValue", + "type": "double" }, { - "desc": "latest known version", - "name": "$X_METRIC_GLOBAL_TIMESTAMPS_EXP_VERSION_CURRENT", - "value": "$X_MAKE_VERSION( 1, 0 )" + "desc": "[out] This provides information about the limits of the control value so that the driver can calculate the set of valid values.", + "name": "MaxValue", + "type": "double" + }, + { + "desc": "[out] This provides information about the limits of the control value so that the driver can calculate the set of valid values.", + "name": "StepValue", + "type": "double" + }, + { + "desc": "[out] The reference value provides the anchor point, UIs can combine this with the user offset request to show the anticipated improvement.", + "name": "RefValue", + "type": "double" + }, + { + "desc": "[out] The shipped out-of-box position of this control. Driver can request this value at any time to return to the out-of-box behavior.", + "name": "DefaultValue", + "type": "double" } ], - "name": "$x_metric_global_timestamps_exp_version_t", - "type": "enum", + "name": "$s_control_property_t", + "type": "struct", "version": "1.5" }, { - "base": "$t_base_desc_t", - "class": "$tMetric", - "desc": "Metric timestamps resolution", - "details": [ - "This structure may be returned from $tMetricGroupGetProperties via the `pNext` member of $t_metric_group_properties_t.", - "Used for mapping metric timestamps to other timers." + "class": "$sOverclock", + "desc": "Overclock VF properties", + "details": [ + "Provides all the VF capabilities supported by the device for the overclock domain." ], "members": [ { - "desc": "[in] type of this structure", - "init": "$T_STRUCTURE_TYPE_METRIC_GLOBAL_TIMESTAMPS_RESOLUTION_EXP", - "name": "stype", - "type": "$t_structure_type_t" + "desc": "[out] Read the minimum frequency that can be be programmed in the custom V-F point..", + "name": "MinFreq", + "type": "double" }, { - "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "const void*" + "desc": "[out] Read the maximum frequency that can be be programmed in the custom V-F point..", + "name": "MaxFreq", + "type": "double" }, { - "desc": "[out] Returns the resolution of metrics timer (used for timestamps) in cycles/sec.", - "name": "timerResolution", - "type": "uint64_t" + "desc": "[out] Read the frequency step that can be be programmed in the custom V-F point..", + "name": "StepFreq", + "type": "double" }, { - "desc": "[out] Returns the number of valid bits in the timestamp value.", - "name": "timestampValidBits", - "type": "uint64_t" + "desc": "[out] Read the minimum voltage that can be be programmed in the custom V-F point..", + "name": "MinVolt", + "type": "double" + }, + { + "desc": "[out] Read the maximum voltage that can be be programmed in the custom V-F point..", + "name": "MaxVolt", + "type": "double" + }, + { + "desc": "[out] Read the voltage step that can be be programmed in the custom V-F point.", + "name": "StepVolt", + "type": "double" } ], - "name": "$t_metric_global_timestamps_resolution_exp_t", + "name": "$s_vf_property_t", "type": "struct", "version": "1.5" }, { - "class": "$tMetricGroup", - "decl": "static", - "desc": "Returns metric timestamps synchronized with global device timestamps, optionally synchronized with host", + "class": "$sDevice", + "desc": "Set the overclock waiver.The overclock waiver setting is persistent until the next pcode boot", "details": [ "The application may call this function from simultaneous threads.", - "By default, the global and metrics timestamps are synchronized to the device." + "The implementation of this function should be lock-free." ], - "hash": "223592fae768685fbaf678e7be2615d9d155a4f4c8d4e984da32b75707c71394", - "name": "GetGlobalTimestampsExp", + "hash": "55c493e98932c5d36afcb11a3c43d6ac222932f5e4d8f125bcc5106787e4a320", + "name": "SetOverclockWaiver", "params": [ { - "desc": "[in] handle of the metric group", - "name": "hMetricGroup", - "type": "$t_metric_group_handle_t" - }, - { - "desc": "[in] Returns the timestamps synchronized to the host or the device.", - "init": "false", - "name": "synchronizedWithHost", - "type": "$x_bool_t" - }, - { - "desc": "[out] Device timestamp.\n", - "name": "globalTimestamp", - "type": "uint64_t*" - }, - { - "desc": "[out] Metric timestamp.\n", - "name": "metricTimestamp", - "type": "uint64_t*" + "desc": "[in] Sysman handle of the device.", + "name": "hDevice", + "type": "$s_device_handle_t" } ], "returns": [ @@ -67337,132 +82245,37 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hMetricGroup`" + "`nullptr == hDevice`" ] }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == globalTimestamp`", - "`nullptr == metricTimestamp`" + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "This product does not support overclocking" ] } ], "type": "function", "version": "1.5" - } - ] - }, - { - "header": { - "desc": "Intel $OneApi Level-Zero Tool Experimental Extension for Exporting Metrics Data", - "ordinal": 1600, - "type": "header", - "version": "1.6" - }, - "name": "metricExportData", - "objects": [ - { - "desc": "Exporting Metrics Data Experimental Extension Name", - "name": "$T_EXPORT_METRICS_DATA_EXP_NAME", - "type": "macro", - "value": "\"$XT_experimental_metric_export_data\"", - "version": "1.6" - }, - { - "desc": "Exporting Metrics Data Experimental Extension Version(s)", - "etors": [ - { - "desc": "version 1.0", - "name": "$T_EXPORT_METRIC_DATA_EXP_VERSION_1_0", - "value": "$X_MAKE_VERSION( 1, 0 )" - }, - { - "desc": "latest known version", - "name": "$T_EXPORT_METRIC_DATA_EXP_VERSION_CURRENT", - "value": "$X_MAKE_VERSION( 1, 0 )" - } - ], - "name": "$t_export_metric_data_exp_version_t", - "type": "enum", - "version": "1.6" - }, - { - "desc": "Maximum count of characters in export data element name", - "name": "$T_MAX_METRIC_EXPORT_DATA_ELEMENT_NAME_EXP", - "type": "macro", - "value": "256", - "version": "1.6" - }, - { - "desc": "Maximum export data element description string size", - "name": "$T_MAX_METRIC_EXPORT_DATA_ELEMENT_DESCRIPTION_EXP", - "type": "macro", - "value": "256", - "version": "1.6" - }, - { - "base": "$t_base_desc_t", - "class": "$tMetric", - "desc": "Metrics calculation descriptor", - "members": [ - { - "desc": "[in] type of this structure", - "init": "$T_STRUCTURE_TYPE_METRIC_CALCULATE_EXP_DESC", - "name": "stype", - "type": "$t_structure_type_t" - }, - { - "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "const void*" - }, - { - "desc": "[in] number of reports to skip during calculation", - "name": "rawReportSkipCount", - "type": "uint32_t" - } - ], - "name": "$t_metric_calculate_exp_desc_t", - "type": "struct", - "version": "1.6" }, { - "class": "$tMetricGroup", - "decl": "static", - "desc": "Export Metrics Data for system independent calculation.", + "class": "$sDevice", + "desc": "Get the list of supported overclock domains for this device", "details": [ - "This function exports raw data and necessary information to perform metrics calculation of collected data in a different system than where data was collected, which may or may not have accelerators.", - "Implementations can choose to describe the data arrangement of the exported data, using any mechanism which allows users to read and process them.", - "The application may call this function from simultaneous threads." + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." ], - "hash": "499db6354496cf5b11624cc913efa9de29684492f7c073d1b6a55a7015e2e9c5", - "name": "GetExportDataExp", + "hash": "0d9d47c012a59f1376b1664e436a9a25f3aece1c27faa5827e7e521c9066e5f7", + "name": "GetOverclockDomains", "params": [ { - "desc": "[in] handle of the metric group", - "name": "hMetricGroup", - "type": "$t_metric_group_handle_t" - }, - { - "desc": "[in] buffer of raw data", - "name": "pRawData", - "type": "const uint8_t*" - }, - { - "desc": "[in] size in bytes of raw data buffer", - "name": "rawDataSize", - "type": "size_t" - }, - { - "desc": "[in,out] size in bytes of export data buffer\nif size is zero, then the driver shall update the value with the number of bytes necessary to store the exported data.\nif size is greater than required, then the driver shall update the value with the actual number of bytes necessary to store the exported data.\n", - "name": "pExportDataSize", - "type": "size_t*" + "desc": "[in] Sysman handle of the device.", + "name": "hDevice", + "type": "$s_device_handle_t" }, { - "desc": "[in,out][optional][range(0, *pExportDataSize)] buffer of exported data.\n", - "name": "pExportData", - "type": "uint8_t *" + "desc": "[in,out] Returns the overclock domains that are supported (a bit for each of enum $s_overclock_domain_t). If no bits are set, the device doesn't support overclocking.", + "name": "pOverclockDomains", + "type": "uint32_t*" } ], "returns": [ @@ -67483,76 +82296,47 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hMetricGroup`" + "`nullptr == hDevice`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pRawData`", - "`nullptr == pExportDataSize`" + "`nullptr == pOverclockDomains`" + ] + }, + { + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "Overclocking is not supported on this control domain" ] } ], "type": "function", - "version": "1.6" + "version": "1.5" }, { - "class": "$tMetricGroup", - "decl": "static", - "desc": "Calculate one or more sets of metric values from exported raw data.", + "class": "$sDevice", + "desc": "Get the list of supported overclock controls available for one of the supported overclock domains on the device", "details": [ - "Calculate metrics values using exported data returned by $tMetricGroupGetExportDataExp.", - "This function is similar to $tMetricGroupCalculateMultipleMetricValuesExp except it would calculate from exported metric data.", - "This function could be used to calculate metrics on a system different from where the metric raw data was collected.", - "The application may call this function from simultaneous threads." + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." ], - "hash": "45b7016f0a5f68adeb96524bb980cfdbf317c31a6a579e8be8dff30f93df6085", - "name": "CalculateMetricExportDataExp", + "hash": "4377753972c5b509120ab9c0d528b6c7428abbbaa4b0eb1c0704a51a7d8c351c", + "name": "GetOverclockControls", "params": [ { - "desc": "[in] handle of the driver instance", - "name": "hDriver", - "type": "$x_driver_handle_t" - }, - { - "desc": "[in] calculation type to be applied on raw data", - "name": "type", - "type": "$t_metric_group_calculation_type_t" - }, - { - "desc": "[in] size in bytes of exported data buffer", - "name": "exportDataSize", - "type": "size_t" - }, - { - "desc": "[in][range(0, exportDataSize)] buffer of exported data to calculate", - "name": "pExportData", - "type": "const uint8_t*" - }, - { - "desc": "[in] descriptor specifying calculation specific parameters", - "name": "pCalculateDescriptor", - "type": "$t_metric_calculate_exp_desc_t*" - }, - { - "desc": "[in,out] pointer to number of metric sets.\nif count is zero, then the driver shall update the value with the total number of metric sets to be calculated.\nif count is greater than the number available in the raw data buffer, then the driver shall update the value with the actual number of metric sets to be calculated.\n", - "name": "pSetCount", - "type": "uint32_t*" + "desc": "[in] Sysman handle of the device.", + "name": "hDevice", + "type": "$s_device_handle_t" }, { - "desc": "[in,out] pointer to number of the total number of metric values calculated, for all metric sets.\nif count is zero, then the driver shall update the value with the total number of metric values to be calculated.\nif count is greater than the number available in the raw data buffer, then the driver shall update the value with the actual number of metric values to be calculated.\n", - "name": "pTotalMetricValueCount", - "type": "uint32_t*" + "desc": "[in] Domain type.", + "name": "domainType", + "type": "$s_overclock_domain_t" }, { - "desc": "[in,out][optional][range(0, *pSetCount)] buffer of metric counts per metric set.\n", - "name": "pMetricCounts", + "desc": "[in,out] Returns the overclock controls that are supported for the specified overclock domain (a bit for each of enum $s_overclock_control_t).", + "name": "pAvailableControls", "type": "uint32_t*" - }, - { - "desc": "[in,out][optional][range(0, *pTotalMetricValueCount)] buffer of calculated metrics.\nif count is less than the number available in the raw data buffer, then driver shall only calculate that number of metric values.\n", - "name": "pMetricValues", - "type": "$t_typed_value_t*" } ], "returns": [ @@ -67573,534 +82357,417 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDriver`" + "`nullptr == hDevice`" ] }, { "$X_RESULT_ERROR_INVALID_ENUMERATION": [ - "`$T_METRIC_GROUP_CALCULATION_TYPE_MAX_METRIC_VALUES < type`" + "`$S_OVERCLOCK_DOMAIN_ADM < domainType`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pExportData`", - "`nullptr == pCalculateDescriptor`", - "`nullptr == pSetCount`", - "`nullptr == pTotalMetricValueCount`" + "`nullptr == pAvailableControls`" + ] + }, + { + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "Overclocking is not supported on this control domain" ] } ], "type": "function", - "version": "1.6" - } - ] - } - ], - [ - { - "header": { - "desc": "Intel $OneApi Level-Zero Sysman API common types", - "ordinal": 0, - "type": "header" - }, - "name": "common", - "objects": [ - { - "alias": "$x_driver_handle_t", - "class": "$sDriver", - "desc": "Handle to a driver instance", - "name": "$s_driver_handle_t", - "type": "handle" - }, - { - "alias": "$x_device_handle_t", - "class": "$sDevice", - "desc": "Handle of device object", - "name": "$s_device_handle_t", - "type": "handle" - }, - { - "class": "$sScheduler", - "desc": "Handle for a Sysman device scheduler queue", - "name": "$s_sched_handle_t", - "type": "handle" - }, - { - "class": "$sPerformanceFactor", - "desc": "Handle for a Sysman device performance factors", - "name": "$s_perf_handle_t", - "type": "handle" - }, - { - "class": "$sPower", - "desc": "Handle for a Sysman device power domain", - "name": "$s_pwr_handle_t", - "type": "handle" - }, - { - "class": "$sFrequency", - "desc": "Handle for a Sysman device frequency domain", - "name": "$s_freq_handle_t", - "type": "handle" - }, - { - "class": "$sEngine", - "desc": "Handle for a Sysman device engine group", - "name": "$s_engine_handle_t", - "type": "handle" - }, - { - "class": "$sStandby", - "desc": "Handle for a Sysman device standby control", - "name": "$s_standby_handle_t", - "type": "handle" - }, - { - "class": "$sFirmware", - "desc": "Handle for a Sysman device firmware", - "name": "$s_firmware_handle_t", - "type": "handle" - }, - { - "class": "$sMemory", - "desc": "Handle for a Sysman device memory module", - "name": "$s_mem_handle_t", - "type": "handle" - }, - { - "class": "$sFabricPort", - "desc": "Handle for a Sysman fabric port", - "name": "$s_fabric_port_handle_t", - "type": "handle" - }, - { - "class": "$sTemperature", - "desc": "Handle for a Sysman device temperature sensor", - "name": "$s_temp_handle_t", - "type": "handle" - }, - { - "class": "$sPsu", - "desc": "Handle for a Sysman device power supply", - "name": "$s_psu_handle_t", - "type": "handle" - }, - { - "class": "$sFan", - "desc": "Handle for a Sysman device fan", - "name": "$s_fan_handle_t", - "type": "handle" - }, - { - "class": "$sLed", - "desc": "Handle for a Sysman device LED", - "name": "$s_led_handle_t", - "type": "handle" - }, - { - "class": "$sRas", - "desc": "Handle for a Sysman device RAS error set", - "name": "$s_ras_handle_t", - "type": "handle" - }, - { - "class": "$sDiagnostics", - "desc": "Handle for a Sysman device diagnostics test suite", - "name": "$s_diag_handle_t", - "type": "handle" - }, - { - "class": "$sOverclock", - "desc": "Handle for a Sysman device overclock domain", - "name": "$s_overclock_handle_t", - "type": "handle", "version": "1.5" }, { - "desc": "Defines structure types", - "etors": [ + "class": "$sDevice", + "desc": "Reset all overclock settings to default values (shipped = 1 or manufacturing =0)", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "7318489a5a2134bc3f0789ac6ae8a5f1712f4d71314cbb846d6d0260eae1b474", + "name": "ResetOverclockSettings", + "params": [ { - "desc": "$s_device_properties_t", - "name": "$S_STRUCTURE_TYPE_DEVICE_PROPERTIES", - "value": "0x1" + "desc": "[in] Sysman handle of the device.", + "name": "hDevice", + "type": "$s_device_handle_t" }, { - "desc": "$s_pci_properties_t", - "name": "$S_STRUCTURE_TYPE_PCI_PROPERTIES", - "value": "0x2" + "desc": "[in] True will reset to shipped state; false will reset to manufacturing state", + "name": "onShippedState", + "type": "$x_bool_t" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] }, { - "desc": "$s_pci_bar_properties_t", - "name": "$S_STRUCTURE_TYPE_PCI_BAR_PROPERTIES", - "value": "0x3" + "$X_RESULT_ERROR_UNINITIALIZED": [] }, { - "desc": "$s_diag_properties_t", - "name": "$S_STRUCTURE_TYPE_DIAG_PROPERTIES", - "value": "0x4" + "$X_RESULT_ERROR_DEVICE_LOST": [] }, { - "desc": "$s_engine_properties_t", - "name": "$S_STRUCTURE_TYPE_ENGINE_PROPERTIES", - "value": "0x5" + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] }, { - "desc": "$s_fabric_port_properties_t", - "name": "$S_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES", - "value": "0x6" + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] }, { - "desc": "$s_fan_properties_t", - "name": "$S_STRUCTURE_TYPE_FAN_PROPERTIES", - "value": "0x7" + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDevice`" + ] }, { - "desc": "$s_firmware_properties_t", - "name": "$S_STRUCTURE_TYPE_FIRMWARE_PROPERTIES", - "value": "0x8" + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "Overclocking is not supported on this control domain" + ] + } + ], + "type": "function", + "version": "1.5" + }, + { + "class": "$sDevice", + "desc": "Determine the state of overclocking", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "bf83d33d94f9f7a4212f5acf692aa525675b4ae890259e8e179069c1a95c83e2", + "name": "ReadOverclockState", + "params": [ + { + "desc": "[in] Sysman handle of the device.", + "name": "hDevice", + "type": "$s_device_handle_t" }, { - "desc": "$s_freq_properties_t", - "name": "$S_STRUCTURE_TYPE_FREQ_PROPERTIES", - "value": "0x9" + "desc": "[out] One of overclock mode.", + "name": "pOverclockMode", + "type": "$s_overclock_mode_t*" }, { - "desc": "$s_led_properties_t", - "name": "$S_STRUCTURE_TYPE_LED_PROPERTIES", - "value": "0xa" + "desc": "[out] Waiver setting: 0 = Waiver not set, 1 = waiver has been set.", + "name": "pWaiverSetting", + "type": "$x_bool_t*" + }, + { + "desc": "[out] Current settings 0 =manufacturing state, 1= shipped state)..", + "name": "pOverclockState", + "type": "$x_bool_t*" + }, + { + "desc": "[out] This enum is returned when the driver attempts to set an overclock control or reset overclock settings.", + "name": "pPendingAction", + "type": "$s_pending_action_t*" }, { - "desc": "$s_mem_properties_t", - "name": "$S_STRUCTURE_TYPE_MEM_PROPERTIES", - "value": "0xb" + "desc": "[out] Pending reset 0 =manufacturing state, 1= shipped state)..", + "name": "pPendingReset", + "type": "$x_bool_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] }, { - "desc": "$s_perf_properties_t", - "name": "$S_STRUCTURE_TYPE_PERF_PROPERTIES", - "value": "0xc" + "$X_RESULT_ERROR_UNINITIALIZED": [] }, { - "desc": "$s_power_properties_t", - "name": "$S_STRUCTURE_TYPE_POWER_PROPERTIES", - "value": "0xd" + "$X_RESULT_ERROR_DEVICE_LOST": [] }, { - "desc": "$s_psu_properties_t", - "name": "$S_STRUCTURE_TYPE_PSU_PROPERTIES", - "value": "0xe" + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] }, { - "desc": "$s_ras_properties_t", - "name": "$S_STRUCTURE_TYPE_RAS_PROPERTIES", - "value": "0xf" + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] }, { - "desc": "$s_sched_properties_t", - "name": "$S_STRUCTURE_TYPE_SCHED_PROPERTIES", - "value": "0x10" + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDevice`" + ] }, { - "desc": "$s_sched_timeout_properties_t", - "name": "$S_STRUCTURE_TYPE_SCHED_TIMEOUT_PROPERTIES", - "value": "0x11" + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pOverclockMode`", + "`nullptr == pWaiverSetting`", + "`nullptr == pOverclockState`", + "`nullptr == pPendingAction`", + "`nullptr == pPendingReset`" + ] }, { - "desc": "$s_sched_timeslice_properties_t", - "name": "$S_STRUCTURE_TYPE_SCHED_TIMESLICE_PROPERTIES", - "value": "0x12" - }, + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "Overclocking is not supported on this control domain" + ] + } + ], + "type": "function", + "version": "1.5" + }, + { + "class": "$sDevice", + "desc": "Get handle of overclock domains", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "4b879a76b3b04fde6760e7c52a1df27690607bd6f77d8eefa431bfe0bde261db", + "name": "EnumOverclockDomains", + "params": [ { - "desc": "$s_standby_properties_t", - "name": "$S_STRUCTURE_TYPE_STANDBY_PROPERTIES", - "value": "0x13" + "desc": "[in] Sysman handle of the device.", + "name": "hDevice", + "type": "$s_device_handle_t" }, { - "desc": "$s_temp_properties_t", - "name": "$S_STRUCTURE_TYPE_TEMP_PROPERTIES", - "value": "0x14" + "desc": "[in,out] pointer to the number of components of this type.\nif count is zero, then the driver shall update the value with the total number of components of this type that are available.\nif count is greater than the number of components of this type that are available, then the driver shall update the value with the correct number of components.\n", + "name": "pCount", + "type": "uint32_t*" }, { - "desc": "$s_device_state_t", - "name": "$S_STRUCTURE_TYPE_DEVICE_STATE", - "value": "0x15" - }, + "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", + "name": "phDomainHandle", + "type": "$s_overclock_handle_t*" + } + ], + "returns": [ { - "desc": "$s_process_state_t", - "name": "$S_STRUCTURE_TYPE_PROCESS_STATE", - "value": "0x16" + "$X_RESULT_SUCCESS": [] }, { - "desc": "$s_pci_state_t", - "name": "$S_STRUCTURE_TYPE_PCI_STATE", - "value": "0x17" + "$X_RESULT_ERROR_UNINITIALIZED": [] }, { - "desc": "$s_fabric_port_config_t", - "name": "$S_STRUCTURE_TYPE_FABRIC_PORT_CONFIG", - "value": "0x18" + "$X_RESULT_ERROR_DEVICE_LOST": [] }, { - "desc": "$s_fabric_port_state_t", - "name": "$S_STRUCTURE_TYPE_FABRIC_PORT_STATE", - "value": "0x19" + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] }, { - "desc": "$s_fan_config_t", - "name": "$S_STRUCTURE_TYPE_FAN_CONFIG", - "value": "0x1a" + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] }, { - "desc": "$s_freq_state_t", - "name": "$S_STRUCTURE_TYPE_FREQ_STATE", - "value": "0x1b" + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDevice`" + ] }, { - "desc": "$s_oc_capabilities_t", - "name": "$S_STRUCTURE_TYPE_OC_CAPABILITIES", - "value": "0x1c" - }, + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCount`" + ] + } + ], + "type": "function", + "version": "1.5" + }, + { + "class": "$sOverclock", + "desc": "Get overclock domain control properties", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "416c9b4d0a45ce8cef79a8367a0d9e5a23de228774dbf59a5c06a7af0ce6e325", + "name": "GetDomainProperties", + "params": [ { - "desc": "$s_led_state_t", - "name": "$S_STRUCTURE_TYPE_LED_STATE", - "value": "0x1d" + "desc": "[in] Handle for the component domain.", + "name": "hDomainHandle", + "type": "$s_overclock_handle_t" }, { - "desc": "$s_mem_state_t", - "name": "$S_STRUCTURE_TYPE_MEM_STATE", - "value": "0x1e" - }, + "desc": "[in,out] The overclock properties for the specified domain.", + "name": "pDomainProperties", + "type": "$s_overclock_properties_t*" + } + ], + "returns": [ { - "desc": "$s_psu_state_t", - "name": "$S_STRUCTURE_TYPE_PSU_STATE", - "value": "0x1f" + "$X_RESULT_SUCCESS": [] }, { - "desc": "$s_base_state_t", - "name": "$S_STRUCTURE_TYPE_BASE_STATE", - "value": "0x20" + "$X_RESULT_ERROR_UNINITIALIZED": [] }, { - "desc": "$s_ras_config_t", - "name": "$S_STRUCTURE_TYPE_RAS_CONFIG", - "value": "0x21" + "$X_RESULT_ERROR_DEVICE_LOST": [] }, { - "desc": "$s_ras_state_t", - "name": "$S_STRUCTURE_TYPE_RAS_STATE", - "value": "0x22" + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] }, { - "desc": "$s_temp_config_t", - "name": "$S_STRUCTURE_TYPE_TEMP_CONFIG", - "value": "0x23" + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] }, { - "desc": "$s_pci_bar_properties_1_2_t", - "name": "$S_STRUCTURE_TYPE_PCI_BAR_PROPERTIES_1_2", - "value": "0x24", - "version": "1.2" + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDomainHandle`" + ] }, { - "desc": "$s_device_ecc_desc_t", - "name": "$S_STRUCTURE_TYPE_DEVICE_ECC_DESC", - "value": "0x25", - "version": "1.4" + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pDomainProperties`" + ] }, { - "desc": "$s_device_ecc_properties_t", - "name": "$S_STRUCTURE_TYPE_DEVICE_ECC_PROPERTIES", - "value": "0x26", - "version": "1.4" + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "Overclocking is not supported on this control domain" + ] + } + ], + "type": "function", + "version": "1.5" + }, + { + "class": "$sOverclock", + "desc": "Read overclock VF min,max and step values", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "899c590948448590df0ce9f6d0767f769d4f1480b939a30cc769cc07f80315c4", + "name": "GetDomainVFProperties", + "params": [ + { + "desc": "[in] Handle for the component domain.", + "name": "hDomainHandle", + "type": "$s_overclock_handle_t" }, { - "desc": "$s_power_limit_ext_desc_t", - "name": "$S_STRUCTURE_TYPE_POWER_LIMIT_EXT_DESC", - "value": "0x27", - "version": "1.4" + "desc": "[in,out] The VF min,max,step for a specified domain.", + "name": "pVFProperties", + "type": "$s_vf_property_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] }, { - "desc": "$s_power_ext_properties_t", - "name": "$S_STRUCTURE_TYPE_POWER_EXT_PROPERTIES", - "value": "0x28", - "version": "1.4" + "$X_RESULT_ERROR_UNINITIALIZED": [] }, { - "desc": "$s_overclock_properties_t", - "name": "$S_STRUCTURE_TYPE_OVERCLOCK_PROPERTIES", - "value": "0x29", - "version": "1.5" + "$X_RESULT_ERROR_DEVICE_LOST": [] }, { - "desc": "$s_fabric_port_error_counters_t", - "name": "$S_STRUCTURE_TYPE_FABRIC_PORT_ERROR_COUNTERS", - "value": "0x2a", - "version": "1.7" + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] }, { - "desc": "$s_engine_ext_properties_t", - "name": "$S_STRUCTURE_TYPE_ENGINE_EXT_PROPERTIES", - "value": "0x2b", - "version": "1.7" + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] }, { - "desc": "$s_reset_properties_t", - "name": "$S_STRUCTURE_TYPE_RESET_PROPERTIES", - "value": "0x2c", - "version": "1.7" + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDomainHandle`" + ] }, { - "desc": "$s_device_ext_properties_t", - "name": "$S_STRUCTURE_TYPE_DEVICE_EXT_PROPERTIES", - "value": "0x2d", - "version": "1.7" + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pVFProperties`" + ] }, { - "desc": "$s_uuid_t", - "name": "$S_STRUCTURE_TYPE_DEVICE_UUID", - "value": "0x2e", - "version": "1.7" + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "Overclocking is not supported on this control domain" + ] } ], - "name": "$s_structure_type_t", - "type": "enum" + "type": "function", + "version": "1.5" }, { - "desc": "Base for all properties types", - "members": [ + "class": "$sOverclock", + "desc": "Read overclock control values - min/max/step/default/ref", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "cade6249e729096d63ce08310fd878151a968afa8abc580980d5c258a9ec48fb", + "name": "GetDomainControlProperties", + "params": [ { - "desc": "[in] type of this structure", - "name": "stype", - "type": "$s_structure_type_t" + "desc": "[in] Handle for the component domain.", + "name": "hDomainHandle", + "type": "$s_overclock_handle_t" }, { - "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "void*" + "desc": "[in] Handle for the component.", + "name": "DomainControl", + "type": "$s_overclock_control_t" + }, + { + "desc": "[in,out] overclock control values.", + "name": "pControlProperties", + "type": "$s_control_property_t*" } ], - "name": "$s_base_properties_t", - "type": "struct" - }, - { - "desc": "Base for all descriptor types", - "members": [ + "returns": [ { - "desc": "[in] type of this structure", - "name": "stype", - "type": "$s_structure_type_t" + "$X_RESULT_SUCCESS": [] }, { - "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "const void*" - } - ], - "name": "$s_base_desc_t", - "type": "struct" - }, - { - "desc": "Base for all state types", - "members": [ + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, { - "desc": "[in] type of this structure", - "name": "stype", - "type": "$s_structure_type_t" + "$X_RESULT_ERROR_DEVICE_LOST": [] }, { - "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "const void*" - } - ], - "name": "$s_base_state_t", - "type": "struct" - }, - { - "desc": "Base for all config types", - "members": [ + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, { - "desc": "[in] type of this structure", - "name": "stype", - "type": "$s_structure_type_t" + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] }, { - "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "const void*" - } - ], - "name": "$s_base_config_t", - "type": "struct" - }, - { - "desc": "Base for all capability types", - "members": [ + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDomainHandle`" + ] + }, { - "desc": "[in] type of this structure", - "name": "stype", - "type": "$s_structure_type_t" + "$X_RESULT_ERROR_INVALID_ENUMERATION": [ + "`$S_OVERCLOCK_CONTROL_ACM_DISABLE < DomainControl`" + ] }, { - "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "const void*" - } - ], - "name": "$s_base_capability_t", - "type": "struct" - } - ] - }, - { - "header": { - "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman)", - "ordinal": 1, - "type": "header" - }, - "name": "driver", - "objects": [ - { - "class": "$s", - "desc": "Supported sysman initialization flags", - "etors": [ + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pControlProperties`" + ] + }, { - "desc": "placeholder for future use", - "name": "$S_INIT_FLAG_PLACEHOLDER", - "value": "$X_BIT(0)" + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "Overclocking is not supported on this control domain" + ] } ], - "name": "$s_init_flags_t", - "type": "enum", + "type": "function", "version": "1.5" }, { - "class": "$s", - "decl": "static", - "desc": "Initialize $OneApi System Resource Management (sysman)", + "class": "$sOverclock", + "desc": "Read the current value for a given overclock control", "details": [ - "The application must call this function or $xInit with the $S_ENABLE_SYSMAN environment variable set before calling any other sysman function.", - "If this function is not called then all other sysman functions will return $X_RESULT_ERROR_UNINITIALIZED.", - "This function will only initialize sysman. To initialize other functions, call $xInit.", - "There is no requirement to call this function before or after $xInit.", - "Only one instance of sysman will be initialized per process.", - "The application must call this function after forking new processes. Each forked process must call this function.", "The application may call this function from simultaneous threads.", - "The implementation of this function must be thread-safe for scenarios where multiple libraries may initialize sysman simultaneously." + "The implementation of this function should be lock-free." ], - "hash": "1bbd5be40cc583c65df6085755af48c663f466a9fc324f6a5c43a9f9c4cb3b97", - "name": "Init", - "ordinal": "0", + "hash": "d9b4cc3a89e0a244a5748ef773a56340b963b51a15ff79e6e84a53598a2a8e06", + "name": "GetControlCurrentValue", "params": [ { - "desc": "[in] initialization flags.\ncurrently unused, must be 0 (default).\n", - "init": "0", - "name": "flags", - "type": "$s_init_flags_t" + "desc": "[in] Handle for the component.", + "name": "hDomainHandle", + "type": "$s_overclock_handle_t" + }, + { + "desc": "[in] Overclock Control.", + "name": "DomainControl", + "type": "$s_overclock_control_t" + }, + { + "desc": "[in,out] Getting overclock control value for the specified control.", + "name": "pValue", + "type": "double*" } ], "returns": [ @@ -68119,42 +82786,54 @@ { "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDomainHandle`" + ] + }, { "$X_RESULT_ERROR_INVALID_ENUMERATION": [ - "`0x1 < flags`" + "`$S_OVERCLOCK_CONTROL_ACM_DISABLE < DomainControl`" ] }, { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pValue`" + ] + }, + { + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "Overclocking is not supported on this control domain" + ] } ], "type": "function", "version": "1.5" }, { - "class": "$sDriver", - "decl": "static", - "desc": "Retrieves sysman driver instances", + "class": "$sOverclock", + "desc": "Read the the reset pending value for a given overclock control", "details": [ - "A sysman driver represents a collection of physical devices.", - "Multiple calls to this function will return identical sysman driver handles, in the same order.", - "The application may pass nullptr for pDrivers when only querying the number of sysman drivers.", "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "25a93e8621b2de9d5cdea1eb8414add47e38defc9e270b7c6759ed52b55ec6d0", - "name": "Get", - "ordinal": "0", + "hash": "9ba2bc75c2454afb04fa795e698945acb130400573382ae99ebf3105a50b4f27", + "name": "GetControlPendingValue", "params": [ { - "desc": "[in,out] pointer to the number of sysman driver instances.\nif count is zero, then the loader shall update the value with the total number of sysman drivers available.\nif count is greater than the number of sysman drivers available, then the loader shall update the value with the correct number of sysman drivers available.\n", - "name": "pCount", - "type": "uint32_t*" + "desc": "[in] Handle for the component domain.", + "name": "hDomainHandle", + "type": "$s_overclock_handle_t" }, { - "desc": "[in,out][optional][range(0, *pCount)] array of sysman driver instance handles.\nif count is less than the number of sysman drivers available, then the loader shall only retrieve that number of sysman drivers.\n", - "name": "phDrivers", - "type": "$s_driver_handle_t*" + "desc": "[in] Overclock Control.", + "name": "DomainControl", + "type": "$s_overclock_control_t" + }, + { + "desc": "[out] Returns the pending value for a given control. The units and format of the value depend on the control type.", + "name": "pValue", + "type": "double*" } ], "returns": [ @@ -68173,53 +82852,59 @@ { "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDomainHandle`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_ENUMERATION": [ + "`$S_OVERCLOCK_CONTROL_ACM_DISABLE < DomainControl`" + ] + }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pCount`" + "`nullptr == pValue`" + ] + }, + { + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "Overclocking is not supported on this control domain" ] } ], "type": "function", "version": "1.5" - } - ] - }, - { - "header": { - "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - Device management", - "ordinal": 2, - "type": "header" - }, - "name": "device", - "objects": [ + }, { - "class": "$sDevice", - "decl": "static", - "desc": "Retrieves sysman devices within a sysman driver", + "class": "$sOverclock", + "desc": "Set the value for a given overclock control", "details": [ - "Multiple calls to this function will return identical sysman device handles, in the same order.", - "The number and order of handles returned from this function is NOT affected by the $X_AFFINITY_MASK, $X_ENABLE_PCI_ID_DEVICE_ORDER, or $X_FLAT_DEVICE_HIERARCHY environment variables.", "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "39d581ecb601676e1aeb2d414243171941d470b923f87b7356eaa9b784c14cfa", - "name": "Get", - "ordinal": "0", + "hash": "dfbb3911b91acb313aa7d4bb72ebd08d0183a56b5663f5f44ea114b83270ac10", + "name": "SetControlUserValue", "params": [ { - "desc": "[in] handle of the sysman driver instance", - "name": "hDriver", - "type": "$s_driver_handle_t" + "desc": "[in] Handle for the component domain.", + "name": "hDomainHandle", + "type": "$s_overclock_handle_t" }, { - "desc": "[in,out] pointer to the number of sysman devices.\nif count is zero, then the driver shall update the value with the total number of sysman devices available.\nif count is greater than the number of sysman devices available, then the driver shall update the value with the correct number of sysman devices available.\n", - "name": "pCount", - "type": "uint32_t*" + "desc": "[in] Domain Control.", + "name": "DomainControl", + "type": "$s_overclock_control_t" }, { - "desc": "[in,out][optional][range(0, *pCount)] array of handle of sysman devices.\nif count is less than the number of sysman devices available, then driver shall only retrieve that number of sysman devices.\n", - "name": "phDevices", - "type": "$s_device_handle_t*" + "desc": "[in] The new value of the control. The units and format of the value depend on the control type.", + "name": "pValue", + "type": "double" + }, + { + "desc": "[out] Pending overclock setting.", + "name": "pPendingAction", + "type": "$s_pending_action_t*" } ], "returns": [ @@ -68240,12 +82925,22 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDriver`" + "`nullptr == hDomainHandle`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_ENUMERATION": [ + "`$S_OVERCLOCK_CONTROL_ACM_DISABLE < DomainControl`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pCount`" + "`nullptr == pPendingAction`" + ] + }, + { + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "Overclocking is not supported on this control domain" ] } ], @@ -68253,417 +82948,358 @@ "version": "1.5" }, { - "desc": "Maximum number of characters in string properties.", - "name": "$S_STRING_PROPERTY_SIZE", - "type": "macro", - "value": "64" - }, - { - "desc": "Maximum device universal unique id (UUID) size in bytes.", - "name": "$S_MAX_UUID_SIZE", - "type": "macro", - "value": "16" - }, - { - "class": "$sDevice", - "desc": "Types of accelerator engines", - "etors": [ - { - "desc": "Undefined types of accelerators.", - "name": "$S_ENGINE_TYPE_FLAG_OTHER", - "value": "$X_BIT(0)" - }, - { - "desc": "Engines that process compute kernels only (no 3D content).", - "name": "$S_ENGINE_TYPE_FLAG_COMPUTE", - "value": "$X_BIT(1)" - }, + "class": "$sOverclock", + "desc": "Determine the state of an overclock control", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "f6955ca25e09f286e83af378e9b44a83ee85177ef351898262df6df3bf834e58", + "name": "GetControlState", + "params": [ { - "desc": "Engines that process 3D content only (no compute kernels).", - "name": "$S_ENGINE_TYPE_FLAG_3D", - "value": "$X_BIT(2)" + "desc": "[in] Handle for the component domain.", + "name": "hDomainHandle", + "type": "$s_overclock_handle_t" }, { - "desc": "Engines that process media workloads.", - "name": "$S_ENGINE_TYPE_FLAG_MEDIA", - "value": "$X_BIT(3)" + "desc": "[in] Domain Control.", + "name": "DomainControl", + "type": "$s_overclock_control_t" }, { - "desc": "Engines that copy blocks of data.", - "name": "$S_ENGINE_TYPE_FLAG_DMA", - "value": "$X_BIT(4)" + "desc": "[out] Current overclock control state.", + "name": "pControlState", + "type": "$s_control_state_t*" }, { - "desc": "Engines that can process both 3D content and compute kernels.", - "name": "$S_ENGINE_TYPE_FLAG_RENDER", - "value": "$X_BIT(5)" + "desc": "[out] Pending overclock setting.", + "name": "pPendingAction", + "type": "$s_pending_action_t*" } ], - "name": "$s_engine_type_flags_t", - "type": "enum" - }, - { - "class": "$sDevice", - "desc": "Device repair status", - "etors": [ + "returns": [ { - "desc": "The device does not support in-field repairs.", - "name": "$S_REPAIR_STATUS_UNSUPPORTED", - "value": "0" + "$X_RESULT_SUCCESS": [] }, { - "desc": "The device has never been repaired.", - "name": "$S_REPAIR_STATUS_NOT_PERFORMED", - "value": "1" + "$X_RESULT_ERROR_UNINITIALIZED": [] }, { - "desc": "The device has been repaired.", - "name": "$S_REPAIR_STATUS_PERFORMED", - "value": "2" - } - ], - "name": "$s_repair_status_t", - "type": "enum" - }, - { - "class": "$sDevice", - "desc": "Device reset reasons", - "etors": [ - { - "desc": "The device needs to be reset because one or more parts of the hardware is wedged", - "name": "$S_RESET_REASON_FLAG_WEDGED", - "value": "$X_BIT(0)" + "$X_RESULT_ERROR_DEVICE_LOST": [] }, { - "desc": "The device needs to be reset in order to complete in-field repairs", - "name": "$S_RESET_REASON_FLAG_REPAIR", - "value": "$X_BIT(1)" - } - ], - "name": "$s_reset_reason_flags_t", - "type": "enum" - }, - { - "class": "$sDevice", - "desc": "Device reset type", - "etors": [ - { - "desc": "Apply warm reset", - "name": "$S_RESET_TYPE_WARM", - "value": "0" + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] }, { - "desc": "Apply cold reset", - "name": "$S_RESET_TYPE_COLD", - "value": "1" + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] }, { - "desc": "Apply FLR reset", - "name": "$S_RESET_TYPE_FLR", - "value": "2" - } - ], - "name": "$s_reset_type_t", - "type": "enum", - "version": "1.7" - }, - { - "base": "$s_base_state_t", - "class": "$sDevice", - "desc": "Device state", - "members": [ - { - "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_DEVICE_STATE", - "name": "stype", - "type": "$s_structure_type_t" + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDomainHandle`" + ] }, { - "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "const void*" + "$X_RESULT_ERROR_INVALID_ENUMERATION": [ + "`$S_OVERCLOCK_CONTROL_ACM_DISABLE < DomainControl`" + ] }, { - "desc": "[out] Indicates if the device needs to be reset and for what reasons.\nreturns 0 (none) or combination of $s_reset_reason_flag_t\n", - "name": "reset", - "type": "$s_reset_reason_flags_t" + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pControlState`", + "`nullptr == pPendingAction`" + ] }, { - "desc": "[out] Indicates if the device has been repaired", - "name": "repaired", - "type": "$s_repair_status_t" + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "Overclocking is not supported on this control domain" + ] } ], - "name": "$s_device_state_t", - "type": "struct" + "type": "function", + "version": "1.5" }, { - "base": "$s_base_properties_t", - "class": "$sDevice", - "desc": "Device reset properties", - "members": [ + "class": "$sOverclock", + "desc": "Read the frequency or voltage of a V-F point from the default or custom V-F curve.", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "8b56f4fb8f854cf65406481cf251f0a09fd6ab09ae35df9a0d8a7362529153a8", + "name": "GetVFPointValues", + "params": [ { - "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_RESET_PROPERTIES", - "name": "stype", - "type": "$s_structure_type_t" + "desc": "[in] Handle for the component domain.", + "name": "hDomainHandle", + "type": "$s_overclock_handle_t" }, { - "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "void*" + "desc": "[in] Voltage or Freqency point to read.", + "name": "VFType", + "type": "$s_vf_type_t" }, { - "desc": "[in] If set to true, all applications that are currently using the device will be forcibly killed.\n", - "name": "force", - "type": "ze_bool_t" + "desc": "[in] User,Default or Live VF array to read from", + "name": "VFArrayType", + "type": "$s_vf_array_type_t" }, { - "desc": "[in] Type of reset needs to be performed", - "name": "resetType", - "type": "$s_reset_type_t" - } - ], - "name": "$s_reset_properties_t", - "type": "struct", - "version": "1.7" - }, - { - "class": "$sDevice", - "desc": "Device universal unique id (UUID)", - "members": [ + "desc": "[in] Point index - number between (0, max_num_points - 1).", + "name": "PointIndex", + "type": "uint32_t" + }, { - "desc": "[out] opaque data representing a device UUID", - "name": "id[$S_MAX_UUID_SIZE]", - "type": "uint8_t" + "desc": "[out] Returns the frequency in 1kHz units or voltage in millivolt units from the custom V-F curve at the specified zero-based index ", + "name": "PointValue", + "type": "uint32_t*" } ], - "name": "$s_uuid_t", - "type": "struct", - "version": "1.7" - }, - { - "class": "$sDevice", - "desc": "Supported device types", - "etors": [ + "returns": [ { - "desc": "Graphics Processing Unit", - "name": "$S_DEVICE_TYPE_GPU", - "value": "1" + "$X_RESULT_SUCCESS": [] }, { - "desc": "Central Processing Unit", - "name": "$S_DEVICE_TYPE_CPU", - "value": "2" + "$X_RESULT_ERROR_UNINITIALIZED": [] }, { - "desc": "Field Programmable Gate Array", - "name": "$S_DEVICE_TYPE_FPGA", - "value": "3" + "$X_RESULT_ERROR_DEVICE_LOST": [] }, { - "desc": "Memory Copy Accelerator", - "name": "$S_DEVICE_TYPE_MCA", - "value": "4" + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] }, { - "desc": "Vision Processing Unit", - "name": "$S_DEVICE_TYPE_VPU", - "value": "5" - } - ], - "name": "$s_device_type_t", - "type": "enum", - "version": "1.7" - }, - { - "class": "$sDevice", - "desc": "Supported device property flags", - "etors": [ + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, { - "desc": "Device is integrated with the Host.", - "name": "$S_DEVICE_PROPERTY_FLAG_INTEGRATED", - "value": "$X_BIT(0)" + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDomainHandle`" + ] }, { - "desc": "Device handle used for query represents a sub-device.", - "name": "$S_DEVICE_PROPERTY_FLAG_SUBDEVICE", - "value": "$X_BIT(1)" + "$X_RESULT_ERROR_INVALID_ENUMERATION": [ + "`$S_VF_TYPE_FREQ < VFType`", + "`$S_VF_ARRAY_TYPE_LIVE_VF_ARRAY < VFArrayType`" + ] }, { - "desc": "Device supports error correction memory access.", - "name": "$S_DEVICE_PROPERTY_FLAG_ECC", - "value": "$X_BIT(2)" + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == PointValue`" + ] }, { - "desc": "Device supports on-demand page-faulting.", - "name": "$S_DEVICE_PROPERTY_FLAG_ONDEMANDPAGING", - "value": "$X_BIT(3)" + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "Overclocking is not supported on this control domain" + ] } ], - "name": "$s_device_property_flags_t", - "type": "enum", - "version": "1.7" + "type": "function", + "version": "1.5" }, { - "base": "$s_base_properties_t", - "class": "$sDevice", - "desc": "Device properties", - "members": [ + "class": "$sOverclock", + "desc": "Write the frequency or voltage of a V-F point to custom V-F curve.", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "8bb361cef11696f36f541cac2d919f200cf453261bc940ec647786681f425e9c", + "name": "SetVFPointValues", + "params": [ { - "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_DEVICE_PROPERTIES", - "name": "stype", - "type": "$s_structure_type_t" + "desc": "[in] Handle for the component domain.", + "name": "hDomainHandle", + "type": "$s_overclock_handle_t" }, { - "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "void*" + "desc": "[in] Voltage or Freqency point to read.", + "name": "VFType", + "type": "$s_vf_type_t" }, { - "desc": "[out] (Deprecated, use $s_uuid_t in the extended structure) Core device properties", - "name": "core", - "type": "$x_device_properties_t" + "desc": "[in] Point index - number between (0, max_num_points - 1).", + "name": "PointIndex", + "type": "uint32_t" }, { - "desc": "[out] Number of sub-devices. A value of 0 indicates that this device doesn't have sub-devices.", - "name": "numSubdevices", + "desc": "[in] Writes frequency in 1kHz units or voltage in millivolt units to custom V-F curve at the specified zero-based index ", + "name": "PointValue", "type": "uint32_t" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] }, { - "desc": "[out] Manufacturing serial number (NULL terminated string value). This value is intended to reflect the Part ID/SoC ID assigned by manufacturer that is unique for a SoC. Will be set to the string \"unknown\" if this cannot be determined for the device.", - "name": "serialNumber[$S_STRING_PROPERTY_SIZE]", - "type": "char" + "$X_RESULT_ERROR_UNINITIALIZED": [] }, { - "desc": "[out] Manufacturing board number (NULL terminated string value). Alternatively \"boardSerialNumber\", this value is intended to reflect the string printed on board label by manufacturer. Will be set to the string \"unknown\" if this cannot be determined for the device.", - "name": "boardNumber[$S_STRING_PROPERTY_SIZE]", - "type": "char" + "$X_RESULT_ERROR_DEVICE_LOST": [] }, { - "desc": "[out] Brand name of the device (NULL terminated string value). Will be set to the string \"unknown\" if this cannot be determined for the device.", - "name": "brandName[$S_STRING_PROPERTY_SIZE]", - "type": "char" + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] }, { - "desc": "[out] Model name of the device (NULL terminated string value). Will be set to the string \"unknown\" if this cannot be determined for the device.", - "name": "modelName[$S_STRING_PROPERTY_SIZE]", - "type": "char" + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] }, { - "desc": "[out] Vendor name of the device (NULL terminated string value). Will be set to the string \"unknown\" if this cannot be determined for the device.", - "name": "vendorName[$S_STRING_PROPERTY_SIZE]", - "type": "char" + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDomainHandle`" + ] }, { - "desc": "[out] Installed driver version (NULL terminated string value). Will be set to the string \"unknown\" if this cannot be determined for the device.", - "name": "driverVersion[$S_STRING_PROPERTY_SIZE]", - "type": "char" + "$X_RESULT_ERROR_INVALID_ENUMERATION": [ + "`$S_VF_TYPE_FREQ < VFType`" + ] + }, + { + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "Overclocking is not supported on this control domain" + ] } ], - "name": "$s_device_properties_t", - "type": "struct" + "type": "function", + "version": "1.5" }, { - "base": "$s_base_properties_t", - "class": "$sDevice", - "desc": "Device properties", + "desc": "C++ wrapper for a Sysman device overclock domain", "members": [ { - "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_DEVICE_EXT_PROPERTIES", - "name": "stype", - "type": "$s_structure_type_t" + "desc": "[in] handle of Sysman object", + "init": "nullptr", + "name": "handle", + "type": "$s_overclock_handle_t" }, { - "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "void*" + "desc": "[in] pointer to owner object", + "name": "pDevice", + "type": "$sDevice*" + } + ], + "name": "$sOverclock", + "owner": "$sDevice", + "type": "class", + "version": "1.5" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - Firmware management", + "ordinal": 1000, + "type": "header" + }, + "name": "diagnostics", + "objects": [ + { + "class": "$sDiagnostics", + "desc": "Diagnostic results", + "etors": [ + { + "desc": "Diagnostic completed without finding errors to repair", + "name": "$S_DIAG_RESULT_NO_ERRORS", + "value": "0" }, { - "desc": "[out] universal unique identifier. Note: uuid obtained from Sysman API is the same as from core API. Subdevices will have their own uuid.", - "name": "uuid", - "type": "$s_uuid_t" + "desc": "Diagnostic had problems running tests", + "name": "$S_DIAG_RESULT_ABORT", + "value": "1" }, { - "desc": "[out] generic device type", - "name": "type", - "type": "$s_device_type_t" + "desc": "Diagnostic had problems setting up repairs", + "name": "$S_DIAG_RESULT_FAIL_CANT_REPAIR", + "value": "2" }, { - "desc": "[out] 0 (none) or a valid combination of $s_device_property_flag_t", - "name": "flags", - "type": "$s_device_property_flags_t" + "desc": "Diagnostics found errors, setup for repair and reboot is required to complete the process", + "name": "$S_DIAG_RESULT_REBOOT_FOR_REPAIR", + "value": "3" } ], - "name": "$s_device_ext_properties_t", - "type": "struct", - "version": "1.7" + "name": "$s_diag_result_t", + "type": "enum" }, { - "class": "$sDevice", - "desc": "Get properties about the device", - "details": [ - "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." - ], - "hash": "c558d1b867032600d877bf98f17dfab339d27cf77a33bb46c846981ac08d0fd0", - "name": "GetProperties", - "params": [ + "desc": "Diagnostic test index to use for the very first test.", + "name": "$S_DIAG_FIRST_TEST_INDEX", + "type": "macro", + "value": "0x0" + }, + { + "desc": "Diagnostic test index to use for the very last test.", + "name": "$S_DIAG_LAST_TEST_INDEX", + "type": "macro", + "value": "0xFFFFFFFF" + }, + { + "class": "$sDiagnostics", + "desc": "Diagnostic test", + "members": [ { - "desc": "[in] Sysman handle of the device.", - "name": "hDevice", - "type": "$s_device_handle_t" + "desc": "[out] Index of the test", + "name": "index", + "type": "uint32_t" }, { - "desc": "[in,out] Structure that will contain information about the device.", - "name": "pProperties", - "type": "$s_device_properties_t*" + "desc": "[out] Name of the test", + "name": "name[$S_STRING_PROPERTY_SIZE]", + "type": "char" } ], - "returns": [ - { - "$X_RESULT_SUCCESS": [] - }, + "name": "$s_diag_test_t", + "type": "struct" + }, + { + "base": "$s_base_properties_t", + "class": "$sDiagnostics", + "desc": "Diagnostics test suite properties", + "members": [ { - "$X_RESULT_ERROR_UNINITIALIZED": [] + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_DIAG_PROPERTIES", + "name": "stype", + "type": "$s_structure_type_t" }, { - "$X_RESULT_ERROR_DEVICE_LOST": [] + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" }, { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "desc": "[out] True if the resource is located on a sub-device; false means that the resource is on the device of the calling Sysman handle", + "name": "onSubdevice", + "type": "$x_bool_t" }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + "desc": "[out] If onSubdevice is true, this gives the ID of the sub-device", + "name": "subdeviceId", + "type": "uint32_t" }, { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDevice`" - ] + "desc": "[out] Name of the diagnostics test suite", + "name": "name[$S_STRING_PROPERTY_SIZE]", + "type": "char" }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pProperties`" - ] + "desc": "[out] Indicates if this test suite has individual tests which can be run separately (use the function $sDiagnosticsGetTests() to get the list of these tests)", + "name": "haveTests", + "type": "$x_bool_t" } ], - "type": "function" + "name": "$s_diag_properties_t", + "type": "struct" }, { "class": "$sDevice", - "desc": "Get information about the state of the device - if a reset is required, reasons for the reset and if the device has been repaired", + "desc": "Get handle of diagnostics test suites", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "28bd626c19e2bd6d9240511ec845060f705570df8951af52c71be55b50515edd", - "name": "GetState", + "hash": "59ed350ef7e70b37e52550c3ab609f5379d8b887c910db4babc51892f01acaed", + "name": "EnumDiagnosticTestSuites", "params": [ { "desc": "[in] Sysman handle of the device.", @@ -68671,9 +83307,14 @@ "type": "$s_device_handle_t" }, { - "desc": "[in,out] Structure that will contain information about the device.", - "name": "pState", - "type": "$s_device_state_t*" + "desc": "[in,out] pointer to the number of components of this type.\nif count is zero, then the driver shall update the value with the total number of components of this type that are available.\nif count is greater than the number of components of this type that are available, then the driver shall update the value with the correct number of components.\n", + "name": "pCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", + "name": "phDiagnostics", + "type": "$s_diag_handle_t*" } ], "returns": [ @@ -68699,33 +83340,31 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pState`" + "`nullptr == pCount`" ] } ], "type": "function" }, { - "class": "$sDevice", - "desc": "Reset device", + "class": "$sDiagnostics", + "desc": "Get properties of a diagnostics test suite", "details": [ - "Performs a PCI bus reset of the device. This will result in all current device state being lost.", - "All applications using the device should be stopped before calling this function.", - "If the force argument is specified, all applications using the device will be forcibly killed.", - "The function will block until the device has restarted or an implementation defined timeout occurred waiting for the reset to complete." + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." ], - "hash": "67b1841611f9320f42b40fbca89a7d36fe40df9eb3f266d1eaa2b10d345bf9dd", - "name": "Reset", + "hash": "3388b8e374bf55f17c6ed5c46ec293e7e127397ad28a759037eb3865c8c4021c", + "name": "GetProperties", "params": [ { - "desc": "[in] Sysman handle for the device", - "name": "hDevice", - "type": "$s_device_handle_t" + "desc": "[in] Handle for the component.", + "name": "hDiagnostics", + "type": "$s_diag_handle_t" }, { - "desc": "[in] If set to true, all applications that are currently using the device will be forcibly killed.", - "name": "force", - "type": "$x_bool_t" + "desc": "[in,out] Structure describing the properties of a diagnostics test suite", + "name": "pProperties", + "type": "$s_diag_properties_t*" } ], "returns": [ @@ -68746,48 +83385,42 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDevice`" - ] - }, - { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to perform this operation." - ] - }, - { - "$X_RESULT_ERROR_HANDLE_OBJECT_IN_USE": [ - "Reset cannot be performed because applications are using this device." + "`nullptr == hDiagnostics`" ] }, { - "$X_RESULT_ERROR_UNKNOWN": [ - "There were problems unloading the device driver, performing a bus reset or reloading the device driver." + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pProperties`" ] } ], "type": "function" }, { - "class": "$sDevice", - "desc": "Reset device extension", + "class": "$sDiagnostics", + "desc": "Get individual tests that can be run separately. Not all test suites permit running individual tests, check the `haveTests` member of $s_diag_properties_t.", "details": [ - "Performs a PCI bus reset of the device. This will result in all current device state being lost.", - "Prior to calling this function, user is responsible for closing applications using the device unless force argument is specified.", - "If the force argument is specified, all applications using the device will be forcibly killed.", - "The function will block until the device has restarted or a implementation specific timeout occurred waiting for the reset to complete." + "The list of available tests is returned in order of increasing test index (see the `index` member of $s_diag_test_t).", + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." ], - "hash": "483a18c10d33993940d82a433a1d1315e607f86845f02ea1cb32d9f41b225fb3", - "name": "ResetExt", + "hash": "4219d4ef7697f5b2b7b20571adf1350eeb3e20d96f93c37d10e86d05b8faed06", + "name": "GetTests", "params": [ { - "desc": "[in] Sysman handle for the device", - "name": "hDevice", - "type": "$s_device_handle_t" + "desc": "[in] Handle for the component.", + "name": "hDiagnostics", + "type": "$s_diag_handle_t" }, { - "desc": "[in] Device reset properties to apply", - "name": "pProperties", - "type": "$s_reset_properties_t*" + "desc": "[in,out] pointer to the number of tests.\nif count is zero, then the driver shall update the value with the total number of tests that are available.\nif count is greater than the number of tests that are available, then the driver shall update the value with the correct number of tests.\n", + "name": "pCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pCount)] array of information about individual tests sorted by increasing value of the `index` member of $s_diag_test_t.\nif count is less than the number of tests that are available, then the driver shall only retrieve that number of tests.\n", + "name": "pTests", + "type": "$s_diag_test_t*" } ], "returns": [ @@ -68808,102 +83441,48 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDevice`" + "`nullptr == hDiagnostics`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pProperties`" - ] - }, - { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to perform this operation." - ] - }, - { - "$X_RESULT_ERROR_HANDLE_OBJECT_IN_USE": [ - "Reset cannot be performed because applications are using this device." - ] - }, - { - "$X_RESULT_ERROR_UNKNOWN": [ - "There were problems unloading the device driver, performing a bus reset or reloading the device driver." + "`nullptr == pCount`" ] } ], - "type": "function", - "version": "1.7" + "type": "function" }, { - "base": "$s_base_state_t", - "class": "$sDevice", - "desc": "Contains information about a process that has an open connection with this device", + "class": "$sDiagnostics", + "desc": "Run a diagnostics test suite, either all tests or a subset of tests.", "details": [ - "The application can use the process ID to query the OS for the owner and the path to the executable." + "WARNING: Running diagnostics may destroy current device state information. Gracefully close any running workloads before initiating.", + "To run all tests in a test suite, set start = $S_DIAG_FIRST_TEST_INDEX and end = $S_DIAG_LAST_TEST_INDEX.", + "If the test suite permits running individual tests, the `haveTests` member of $s_diag_properties_t will be true. In this case, the function $sDiagnosticsGetTests() can be called to get the list of tests and corresponding indices that can be supplied to the arguments start and end in this function.", + "This function will block until the diagnostics have completed and force reset based on result" ], - "members": [ - { - "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_PROCESS_STATE", - "name": "stype", - "type": "$s_structure_type_t" - }, + "hash": "349d2006c7ca8ec132f2c6eb5efdabdcbb4c439f9905517fd0fb216f63671c28", + "name": "RunTests", + "params": [ { - "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "const void*" + "desc": "[in] Handle for the component.", + "name": "hDiagnostics", + "type": "$s_diag_handle_t" }, { - "desc": "[out] Host OS process ID.", - "name": "processId", + "desc": "[in] The index of the first test to run. Set to $S_DIAG_FIRST_TEST_INDEX to start from the beginning.", + "name": "startIndex", "type": "uint32_t" }, { - "desc": "[out] Device memory size in bytes allocated by this process (may not necessarily be resident on the device at the time of reading).", - "name": "memSize", - "type": "uint64_t" - }, - { - "desc": "[out] The size of shared device memory mapped into this process (may not necessarily be resident on the device at the time of reading).", - "name": "sharedSize", - "type": "uint64_t" - }, - { - "desc": "[out] Bitfield of accelerator engine types being used by this process.", - "name": "engines", - "type": "$s_engine_type_flags_t" - } - ], - "name": "$s_process_state_t", - "type": "struct" - }, - { - "class": "$sDevice", - "desc": "Get information about host processes using the device", - "details": [ - "The number of processes connected to the device is dynamic. This means that between a call to determine the value of pCount and the subsequent call, the number of processes may have increased or decreased. It is recommended that a large array be passed in so as to avoid receiving the error $X_RESULT_ERROR_INVALID_SIZE. Also, always check the returned value in pCount since it may be less than the earlier call to get the required array size.", - "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." - ], - "hash": "e0532e5c68d72d06053786f30f98e8586a9f97e4123742ec00b31bd1190d67b0", - "name": "ProcessesGetState", - "params": [ - { - "desc": "[in] Sysman handle for the device", - "name": "hDevice", - "type": "$s_device_handle_t" - }, - { - "desc": "[in,out] pointer to the number of processes.\nif count is zero, then the driver shall update the value with the total number of processes currently attached to the device.\nif count is greater than the number of processes currently attached to the device, then the driver shall update the value with the correct number of processes.\n", - "name": "pCount", - "type": "uint32_t*" + "desc": "[in] The index of the last test to run. Set to $S_DIAG_LAST_TEST_INDEX to complete all tests after the start test.", + "name": "endIndex", + "type": "uint32_t" }, { - "desc": "[in,out][optional][range(0, *pCount)] array of process information.\nif count is less than the number of processes currently attached to the device, then the driver shall only retrieve information about that number of processes. In this case, the return code will $X_RESULT_ERROR_INVALID_SIZE.\n", - "name": "pProcesses", - "type": "$s_process_state_t*" + "desc": "[in,out] The result of the diagnostics", + "name": "pResult", + "type": "$s_diag_result_t*" } ], "returns": [ @@ -68924,396 +83503,187 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDevice`" + "`nullptr == hDiagnostics`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pCount`" + "`nullptr == pResult`" ] }, { - "$X_RESULT_ERROR_INVALID_SIZE": [ - "The provided value of pCount is not big enough to store information about all the processes currently attached to the device." + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "User does not have permissions to perform diagnostics." ] } ], "type": "function" }, { - "class": "$sDevice", - "desc": "PCI address", - "members": [ - { - "desc": "[out] BDF domain", - "name": "domain", - "type": "uint32_t" - }, - { - "desc": "[out] BDF bus", - "name": "bus", - "type": "uint32_t" - }, - { - "desc": "[out] BDF device", - "name": "device", - "type": "uint32_t" - }, - { - "desc": "[out] BDF function", - "name": "function", - "type": "uint32_t" - } - ], - "name": "$s_pci_address_t", - "type": "struct" - }, - { - "class": "$sDevice", - "desc": "PCI speed", - "members": [ - { - "desc": "[out] The link generation. A value of -1 means that this property is unknown.", - "name": "gen", - "type": "int32_t" - }, - { - "desc": "[out] The number of lanes. A value of -1 means that this property is unknown.", - "name": "width", - "type": "int32_t" - }, - { - "desc": "[out] The maximum bandwidth in bytes/sec (sum of all lanes). A value of -1 means that this property is unknown.", - "name": "maxBandwidth", - "type": "int64_t" - } - ], - "name": "$s_pci_speed_t", - "type": "struct" - }, - { - "base": "$s_base_properties_t", - "class": "$sDevice", - "desc": "Static PCI properties", + "desc": "C++ wrapper for a Sysman device diagnostic test suite", "members": [ { - "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_PCI_PROPERTIES", - "name": "stype", - "type": "$s_structure_type_t" - }, - { - "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "desc": "[in] handle of Sysman object", "init": "nullptr", - "name": "pNext", - "type": "void*" - }, - { - "desc": "[out] The BDF address", - "name": "address", - "type": "$s_pci_address_t" - }, - { - "desc": "[out] Fastest port configuration supported by the device (sum of all lanes)", - "name": "maxSpeed", - "type": "$s_pci_speed_t" - }, - { - "desc": "[out] Indicates whether the `rxCounter` and `txCounter` members of $s_pci_stats_t will have valid values", - "name": "haveBandwidthCounters", - "type": "$x_bool_t" - }, - { - "desc": "[out] Indicates whether the `packetCounter` member of $s_pci_stats_t will have a valid value", - "name": "havePacketCounters", - "type": "$x_bool_t" + "name": "handle", + "type": "$s_diag_handle_t" }, { - "desc": "[out] Indicates whether the `replayCounter` member of $s_pci_stats_t will have a valid value", - "name": "haveReplayCounters", - "type": "$x_bool_t" + "desc": "[in] pointer to owner object", + "name": "pDevice", + "type": "$sDevice*" } ], - "name": "$s_pci_properties_t", - "type": "struct" - }, + "name": "$sDiagnostics", + "owner": "$sDevice", + "type": "class" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - ECC management", + "ordinal": 1000, + "type": "header" + }, + "name": "ecc", + "objects": [ { "class": "$sDevice", - "desc": "PCI link status", + "desc": "ECC State", "etors": [ { - "desc": "The link status could not be determined", - "name": "$S_PCI_LINK_STATUS_UNKNOWN", + "desc": "None", + "name": "$S_DEVICE_ECC_STATE_UNAVAILABLE", "value": "0" }, { - "desc": "The link is up and operating as expected", - "name": "$S_PCI_LINK_STATUS_GOOD", + "desc": "ECC enabled.", + "name": "$S_DEVICE_ECC_STATE_ENABLED", "value": "1" }, { - "desc": "The link is up but has quality and/or bandwidth degradation", - "name": "$S_PCI_LINK_STATUS_QUALITY_ISSUES", + "desc": "ECC disabled.", + "name": "$S_DEVICE_ECC_STATE_DISABLED", "value": "2" - }, - { - "desc": "The link has stability issues and preventing workloads making forward progress", - "name": "$S_PCI_LINK_STATUS_STABILITY_ISSUES", - "value": "3" - } - ], - "name": "$s_pci_link_status_t", - "type": "enum" - }, - { - "class": "$sDevice", - "desc": "PCI link quality degradation reasons", - "etors": [ - { - "desc": "A significant number of replays are occurring", - "name": "$S_PCI_LINK_QUAL_ISSUE_FLAG_REPLAYS", - "value": "$X_BIT(0)" - }, - { - "desc": "There is a degradation in the maximum bandwidth of the link", - "name": "$S_PCI_LINK_QUAL_ISSUE_FLAG_SPEED", - "value": "$X_BIT(1)" - } - ], - "name": "$s_pci_link_qual_issue_flags_t", - "type": "enum" - }, - { - "class": "$sDevice", - "desc": "PCI link stability issues", - "etors": [ - { - "desc": "Link retraining has occurred to deal with quality issues", - "name": "$S_PCI_LINK_STAB_ISSUE_FLAG_RETRAINING", - "value": "$X_BIT(0)" - } - ], - "name": "$s_pci_link_stab_issue_flags_t", - "type": "enum" - }, - { - "base": "$s_base_state_t", - "class": "$sDevice", - "desc": "Dynamic PCI state", - "members": [ - { - "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_PCI_STATE", - "name": "stype", - "type": "$s_structure_type_t" - }, - { - "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "const void*" - }, - { - "desc": "[out] The current status of the port", - "name": "status", - "type": "$s_pci_link_status_t" - }, - { - "desc": "[out] If status is $S_PCI_LINK_STATUS_QUALITY_ISSUES, \nthen this gives a combination of $s_pci_link_qual_issue_flag_t for quality issues that have been detected;\notherwise, 0 indicates there are no quality issues with the link at this time.\"\n", - "name": "qualityIssues", - "type": "$s_pci_link_qual_issue_flags_t" - }, - { - "desc": "[out] If status is $S_PCI_LINK_STATUS_STABILITY_ISSUES, \nthen this gives a combination of $s_pci_link_stab_issue_flag_t for reasons for the connection instability;\notherwise, 0 indicates there are no connection stability issues at this time.\"\n", - "name": "stabilityIssues", - "type": "$s_pci_link_stab_issue_flags_t" - }, - { - "desc": "[out] The current port configure speed", - "name": "speed", - "type": "$s_pci_speed_t" } ], - "name": "$s_pci_state_t", - "type": "struct" + "name": "$s_device_ecc_state_t", + "type": "enum", + "version": "1.4" }, { "class": "$sDevice", - "desc": "PCI bar types", + "desc": "State Change Requirements", "etors": [ { - "desc": "MMIO registers", - "name": "$S_PCI_BAR_TYPE_MMIO", + "desc": "No action.", + "name": "$S_DEVICE_ACTION_NONE", "value": "0" }, { - "desc": "ROM aperture", - "name": "$S_PCI_BAR_TYPE_ROM", + "desc": "Warm reset of the card.", + "name": "$S_DEVICE_ACTION_WARM_CARD_RESET", "value": "1" }, { - "desc": "Device memory", - "name": "$S_PCI_BAR_TYPE_MEM", + "desc": "Cold reset of the card.", + "name": "$S_DEVICE_ACTION_COLD_CARD_RESET", "value": "2" - } - ], - "name": "$s_pci_bar_type_t", - "type": "enum" - }, - { - "base": "$s_base_properties_t", - "class": "$sDevice", - "desc": "Properties of a pci bar", - "members": [ - { - "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_PCI_BAR_PROPERTIES", - "name": "stype", - "type": "$s_structure_type_t" - }, - { - "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "void*" - }, - { - "desc": "[out] The type of bar", - "name": "type", - "type": "$s_pci_bar_type_t" - }, - { - "desc": "[out] The index of the bar", - "name": "index", - "type": "uint32_t" - }, - { - "desc": "[out] Base address of the bar.", - "name": "base", - "type": "uint64_t" }, { - "desc": "[out] Size of the bar.", - "name": "size", - "type": "uint64_t" + "desc": "Cold reboot of the system.", + "name": "$S_DEVICE_ACTION_COLD_SYSTEM_REBOOT", + "value": "3" } ], - "name": "$s_pci_bar_properties_t", - "type": "struct" + "name": "$s_device_action_t", + "type": "enum", + "version": "1.4" }, { - "base": "$s_base_properties_t", + "base": "$s_base_desc_t", "class": "$sDevice", - "desc": "Properties of a pci bar, including the resizable bar.", + "desc": "ECC State Descriptor", "members": [ { "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_PCI_BAR_PROPERTIES_1_2", + "init": "$S_STRUCTURE_TYPE_DEVICE_ECC_DESC", "name": "stype", "type": "$s_structure_type_t" }, { - "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", "init": "nullptr", "name": "pNext", - "type": "void*" - }, - { - "desc": "[out] The type of bar", - "name": "type", - "type": "$s_pci_bar_type_t" - }, - { - "desc": "[out] The index of the bar", - "name": "index", - "type": "uint32_t" - }, - { - "desc": "[out] Base address of the bar.", - "name": "base", - "type": "uint64_t" - }, - { - "desc": "[out] Size of the bar.", - "name": "size", - "type": "uint64_t" - }, - { - "desc": "[out] Support for Resizable Bar on this device.", - "name": "resizableBarSupported", - "type": "$x_bool_t" + "type": "const void*" }, { - "desc": "[out] Resizable Bar enabled on this device", - "name": "resizableBarEnabled", - "type": "$x_bool_t" + "desc": "[out] ECC state", + "name": "state", + "type": "$s_device_ecc_state_t" } ], - "name": "$s_pci_bar_properties_1_2_t", + "name": "$s_device_ecc_desc_t", "type": "struct", - "version": "1.2" + "version": "1.4" }, { + "base": "$s_base_properties_t", "class": "$sDevice", - "desc": "PCI stats counters", - "details": [ - "Percent replays is calculated by taking two snapshots (s1, s2) and using the equation: %replay = 10^6 * (s2.replayCounter - s1.replayCounter) / (s2.maxBandwidth * (s2.timestamp - s1.timestamp))", - "Percent throughput is calculated by taking two snapshots (s1, s2) and using the equation: %bw = 10^6 * ((s2.rxCounter - s1.rxCounter) + (s2.txCounter - s1.txCounter)) / (s2.maxBandwidth * (s2.timestamp - s1.timestamp))" - ], + "desc": "ECC State", "members": [ { - "desc": "[out] Monotonic timestamp counter in microseconds when the measurement was made.\nThis timestamp should only be used to calculate delta time between snapshots of this structure.\nNever take the delta of this timestamp with the timestamp from a different structure since they are not guaranteed to have the same base.\nThe absolute value of the timestamp is only valid during within the application and may be different on the next execution.\n", - "name": "timestamp", - "type": "uint64_t" - }, - { - "desc": "[out] Monotonic counter for the number of replay packets (sum of all lanes). Will always be 0 when the `haveReplayCounters` member of $s_pci_properties_t is FALSE.", - "name": "replayCounter", - "type": "uint64_t" + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_DEVICE_ECC_PROPERTIES", + "name": "stype", + "type": "$s_structure_type_t" }, { - "desc": "[out] Monotonic counter for the number of packets (sum of all lanes). Will always be 0 when the `havePacketCounters` member of $s_pci_properties_t is FALSE.", - "name": "packetCounter", - "type": "uint64_t" + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" }, { - "desc": "[out] Monotonic counter for the number of bytes received (sum of all lanes). Will always be 0 when the `haveBandwidthCounters` member of $s_pci_properties_t is FALSE.", - "name": "rxCounter", - "type": "uint64_t" + "desc": "[out] Current ECC state", + "name": "currentState", + "type": "$s_device_ecc_state_t" }, { - "desc": "[out] Monotonic counter for the number of bytes transmitted (including replays) (sum of all lanes). Will always be 0 when the `haveBandwidthCounters` member of $s_pci_properties_t is FALSE.", - "name": "txCounter", - "type": "uint64_t" + "desc": "[out] Pending ECC state", + "name": "pendingState", + "type": "$s_device_ecc_state_t" }, { - "desc": "[out] The current speed of the link (sum of all lanes)", - "name": "speed", - "type": "$s_pci_speed_t" + "desc": "[out] Pending action", + "name": "pendingAction", + "type": "$s_device_action_t" } ], - "name": "$s_pci_stats_t", - "type": "struct" + "name": "$s_device_ecc_properties_t", + "type": "struct", + "version": "1.4" }, { "class": "$sDevice", - "desc": "Get PCI properties - address, max speed", + "desc": "Is ECC functionality available - true or false?", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "e87d7976293d00d44adf69bd42f1430f154f7bf820abeda534a7330211550eec", - "name": "PciGetProperties", + "hash": "264b6e89d9b7c9216eab024643025dc409bda4982818418314482dbb1724ff12", + "name": "EccAvailable", "params": [ { - "desc": "[in] Sysman handle of the device.", + "desc": "[in] Handle for the component.", "name": "hDevice", "type": "$s_device_handle_t" }, { - "desc": "[in,out] Will contain the PCI properties.", - "name": "pProperties", - "type": "$s_pci_properties_t*" + "desc": "[out] ECC functionality is available (true)/unavailable (false).", + "name": "pAvailable", + "type": "$x_bool_t*" } ], "returns": [ @@ -69339,31 +83709,32 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pProperties`" + "`nullptr == pAvailable`" ] } ], - "type": "function" + "type": "function", + "version": "1.4" }, { "class": "$sDevice", - "desc": "Get current PCI state - current speed", + "desc": "Is ECC support configurable - true or false?", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "84dc8436ca5d1cfcdace8795f05b6fff03f037f9e33c0871a68a7df0c4919ac9", - "name": "PciGetState", + "hash": "0f8ff49a7a8abe8cde740b8234ca60bae96be561699e0a742338476b52a94218", + "name": "EccConfigurable", "params": [ { - "desc": "[in] Sysman handle of the device.", + "desc": "[in] Handle for the component.", "name": "hDevice", "type": "$s_device_handle_t" }, { - "desc": "[in,out] Will contain the PCI properties.", - "name": "pState", - "type": "$s_pci_state_t*" + "desc": "[out] ECC can be enabled/disabled (true)/enabled/disabled (false).", + "name": "pConfigurable", + "type": "$x_bool_t*" } ], "returns": [ @@ -69389,36 +83760,32 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pState`" + "`nullptr == pConfigurable`" ] } ], - "type": "function" + "type": "function", + "version": "1.4" }, { "class": "$sDevice", - "desc": "Get information about each configured bar", + "desc": "Get current ECC state, pending state, and pending action", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "88ba4b62a295f7ab057dac57aabd8ab6e46cd95e29f99e9c4c094d837c6d141d", - "name": "PciGetBars", + "hash": "6c8f13b7f3cc21e39963799875b4651b8a7bc0d3790f8cfec04d2a216d242634", + "name": "GetEccState", "params": [ { - "desc": "[in] Sysman handle of the device.", + "desc": "[in] Handle for the component.", "name": "hDevice", "type": "$s_device_handle_t" }, { - "desc": "[in,out] pointer to the number of PCI bars.\nif count is zero, then the driver shall update the value with the total number of PCI bars that are setup.\nif count is greater than the number of PCI bars that are setup, then the driver shall update the value with the correct number of PCI bars.\n", - "name": "pCount", - "type": "uint32_t*" - }, - { - "desc": "[in,out][optional][range(0, *pCount)] array of information about setup PCI bars.\nif count is less than the number of PCI bars that are setup, then the driver shall only retrieve information about that number of PCI bars.\n", - "name": "pProperties", - "type": "$s_pci_bar_properties_t*" + "desc": "[out] ECC state, pending state, and pending action for state change.", + "name": "pState", + "type": "$s_device_ecc_properties_t*" } ], "returns": [ @@ -69444,31 +83811,38 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pCount`" + "`nullptr == pState`" ] } ], - "type": "function" + "type": "function", + "version": "1.4" }, { "class": "$sDevice", - "desc": "Get PCI stats - bandwidth, number of packets, number of replays", + "desc": "Set new ECC state", "details": [ "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The implementation of this function should be lock-free.", + "$sDeviceGetState should be called to determine pending action required to implement state change." ], - "hash": "a4510a9789e8a79b17f288aee861954692b2662324b154bcb479f977c08e0e08", - "name": "PciGetStats", + "hash": "5170246117a72b8ffc924046f9ebe857e8e0da6f5e41829c7029a7d8eb4b280e", + "name": "SetEccState", "params": [ { - "desc": "[in] Sysman handle of the device.", + "desc": "[in] Handle for the component.", "name": "hDevice", "type": "$s_device_handle_t" }, { - "desc": "[in,out] Will contain a snapshot of the latest stats.", - "name": "pStats", - "type": "$s_pci_stats_t*" + "desc": "[in] Pointer to desired ECC state.", + "name": "newState", + "type": "const $s_device_ecc_desc_t*" + }, + { + "desc": "[out] ECC state, pending state, and pending action for state change.", + "name": "pState", + "type": "$s_device_ecc_properties_t*" } ], "returns": [ @@ -69494,456 +83868,204 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pStats`" + "`nullptr == newState`", + "`nullptr == pState`" ] }, { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to query this telemetry." + "$X_RESULT_ERROR_INVALID_ENUMERATION": [ + "`$S_DEVICE_ECC_STATE_DISABLED < newState->state`" + ] + }, + { + "$X_RESULT_WARNING_ACTION_REQUIRED": [ + "User must look at the pendingAction attribute of pState & perform the action required to complete the ECC state change." ] } ], - "type": "function" - }, - { - "base": "$xDriver", - "desc": "C++ wrapper for driver instance", - "members": [], - "name": "$sDriver", - "type": "class" - }, - { - "base": "$xDevice", - "desc": "C++ wrapper for device", - "members": [], - "name": "$sDevice", - "type": "class" + "type": "function", + "version": "1.4" } ] }, { "header": { - "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - Overclock controls, VF curve manipulation", + "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - Engine groups", "ordinal": 1000, "type": "header" }, - "name": "Overclock", + "name": "engine", "objects": [ { - "class": "$sDevice", - "desc": "Overclock domains.", + "class": "$sEngine", + "desc": "Accelerator engine groups", "etors": [ { - "desc": "Overclocking card level properties such as temperature limits.", - "name": "$S_OVERCLOCK_DOMAIN_CARD", - "value": "1" - }, - { - "desc": "Overclocking package level properties such as power limits.", - "name": "$S_OVERCLOCK_DOMAIN_PACKAGE", - "value": "2" - }, - { - "desc": "Overclocking a GPU that has all accelerator assets on the same PLL/VR.", - "name": "$S_OVERCLOCK_DOMAIN_GPU_ALL", - "value": "4" - }, - { - "desc": "Overclocking a GPU with render and compute assets on the same PLL/VR.", - "name": "$S_OVERCLOCK_DOMAIN_GPU_RENDER_COMPUTE", - "value": "8" - }, - { - "desc": "Overclocking a GPU with render assets on its own PLL/VR.", - "name": "$S_OVERCLOCK_DOMAIN_GPU_RENDER", - "value": "16" - }, - { - "desc": "Overclocking a GPU with compute assets on its own PLL/VR.", - "name": "$S_OVERCLOCK_DOMAIN_GPU_COMPUTE", - "value": "32" - }, - { - "desc": "Overclocking a GPU with media assets on its own PLL/VR.", - "name": "$S_OVERCLOCK_DOMAIN_GPU_MEDIA", - "value": "64" - }, - { - "desc": "Overclocking device local memory.", - "name": "$S_OVERCLOCK_DOMAIN_VRAM", - "value": "128" + "desc": "Access information about all engines combined.", + "name": "$S_ENGINE_GROUP_ALL", + "value": "0" }, { - "desc": "Overclocking LLC/L4 cache.", - "name": "$S_OVERCLOCK_DOMAIN_ADM", - "value": "256" - } - ], - "name": "$s_overclock_domain_t", - "type": "enum", - "version": "1.5" - }, - { - "class": "$sOverclock", - "desc": "Overclock controls.", - "etors": [ - { - "desc": "This control permits setting a custom V-F curve.", - "name": "$S_OVERCLOCK_CONTROL_VF", + "desc": "Access information about all compute engines combined. Compute engines can only process compute kernels (no 3D content).", + "name": "$S_ENGINE_GROUP_COMPUTE_ALL", "value": "1" }, { - "desc": "The V-F curve of the overclock domain can be shifted up or down using this control.", - "name": "$S_OVERCLOCK_CONTROL_FREQ_OFFSET", - "value": "2" - }, - { - "desc": "This control is used to increase the permitted voltage above the shipped voltage maximum.", - "name": "$S_OVERCLOCK_CONTROL_VMAX_OFFSET", - "value": "4" - }, - { - "desc": "This control permits direct changes to the operating frequency.", - "name": "$S_OVERCLOCK_CONTROL_FREQ", - "value": "8" - }, - { - "desc": "This control prevents frequencies that would push the voltage above this value, typically used by V-F scanners.", - "name": "$S_OVERCLOCK_CONTROL_VOLT_LIMIT", - "value": "16" - }, - { - "desc": "This control changes the sustained power limit (PL1).", - "name": "$S_OVERCLOCK_CONTROL_POWER_SUSTAINED_LIMIT", - "value": "32" - }, - { - "desc": "This control changes the burst power limit (PL2).", - "name": "$S_OVERCLOCK_CONTROL_POWER_BURST_LIMIT", - "value": "64" - }, - { - "desc": "his control changes the peak power limit (PL4).", - "name": "$S_OVERCLOCK_CONTROL_POWER_PEAK_LIMIT", - "value": "128" - }, - { - "desc": "This control changes the value of IccMax..", - "name": "$S_OVERCLOCK_CONTROL_ICCMAX_LIMIT", - "value": "256" - }, - { - "desc": "This control changes the value of TjMax.", - "name": "$S_OVERCLOCK_CONTROL_TEMP_LIMIT", - "value": "512" - }, - { - "desc": "This control permits disabling the adaptive voltage feature ITD", - "name": "$S_OVERCLOCK_CONTROL_ITD_DISABLE", - "value": "1024" - }, - { - "desc": "This control permits disabling the adaptive voltage feature ACM.", - "name": "$S_OVERCLOCK_CONTROL_ACM_DISABLE", - "value": "2048" - } - ], - "name": "$s_overclock_control_t", - "type": "enum", - "version": "1.5" - }, - { - "class": "$sOverclock", - "desc": "Overclock modes.", - "etors": [ - { - "desc": "Overclock mode is off", - "name": "$S_OVERCLOCK_MODE_MODE_OFF", - "value": "0" - }, - { - "desc": "Stock (manufacturing settings) are being used.", - "name": "$S_OVERCLOCK_MODE_MODE_STOCK", + "desc": "Access information about all media engines combined.", + "name": "$S_ENGINE_GROUP_MEDIA_ALL", "value": "2" }, { - "desc": "Overclock mode is on.", - "name": "$S_OVERCLOCK_MODE_MODE_ON", + "desc": "Access information about all copy (blitter) engines combined.", + "name": "$S_ENGINE_GROUP_COPY_ALL", "value": "3" }, { - "desc": "Overclocking is unavailable at this time since the system is running on battery.", - "name": "$S_OVERCLOCK_MODE_MODE_UNAVAILABLE", + "desc": "Access information about a single compute engine - this is an engine that can process compute kernels. Note that single engines may share the same underlying accelerator resources as other engines so activity of such an engine may not be indicative of the underlying resource utilization - use $S_ENGINE_GROUP_3D_RENDER_COMPUTE_ALL for that.", + "name": "$S_ENGINE_GROUP_COMPUTE_SINGLE", "value": "4" }, { - "desc": "Overclock mode is disabled.", - "name": "$S_OVERCLOCK_MODE_MODE_DISABLED", + "desc": "Access information about a single render engine - this is an engine that can process both 3D content and compute kernels. Note that single engines may share the same underlying accelerator resources as other engines so activity of such an engine may not be indicative of the underlying resource utilization - use $S_ENGINE_GROUP_3D_RENDER_COMPUTE_ALL for that.", + "name": "$S_ENGINE_GROUP_RENDER_SINGLE", "value": "5" - } - ], - "name": "$s_overclock_mode_t", - "type": "enum", - "version": "1.5" - }, - { - "class": "$sOverclock", - "desc": "Overclock control states.", - "etors": [ - { - "desc": "No overclock control has not been changed by the driver since the last boot/reset.", - "name": "$S_CONTROL_STATE_STATE_UNSET", - "value": "0" - }, - { - "desc": "The overclock control has been set and it is active.", - "name": "$S_CONTROL_STATE_STATE_ACTIVE", - "value": "2" - }, - { - "desc": "The overclock control value has been disabled due to the current power configuration (typically when running on DC).", - "name": "$S_CONTROL_STATE_STATE_DISABLED", - "value": "3" - } - ], - "name": "$s_control_state_t", - "type": "enum", - "version": "1.5" - }, - { - "class": "$sOverclock", - "desc": "Overclock pending actions.", - "etors": [ - { - "desc": "There no pending actions. .", - "name": "$S_PENDING_ACTION_PENDING_NONE", - "value": "0" - }, - { - "desc": "The requested change is in progress and should complete soon.", - "name": "$S_PENDING_ACTION_PENDING_IMMINENT", - "value": "1" - }, - { - "desc": "The requested change requires a device cold reset (hotplug, system boot).", - "name": "$S_PENDING_ACTION_PENDING_COLD_RESET", - "value": "2" - }, - { - "desc": "The requested change requires a device warm reset (PCIe FLR).", - "name": "$S_PENDING_ACTION_PENDING_WARM_RESET", - "value": "3" - } - ], - "name": "$s_pending_action_t", - "type": "enum", - "version": "1.5" - }, - { - "class": "$sOverclock", - "desc": "Overclock V-F curve programing.", - "etors": [ - { - "desc": "Can program an arbitrary number of V-F points up to the maximum number and each point can have arbitrary voltage and frequency values within the min/max/step limits", - "name": "$S_VF_PROGRAM_TYPE_VF_ARBITRARY", - "value": "0" - }, - { - "desc": "Can only program the voltage for the V-F points that it reads back - the frequency of those points cannot be changed", - "name": "$S_VF_PROGRAM_TYPE_VF_FREQ_FIXED", - "value": "1" }, { - "desc": "Can only program the frequency for the V-F points that is reads back - the voltage of each point cannot be changed.", - "name": "$S_VF_PROGRAM_TYPE_VF_VOLT_FIXED", - "value": "2" - } - ], - "name": "$s_vf_program_type_t", - "type": "enum", - "version": "1.5" - }, - { - "class": "$sOverclock", - "desc": "VF type", - "etors": [ - { - "desc": "VF Voltage point", - "name": "$S_VF_TYPE_VOLT", - "value": "0" + "desc": "[DEPRECATED] No longer supported.", + "name": "$S_ENGINE_GROUP_MEDIA_DECODE_SINGLE", + "value": "6" }, { - "desc": "VF Frequency point", - "name": "$S_VF_TYPE_FREQ", - "value": "1" - } - ], - "name": "$s_vf_type_t", - "type": "enum", - "version": "1.5" - }, - { - "class": "$sOverclock", - "desc": "VF type", - "etors": [ - { - "desc": "User V-F array", - "name": "$S_VF_ARRAY_TYPE_USER_VF_ARRAY", - "value": "0" + "desc": "[DEPRECATED] No longer supported.", + "name": "$S_ENGINE_GROUP_MEDIA_ENCODE_SINGLE", + "value": "7" }, { - "desc": "Default V-F array", - "name": "$S_VF_ARRAY_TYPE_DEFAULT_VF_ARRAY", - "value": "1" + "desc": "Access information about a single media encode engine. Note that single engines may share the same underlying accelerator resources as other engines so activity of such an engine may not be indicative of the underlying resource utilization - use $S_ENGINE_GROUP_COPY_ALL for that.", + "name": "$S_ENGINE_GROUP_COPY_SINGLE", + "value": "8" }, { - "desc": "Live V-F array", - "name": "$S_VF_ARRAY_TYPE_LIVE_VF_ARRAY", - "value": "2" - } - ], - "name": "$s_vf_array_type_t", - "type": "enum", - "version": "1.5" - }, - { - "base": "$s_base_properties_t", - "class": "$sOverclock", - "desc": "Overclock properties", - "details": [ - "Information on the overclock domain type and all the contols that are part of the domain." - ], - "members": [ - { - "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_OVERCLOCK_PROPERTIES", - "name": "stype", - "type": "$s_structure_type_t" + "desc": "Access information about a single media enhancement engine. Note that single engines may share the same underlying accelerator resources as other engines so activity of such an engine may not be indicative of the underlying resource utilization - use $S_ENGINE_GROUP_MEDIA_ALL for that.", + "name": "$S_ENGINE_GROUP_MEDIA_ENHANCEMENT_SINGLE", + "value": "9" }, { - "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "void*" + "desc": "[DEPRECATED] No longer supported.", + "name": "$S_ENGINE_GROUP_3D_SINGLE", + "value": "10" }, { - "desc": "[out] The hardware block that this overclock domain controls (GPU, VRAM, ...)", - "name": "domainType", - "type": "$s_overclock_domain_t" + "desc": "[DEPRECATED] No longer supported.", + "name": "$S_ENGINE_GROUP_3D_RENDER_COMPUTE_ALL", + "value": "11" }, { - "desc": "[out] Returns the overclock controls that are supported (a bit for each of enum $s_overclock_control_t). If no bits are set, the domain doesn't support overclocking.", - "name": "AvailableControls", - "type": "uint32_t" + "desc": "Access information about all render engines combined. Render engines are those than process both 3D content and compute kernels.", + "name": "$S_ENGINE_GROUP_RENDER_ALL", + "value": "12" }, { - "desc": "[out] Type of V-F curve programming that is permitted:.", - "name": "VFProgramType", - "type": "$s_vf_program_type_t" + "desc": "[DEPRECATED] No longer supported.", + "name": "$S_ENGINE_GROUP_3D_ALL", + "value": "13" }, { - "desc": "[out] Number of VF points that can be programmed - max_num_points", - "name": "NumberOfVFPoints", - "type": "uint32_t" + "desc": "Access information about a single media engine. Note that single engines may share the same underlying accelerator resources as other engines so activity of such an engine may not be indicative of the underlying resource utilization - use $S_ENGINE_GROUP_MEDIA_ALL for that.", + "name": "$S_ENGINE_GROUP_MEDIA_CODEC_SINGLE", + "value": "14", + "version": "1.8" } ], - "name": "$s_overclock_properties_t", - "type": "struct", - "version": "1.5" + "name": "$s_engine_group_t", + "type": "enum" }, { - "class": "$sOverclock", - "desc": "Overclock Control properties", - "details": [ - "Provides all the control capabilities supported by the device for the overclock domain." - ], + "base": "$s_base_properties_t", + "class": "$sEngine", + "desc": "Engine group properties", "members": [ { - "desc": "[out] This provides information about the limits of the control value so that the driver can calculate the set of valid values.", - "name": "MinValue", - "type": "double" + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_ENGINE_PROPERTIES", + "name": "stype", + "type": "$s_structure_type_t" }, { - "desc": "[out] This provides information about the limits of the control value so that the driver can calculate the set of valid values.", - "name": "MaxValue", - "type": "double" + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" }, { - "desc": "[out] This provides information about the limits of the control value so that the driver can calculate the set of valid values.", - "name": "StepValue", - "type": "double" + "desc": "[out] The engine group", + "name": "type", + "type": "$s_engine_group_t" }, { - "desc": "[out] The reference value provides the anchor point, UIs can combine this with the user offset request to show the anticipated improvement.", - "name": "RefValue", - "type": "double" + "desc": "[out] True if this resource is located on a sub-device; false means that the resource is on the device of the calling Sysman handle", + "name": "onSubdevice", + "type": "$x_bool_t" }, { - "desc": "[out] The shipped out-of-box position of this control. Driver can request this value at any time to return to the out-of-box behavior.", - "name": "DefaultValue", - "type": "double" + "desc": "[out] If onSubdevice is true, this gives the ID of the sub-device", + "name": "subdeviceId", + "type": "uint32_t" } ], - "name": "$s_control_property_t", - "type": "struct", - "version": "1.5" + "name": "$s_engine_properties_t", + "type": "struct" }, { - "class": "$sOverclock", - "desc": "Overclock VF properties", + "class": "$sEngine", + "desc": "Engine activity counters", "details": [ - "Provides all the VF capabilities supported by the device for the overclock domain." + "Percent utilization is calculated by taking two snapshots (s1, s2) and using the equation: %util = (s2.activeTime - s1.activeTime) / (s2.timestamp - s1.timestamp)", + "The `activeTime` time units are implementation-specific since the value is only intended to be used for calculating utilization percentage.", + "The `timestamp` should only be used to calculate delta between snapshots of this structure.", + "The application should never take the delta of `timestamp` with the timestamp from a different structure since they are not guaranteed to have the same base.", + "When taking the delta, the difference between `timestamp` samples could be `0`, if the frequency of sampling the snapshots is higher than the frequency of the timestamp update.", + "The absolute value of `timestamp` is only valid during within the application and may be different on the next execution." ], "members": [ { - "desc": "[out] Read the minimum frequency that can be be programmed in the custom V-F point..", - "name": "MinFreq", - "type": "double" - }, - { - "desc": "[out] Read the maximum frequency that can be be programmed in the custom V-F point..", - "name": "MaxFreq", - "type": "double" - }, - { - "desc": "[out] Read the frequency step that can be be programmed in the custom V-F point..", - "name": "StepFreq", - "type": "double" - }, - { - "desc": "[out] Read the minimum voltage that can be be programmed in the custom V-F point..", - "name": "MinVolt", - "type": "double" - }, - { - "desc": "[out] Read the maximum voltage that can be be programmed in the custom V-F point..", - "name": "MaxVolt", - "type": "double" + "desc": "[out] Monotonic counter where the resource is actively running workloads.", + "name": "activeTime", + "type": "uint64_t" }, { - "desc": "[out] Read the voltage step that can be be programmed in the custom V-F point.", - "name": "StepVolt", - "type": "double" + "desc": "[out] Monotonic counter when activeTime counter was sampled.", + "name": "timestamp", + "type": "uint64_t" } ], - "name": "$s_vf_property_t", - "type": "struct", - "version": "1.5" + "name": "$s_engine_stats_t", + "type": "struct" }, { "class": "$sDevice", - "desc": "Set the overclock waiver.The overclock waiver setting is persistent until the next pcode boot", + "desc": "Get handle of engine groups", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "55c493e98932c5d36afcb11a3c43d6ac222932f5e4d8f125bcc5106787e4a320", - "name": "SetOverclockWaiver", + "hash": "25e6a47559c32a64fa8b2e4c45eae905a6ec1127530dcbbeb65637befa658e26", + "name": "EnumEngineGroups", "params": [ { "desc": "[in] Sysman handle of the device.", "name": "hDevice", "type": "$s_device_handle_t" + }, + { + "desc": "[in,out] pointer to the number of components of this type.\nif count is zero, then the driver shall update the value with the total number of components of this type that are available.\nif count is greater than the number of components of this type that are available, then the driver shall update the value with the correct number of components.\n", + "name": "pCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", + "name": "phEngine", + "type": "$s_engine_handle_t*" } ], "returns": [ @@ -69968,33 +84090,32 @@ ] }, { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "This product does not support overclocking" + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCount`" ] } ], - "type": "function", - "version": "1.5" + "type": "function" }, { - "class": "$sDevice", - "desc": "Get the list of supported overclock domains for this device", + "class": "$sEngine", + "desc": "Get engine group properties", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "0d9d47c012a59f1376b1664e436a9a25f3aece1c27faa5827e7e521c9066e5f7", - "name": "GetOverclockDomains", + "hash": "df26d108743e24d58025aaf75554da14e82d69ca34bcebf1578440f7d360d5a6", + "name": "GetProperties", "params": [ { - "desc": "[in] Sysman handle of the device.", - "name": "hDevice", - "type": "$s_device_handle_t" + "desc": "[in] Handle for the component.", + "name": "hEngine", + "type": "$s_engine_handle_t" }, { - "desc": "[in,out] Returns the overclock domains that are supported (a bit for each of enum $s_overclock_domain_t). If no bits are set, the device doesn't support overclocking.", - "name": "pOverclockDomains", - "type": "uint32_t*" + "desc": "[in,out] The properties for the specified engine group.", + "name": "pProperties", + "type": "$s_engine_properties_t*" } ], "returns": [ @@ -70015,47 +84136,37 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDevice`" + "`nullptr == hEngine`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pOverclockDomains`" - ] - }, - { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "Overclocking is not supported on this control domain" + "`nullptr == pProperties`" ] } ], - "type": "function", - "version": "1.5" + "type": "function" }, { - "class": "$sDevice", - "desc": "Get the list of supported overclock controls available for one of the supported overclock domains on the device", + "class": "$sEngine", + "desc": "Get the activity stats for an engine group.", "details": [ + "This function also returns the engine activity inside a Virtual Machine (VM), in the presence of hardware virtualization (SRIOV)", "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "4377753972c5b509120ab9c0d528b6c7428abbbaa4b0eb1c0704a51a7d8c351c", - "name": "GetOverclockControls", + "hash": "b4c7b2006754814930556a754b21e2fd5ee2df9dcbf6aef7521d44488a217f5e", + "name": "GetActivity", "params": [ { - "desc": "[in] Sysman handle of the device.", - "name": "hDevice", - "type": "$s_device_handle_t" - }, - { - "desc": "[in] Domain type.", - "name": "domainType", - "type": "$s_overclock_domain_t" + "desc": "[in] Handle for the component.", + "name": "hEngine", + "type": "$s_engine_handle_t" }, { - "desc": "[in,out] Returns the overclock controls that are supported for the specified overclock domain (a bit for each of enum $s_overclock_control_t).", - "name": "pAvailableControls", - "type": "uint32_t*" + "desc": "[in,out] Will contain a snapshot of the engine group activity counters.", + "name": "pStats", + "type": "$s_engine_stats_t*" } ], "returns": [ @@ -70076,47 +84187,155 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDevice`" + "`nullptr == hEngine`" ] }, { - "$X_RESULT_ERROR_INVALID_ENUMERATION": [ - "`$S_OVERCLOCK_DOMAIN_ADM < domainType`" + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pStats`" ] + } + ], + "type": "function", + "version": "1.7" + }, + { + "desc": "C++ wrapper for a Sysman device engine group", + "members": [ + { + "desc": "[in] handle of Sysman object", + "init": "nullptr", + "name": "handle", + "type": "$s_engine_handle_t" }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pAvailableControls`" - ] + "desc": "[in] pointer to owner object", + "name": "pDevice", + "type": "$sDevice*" + } + ], + "name": "$sEngine", + "owner": "$sDevice", + "type": "class" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - Event management", + "ordinal": 1000, + "type": "header" + }, + "name": "events", + "objects": [ + { + "class": "$sDriver", + "desc": "Event types", + "etors": [ + { + "desc": "Event is triggered when the device is no longer available (due to a reset or being disabled).", + "name": "$S_EVENT_TYPE_FLAG_DEVICE_DETACH", + "value": "$X_BIT(0)" }, { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "Overclocking is not supported on this control domain" - ] + "desc": "Event is triggered after the device is available again.", + "name": "$S_EVENT_TYPE_FLAG_DEVICE_ATTACH", + "value": "$X_BIT(1)" + }, + { + "desc": "Event is triggered when the driver is about to put the device into a deep sleep state", + "name": "$S_EVENT_TYPE_FLAG_DEVICE_SLEEP_STATE_ENTER", + "value": "$X_BIT(2)" + }, + { + "desc": "Event is triggered when the driver is waking the device up from a deep sleep state", + "name": "$S_EVENT_TYPE_FLAG_DEVICE_SLEEP_STATE_EXIT", + "value": "$X_BIT(3)" + }, + { + "desc": "Event is triggered when the frequency starts being throttled", + "name": "$S_EVENT_TYPE_FLAG_FREQ_THROTTLED", + "value": "$X_BIT(4)" + }, + { + "desc": "Event is triggered when the energy consumption threshold is reached (use $sPowerSetEnergyThreshold() to configure).", + "name": "$S_EVENT_TYPE_FLAG_ENERGY_THRESHOLD_CROSSED", + "value": "$X_BIT(5)" + }, + { + "desc": "Event is triggered when the critical temperature is reached (use $sTemperatureSetConfig() to configure - disabled by default).", + "name": "$S_EVENT_TYPE_FLAG_TEMP_CRITICAL", + "value": "$X_BIT(6)" + }, + { + "desc": "Event is triggered when the temperature crosses threshold 1 (use $sTemperatureSetConfig() to configure - disabled by default).", + "name": "$S_EVENT_TYPE_FLAG_TEMP_THRESHOLD1", + "value": "$X_BIT(7)" + }, + { + "desc": "Event is triggered when the temperature crosses threshold 2 (use $sTemperatureSetConfig() to configure - disabled by default).", + "name": "$S_EVENT_TYPE_FLAG_TEMP_THRESHOLD2", + "value": "$X_BIT(8)" + }, + { + "desc": "Event is triggered when the health of device memory changes.", + "name": "$S_EVENT_TYPE_FLAG_MEM_HEALTH", + "value": "$X_BIT(9)" + }, + { + "desc": "Event is triggered when the health of fabric ports change.", + "name": "$S_EVENT_TYPE_FLAG_FABRIC_PORT_HEALTH", + "value": "$X_BIT(10)" + }, + { + "desc": "Event is triggered when the health of the PCI link changes.", + "name": "$S_EVENT_TYPE_FLAG_PCI_LINK_HEALTH", + "value": "$X_BIT(11)" + }, + { + "desc": "Event is triggered when accelerator RAS correctable errors cross thresholds (use $sRasSetConfig() to configure - disabled by default).", + "name": "$S_EVENT_TYPE_FLAG_RAS_CORRECTABLE_ERRORS", + "value": "$X_BIT(12)" + }, + { + "desc": "Event is triggered when accelerator RAS uncorrectable errors cross thresholds (use $sRasSetConfig() to configure - disabled by default).", + "name": "$S_EVENT_TYPE_FLAG_RAS_UNCORRECTABLE_ERRORS", + "value": "$X_BIT(13)" + }, + { + "desc": "Event is triggered when the device needs to be reset (use $sDeviceGetState() to determine the reasons for the reset).", + "name": "$S_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED", + "value": "$X_BIT(14)" + }, + { + "desc": "Event is triggered when graphics driver encounter an error condition.", + "name": "$S_EVENT_TYPE_FLAG_SURVIVABILITY_MODE_DETECTED", + "value": "$X_BIT(15)", + "version": "1.9" } ], - "type": "function", - "version": "1.5" + "name": "$s_event_type_flags_t", + "type": "enum" }, { "class": "$sDevice", - "desc": "Reset all overclock settings to default values (shipped = 1 or manufacturing =0)", + "desc": "Specify the list of events to listen to for a given device", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "7318489a5a2134bc3f0789ac6ae8a5f1712f4d71314cbb846d6d0260eae1b474", - "name": "ResetOverclockSettings", + "hash": "26fc8939c3a29505329de969535a2946e59d9e03b312a2da336655b503bc9f28", + "name": "EventRegister", "params": [ { - "desc": "[in] Sysman handle of the device.", + "desc": "[in] The device handle.", "name": "hDevice", "type": "$s_device_handle_t" }, { - "desc": "[in] True will reset to shipped state; false will reset to manufacturing state", - "name": "onShippedState", - "type": "$x_bool_t" + "desc": "[in] List of events to listen to.", + "name": "events", + "type": "$s_event_type_flags_t" } ], "returns": [ @@ -70141,53 +84360,53 @@ ] }, { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "Overclocking is not supported on this control domain" + "$X_RESULT_ERROR_INVALID_ENUMERATION": [ + "`0xffff < events`" ] } ], - "type": "function", - "version": "1.5" + "type": "function" }, { - "class": "$sDevice", - "desc": "Determine the state of overclocking", + "class": "$sDriver", + "decl": "static", + "desc": "Wait for events to be received from a one or more devices.", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "bf83d33d94f9f7a4212f5acf692aa525675b4ae890259e8e179069c1a95c83e2", - "name": "ReadOverclockState", + "hash": "b00de872443c97d166cd17f0042a606d264fb05f1b2ce96a3203bef5552dc652", + "name": "EventListen", "params": [ { - "desc": "[in] Sysman handle of the device.", - "name": "hDevice", - "type": "$s_device_handle_t" + "desc": "[in] handle of the driver instance", + "name": "hDriver", + "type": "$x_driver_handle_t" }, { - "desc": "[out] One of overclock mode.", - "name": "pOverclockMode", - "type": "$s_overclock_mode_t*" + "desc": "[in] if non-zero, then indicates the maximum time (in milliseconds) to yield before returning $X_RESULT_SUCCESS or $X_RESULT_NOT_READY;\nif zero, then will check status and return immediately;\nif `UINT32_MAX`, then function will not return until events arrive.\n", + "name": "timeout", + "type": "uint32_t" }, { - "desc": "[out] Waiver setting: 0 = Waiver not set, 1 = waiver has been set.", - "name": "pWaiverSetting", - "type": "$x_bool_t*" + "desc": "[in] Number of device handles in phDevices.", + "name": "count", + "type": "uint32_t" }, { - "desc": "[out] Current settings 0 =manufacturing state, 1= shipped state)..", - "name": "pOverclockState", - "type": "$x_bool_t*" + "desc": "[in][range(0, count)] Device handles to listen to for events. Only devices from the provided driver handle can be specified in this list.", + "name": "phDevices", + "type": "$s_device_handle_t*" }, { - "desc": "[out] This enum is returned when the driver attempts to set an overclock control or reset overclock settings.", - "name": "pPendingAction", - "type": "$s_pending_action_t*" + "desc": "[in,out] Will contain the actual number of devices in phDevices that generated events. If non-zero, check pEvents to determine the devices and events that were received.", + "name": "pNumDeviceEvents", + "type": "uint32_t*" }, { - "desc": "[out] Pending reset 0 =manufacturing state, 1= shipped state)..", - "name": "pPendingReset", - "type": "$x_bool_t*" + "desc": "[in,out] An array that will continue the list of events for each device listened in phDevices.\nThis array must be at least as big as count.\nFor every device handle in phDevices, this will provide the events that occurred for that device at the same position in this array. If no event was received for a given device, the corresponding array entry will be zero.\n", + "name": "pEvents", + "type": "$s_event_type_flags_t*" } ], "returns": [ @@ -70208,51 +84427,69 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDevice`" + "`nullptr == hDriver`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pOverclockMode`", - "`nullptr == pWaiverSetting`", - "`nullptr == pOverclockState`", - "`nullptr == pPendingAction`", - "`nullptr == pPendingReset`" + "`nullptr == phDevices`", + "`nullptr == pNumDeviceEvents`", + "`nullptr == pEvents`" ] }, { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "Overclocking is not supported on this control domain" + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "User does not have permissions to listen to events." + ] + }, + { + "$X_RESULT_ERROR_INVALID_ARGUMENT": [ + "One or more of the supplied device handles belongs to a different driver." ] } ], - "type": "function", - "version": "1.5" + "type": "function" }, { - "class": "$sDevice", - "desc": "Get handle of overclock domains", + "class": "$sDriver", + "decl": "static", + "desc": "Wait for events to be received from a one or more devices.", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "4b879a76b3b04fde6760e7c52a1df27690607bd6f77d8eefa431bfe0bde261db", - "name": "EnumOverclockDomains", + "hash": "60aaa2b499d532b22ccc6b5ce05ee5e7008c45c69550bd6c1f6e3010e6cffc01", + "name": "EventListenEx", "params": [ { - "desc": "[in] Sysman handle of the device.", - "name": "hDevice", - "type": "$s_device_handle_t" + "desc": "[in] handle of the driver instance", + "name": "hDriver", + "type": "$x_driver_handle_t" }, { - "desc": "[in,out] pointer to the number of components of this type.\nif count is zero, then the driver shall update the value with the total number of components of this type that are available.\nif count is greater than the number of components of this type that are available, then the driver shall update the value with the correct number of components.\n", - "name": "pCount", + "desc": "[in] if non-zero, then indicates the maximum time (in milliseconds) to yield before returning $X_RESULT_SUCCESS or $X_RESULT_NOT_READY;\nif zero, then will check status and return immediately;\nif `UINT64_MAX`, then function will not return until events arrive.\n", + "name": "timeout", + "type": "uint64_t" + }, + { + "desc": "[in] Number of device handles in phDevices.", + "name": "count", + "type": "uint32_t" + }, + { + "desc": "[in][range(0, count)] Device handles to listen to for events. Only devices from the provided driver handle can be specified in this list.", + "name": "phDevices", + "type": "$s_device_handle_t*" + }, + { + "desc": "[in,out] Will contain the actual number of devices in phDevices that generated events. If non-zero, check pEvents to determine the devices and events that were received.", + "name": "pNumDeviceEvents", "type": "uint32_t*" }, { - "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", - "name": "phDomainHandle", - "type": "$s_overclock_handle_t*" + "desc": "[in,out] An array that will continue the list of events for each device listened in phDevices.\nThis array must be at least as big as count.\nFor every device handle in phDevices, this will provide the events that occurred for that device at the same position in this array. If no event was received for a given device, the corresponding array entry will be zero.\n", + "name": "pEvents", + "type": "$s_event_type_flags_t*" } ], "returns": [ @@ -70273,357 +84510,406 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDevice`" + "`nullptr == hDriver`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pCount`" + "`nullptr == phDevices`", + "`nullptr == pNumDeviceEvents`", + "`nullptr == pEvents`" ] - } - ], - "type": "function", - "version": "1.5" - }, - { - "class": "$sOverclock", - "desc": "Get overclock domain control properties", - "details": [ - "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." - ], - "hash": "416c9b4d0a45ce8cef79a8367a0d9e5a23de228774dbf59a5c06a7af0ce6e325", - "name": "GetDomainProperties", - "params": [ + }, { - "desc": "[in] Handle for the component domain.", - "name": "hDomainHandle", - "type": "$s_overclock_handle_t" + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "User does not have permissions to listen to events." + ] }, { - "desc": "[in,out] The overclock properties for the specified domain.", - "name": "pDomainProperties", - "type": "$s_overclock_properties_t*" + "$X_RESULT_ERROR_INVALID_ARGUMENT": [ + "One or more of the supplied device handles belongs to a different driver." + ] } ], - "returns": [ - { - "$X_RESULT_SUCCESS": [] - }, - { - "$X_RESULT_ERROR_UNINITIALIZED": [] - }, - { - "$X_RESULT_ERROR_DEVICE_LOST": [] - }, + "type": "function", + "version": "1.1" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - Firmware management", + "ordinal": 1000, + "type": "header" + }, + "name": "fabric", + "objects": [ + { + "desc": "Maximum Fabric port model string size", + "name": "$S_MAX_FABRIC_PORT_MODEL_SIZE", + "type": "macro", + "value": "256" + }, + { + "desc": "Maximum size of the buffer that will return information about link types", + "name": "$S_MAX_FABRIC_LINK_TYPE_SIZE", + "type": "macro", + "value": "256" + }, + { + "class": "$sFabricPort", + "desc": "Fabric port status", + "etors": [ { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "desc": "The port status cannot be determined", + "name": "$S_FABRIC_PORT_STATUS_UNKNOWN", + "value": "0" }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + "desc": "The port is up and operating as expected", + "name": "$S_FABRIC_PORT_STATUS_HEALTHY", + "value": "1" }, { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDomainHandle`" - ] + "desc": "The port is up but has quality and/or speed degradation", + "name": "$S_FABRIC_PORT_STATUS_DEGRADED", + "value": "2" }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pDomainProperties`" - ] + "desc": "Port connection instabilities are preventing workloads making forward progress", + "name": "$S_FABRIC_PORT_STATUS_FAILED", + "value": "3" }, { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "Overclocking is not supported on this control domain" - ] + "desc": "The port is configured down", + "name": "$S_FABRIC_PORT_STATUS_DISABLED", + "value": "4" } ], - "type": "function", - "version": "1.5" + "name": "$s_fabric_port_status_t", + "type": "enum" }, { - "class": "$sOverclock", - "desc": "Read overclock VF min,max and step values", - "details": [ - "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." - ], - "hash": "899c590948448590df0ce9f6d0767f769d4f1480b939a30cc769cc07f80315c4", - "name": "GetDomainVFProperties", - "params": [ + "class": "$sFabricPort", + "desc": "Fabric port quality degradation reasons", + "etors": [ { - "desc": "[in] Handle for the component domain.", - "name": "hDomainHandle", - "type": "$s_overclock_handle_t" + "desc": "Excessive link errors are occurring", + "name": "$S_FABRIC_PORT_QUAL_ISSUE_FLAG_LINK_ERRORS", + "value": "$X_BIT(0)" }, { - "desc": "[in,out] The VF min,max,step for a specified domain.", - "name": "pVFProperties", - "type": "$s_vf_property_t*" + "desc": "There is a degradation in the bitrate and/or width of the link", + "name": "$S_FABRIC_PORT_QUAL_ISSUE_FLAG_SPEED", + "value": "$X_BIT(1)" } ], - "returns": [ - { - "$X_RESULT_SUCCESS": [] - }, - { - "$X_RESULT_ERROR_UNINITIALIZED": [] - }, - { - "$X_RESULT_ERROR_DEVICE_LOST": [] - }, - { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] - }, - { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] - }, + "name": "$s_fabric_port_qual_issue_flags_t", + "type": "enum" + }, + { + "class": "$sFabricPort", + "desc": "Fabric port failure reasons", + "etors": [ { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDomainHandle`" - ] + "desc": "A previously operating link has failed. Hardware will automatically retrain this port. This state will persist until either the physical connection is removed or the link trains successfully.", + "name": "$S_FABRIC_PORT_FAILURE_FLAG_FAILED", + "value": "$X_BIT(0)" }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pVFProperties`" - ] + "desc": "A connection has not been established within an expected time. Hardware will continue to attempt port training. This status will persist until either the physical connection is removed or the link successfully trains.", + "name": "$S_FABRIC_PORT_FAILURE_FLAG_TRAINING_TIMEOUT", + "value": "$X_BIT(1)" }, { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "Overclocking is not supported on this control domain" - ] + "desc": "Port has excessively trained and then transitioned down for some period of time. Driver will allow port to continue to train, but will not enable the port for use until the port has been disabled and subsequently re-enabled using $sFabricPortSetConfig().", + "name": "$S_FABRIC_PORT_FAILURE_FLAG_FLAPPING", + "value": "$X_BIT(2)" } ], - "type": "function", - "version": "1.5" + "name": "$s_fabric_port_failure_flags_t", + "type": "enum" }, { - "class": "$sOverclock", - "desc": "Read overclock control values - min/max/step/default/ref", + "class": "$sFabricPort", + "desc": "Unique identifier for a fabric port", "details": [ - "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "This not a universal identifier. The identified is garanteed to be unique for the current hardware configuration of the system. Changes in the hardware may result in a different identifier for a given port.", + "The main purpose of this identifier to build up an instantaneous topology map of system connectivity. An application should enumerate all fabric ports and match the `remotePortId` member of $s_fabric_port_state_t to the `portId` member of $s_fabric_port_properties_t." ], - "hash": "cade6249e729096d63ce08310fd878151a968afa8abc580980d5c258a9ec48fb", - "name": "GetDomainControlProperties", - "params": [ + "members": [ { - "desc": "[in] Handle for the component domain.", - "name": "hDomainHandle", - "type": "$s_overclock_handle_t" + "desc": "[out] Unique identifier for the fabric end-point", + "name": "fabricId", + "type": "uint32_t" }, { - "desc": "[in] Handle for the component.", - "name": "DomainControl", - "type": "$s_overclock_control_t" + "desc": "[out] Unique identifier for the device attachment point", + "name": "attachId", + "type": "uint32_t" }, { - "desc": "[in,out] overclock control values.", - "name": "pControlProperties", - "type": "$s_control_property_t*" + "desc": "[out] The logical port number (this is typically marked somewhere on the physical device)", + "name": "portNumber", + "type": "uint8_t" } ], - "returns": [ + "name": "$s_fabric_port_id_t", + "type": "struct" + }, + { + "class": "$sFabricPort", + "desc": "Fabric port speed in one direction", + "members": [ { - "$X_RESULT_SUCCESS": [] + "desc": "[out] Bits/sec that the link is operating at. A value of -1 means that this property is unknown.", + "name": "bitRate", + "type": "int64_t" }, { - "$X_RESULT_ERROR_UNINITIALIZED": [] + "desc": "[out] The number of lanes. A value of -1 means that this property is unknown.", + "name": "width", + "type": "int32_t" + } + ], + "name": "$s_fabric_port_speed_t", + "type": "struct" + }, + { + "base": "$s_base_properties_t", + "class": "$sFabricPort", + "desc": "Fabric port properties", + "members": [ + { + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES", + "name": "stype", + "type": "$s_structure_type_t" }, { - "$X_RESULT_ERROR_DEVICE_LOST": [] + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" }, { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "desc": "[out] Description of port technology. Will be set to the string \"unkown\" if this cannot be determined for this port.", + "name": "model[$S_MAX_FABRIC_PORT_MODEL_SIZE]", + "type": "char" }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + "desc": "[out] True if the port is located on a sub-device; false means that the port is on the device of the calling Sysman handle", + "name": "onSubdevice", + "type": "$x_bool_t" }, { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDomainHandle`" - ] + "desc": "[out] If onSubdevice is true, this gives the ID of the sub-device", + "name": "subdeviceId", + "type": "uint32_t" }, { - "$X_RESULT_ERROR_INVALID_ENUMERATION": [ - "`$S_OVERCLOCK_CONTROL_ACM_DISABLE < DomainControl`" - ] + "desc": "[out] The unique port identifier", + "name": "portId", + "type": "$s_fabric_port_id_t" }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pControlProperties`" - ] + "desc": "[out] Maximum speed supported by the receive side of the port (sum of all lanes)", + "name": "maxRxSpeed", + "type": "$s_fabric_port_speed_t" }, { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "Overclocking is not supported on this control domain" - ] + "desc": "[out] Maximum speed supported by the transmit side of the port (sum of all lanes)", + "name": "maxTxSpeed", + "type": "$s_fabric_port_speed_t" } ], - "type": "function", - "version": "1.5" + "name": "$s_fabric_port_properties_t", + "type": "struct" }, { - "class": "$sOverclock", - "desc": "Read the current value for a given overclock control", - "details": [ - "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "class": "$sFabricPort", + "desc": "Provides information about the fabric link attached to a port", + "members": [ + { + "desc": "[out] Description of link technology. Will be set to the string \"unkown\" if this cannot be determined for this link.", + "name": "desc[$S_MAX_FABRIC_LINK_TYPE_SIZE]", + "type": "char" + } ], - "hash": "d9b4cc3a89e0a244a5748ef773a56340b963b51a15ff79e6e84a53598a2a8e06", - "name": "GetControlCurrentValue", - "params": [ + "name": "$s_fabric_link_type_t", + "type": "struct" + }, + { + "base": "$s_base_config_t", + "class": "$sFabricPort", + "desc": "Fabric port configuration", + "members": [ { - "desc": "[in] Handle for the component.", - "name": "hDomainHandle", - "type": "$s_overclock_handle_t" + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_FABRIC_PORT_CONFIG", + "name": "stype", + "type": "$s_structure_type_t" }, { - "desc": "[in] Overclock Control.", - "name": "DomainControl", - "type": "$s_overclock_control_t" + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" }, { - "desc": "[in,out] Getting overclock control value for the specified control.", - "name": "pValue", - "type": "double*" + "desc": "[in,out] Port is configured up/down", + "name": "enabled", + "type": "$x_bool_t" + }, + { + "desc": "[in,out] Beaconing is configured on/off", + "name": "beaconing", + "type": "$x_bool_t" } ], - "returns": [ - { - "$X_RESULT_SUCCESS": [] - }, + "name": "$s_fabric_port_config_t", + "type": "struct" + }, + { + "base": "$s_base_state_t", + "class": "$sFabricPort", + "desc": "Fabric port state", + "members": [ { - "$X_RESULT_ERROR_UNINITIALIZED": [] + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_FABRIC_PORT_STATE", + "name": "stype", + "type": "$s_structure_type_t" }, { - "$X_RESULT_ERROR_DEVICE_LOST": [] + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" }, { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "desc": "[out] The current status of the port", + "name": "status", + "type": "$s_fabric_port_status_t" }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + "desc": "[out] If status is $S_FABRIC_PORT_STATUS_DEGRADED,\nthen this gives a combination of $s_fabric_port_qual_issue_flag_t for quality issues that have been detected;\notherwise, 0 indicates there are no quality issues with the link at this time.\n", + "name": "qualityIssues", + "type": "$s_fabric_port_qual_issue_flags_t" }, { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDomainHandle`" - ] + "desc": "[out] If status is $S_FABRIC_PORT_STATUS_FAILED,\nthen this gives a combination of $s_fabric_port_failure_flag_t for reasons for the connection instability;\notherwise, 0 indicates there are no connection stability issues at this time.\n", + "name": "failureReasons", + "type": "$s_fabric_port_failure_flags_t" }, { - "$X_RESULT_ERROR_INVALID_ENUMERATION": [ - "`$S_OVERCLOCK_CONTROL_ACM_DISABLE < DomainControl`" - ] + "desc": "[out] The unique port identifier for the remote connection point if status is $S_FABRIC_PORT_STATUS_HEALTHY, $S_FABRIC_PORT_STATUS_DEGRADED or $S_FABRIC_PORT_STATUS_FAILED", + "name": "remotePortId", + "type": "$s_fabric_port_id_t" }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pValue`" - ] + "desc": "[out] Current maximum receive speed (sum of all lanes)", + "name": "rxSpeed", + "type": "$s_fabric_port_speed_t" }, { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "Overclocking is not supported on this control domain" - ] + "desc": "[out] Current maximum transmit speed (sum of all lanes)", + "name": "txSpeed", + "type": "$s_fabric_port_speed_t" } ], - "type": "function", - "version": "1.5" + "name": "$s_fabric_port_state_t", + "type": "struct" }, { - "class": "$sOverclock", - "desc": "Read the the reset pending value for a given overclock control", - "details": [ - "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." - ], - "hash": "9ba2bc75c2454afb04fa795e698945acb130400573382ae99ebf3105a50b4f27", - "name": "GetControlPendingValue", - "params": [ + "class": "$sFabricPort", + "desc": "Fabric port throughput.", + "members": [ { - "desc": "[in] Handle for the component domain.", - "name": "hDomainHandle", - "type": "$s_overclock_handle_t" + "desc": "[out] Monotonic timestamp counter in microseconds when the measurement was made.\nThis timestamp should only be used to calculate delta time between snapshots of this structure.\nNever take the delta of this timestamp with the timestamp from a different structure since they are not guaranteed to have the same base.\nThe absolute value of the timestamp is only valid during within the application and may be different on the next execution.\n", + "name": "timestamp", + "type": "uint64_t" }, { - "desc": "[in] Overclock Control.", - "name": "DomainControl", - "type": "$s_overclock_control_t" + "desc": "[out] Monotonic counter for the number of bytes received (sum of all lanes). This includes all protocol overhead, not only the GPU traffic.", + "name": "rxCounter", + "type": "uint64_t" }, { - "desc": "[out] Returns the pending value for a given control. The units and format of the value depend on the control type.", - "name": "pValue", - "type": "double*" + "desc": "[out] Monotonic counter for the number of bytes transmitted (sum of all lanes). This includes all protocol overhead, not only the GPU traffic.", + "name": "txCounter", + "type": "uint64_t" } ], - "returns": [ - { - "$X_RESULT_SUCCESS": [] - }, - { - "$X_RESULT_ERROR_UNINITIALIZED": [] - }, - { - "$X_RESULT_ERROR_DEVICE_LOST": [] - }, + "name": "$s_fabric_port_throughput_t", + "type": "struct" + }, + { + "base": "$s_base_properties_t", + "class": "$sFabricPort", + "desc": "Fabric Port Error Counters", + "members": [ { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_FABRIC_PORT_ERROR_COUNTERS", + "name": "stype", + "type": "$s_structure_type_t" }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" }, { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDomainHandle`" - ] + "desc": "[out] Link Failure Error Count reported per port", + "name": "linkFailureCount", + "type": "uint64_t" }, { - "$X_RESULT_ERROR_INVALID_ENUMERATION": [ - "`$S_OVERCLOCK_CONTROL_ACM_DISABLE < DomainControl`" - ] + "desc": "[out] Firmware Communication Error Count reported per device", + "name": "fwCommErrorCount", + "type": "uint64_t" }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pValue`" - ] + "desc": "[out] Firmware reported Error Count reported per device", + "name": "fwErrorCount", + "type": "uint64_t" }, { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "Overclocking is not supported on this control domain" - ] + "desc": "[out] Link Degrade Error Count reported per port", + "name": "linkDegradeCount", + "type": "uint64_t" } ], - "type": "function", - "version": "1.5" + "name": "$s_fabric_port_error_counters_t", + "type": "struct", + "version": "1.7" }, { - "class": "$sOverclock", - "desc": "Set the value for a given overclock control", + "class": "$sDevice", + "desc": "Get handle of Fabric ports in a device", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "dfbb3911b91acb313aa7d4bb72ebd08d0183a56b5663f5f44ea114b83270ac10", - "name": "SetControlUserValue", + "hash": "f8b22e29f845c563af633d8a69c44bcecceda14be9ca6c0151d348a192c5f7ff", + "name": "EnumFabricPorts", "params": [ { - "desc": "[in] Handle for the component domain.", - "name": "hDomainHandle", - "type": "$s_overclock_handle_t" - }, - { - "desc": "[in] Domain Control.", - "name": "DomainControl", - "type": "$s_overclock_control_t" + "desc": "[in] Sysman handle of the device.", + "name": "hDevice", + "type": "$s_device_handle_t" }, { - "desc": "[in] The new value of the control. The units and format of the value depend on the control type.", - "name": "pValue", - "type": "double" + "desc": "[in,out] pointer to the number of components of this type.\nif count is zero, then the driver shall update the value with the total number of components of this type that are available.\nif count is greater than the number of components of this type that are available, then the driver shall update the value with the correct number of components.\n", + "name": "pCount", + "type": "uint32_t*" }, { - "desc": "[out] Pending overclock setting.", - "name": "pPendingAction", - "type": "$s_pending_action_t*" + "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", + "name": "phPort", + "type": "$s_fabric_port_handle_t*" } ], "returns": [ @@ -70644,57 +84930,36 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDomainHandle`" - ] - }, - { - "$X_RESULT_ERROR_INVALID_ENUMERATION": [ - "`$S_OVERCLOCK_CONTROL_ACM_DISABLE < DomainControl`" + "`nullptr == hDevice`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pPendingAction`" - ] - }, - { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "Overclocking is not supported on this control domain" + "`nullptr == pCount`" ] } ], - "type": "function", - "version": "1.5" + "type": "function" }, { - "class": "$sOverclock", - "desc": "Determine the state of an overclock control", + "class": "$sFabricPort", + "desc": "Get Fabric port properties", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "f6955ca25e09f286e83af378e9b44a83ee85177ef351898262df6df3bf834e58", - "name": "GetControlState", + "hash": "ea925c2484ecfb42a7ff5ac43d9d1d5317c3c0eac0b00b153eecbb1025a2a12f", + "name": "GetProperties", "params": [ { - "desc": "[in] Handle for the component domain.", - "name": "hDomainHandle", - "type": "$s_overclock_handle_t" - }, - { - "desc": "[in] Domain Control.", - "name": "DomainControl", - "type": "$s_overclock_control_t" - }, - { - "desc": "[out] Current overclock control state.", - "name": "pControlState", - "type": "$s_control_state_t*" + "desc": "[in] Handle for the component.", + "name": "hPort", + "type": "$s_fabric_port_handle_t" }, { - "desc": "[out] Pending overclock setting.", - "name": "pPendingAction", - "type": "$s_pending_action_t*" + "desc": "[in,out] Will contain properties of the Fabric Port.", + "name": "pProperties", + "type": "$s_fabric_port_properties_t*" } ], "returns": [ @@ -70715,63 +84980,36 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDomainHandle`" - ] - }, - { - "$X_RESULT_ERROR_INVALID_ENUMERATION": [ - "`$S_OVERCLOCK_CONTROL_ACM_DISABLE < DomainControl`" + "`nullptr == hPort`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pControlState`", - "`nullptr == pPendingAction`" - ] - }, - { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "Overclocking is not supported on this control domain" + "`nullptr == pProperties`" ] } - ], - "type": "function", - "version": "1.5" - }, - { - "class": "$sOverclock", - "desc": "Read the frequency or voltage of a V-F point from the default or custom V-F curve.", - "details": [ - "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." - ], - "hash": "8b56f4fb8f854cf65406481cf251f0a09fd6ab09ae35df9a0d8a7362529153a8", - "name": "GetVFPointValues", - "params": [ - { - "desc": "[in] Handle for the component domain.", - "name": "hDomainHandle", - "type": "$s_overclock_handle_t" - }, - { - "desc": "[in] Voltage or Freqency point to read.", - "name": "VFType", - "type": "$s_vf_type_t" - }, - { - "desc": "[in] User,Default or Live VF array to read from", - "name": "VFArrayType", - "type": "$s_vf_array_type_t" - }, + ], + "type": "function" + }, + { + "class": "$sFabricPort", + "desc": "Get Fabric port link type", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "ded4dbd69e173ddcbb1a8dfa0aa5d9c019a40c71a09ab024e055ef4dbbad1ca0", + "name": "GetLinkType", + "params": [ { - "desc": "[in] Point index - number between (0, max_num_points - 1).", - "name": "PointIndex", - "type": "uint32_t" + "desc": "[in] Handle for the component.", + "name": "hPort", + "type": "$s_fabric_port_handle_t" }, { - "desc": "[out] Returns the frequency in 1kHz units or voltage in millivolt units from the custom V-F curve at the specified zero-based index ", - "name": "PointValue", - "type": "uint32_t*" + "desc": "[in,out] Will contain details about the link attached to the Fabric port.", + "name": "pLinkType", + "type": "$s_fabric_link_type_t*" } ], "returns": [ @@ -70792,58 +85030,36 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDomainHandle`" - ] - }, - { - "$X_RESULT_ERROR_INVALID_ENUMERATION": [ - "`$S_VF_TYPE_FREQ < VFType`", - "`$S_VF_ARRAY_TYPE_LIVE_VF_ARRAY < VFArrayType`" + "`nullptr == hPort`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == PointValue`" - ] - }, - { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "Overclocking is not supported on this control domain" + "`nullptr == pLinkType`" ] } ], - "type": "function", - "version": "1.5" + "type": "function" }, { - "class": "$sOverclock", - "desc": "Write the frequency or voltage of a V-F point to custom V-F curve.", + "class": "$sFabricPort", + "desc": "Get Fabric port configuration", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "8bb361cef11696f36f541cac2d919f200cf453261bc940ec647786681f425e9c", - "name": "SetVFPointValues", + "hash": "9b752ed8f8cb948b4bc79d6e0e9a013e741232e239086a6095d66f75aa1ff9ab", + "name": "GetConfig", "params": [ { - "desc": "[in] Handle for the component domain.", - "name": "hDomainHandle", - "type": "$s_overclock_handle_t" - }, - { - "desc": "[in] Voltage or Freqency point to read.", - "name": "VFType", - "type": "$s_vf_type_t" - }, - { - "desc": "[in] Point index - number between (0, max_num_points - 1).", - "name": "PointIndex", - "type": "uint32_t" + "desc": "[in] Handle for the component.", + "name": "hPort", + "type": "$s_fabric_port_handle_t" }, { - "desc": "[in] Writes frequency in 1kHz units or voltage in millivolt units to custom V-F curve at the specified zero-based index ", - "name": "PointValue", - "type": "uint32_t" + "desc": "[in,out] Will contain configuration of the Fabric Port.", + "name": "pConfig", + "type": "$s_fabric_port_config_t*" } ], "returns": [ @@ -70864,176 +85080,91 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDomainHandle`" - ] - }, - { - "$X_RESULT_ERROR_INVALID_ENUMERATION": [ - "`$S_VF_TYPE_FREQ < VFType`" + "`nullptr == hPort`" ] }, { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "Overclocking is not supported on this control domain" + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pConfig`" ] } ], - "type": "function", - "version": "1.5" + "type": "function" }, { - "desc": "C++ wrapper for a Sysman device overclock domain", - "members": [ - { - "desc": "[in] handle of Sysman object", - "init": "nullptr", - "name": "handle", - "type": "$s_overclock_handle_t" - }, - { - "desc": "[in] pointer to owner object", - "name": "pDevice", - "type": "$sDevice*" - } + "class": "$sFabricPort", + "desc": "Set Fabric port configuration", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." ], - "name": "$sOverclock", - "owner": "$sDevice", - "type": "class", - "version": "1.5" - } - ] - }, - { - "header": { - "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - Firmware management", - "ordinal": 1000, - "type": "header" - }, - "name": "diagnostics", - "objects": [ - { - "class": "$sDiagnostics", - "desc": "Diagnostic results", - "etors": [ - { - "desc": "Diagnostic completed without finding errors to repair", - "name": "$S_DIAG_RESULT_NO_ERRORS", - "value": "0" - }, - { - "desc": "Diagnostic had problems running tests", - "name": "$S_DIAG_RESULT_ABORT", - "value": "1" - }, + "hash": "42192be3f94acb29b90f3c2405d35dc74ef538f272549e9127f112946a2a9884", + "name": "SetConfig", + "params": [ { - "desc": "Diagnostic had problems setting up repairs", - "name": "$S_DIAG_RESULT_FAIL_CANT_REPAIR", - "value": "2" + "desc": "[in] Handle for the component.", + "name": "hPort", + "type": "$s_fabric_port_handle_t" }, { - "desc": "Diagnostics found errors, setup for repair and reboot is required to complete the process", - "name": "$S_DIAG_RESULT_REBOOT_FOR_REPAIR", - "value": "3" + "desc": "[in] Contains new configuration of the Fabric Port.", + "name": "pConfig", + "type": "const $s_fabric_port_config_t*" } ], - "name": "$s_diag_result_t", - "type": "enum" - }, - { - "desc": "Diagnostic test index to use for the very first test.", - "name": "$S_DIAG_FIRST_TEST_INDEX", - "type": "macro", - "value": "0x0" - }, - { - "desc": "Diagnostic test index to use for the very last test.", - "name": "$S_DIAG_LAST_TEST_INDEX", - "type": "macro", - "value": "0xFFFFFFFF" - }, - { - "class": "$sDiagnostics", - "desc": "Diagnostic test", - "members": [ + "returns": [ { - "desc": "[out] Index of the test", - "name": "index", - "type": "uint32_t" + "$X_RESULT_SUCCESS": [] }, { - "desc": "[out] Name of the test", - "name": "name[$S_STRING_PROPERTY_SIZE]", - "type": "char" - } - ], - "name": "$s_diag_test_t", - "type": "struct" - }, - { - "base": "$s_base_properties_t", - "class": "$sDiagnostics", - "desc": "Diagnostics test suite properties", - "members": [ + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, { - "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_DIAG_PROPERTIES", - "name": "stype", - "type": "$s_structure_type_t" + "$X_RESULT_ERROR_DEVICE_LOST": [] }, { - "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "void*" + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] }, { - "desc": "[out] True if the resource is located on a sub-device; false means that the resource is on the device of the calling Sysman handle", - "name": "onSubdevice", - "type": "$x_bool_t" + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] }, { - "desc": "[out] If onSubdevice is true, this gives the ID of the sub-device", - "name": "subdeviceId", - "type": "uint32_t" + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hPort`" + ] }, { - "desc": "[out] Name of the diagnostics test suite", - "name": "name[$S_STRING_PROPERTY_SIZE]", - "type": "char" + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pConfig`" + ] }, { - "desc": "[out] Indicates if this test suite has individual tests which can be run separately (use the function $sDiagnosticsGetTests() to get the list of these tests)", - "name": "haveTests", - "type": "$x_bool_t" + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "User does not have permissions to make these modifications." + ] } ], - "name": "$s_diag_properties_t", - "type": "struct" + "type": "function" }, { - "class": "$sDevice", - "desc": "Get handle of diagnostics test suites", + "class": "$sFabricPort", + "desc": "Get Fabric port state - status (health/degraded/failed/disabled), reasons for link degradation or instability, current rx/tx speed", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "59ed350ef7e70b37e52550c3ab609f5379d8b887c910db4babc51892f01acaed", - "name": "EnumDiagnosticTestSuites", + "hash": "3739f03de8c9a2903fff758a13d5837ea02e4af8855c832f298fadb60c5b2924", + "name": "GetState", "params": [ { - "desc": "[in] Sysman handle of the device.", - "name": "hDevice", - "type": "$s_device_handle_t" - }, - { - "desc": "[in,out] pointer to the number of components of this type.\nif count is zero, then the driver shall update the value with the total number of components of this type that are available.\nif count is greater than the number of components of this type that are available, then the driver shall update the value with the correct number of components.\n", - "name": "pCount", - "type": "uint32_t*" + "desc": "[in] Handle for the component.", + "name": "hPort", + "type": "$s_fabric_port_handle_t" }, { - "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", - "name": "phDiagnostics", - "type": "$s_diag_handle_t*" + "desc": "[in,out] Will contain the current state of the Fabric Port", + "name": "pState", + "type": "$s_fabric_port_state_t*" } ], "returns": [ @@ -71054,36 +85185,36 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDevice`" + "`nullptr == hPort`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pCount`" + "`nullptr == pState`" ] } ], "type": "function" }, { - "class": "$sDiagnostics", - "desc": "Get properties of a diagnostics test suite", + "class": "$sFabricPort", + "desc": "Get Fabric port throughput", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "3388b8e374bf55f17c6ed5c46ec293e7e127397ad28a759037eb3865c8c4021c", - "name": "GetProperties", + "hash": "b624dbb1f8e689bd83898f312af1283e0d67d3606e5440a6dbff6351ab6556b4", + "name": "GetThroughput", "params": [ { "desc": "[in] Handle for the component.", - "name": "hDiagnostics", - "type": "$s_diag_handle_t" + "name": "hPort", + "type": "$s_fabric_port_handle_t" }, { - "desc": "[in,out] Structure describing the properties of a diagnostics test suite", - "name": "pProperties", - "type": "$s_diag_properties_t*" + "desc": "[in,out] Will contain the Fabric port throughput counters.", + "name": "pThroughput", + "type": "$s_fabric_port_throughput_t*" } ], "returns": [ @@ -71104,42 +85235,42 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDiagnostics`" + "`nullptr == hPort`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pProperties`" + "`nullptr == pThroughput`" + ] + }, + { + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "User does not have permissions to query this telemetry." ] } ], "type": "function" }, { - "class": "$sDiagnostics", - "desc": "Get individual tests that can be run separately. Not all test suites permit running individual tests, check the `haveTests` member of $s_diag_properties_t.", + "class": "$sFabricPort", + "desc": "Get Fabric Port Error Counters", "details": [ - "The list of available tests is returned in order of increasing test index (see the `index` member of $s_diag_test_t).", "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The implementation of this function should be lock-free.", + "The memory backing the arrays for phPorts and ppThroughputs must be allocated in system memory by the user who is also responsible for releasing them when they are no longer needed." ], - "hash": "4219d4ef7697f5b2b7b20571adf1350eeb3e20d96f93c37d10e86d05b8faed06", - "name": "GetTests", + "hash": "67d5b753e3b6f42b1997d5d3db8f20671924a2eee917e7a8147cef40cc6dfeb0", + "name": "GetFabricErrorCounters", "params": [ { "desc": "[in] Handle for the component.", - "name": "hDiagnostics", - "type": "$s_diag_handle_t" - }, - { - "desc": "[in,out] pointer to the number of tests.\nif count is zero, then the driver shall update the value with the total number of tests that are available.\nif count is greater than the number of tests that are available, then the driver shall update the value with the correct number of tests.\n", - "name": "pCount", - "type": "uint32_t*" + "name": "hPort", + "type": "$s_fabric_port_handle_t" }, { - "desc": "[in,out][optional][range(0, *pCount)] array of information about individual tests sorted by increasing value of the `index` member of $s_diag_test_t.\nif count is less than the number of tests that are available, then the driver shall only retrieve that number of tests.\n", - "name": "pTests", - "type": "$s_diag_test_t*" + "desc": "[in,out] Will contain the Fabric port Error counters.", + "name": "pErrors", + "type": "$s_fabric_port_error_counters_t*" } ], "returns": [ @@ -71160,48 +85291,52 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDiagnostics`" + "`nullptr == hPort`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pCount`" + "`nullptr == pErrors`" + ] + }, + { + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "User does not have permissions to query this telemetry." ] } ], - "type": "function" + "type": "function", + "version": "1.7" }, { - "class": "$sDiagnostics", - "desc": "Run a diagnostics test suite, either all tests or a subset of tests.", + "class": "$sFabricPort", + "desc": "Get Fabric port throughput from multiple ports in a single call", "details": [ - "WARNING: Running diagnostics may destroy current device state information. Gracefully close any running workloads before initiating.", - "To run all tests in a test suite, set start = $S_DIAG_FIRST_TEST_INDEX and end = $S_DIAG_LAST_TEST_INDEX.", - "If the test suite permits running individual tests, the `haveTests` member of $s_diag_properties_t will be true. In this case, the function $sDiagnosticsGetTests() can be called to get the list of tests and corresponding indices that can be supplied to the arguments start and end in this function.", - "This function will block until the diagnostics have completed and force reset based on result" + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." ], - "hash": "349d2006c7ca8ec132f2c6eb5efdabdcbb4c439f9905517fd0fb216f63671c28", - "name": "RunTests", + "hash": "b19183e0e5208c1c5bac396db4c5d36d7334fbfdc1a7eedd01031666a174a232", + "name": "GetMultiPortThroughput", "params": [ { - "desc": "[in] Handle for the component.", - "name": "hDiagnostics", - "type": "$s_diag_handle_t" + "desc": "[in] Sysman handle of the device.", + "name": "hDevice", + "type": "$s_device_handle_t" }, { - "desc": "[in] The index of the first test to run. Set to $S_DIAG_FIRST_TEST_INDEX to start from the beginning.", - "name": "startIndex", + "desc": "[in] Number of ports enumerated in function $sDeviceEnumFabricPorts", + "name": "numPorts", "type": "uint32_t" }, { - "desc": "[in] The index of the last test to run. Set to $S_DIAG_LAST_TEST_INDEX to complete all tests after the start test.", - "name": "endIndex", - "type": "uint32_t" + "desc": "[in][range(0, numPorts)] array of fabric port handles provided by user to gather throughput values. \n", + "name": "phPort", + "type": "$s_fabric_port_handle_t*" }, { - "desc": "[in,out] The result of the diagnostics", - "name": "pResult", - "type": "$s_diag_result_t*" + "desc": "[out][range(0, numPorts)] array of fabric port throughput counters from multiple ports of type $s_fabric_port_throughput_t.\n", + "name": "pThroughput", + "type": "$s_fabric_port_throughput_t**" } ], "returns": [ @@ -71222,30 +85357,27 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDiagnostics`" + "`nullptr == hDevice`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pResult`" - ] - }, - { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to perform diagnostics." + "`nullptr == phPort`", + "`nullptr == pThroughput`" ] } ], - "type": "function" + "type": "function", + "version": "1.7" }, { - "desc": "C++ wrapper for a Sysman device diagnostic test suite", + "desc": "C++ wrapper for a Sysman device Fabric port", "members": [ { "desc": "[in] handle of Sysman object", "init": "nullptr", "name": "handle", - "type": "$s_diag_handle_t" + "type": "$s_fabric_port_handle_t" }, { "desc": "[in] pointer to owner object", @@ -71253,7 +85385,7 @@ "type": "$sDevice*" } ], - "name": "$sDiagnostics", + "name": "$sFabricPort", "owner": "$sDevice", "type": "class" } @@ -71261,148 +85393,229 @@ }, { "header": { - "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - ECC management", + "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - Firmware management", "ordinal": 1000, "type": "header" }, - "name": "ecc", + "name": "fan", "objects": [ { - "class": "$sDevice", - "desc": "ECC State", + "class": "$sFan", + "desc": "Fan resource speed mode", "etors": [ { - "desc": "None", - "name": "$S_DEVICE_ECC_STATE_UNAVAILABLE", + "desc": "The fan speed is operating using the hardware default settings", + "name": "$S_FAN_SPEED_MODE_DEFAULT", "value": "0" }, { - "desc": "ECC enabled.", - "name": "$S_DEVICE_ECC_STATE_ENABLED", + "desc": "The fan speed is currently set to a fixed value", + "name": "$S_FAN_SPEED_MODE_FIXED", "value": "1" }, { - "desc": "ECC disabled.", - "name": "$S_DEVICE_ECC_STATE_DISABLED", + "desc": "The fan speed is currently controlled dynamically by hardware based on a temp/speed table", + "name": "$S_FAN_SPEED_MODE_TABLE", "value": "2" } ], - "name": "$s_device_ecc_state_t", - "type": "enum", - "version": "1.4" + "name": "$s_fan_speed_mode_t", + "type": "enum" }, { - "class": "$sDevice", - "desc": "State Change Requirements", + "class": "$sFan", + "desc": "Fan speed units", "etors": [ { - "desc": "No action.", - "name": "$S_DEVICE_ACTION_NONE", + "desc": "The fan speed is in units of revolutions per minute (rpm)", + "name": "$S_FAN_SPEED_UNITS_RPM", "value": "0" }, { - "desc": "Warm reset of the card.", - "name": "$S_DEVICE_ACTION_WARM_CARD_RESET", + "desc": "The fan speed is a percentage of the maximum speed of the fan", + "name": "$S_FAN_SPEED_UNITS_PERCENT", "value": "1" + } + ], + "name": "$s_fan_speed_units_t", + "type": "enum" + }, + { + "class": "$sFan", + "desc": "Fan speed", + "members": [ + { + "desc": "[in,out] The speed of the fan. On output, a value of -1 indicates that there is no fixed fan speed setting.", + "name": "speed", + "type": "int32_t" }, { - "desc": "Cold reset of the card.", - "name": "$S_DEVICE_ACTION_COLD_CARD_RESET", - "value": "2" + "desc": "[in,out] The units that the fan speed is expressed in. On output, if fan speed is -1 then units should be ignored.", + "name": "units", + "type": "$s_fan_speed_units_t" + } + ], + "name": "$s_fan_speed_t", + "type": "struct" + }, + { + "class": "$sFan", + "desc": "Fan temperature/speed pair", + "members": [ + { + "desc": "[in,out] Temperature in degrees Celsius.", + "name": "temperature", + "type": "uint32_t" + }, + { + "desc": "[in,out] The speed of the fan", + "name": "speed", + "type": "$s_fan_speed_t" + } + ], + "name": "$s_fan_temp_speed_t", + "type": "struct" + }, + { + "desc": "Maximum number of fan temperature/speed pairs in the fan speed table.", + "name": "$S_FAN_TEMP_SPEED_PAIR_COUNT", + "type": "macro", + "value": "32" + }, + { + "class": "$sFan", + "desc": "Fan speed table", + "members": [ + { + "desc": "[in,out] The number of valid points in the fan speed table. 0 means that there is no fan speed table configured. -1 means that a fan speed table is not supported by the hardware.", + "name": "numPoints", + "type": "int32_t" + }, + { + "desc": "[in,out] Array of temperature/fan speed pairs. The table is ordered based on temperature from lowest to highest.", + "name": "table[$S_FAN_TEMP_SPEED_PAIR_COUNT]", + "type": "$s_fan_temp_speed_t" + } + ], + "name": "$s_fan_speed_table_t", + "type": "struct" + }, + { + "base": "$s_base_properties_t", + "class": "$sFan", + "desc": "Fan properties", + "members": [ + { + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_FAN_PROPERTIES", + "name": "stype", + "type": "$s_structure_type_t" + }, + { + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" + }, + { + "desc": "[out] True if the resource is located on a sub-device; false means that the resource is on the device of the calling Sysman handle", + "name": "onSubdevice", + "type": "$x_bool_t" + }, + { + "desc": "[out] If onSubdevice is true, this gives the ID of the sub-device", + "name": "subdeviceId", + "type": "uint32_t" + }, + { + "desc": "[out] Indicates if software can control the fan speed assuming the user has permissions", + "name": "canControl", + "type": "$x_bool_t" + }, + { + "desc": "[out] Bitfield of supported fan configuration modes (1<<$s_fan_speed_mode_t)", + "name": "supportedModes", + "type": "uint32_t" }, { - "desc": "Cold reboot of the system.", - "name": "$S_DEVICE_ACTION_COLD_SYSTEM_REBOOT", - "value": "3" - } - ], - "name": "$s_device_action_t", - "type": "enum", - "version": "1.4" - }, - { - "base": "$s_base_desc_t", - "class": "$sDevice", - "desc": "ECC State Descriptor", - "members": [ - { - "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_DEVICE_ECC_DESC", - "name": "stype", - "type": "$s_structure_type_t" + "desc": "[out] Bitfield of supported fan speed units (1<<$s_fan_speed_units_t)", + "name": "supportedUnits", + "type": "uint32_t" }, { - "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "const void*" + "desc": "[out] The maximum RPM of the fan. A value of -1 means that this property is unknown. ", + "name": "maxRPM", + "type": "int32_t" }, { - "desc": "[out] ECC state", - "name": "state", - "type": "$s_device_ecc_state_t" + "desc": "[out] The maximum number of points in the fan temp/speed table. A value of -1 means that this fan doesn't support providing a temp/speed table.", + "name": "maxPoints", + "type": "int32_t" } ], - "name": "$s_device_ecc_desc_t", - "type": "struct", - "version": "1.4" + "name": "$s_fan_properties_t", + "type": "struct" }, { - "base": "$s_base_properties_t", - "class": "$sDevice", - "desc": "ECC State", + "base": "$s_base_config_t", + "class": "$sFan", + "desc": "Fan configuration", "members": [ { "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_DEVICE_ECC_PROPERTIES", + "init": "$S_STRUCTURE_TYPE_FAN_CONFIG", "name": "stype", "type": "$s_structure_type_t" }, { - "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", "init": "nullptr", "name": "pNext", - "type": "void*" + "type": "const void*" }, { - "desc": "[out] Current ECC state", - "name": "currentState", - "type": "$s_device_ecc_state_t" + "desc": "[in,out] The fan speed mode (fixed, temp-speed table)", + "name": "mode", + "type": "$s_fan_speed_mode_t" }, { - "desc": "[out] Pending ECC state", - "name": "pendingState", - "type": "$s_device_ecc_state_t" + "desc": "[in,out] The current fixed fan speed setting", + "name": "speedFixed", + "type": "$s_fan_speed_t" }, { - "desc": "[out] Pending action", - "name": "pendingAction", - "type": "$s_device_action_t" + "desc": "[out] A table containing temperature/speed pairs", + "name": "speedTable", + "type": "$s_fan_speed_table_t" } ], - "name": "$s_device_ecc_properties_t", - "type": "struct", - "version": "1.4" + "name": "$s_fan_config_t", + "type": "struct" }, { "class": "$sDevice", - "desc": "Is ECC functionality available - true or false?", + "desc": "Get handle of fans", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "264b6e89d9b7c9216eab024643025dc409bda4982818418314482dbb1724ff12", - "name": "EccAvailable", + "hash": "cd402f983e5dc2e1f226dccb0609064e6bd118037410019a20723a8a58c6c4a5", + "name": "EnumFans", "params": [ { - "desc": "[in] Handle for the component.", + "desc": "[in] Sysman handle of the device.", "name": "hDevice", "type": "$s_device_handle_t" }, { - "desc": "[out] ECC functionality is available (true)/unavailable (false).", - "name": "pAvailable", - "type": "$x_bool_t*" + "desc": "[in,out] pointer to the number of components of this type.\nif count is zero, then the driver shall update the value with the total number of components of this type that are available.\nif count is greater than the number of components of this type that are available, then the driver shall update the value with the correct number of components.\n", + "name": "pCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", + "name": "phFan", + "type": "$s_fan_handle_t*" } ], "returns": [ @@ -71428,32 +85641,31 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pAvailable`" + "`nullptr == pCount`" ] } ], - "type": "function", - "version": "1.4" + "type": "function" }, { - "class": "$sDevice", - "desc": "Is ECC support configurable - true or false?", + "class": "$sFan", + "desc": "Get fan properties", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "0f8ff49a7a8abe8cde740b8234ca60bae96be561699e0a742338476b52a94218", - "name": "EccConfigurable", + "hash": "0e96fab12a31e4d2266ddf46d5810c1f16c5e021efe80d5aab57b063de11a434", + "name": "GetProperties", "params": [ { "desc": "[in] Handle for the component.", - "name": "hDevice", - "type": "$s_device_handle_t" + "name": "hFan", + "type": "$s_fan_handle_t" }, { - "desc": "[out] ECC can be enabled/disabled (true)/enabled/disabled (false).", - "name": "pConfigurable", - "type": "$x_bool_t*" + "desc": "[in,out] Will contain the properties of the fan.", + "name": "pProperties", + "type": "$s_fan_properties_t*" } ], "returns": [ @@ -71474,37 +85686,36 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDevice`" + "`nullptr == hFan`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pConfigurable`" + "`nullptr == pProperties`" ] } ], - "type": "function", - "version": "1.4" + "type": "function" }, { - "class": "$sDevice", - "desc": "Get current ECC state, pending state, and pending action", + "class": "$sFan", + "desc": "Get fan configurations and the current fan speed mode (default, fixed, temp-speed table)", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "6c8f13b7f3cc21e39963799875b4651b8a7bc0d3790f8cfec04d2a216d242634", - "name": "GetEccState", + "hash": "43951de8c82fdfc9dd54e3fe5219be6e9cca4baef47fa8dd07bef5e59840df82", + "name": "GetConfig", "params": [ { "desc": "[in] Handle for the component.", - "name": "hDevice", - "type": "$s_device_handle_t" + "name": "hFan", + "type": "$s_fan_handle_t" }, { - "desc": "[out] ECC state, pending state, and pending action for state change.", - "name": "pState", - "type": "$s_device_ecc_properties_t*" + "desc": "[in,out] Will contain the current configuration of the fan.", + "name": "pConfig", + "type": "$s_fan_config_t*" } ], "returns": [ @@ -71525,43 +85736,31 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDevice`" + "`nullptr == hFan`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pState`" + "`nullptr == pConfig`" ] } ], - "type": "function", - "version": "1.4" + "type": "function" }, { - "class": "$sDevice", - "desc": "Set new ECC state", + "class": "$sFan", + "desc": "Configure the fan to run with hardware factory settings (set mode to $S_FAN_SPEED_MODE_DEFAULT)", "details": [ "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free.", - "$sDeviceGetState should be called to determine pending action required to implement state change." + "The implementation of this function should be lock-free." ], - "hash": "5170246117a72b8ffc924046f9ebe857e8e0da6f5e41829c7029a7d8eb4b280e", - "name": "SetEccState", + "hash": "3f32c8b4c13c29cd9a801fb9abdb42c1b1e96c76465506d70a3c9b0a234997c5", + "name": "SetDefaultMode", "params": [ { "desc": "[in] Handle for the component.", - "name": "hDevice", - "type": "$s_device_handle_t" - }, - { - "desc": "[in] Pointer to desired ECC state.", - "name": "newState", - "type": "const $s_device_ecc_desc_t*" - }, - { - "desc": "[out] ECC state, pending state, and pending action for state change.", - "name": "pState", - "type": "$s_device_ecc_properties_t*" + "name": "hFan", + "type": "$s_fan_handle_t" } ], "returns": [ @@ -71582,198 +85781,36 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDevice`" - ] - }, - { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == newState`", - "`nullptr == pState`" - ] - }, - { - "$X_RESULT_ERROR_INVALID_ENUMERATION": [ - "`$S_DEVICE_ECC_STATE_DISABLED < newState->state`" + "`nullptr == hFan`" ] }, { - "$X_RESULT_WARNING_ACTION_REQUIRED": [ - "User must look at the pendingAction attribute of pState & perform the action required to complete the ECC state change." + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "User does not have permissions to make these modifications." ] } ], - "type": "function", - "version": "1.4" - } - ] - }, - { - "header": { - "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - Engine groups", - "ordinal": 1000, - "type": "header" - }, - "name": "engine", - "objects": [ - { - "class": "$sEngine", - "desc": "Accelerator engine groups", - "etors": [ - { - "desc": "Access information about all engines combined.", - "name": "$S_ENGINE_GROUP_ALL", - "value": "0" - }, - { - "desc": "Access information about all compute engines combined. Compute engines can only process compute kernels (no 3D content).", - "name": "$S_ENGINE_GROUP_COMPUTE_ALL", - "value": "1" - }, - { - "desc": "Access information about all media engines combined.", - "name": "$S_ENGINE_GROUP_MEDIA_ALL", - "value": "2" - }, - { - "desc": "Access information about all copy (blitter) engines combined.", - "name": "$S_ENGINE_GROUP_COPY_ALL", - "value": "3" - }, - { - "desc": "Access information about a single compute engine - this is an engine that can process compute kernels. Note that single engines may share the same underlying accelerator resources as other engines so activity of such an engine may not be indicative of the underlying resource utilization - use $S_ENGINE_GROUP_3D_RENDER_COMPUTE_ALL for that.", - "name": "$S_ENGINE_GROUP_COMPUTE_SINGLE", - "value": "4" - }, - { - "desc": "Access information about a single render engine - this is an engine that can process both 3D content and compute kernels. Note that single engines may share the same underlying accelerator resources as other engines so activity of such an engine may not be indicative of the underlying resource utilization - use $S_ENGINE_GROUP_3D_RENDER_COMPUTE_ALL for that.", - "name": "$S_ENGINE_GROUP_RENDER_SINGLE", - "value": "5" - }, - { - "desc": "Access information about a single media decode engine. Note that single engines may share the same underlying accelerator resources as other engines so activity of such an engine may not be indicative of the underlying resource utilization - use $S_ENGINE_GROUP_MEDIA_ALL for that.", - "name": "$S_ENGINE_GROUP_MEDIA_DECODE_SINGLE", - "value": "6" - }, - { - "desc": "Access information about a single media encode engine. Note that single engines may share the same underlying accelerator resources as other engines so activity of such an engine may not be indicative of the underlying resource utilization - use $S_ENGINE_GROUP_MEDIA_ALL for that.", - "name": "$S_ENGINE_GROUP_MEDIA_ENCODE_SINGLE", - "value": "7" - }, - { - "desc": "Access information about a single media encode engine. Note that single engines may share the same underlying accelerator resources as other engines so activity of such an engine may not be indicative of the underlying resource utilization - use $S_ENGINE_GROUP_COPY_ALL for that.", - "name": "$S_ENGINE_GROUP_COPY_SINGLE", - "value": "8" - }, - { - "desc": "Access information about a single media enhancement engine. Note that single engines may share the same underlying accelerator resources as other engines so activity of such an engine may not be indicative of the underlying resource utilization - use $S_ENGINE_GROUP_MEDIA_ALL for that.", - "name": "$S_ENGINE_GROUP_MEDIA_ENHANCEMENT_SINGLE", - "value": "9" - }, - { - "desc": "Access information about a single 3D engine - this is an engine that can process 3D content only. Note that single engines may share the same underlying accelerator resources as other engines so activity of such an engine may not be indicative of the underlying resource utilization - use $S_ENGINE_GROUP_3D_RENDER_COMPUTE_ALL for that.", - "name": "$S_ENGINE_GROUP_3D_SINGLE", - "value": "10" - }, - { - "desc": "Access information about all 3D/render/compute engines combined.", - "name": "$S_ENGINE_GROUP_3D_RENDER_COMPUTE_ALL", - "value": "11" - }, - { - "desc": "Access information about all render engines combined. Render engines are those than process both 3D content and compute kernels.", - "name": "$S_ENGINE_GROUP_RENDER_ALL", - "value": "12" - }, - { - "desc": "Access information about all 3D engines combined. 3D engines can process 3D content only (no compute kernels).", - "name": "$S_ENGINE_GROUP_3D_ALL", - "value": "13" - } - ], - "name": "$s_engine_group_t", - "type": "enum" - }, - { - "base": "$s_base_properties_t", - "class": "$sEngine", - "desc": "Engine group properties", - "members": [ - { - "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_ENGINE_PROPERTIES", - "name": "stype", - "type": "$s_structure_type_t" - }, - { - "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "void*" - }, - { - "desc": "[out] The engine group", - "name": "type", - "type": "$s_engine_group_t" - }, - { - "desc": "[out] True if this resource is located on a sub-device; false means that the resource is on the device of the calling Sysman handle", - "name": "onSubdevice", - "type": "$x_bool_t" - }, - { - "desc": "[out] If onSubdevice is true, this gives the ID of the sub-device", - "name": "subdeviceId", - "type": "uint32_t" - } - ], - "name": "$s_engine_properties_t", - "type": "struct" - }, - { - "class": "$sEngine", - "desc": "Engine activity counters", - "details": [ - "Percent utilization is calculated by taking two snapshots (s1, s2) and using the equation: %util = (s2.activeTime - s1.activeTime) / (s2.timestamp - s1.timestamp)" - ], - "members": [ - { - "desc": "[out] Monotonic counter for time in microseconds that this resource is actively running workloads.", - "name": "activeTime", - "type": "uint64_t" - }, - { - "desc": "[out] Monotonic timestamp counter in microseconds when activeTime counter was sampled.\nThis timestamp should only be used to calculate delta time between snapshots of this structure.\nNever take the delta of this timestamp with the timestamp from a different structure since they are not guaranteed to have the same base.\nThe absolute value of the timestamp is only valid during within the application and may be different on the next execution.\n", - "name": "timestamp", - "type": "uint64_t" - } - ], - "name": "$s_engine_stats_t", - "type": "struct" + "type": "function" }, { - "class": "$sDevice", - "desc": "Get handle of engine groups", + "class": "$sFan", + "desc": "Configure the fan to rotate at a fixed speed (set mode to $S_FAN_SPEED_MODE_FIXED)", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "25e6a47559c32a64fa8b2e4c45eae905a6ec1127530dcbbeb65637befa658e26", - "name": "EnumEngineGroups", + "hash": "398f43a1f432602ccfac89afb43dfcb063e4d3b17e473a0e486fcfed9bae3945", + "name": "SetFixedSpeedMode", "params": [ { - "desc": "[in] Sysman handle of the device.", - "name": "hDevice", - "type": "$s_device_handle_t" - }, - { - "desc": "[in,out] pointer to the number of components of this type.\nif count is zero, then the driver shall update the value with the total number of components of this type that are available.\nif count is greater than the number of components of this type that are available, then the driver shall update the value with the correct number of components.\n", - "name": "pCount", - "type": "uint32_t*" + "desc": "[in] Handle for the component.", + "name": "hFan", + "type": "$s_fan_handle_t" }, { - "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", - "name": "phEngine", - "type": "$s_engine_handle_t*" + "desc": "[in] The fixed fan speed setting", + "name": "speed", + "type": "const $s_fan_speed_t*" } ], "returns": [ @@ -71794,36 +85831,46 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDevice`" + "`nullptr == hFan`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pCount`" + "`nullptr == speed`" + ] + }, + { + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "User does not have permissions to make these modifications." + ] + }, + { + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "Fixing the fan speed not supported by the hardware or the fan speed units are not supported. See the `supportedModes` and `supportedUnits` members of $s_fan_properties_t." ] } ], "type": "function" }, { - "class": "$sEngine", - "desc": "Get engine group properties", + "class": "$sFan", + "desc": "Configure the fan to adjust speed based on a temperature/speed table (set mode to $S_FAN_SPEED_MODE_TABLE)", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "df26d108743e24d58025aaf75554da14e82d69ca34bcebf1578440f7d360d5a6", - "name": "GetProperties", + "hash": "4a3133b6a3f27db154819ab2a6b881355cad632a0ef1c30235d89948bf2273c8", + "name": "SetSpeedTableMode", "params": [ { "desc": "[in] Handle for the component.", - "name": "hEngine", - "type": "$s_engine_handle_t" + "name": "hFan", + "type": "$s_fan_handle_t" }, { - "desc": "[in,out] The properties for the specified engine group.", - "name": "pProperties", - "type": "$s_engine_properties_t*" + "desc": "[in] A table containing temperature/speed pairs.", + "name": "speedTable", + "type": "const $s_fan_speed_table_t*" } ], "returns": [ @@ -71844,37 +85891,56 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hEngine`" + "`nullptr == hFan`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pProperties`" + "`nullptr == speedTable`" + ] + }, + { + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "User does not have permissions to make these modifications." + ] + }, + { + "$X_RESULT_ERROR_INVALID_ARGUMENT": [ + "The temperature/speed pairs in the array are not sorted on temperature from lowest to highest." + ] + }, + { + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "Fan speed table not supported by the hardware or the fan speed units are not supported. See the `supportedModes` and `supportedUnits` members of $s_fan_properties_t." ] } ], "type": "function" }, { - "class": "$sEngine", - "desc": "Get the activity stats for an engine group.", + "class": "$sFan", + "desc": "Get current state of a fan - current mode and speed", "details": [ - "This function also returns the engine activity inside a Virtual Machine (VM), in the presence of hardware virtualization (SRIOV)", "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "b4c7b2006754814930556a754b21e2fd5ee2df9dcbf6aef7521d44488a217f5e", - "name": "GetActivity", + "hash": "337b9820995404b2f3e61231b0396074ccf89065c86f1e223fd07365483735f0", + "name": "GetState", "params": [ { "desc": "[in] Handle for the component.", - "name": "hEngine", - "type": "$s_engine_handle_t" + "name": "hFan", + "type": "$s_fan_handle_t" }, { - "desc": "[in,out] Will contain a snapshot of the engine group activity counters.", - "name": "pStats", - "type": "$s_engine_stats_t*" + "desc": "[in] The units in which the fan speed should be returned.", + "name": "units", + "type": "$s_fan_speed_units_t" + }, + { + "desc": "[in,out] Will contain the current speed of the fan in the units requested. A value of -1 indicates that the fan speed cannot be measured.", + "name": "pSpeed", + "type": "int32_t*" } ], "returns": [ @@ -71895,26 +85961,35 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hEngine`" + "`nullptr == hFan`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_ENUMERATION": [ + "`$S_FAN_SPEED_UNITS_PERCENT < units`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pStats`" + "`nullptr == pSpeed`" + ] + }, + { + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "The requested fan speed units are not supported. See the `supportedUnits` member of $s_fan_properties_t." ] } ], - "type": "function", - "version": "1.7" + "type": "function" }, { - "desc": "C++ wrapper for a Sysman device engine group", + "desc": "C++ wrapper for a Sysman device fan", "members": [ { "desc": "[in] handle of Sysman object", "init": "nullptr", "name": "handle", - "type": "$s_engine_handle_t" + "type": "$s_fan_handle_t" }, { "desc": "[in] pointer to owner object", @@ -71922,7 +85997,7 @@ "type": "$sDevice*" } ], - "name": "$sEngine", + "name": "$sFan", "owner": "$sDevice", "type": "class" } @@ -71930,114 +86005,82 @@ }, { "header": { - "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - Event management", + "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - Firmware management", "ordinal": 1000, "type": "header" }, - "name": "events", + "name": "firmware", "objects": [ { - "class": "$sDriver", - "desc": "Event types", - "etors": [ - { - "desc": "Event is triggered when the device is no longer available (due to a reset or being disabled).", - "name": "$S_EVENT_TYPE_FLAG_DEVICE_DETACH", - "value": "$X_BIT(0)" - }, - { - "desc": "Event is triggered after the device is available again.", - "name": "$S_EVENT_TYPE_FLAG_DEVICE_ATTACH", - "value": "$X_BIT(1)" - }, - { - "desc": "Event is triggered when the driver is about to put the device into a deep sleep state", - "name": "$S_EVENT_TYPE_FLAG_DEVICE_SLEEP_STATE_ENTER", - "value": "$X_BIT(2)" - }, - { - "desc": "Event is triggered when the driver is waking the device up from a deep sleep state", - "name": "$S_EVENT_TYPE_FLAG_DEVICE_SLEEP_STATE_EXIT", - "value": "$X_BIT(3)" - }, - { - "desc": "Event is triggered when the frequency starts being throttled", - "name": "$S_EVENT_TYPE_FLAG_FREQ_THROTTLED", - "value": "$X_BIT(4)" - }, - { - "desc": "Event is triggered when the energy consumption threshold is reached (use $sPowerSetEnergyThreshold() to configure).", - "name": "$S_EVENT_TYPE_FLAG_ENERGY_THRESHOLD_CROSSED", - "value": "$X_BIT(5)" - }, - { - "desc": "Event is triggered when the critical temperature is reached (use $sTemperatureSetConfig() to configure - disabled by default).", - "name": "$S_EVENT_TYPE_FLAG_TEMP_CRITICAL", - "value": "$X_BIT(6)" - }, - { - "desc": "Event is triggered when the temperature crosses threshold 1 (use $sTemperatureSetConfig() to configure - disabled by default).", - "name": "$S_EVENT_TYPE_FLAG_TEMP_THRESHOLD1", - "value": "$X_BIT(7)" - }, + "base": "$s_base_properties_t", + "class": "$sFirmware", + "desc": "Firmware properties", + "members": [ { - "desc": "Event is triggered when the temperature crosses threshold 2 (use $sTemperatureSetConfig() to configure - disabled by default).", - "name": "$S_EVENT_TYPE_FLAG_TEMP_THRESHOLD2", - "value": "$X_BIT(8)" + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_FIRMWARE_PROPERTIES", + "name": "stype", + "type": "$s_structure_type_t" }, { - "desc": "Event is triggered when the health of device memory changes.", - "name": "$S_EVENT_TYPE_FLAG_MEM_HEALTH", - "value": "$X_BIT(9)" + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" }, { - "desc": "Event is triggered when the health of fabric ports change.", - "name": "$S_EVENT_TYPE_FLAG_FABRIC_PORT_HEALTH", - "value": "$X_BIT(10)" + "desc": "[out] True if the resource is located on a sub-device; false means that the resource is on the device of the calling Sysman handle", + "name": "onSubdevice", + "type": "$x_bool_t" }, { - "desc": "Event is triggered when the health of the PCI link changes.", - "name": "$S_EVENT_TYPE_FLAG_PCI_LINK_HEALTH", - "value": "$X_BIT(11)" + "desc": "[out] If onSubdevice is true, this gives the ID of the sub-device", + "name": "subdeviceId", + "type": "uint32_t" }, { - "desc": "Event is triggered when accelerator RAS correctable errors cross thresholds (use $sRasSetConfig() to configure - disabled by default).", - "name": "$S_EVENT_TYPE_FLAG_RAS_CORRECTABLE_ERRORS", - "value": "$X_BIT(12)" + "desc": "[out] Indicates if software can flash the firmware assuming the user has permissions", + "name": "canControl", + "type": "$x_bool_t" }, { - "desc": "Event is triggered when accelerator RAS uncorrectable errors cross thresholds (use $sRasSetConfig() to configure - disabled by default).", - "name": "$S_EVENT_TYPE_FLAG_RAS_UNCORRECTABLE_ERRORS", - "value": "$X_BIT(13)" + "desc": "[out] NULL terminated string value. The string \"unknown\" will be returned if this property cannot be determined.", + "name": "name[$S_STRING_PROPERTY_SIZE]", + "type": "char" }, { - "desc": "Event is triggered when the device needs to be reset (use $sDeviceGetState() to determine the reasons for the reset).", - "name": "$S_EVENT_TYPE_FLAG_DEVICE_RESET_REQUIRED", - "value": "$X_BIT(14)" + "desc": "[out] NULL terminated string value. The string \"unknown\" will be returned if this property cannot be determined.", + "name": "version[$S_STRING_PROPERTY_SIZE]", + "type": "char" } ], - "name": "$s_event_type_flags_t", - "type": "enum" + "name": "$s_firmware_properties_t", + "type": "struct" }, { "class": "$sDevice", - "desc": "Specify the list of events to listen to for a given device", + "desc": "Get handle of firmwares", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "26fc8939c3a29505329de969535a2946e59d9e03b312a2da336655b503bc9f28", - "name": "EventRegister", + "hash": "9ba0753daddbd3a471d4b8ecb7290ed7990b77741e191e3498fd13a8961ca8bf", + "name": "EnumFirmwares", "params": [ { - "desc": "[in] The device handle.", + "desc": "[in] Sysman handle of the device.", "name": "hDevice", "type": "$s_device_handle_t" }, { - "desc": "[in] List of events to listen to.", - "name": "events", - "type": "$s_event_type_flags_t" + "desc": "[in,out] pointer to the number of components of this type.\nif count is zero, then the driver shall update the value with the total number of components of this type that are available.\nif count is greater than the number of components of this type that are available, then the driver shall update the value with the correct number of components.\n", + "name": "pCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", + "name": "phFirmware", + "type": "$s_firmware_handle_t*" } ], "returns": [ @@ -72062,53 +86105,89 @@ ] }, { - "$X_RESULT_ERROR_INVALID_ENUMERATION": [ - "`0x7fff < events`" + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCount`" ] } ], "type": "function" }, { - "class": "$sDriver", - "decl": "static", - "desc": "Wait for events to be received from a one or more devices.", + "class": "$sFirmware", + "desc": "Get firmware properties", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "b00de872443c97d166cd17f0042a606d264fb05f1b2ce96a3203bef5552dc652", - "name": "EventListen", + "hash": "11f91797bbbaac14954b82406293fb175c9081593e31494018c8487316177204", + "name": "GetProperties", "params": [ { - "desc": "[in] handle of the driver instance", - "name": "hDriver", - "type": "$x_driver_handle_t" + "desc": "[in] Handle for the component.", + "name": "hFirmware", + "type": "$s_firmware_handle_t" }, { - "desc": "[in] if non-zero, then indicates the maximum time (in milliseconds) to yield before returning $X_RESULT_SUCCESS or $X_RESULT_NOT_READY;\nif zero, then will check status and return immediately;\nif `UINT32_MAX`, then function will not return until events arrive.\n", - "name": "timeout", - "type": "uint32_t" + "desc": "[in,out] Pointer to an array that will hold the properties of the firmware", + "name": "pProperties", + "type": "$s_firmware_properties_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] }, { - "desc": "[in] Number of device handles in phDevices.", - "name": "count", - "type": "uint32_t" + "$X_RESULT_ERROR_UNINITIALIZED": [] }, { - "desc": "[in][range(0, count)] Device handles to listen to for events. Only devices from the provided driver handle can be specified in this list.", - "name": "phDevices", - "type": "$s_device_handle_t*" + "$X_RESULT_ERROR_DEVICE_LOST": [] }, { - "desc": "[in,out] Will contain the actual number of devices in phDevices that generated events. If non-zero, check pEvents to determine the devices and events that were received.", - "name": "pNumDeviceEvents", - "type": "uint32_t*" + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] }, { - "desc": "[in,out] An array that will continue the list of events for each device listened in phDevices.\nThis array must be at least as big as count.\nFor every device handle in phDevices, this will provide the events that occurred for that device at the same position in this array. If no event was received for a given device, the corresponding array entry will be zero.\n", - "name": "pEvents", - "type": "$s_event_type_flags_t*" + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hFirmware`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pProperties`" + ] + } + ], + "type": "function" + }, + { + "class": "$sFirmware", + "desc": "Flash a new firmware image", + "details": [ + "Any running workload must be gracefully closed before invoking this function.", + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free.", + "This is a non-blocking call. Application may call $sFirmwareGetFlashProgress to get completion status." + ], + "hash": "a6cc43172f030767262ce409a236ed03fd2f41a4abb336ece7e0e1bd642004b4", + "name": "Flash", + "params": [ + { + "desc": "[in] Handle for the component.", + "name": "hFirmware", + "type": "$s_firmware_handle_t" + }, + { + "desc": "[in] Image of the new firmware to flash.", + "name": "pImage", + "type": "void*" + }, + { + "desc": "[in] Size of the flash image.", + "name": "size", + "type": "uint32_t" } ], "returns": [ @@ -72129,69 +86208,99 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDriver`" + "`nullptr == hFirmware`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == phDevices`", - "`nullptr == pNumDeviceEvents`", - "`nullptr == pEvents`" + "`nullptr == pImage`" ] }, { "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to listen to events." - ] - }, - { - "$X_RESULT_ERROR_INVALID_ARGUMENT": [ - "One or more of the supplied device handles belongs to a different driver." + "User does not have permissions to perform this operation." ] } ], "type": "function" }, { - "class": "$sDriver", - "decl": "static", - "desc": "Wait for events to be received from a one or more devices.", + "class": "$sFirmware", + "desc": "Get Firmware Flash Progress", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "60aaa2b499d532b22ccc6b5ce05ee5e7008c45c69550bd6c1f6e3010e6cffc01", - "name": "EventListenEx", + "hash": "372362463218b6c44bc0ebc304c24d5aa9b4f8225422f4ad37537dea53167a1e", + "name": "GetFlashProgress", "params": [ { - "desc": "[in] handle of the driver instance", - "name": "hDriver", - "type": "$x_driver_handle_t" + "desc": "[in] Handle for the component.", + "name": "hFirmware", + "type": "$s_firmware_handle_t" }, { - "desc": "[in] if non-zero, then indicates the maximum time (in milliseconds) to yield before returning $X_RESULT_SUCCESS or $X_RESULT_NOT_READY;\nif zero, then will check status and return immediately;\nif `UINT64_MAX`, then function will not return until events arrive.\n", - "name": "timeout", - "type": "uint64_t" + "desc": "[in,out] Pointer to the Completion Percentage of Firmware Update", + "name": "pCompletionPercent", + "type": "uint32_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] }, { - "desc": "[in] Number of device handles in phDevices.", - "name": "count", - "type": "uint32_t" + "$X_RESULT_ERROR_UNINITIALIZED": [] }, { - "desc": "[in][range(0, count)] Device handles to listen to for events. Only devices from the provided driver handle can be specified in this list.", - "name": "phDevices", - "type": "$s_device_handle_t*" + "$X_RESULT_ERROR_DEVICE_LOST": [] }, { - "desc": "[in,out] Will contain the actual number of devices in phDevices that generated events. If non-zero, check pEvents to determine the devices and events that were received.", - "name": "pNumDeviceEvents", - "type": "uint32_t*" + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] }, { - "desc": "[in,out] An array that will continue the list of events for each device listened in phDevices.\nThis array must be at least as big as count.\nFor every device handle in phDevices, this will provide the events that occurred for that device at the same position in this array. If no event was received for a given device, the corresponding array entry will be zero.\n", - "name": "pEvents", - "type": "$s_event_type_flags_t*" + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hFirmware`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCompletionPercent`" + ] + } + ], + "type": "function", + "version": "1.8" + }, + { + "class": "$sFirmware", + "desc": "Get Firmware Console Logs", + "details": [ + "The caller may pass nullptr for pFirmwareLog and set pSize to zero when querying only for size.", + "The caller must provide memory for Firmware log.", + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "e19514a02c0880e3755bae04de8e0394819ec81d1beb2bac36d5d0b79d56be33", + "name": "GetConsoleLogs", + "params": [ + { + "desc": "[in] Handle for the component.", + "name": "hFirmware", + "type": "$s_firmware_handle_t" + }, + { + "desc": "[in,out] size of firmware log", + "name": "pSize", + "type": "size_t*" + }, + { + "desc": "[in,out][optional] pointer to null-terminated string of the log.", + "name": "pFirmwareLog", + "type": "char*" } ], "returns": [ @@ -72212,274 +86321,312 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDriver`" + "`nullptr == hFirmware`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == phDevices`", - "`nullptr == pNumDeviceEvents`", - "`nullptr == pEvents`" + "`nullptr == pSize`" ] - }, + } + ], + "type": "function", + "version": "1.9" + }, + { + "desc": "C++ wrapper for a Sysman device firmware", + "members": [ { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to listen to events." - ] + "desc": "[in] handle of Sysman object", + "init": "nullptr", + "name": "handle", + "type": "$s_firmware_handle_t" }, { - "$X_RESULT_ERROR_INVALID_ARGUMENT": [ - "One or more of the supplied device handles belongs to a different driver." - ] + "desc": "[in] pointer to owner object", + "name": "pDevice", + "type": "$sDevice*" } ], - "type": "function", - "version": "1.1" + "name": "$sFirmware", + "owner": "$sDevice", + "type": "class" } ] }, { "header": { - "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - Firmware management", + "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - Frequency domains", "ordinal": 1000, "type": "header" }, - "name": "fabric", + "name": "frequency", "objects": [ { - "desc": "Maximum Fabric port model string size", - "name": "$S_MAX_FABRIC_PORT_MODEL_SIZE", - "type": "macro", - "value": "256" - }, - { - "desc": "Maximum size of the buffer that will return information about link types", - "name": "$S_MAX_FABRIC_LINK_TYPE_SIZE", - "type": "macro", - "value": "256" - }, - { - "class": "$sFabricPort", - "desc": "Fabric port status", + "class": "$sDevice", + "desc": "Frequency domains.", "etors": [ { - "desc": "The port status cannot be determined", - "name": "$S_FABRIC_PORT_STATUS_UNKNOWN", + "desc": "GPU Core Domain.", + "name": "$S_FREQ_DOMAIN_GPU", "value": "0" }, { - "desc": "The port is up and operating as expected", - "name": "$S_FABRIC_PORT_STATUS_HEALTHY", + "desc": "Local Memory Domain.", + "name": "$S_FREQ_DOMAIN_MEMORY", "value": "1" }, { - "desc": "The port is up but has quality and/or speed degradation", - "name": "$S_FABRIC_PORT_STATUS_DEGRADED", - "value": "2" - }, - { - "desc": "Port connection instabilities are preventing workloads making forward progress", - "name": "$S_FABRIC_PORT_STATUS_FAILED", - "value": "3" - }, - { - "desc": "The port is configured down", - "name": "$S_FABRIC_PORT_STATUS_DISABLED", - "value": "4" + "desc": "GPU Media Domain.", + "name": "$S_FREQ_DOMAIN_MEDIA", + "value": "2", + "version": "1.6" } ], - "name": "$s_fabric_port_status_t", + "name": "$s_freq_domain_t", "type": "enum" }, { - "class": "$sFabricPort", - "desc": "Fabric port quality degradation reasons", - "etors": [ + "base": "$s_base_properties_t", + "class": "$sFrequency", + "desc": "Frequency properties", + "details": [ + "Indicates if this frequency domain can be overclocked (if true, functions such as $sFrequencyOcSetFrequencyTarget() are supported).", + "The min/max hardware frequencies are specified for non-overclock configurations. For overclock configurations, use $sFrequencyOcGetFrequencyTarget() to determine the maximum frequency that can be requested." + ], + "members": [ { - "desc": "Excessive link errors are occurring", - "name": "$S_FABRIC_PORT_QUAL_ISSUE_FLAG_LINK_ERRORS", - "value": "$X_BIT(0)" + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_FREQ_PROPERTIES", + "name": "stype", + "type": "$s_structure_type_t" }, { - "desc": "There is a degradation in the bitrate and/or width of the link", - "name": "$S_FABRIC_PORT_QUAL_ISSUE_FLAG_SPEED", - "value": "$X_BIT(1)" - } - ], - "name": "$s_fabric_port_qual_issue_flags_t", - "type": "enum" - }, - { - "class": "$sFabricPort", - "desc": "Fabric port failure reasons", - "etors": [ + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" + }, { - "desc": "A previously operating link has failed. Hardware will automatically retrain this port. This state will persist until either the physical connection is removed or the link trains successfully.", - "name": "$S_FABRIC_PORT_FAILURE_FLAG_FAILED", - "value": "$X_BIT(0)" + "desc": "[out] The hardware block that this frequency domain controls (GPU, memory, ...)", + "name": "type", + "type": "$s_freq_domain_t" }, { - "desc": "A connection has not been established within an expected time. Hardware will continue to attempt port training. This status will persist until either the physical connection is removed or the link successfully trains.", - "name": "$S_FABRIC_PORT_FAILURE_FLAG_TRAINING_TIMEOUT", - "value": "$X_BIT(1)" + "desc": "[out] True if this resource is located on a sub-device; false means that the resource is on the device of the calling Sysman handle", + "name": "onSubdevice", + "type": "$x_bool_t" }, { - "desc": "Port has excessively trained and then transitioned down for some period of time. Driver will allow port to continue to train, but will not enable the port for use until the port has been disabled and subsequently re-enabled using $sFabricPortSetConfig().", - "name": "$S_FABRIC_PORT_FAILURE_FLAG_FLAPPING", - "value": "$X_BIT(2)" + "desc": "[out] If onSubdevice is true, this gives the ID of the sub-device", + "name": "subdeviceId", + "type": "uint32_t" + }, + { + "desc": "[out] Indicates if software can control the frequency of this domain assuming the user has permissions", + "name": "canControl", + "type": "$x_bool_t" + }, + { + "desc": "[out] Indicates if software can register to receive event $S_EVENT_TYPE_FLAG_FREQ_THROTTLED", + "name": "isThrottleEventSupported", + "type": "$x_bool_t" + }, + { + "desc": "[out] The minimum hardware clock frequency in units of MHz.", + "name": "min", + "type": "double" + }, + { + "desc": "[out] The maximum non-overclock hardware clock frequency in units of MHz.", + "name": "max", + "type": "double" } ], - "name": "$s_fabric_port_failure_flags_t", - "type": "enum" + "name": "$s_freq_properties_t", + "type": "struct" }, { - "class": "$sFabricPort", - "desc": "Unique identifier for a fabric port", + "class": "$sFrequency", + "desc": "Frequency range between which the hardware can operate.", "details": [ - "This not a universal identifier. The identified is garanteed to be unique for the current hardware configuration of the system. Changes in the hardware may result in a different identifier for a given port.", - "The main purpose of this identifier to build up an instantaneous topology map of system connectivity. An application should enumerate all fabric ports and match the `remotePortId` member of $s_fabric_port_state_t to the `portId` member of $s_fabric_port_properties_t." + "When setting limits, they will be clamped to the hardware limits.", + "When setting limits, ensure that the max frequency is greater than or equal to the min frequency specified.", + "When setting limits to return to factory settings, specify -1 for both the min and max limit." ], "members": [ { - "desc": "[out] Unique identifier for the fabric end-point", - "name": "fabricId", - "type": "uint32_t" - }, - { - "desc": "[out] Unique identifier for the device attachment point", - "name": "attachId", - "type": "uint32_t" + "desc": "[in,out] The min frequency in MHz below which hardware frequency management will not request frequencies. On input, setting to 0 will permit the frequency to go down to the hardware minimum while setting to -1 will return the min frequency limit to the factory value (can be larger than the hardware min). On output, a negative value indicates that no external minimum frequency limit is in effect.", + "name": "min", + "type": "double" }, { - "desc": "[out] The logical port number (this is typically marked somewhere on the physical device)", - "name": "portNumber", - "type": "uint8_t" + "desc": "[in,out] The max frequency in MHz above which hardware frequency management will not request frequencies. On input, setting to 0 or a very big number will permit the frequency to go all the way up to the hardware maximum while setting to -1 will return the max frequency to the factory value (which can be less than the hardware max). On output, a negative number indicates that no external maximum frequency limit is in effect.", + "name": "max", + "type": "double" } ], - "name": "$s_fabric_port_id_t", + "name": "$s_freq_range_t", "type": "struct" }, { - "class": "$sFabricPort", - "desc": "Fabric port speed in one direction", - "members": [ + "class": "$sFrequency", + "desc": "Frequency throttle reasons", + "etors": [ { - "desc": "[out] Bits/sec that the link is operating at. A value of -1 means that this property is unknown.", - "name": "bitRate", - "type": "int64_t" + "desc": "frequency throttled due to average power excursion (PL1)", + "name": "$S_FREQ_THROTTLE_REASON_FLAG_AVE_PWR_CAP", + "value": "$X_BIT(0)" }, { - "desc": "[out] The number of lanes. A value of -1 means that this property is unknown.", - "name": "width", - "type": "int32_t" + "desc": "frequency throttled due to burst power excursion (PL2)", + "name": "$S_FREQ_THROTTLE_REASON_FLAG_BURST_PWR_CAP", + "value": "$X_BIT(1)" + }, + { + "desc": "frequency throttled due to current excursion (PL4)", + "name": "$S_FREQ_THROTTLE_REASON_FLAG_CURRENT_LIMIT", + "value": "$X_BIT(2)" + }, + { + "desc": "frequency throttled due to thermal excursion (T > TjMax)", + "name": "$S_FREQ_THROTTLE_REASON_FLAG_THERMAL_LIMIT", + "value": "$X_BIT(3)" + }, + { + "desc": "frequency throttled due to power supply assertion", + "name": "$S_FREQ_THROTTLE_REASON_FLAG_PSU_ALERT", + "value": "$X_BIT(4)" + }, + { + "desc": "frequency throttled due to software supplied frequency range", + "name": "$S_FREQ_THROTTLE_REASON_FLAG_SW_RANGE", + "value": "$X_BIT(5)" + }, + { + "desc": "frequency throttled due to a sub block that has a lower frequency range when it receives clocks", + "name": "$S_FREQ_THROTTLE_REASON_FLAG_HW_RANGE", + "value": "$X_BIT(6)" } ], - "name": "$s_fabric_port_speed_t", - "type": "struct" + "name": "$s_freq_throttle_reason_flags_t", + "type": "enum" }, { - "base": "$s_base_properties_t", - "class": "$sFabricPort", - "desc": "Fabric port properties", + "base": "$s_base_state_t", + "class": "$sFrequency", + "desc": "Frequency state", "members": [ { "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES", + "init": "$S_STRUCTURE_TYPE_FREQ_STATE", "name": "stype", "type": "$s_structure_type_t" }, { - "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", "init": "nullptr", "name": "pNext", - "type": "void*" + "type": "const void*" }, { - "desc": "[out] Description of port technology. Will be set to the string \"unkown\" if this cannot be determined for this port.", - "name": "model[$S_MAX_FABRIC_PORT_MODEL_SIZE]", - "type": "char" + "desc": "[out] Current voltage in Volts. A negative value indicates that this property is not known.", + "name": "currentVoltage", + "type": "double" }, { - "desc": "[out] True if the port is located on a sub-device; false means that the port is on the device of the calling Sysman handle", - "name": "onSubdevice", - "type": "$x_bool_t" + "desc": "[out] The current frequency request in MHz. A negative value indicates that this property is not known.", + "name": "request", + "type": "double" }, { - "desc": "[out] If onSubdevice is true, this gives the ID of the sub-device", - "name": "subdeviceId", - "type": "uint32_t" + "desc": "[out] The maximum frequency in MHz supported under the current TDP conditions. This fluctuates dynamically based on the power and thermal limits of the part. A negative value indicates that this property is not known.", + "name": "tdp", + "type": "double" }, { - "desc": "[out] The unique port identifier", - "name": "portId", - "type": "$s_fabric_port_id_t" + "desc": "[out] The efficient minimum frequency in MHz. A negative value indicates that this property is not known.", + "name": "efficient", + "type": "double" }, { - "desc": "[out] Maximum speed supported by the receive side of the port (sum of all lanes)", - "name": "maxRxSpeed", - "type": "$s_fabric_port_speed_t" + "desc": "[out] The resolved frequency in MHz. A negative value indicates that this property is not known.", + "name": "actual", + "type": "double" }, { - "desc": "[out] Maximum speed supported by the transmit side of the port (sum of all lanes)", - "name": "maxTxSpeed", - "type": "$s_fabric_port_speed_t" + "desc": "[out] The reasons that the frequency is being limited by the hardware.\nReturns 0 (frequency not throttled) or a combination of $s_freq_throttle_reason_flag_t.\n", + "name": "throttleReasons", + "type": "$s_freq_throttle_reason_flags_t" } ], - "name": "$s_fabric_port_properties_t", + "name": "$s_freq_state_t", "type": "struct" }, { - "class": "$sFabricPort", - "desc": "Provides information about the fabric link attached to a port", + "class": "$sFrequency", + "desc": "Frequency throttle time snapshot", + "details": [ + "Percent time throttled is calculated by taking two snapshots (s1, s2) and using the equation: %throttled = (s2.throttleTime - s1.throttleTime) / (s2.timestamp - s1.timestamp)" + ], "members": [ { - "desc": "[out] Description of link technology. Will be set to the string \"unkown\" if this cannot be determined for this link.", - "name": "desc[$S_MAX_FABRIC_LINK_TYPE_SIZE]", - "type": "char" + "desc": "[out] The monotonic counter of time in microseconds that the frequency has been limited by the hardware.", + "name": "throttleTime", + "type": "uint64_t" + }, + { + "desc": "[out] Microsecond timestamp when throttleTime was captured.\nThis timestamp should only be used to calculate delta time between snapshots of this structure.\nNever take the delta of this timestamp with the timestamp from a different structure since they are not guaranteed to have the same base.\nThe absolute value of the timestamp is only valid during within the application and may be different on the next execution.\n", + "name": "timestamp", + "type": "uint64_t" } ], - "name": "$s_fabric_link_type_t", + "name": "$s_freq_throttle_time_t", "type": "struct" }, { - "base": "$s_base_config_t", - "class": "$sFabricPort", - "desc": "Fabric port configuration", - "members": [ + "class": "$sFrequency", + "desc": "Overclocking modes", + "details": [ + "[DEPRECATED] No longer supported." + ], + "etors": [ { - "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_FABRIC_PORT_CONFIG", - "name": "stype", - "type": "$s_structure_type_t" + "desc": "Overclocking if off - hardware is running using factory default voltages/frequencies.", + "name": "$S_OC_MODE_OFF", + "value": "0" }, { - "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "const void*" + "desc": "Overclock override mode - In this mode, a fixed user-supplied voltage is applied independent of the frequency request. The maximum permitted frequency can also be increased. This mode disables INTERPOLATIVE and FIXED modes.", + "name": "$S_OC_MODE_OVERRIDE", + "value": "1" }, { - "desc": "[in,out] Port is configured up/down", - "name": "enabled", - "type": "$x_bool_t" + "desc": "Overclock interpolative mode - In this mode, the voltage/frequency curve can be extended with a new voltage/frequency point that will be interpolated. The existing voltage/frequency points can also be offset (up or down) by a fixed voltage. This mode disables FIXED and OVERRIDE modes.", + "name": "$S_OC_MODE_INTERPOLATIVE", + "value": "2" }, { - "desc": "[in,out] Beaconing is configured on/off", - "name": "beaconing", - "type": "$x_bool_t" + "desc": "Overclocking fixed Mode - In this mode, hardware will disable most frequency throttling and lock the frequency and voltage at the specified overclock values. This mode disables OVERRIDE and INTERPOLATIVE modes. This mode can damage the part, most of the protections are disabled on this mode.", + "name": "$S_OC_MODE_FIXED", + "value": "3" } ], - "name": "$s_fabric_port_config_t", - "type": "struct" + "name": "$s_oc_mode_t", + "type": "enum" }, { - "base": "$s_base_state_t", - "class": "$sFabricPort", - "desc": "Fabric port state", + "base": "$s_base_capability_t", + "class": "$sFrequency", + "desc": "Overclocking properties", + "details": [ + "Provides all the overclocking capabilities and properties supported by the device for the frequency domain.", + "[DEPRECATED] No longer supported." + ], "members": [ { "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_FABRIC_PORT_STATE", + "init": "$S_STRUCTURE_TYPE_OC_CAPABILITIES", "name": "stype", "type": "$s_structure_type_t" }, @@ -72490,113 +86637,83 @@ "type": "const void*" }, { - "desc": "[out] The current status of the port", - "name": "status", - "type": "$s_fabric_port_status_t" + "desc": "[out] Indicates if any overclocking features are supported on this frequency domain.", + "name": "isOcSupported", + "type": "$x_bool_t" }, { - "desc": "[out] If status is $S_FABRIC_PORT_STATUS_DEGRADED,\nthen this gives a combination of $s_fabric_port_qual_issue_flag_t for quality issues that have been detected;\notherwise, 0 indicates there are no quality issues with the link at this time.\n", - "name": "qualityIssues", - "type": "$s_fabric_port_qual_issue_flags_t" + "desc": "[out] Factory default non-overclock maximum frequency in Mhz.", + "name": "maxFactoryDefaultFrequency", + "type": "double" }, { - "desc": "[out] If status is $S_FABRIC_PORT_STATUS_FAILED,\nthen this gives a combination of $s_fabric_port_failure_flag_t for reasons for the connection instability;\notherwise, 0 indicates there are no connection stability issues at this time.\n", - "name": "failureReasons", - "type": "$s_fabric_port_failure_flags_t" + "desc": "[out] Factory default voltage used for the non-overclock maximum frequency in MHz.", + "name": "maxFactoryDefaultVoltage", + "type": "double" }, { - "desc": "[out] The unique port identifier for the remote connection point if status is $S_FABRIC_PORT_STATUS_HEALTHY, $S_FABRIC_PORT_STATUS_DEGRADED or $S_FABRIC_PORT_STATUS_FAILED", - "name": "remotePortId", - "type": "$s_fabric_port_id_t" + "desc": "[out] Maximum hardware overclocking frequency limit in Mhz.", + "name": "maxOcFrequency", + "type": "double" }, { - "desc": "[out] Current maximum receive speed (sum of all lanes)", - "name": "rxSpeed", - "type": "$s_fabric_port_speed_t" + "desc": "[out] The minimum voltage offset that can be applied to the voltage/frequency curve. Note that this number can be negative.", + "name": "minOcVoltageOffset", + "type": "double" }, { - "desc": "[out] Current maximum transmit speed (sum of all lanes)", - "name": "txSpeed", - "type": "$s_fabric_port_speed_t" - } - ], - "name": "$s_fabric_port_state_t", - "type": "struct" - }, - { - "class": "$sFabricPort", - "desc": "Fabric port throughput.", - "members": [ - { - "desc": "[out] Monotonic timestamp counter in microseconds when the measurement was made.\nThis timestamp should only be used to calculate delta time between snapshots of this structure.\nNever take the delta of this timestamp with the timestamp from a different structure since they are not guaranteed to have the same base.\nThe absolute value of the timestamp is only valid during within the application and may be different on the next execution.\n", - "name": "timestamp", - "type": "uint64_t" + "desc": "[out] The maximum voltage offset that can be applied to the voltage/frequency curve.", + "name": "maxOcVoltageOffset", + "type": "double" }, { - "desc": "[out] Monotonic counter for the number of bytes received (sum of all lanes). This includes all protocol overhead, not only the GPU traffic.", - "name": "rxCounter", - "type": "uint64_t" + "desc": "[out] The maximum overclock voltage that hardware supports.", + "name": "maxOcVoltage", + "type": "double" }, { - "desc": "[out] Monotonic counter for the number of bytes transmitted (sum of all lanes). This includes all protocol overhead, not only the GPU traffic.", - "name": "txCounter", - "type": "uint64_t" - } - ], - "name": "$s_fabric_port_throughput_t", - "type": "struct" - }, - { - "base": "$s_base_properties_t", - "class": "$sFabricPort", - "desc": "Fabric Port Error Counters", - "members": [ - { - "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_FABRIC_PORT_ERROR_COUNTERS", - "name": "stype", - "type": "$s_structure_type_t" + "desc": "[out] Indicates if the maximum temperature limit (TjMax) can be changed for this frequency domain.", + "name": "isTjMaxSupported", + "type": "$x_bool_t" }, { - "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "void*" + "desc": "[out] Indicates if the maximum current (IccMax) can be changed for this frequency domain.", + "name": "isIccMaxSupported", + "type": "$x_bool_t" }, { - "desc": "[out] Link Failure Error Count reported per port", - "name": "linkFailureCount", - "type": "uint64_t" + "desc": "[out] Indicates if this frequency domains supports a feature to set very high voltages.", + "name": "isHighVoltModeCapable", + "type": "$x_bool_t" }, { - "desc": "[out] Firmware Communication Error Count reported per device", - "name": "fwCommErrorCount", - "type": "uint64_t" + "desc": "[out] Indicates if very high voltages are permitted on this frequency domain.", + "name": "isHighVoltModeEnabled", + "type": "$x_bool_t" }, { - "desc": "[out] Firmware reported Error Count reported per device", - "name": "fwErrorCount", - "type": "uint64_t" + "desc": "[out] Indicates if the extended overclocking features are supported. If this is supported, increments are on 1 Mhz basis.", + "name": "isExtendedModeSupported", + "type": "$x_bool_t" }, { - "desc": "[out] Link Degrade Error Count reported per port", - "name": "linkDegradeCount", - "type": "uint64_t" + "desc": "[out] Indicates if the fixed mode is supported. In this mode, hardware will disable most frequency throttling and lock the frequency and voltage at the specified overclock values.", + "name": "isFixedModeSupported", + "type": "$x_bool_t" } ], - "name": "$s_fabric_port_error_counters_t", - "type": "struct", - "version": "1.7" + "name": "$s_oc_capabilities_t", + "type": "struct" }, { "class": "$sDevice", - "desc": "Get handle of Fabric ports in a device", + "desc": "Get handle of frequency domains", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "f8b22e29f845c563af633d8a69c44bcecceda14be9ca6c0151d348a192c5f7ff", - "name": "EnumFabricPorts", + "hash": "3a4d3adfa79bc56aef50d3cd79d36487a13688f3b3c2bf544441d95b1271691a", + "name": "EnumFrequencyDomains", "params": [ { "desc": "[in] Sysman handle of the device.", @@ -72610,8 +86727,8 @@ }, { "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", - "name": "phPort", - "type": "$s_fabric_port_handle_t*" + "name": "phFrequency", + "type": "$s_freq_handle_t*" } ], "returns": [ @@ -72644,24 +86761,24 @@ "type": "function" }, { - "class": "$sFabricPort", - "desc": "Get Fabric port properties", + "class": "$sFrequency", + "desc": "Get frequency properties - available frequencies", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "ea925c2484ecfb42a7ff5ac43d9d1d5317c3c0eac0b00b153eecbb1025a2a12f", + "hash": "b210e5b5cec54e67a85b2332aea68467458e3b15a971322b850426200f3aa94d", "name": "GetProperties", "params": [ { "desc": "[in] Handle for the component.", - "name": "hPort", - "type": "$s_fabric_port_handle_t" + "name": "hFrequency", + "type": "$s_freq_handle_t" }, { - "desc": "[in,out] Will contain properties of the Fabric Port.", + "desc": "[in,out] The frequency properties for the specified domain.", "name": "pProperties", - "type": "$s_fabric_port_properties_t*" + "type": "$s_freq_properties_t*" } ], "returns": [ @@ -72682,7 +86799,7 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hPort`" + "`nullptr == hFrequency`" ] }, { @@ -72694,24 +86811,30 @@ "type": "function" }, { - "class": "$sFabricPort", - "desc": "Get Fabric port link type", + "class": "$sFrequency", + "desc": "Get available non-overclocked hardware clock frequencies for the frequency domain", "details": [ + "The list of available frequencies is returned in order of slowest to fastest.", "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "ded4dbd69e173ddcbb1a8dfa0aa5d9c019a40c71a09ab024e055ef4dbbad1ca0", - "name": "GetLinkType", + "hash": "1e3eebd0166a83daf2ae65a559bf765664cd393e3e131aa4e983f538ba8baf64", + "name": "GetAvailableClocks", "params": [ { - "desc": "[in] Handle for the component.", - "name": "hPort", - "type": "$s_fabric_port_handle_t" + "desc": "[in] Sysman handle of the device.", + "name": "hFrequency", + "type": "$s_freq_handle_t" }, { - "desc": "[in,out] Will contain details about the link attached to the Fabric port.", - "name": "pLinkType", - "type": "$s_fabric_link_type_t*" + "desc": "[in,out] pointer to the number of frequencies.\nif count is zero, then the driver shall update the value with the total number of frequencies that are available.\nif count is greater than the number of frequencies that are available, then the driver shall update the value with the correct number of frequencies.\n", + "name": "pCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pCount)] array of frequencies in units of MHz and sorted from slowest to fastest.\nif count is less than the number of frequencies that are available, then the driver shall only retrieve that number of frequencies.\n", + "name": "phFrequency", + "type": "double*" } ], "returns": [ @@ -72732,36 +86855,36 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hPort`" + "`nullptr == hFrequency`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pLinkType`" + "`nullptr == pCount`" ] } ], "type": "function" }, { - "class": "$sFabricPort", - "desc": "Get Fabric port configuration", + "class": "$sFrequency", + "desc": "Get current frequency limits", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "9b752ed8f8cb948b4bc79d6e0e9a013e741232e239086a6095d66f75aa1ff9ab", - "name": "GetConfig", + "hash": "a9d1984f6ba89157405380e202cbd1031171726de90f2ed76f1c3ae3c1c5ec15", + "name": "GetRange", "params": [ { "desc": "[in] Handle for the component.", - "name": "hPort", - "type": "$s_fabric_port_handle_t" + "name": "hFrequency", + "type": "$s_freq_handle_t" }, { - "desc": "[in,out] Will contain configuration of the Fabric Port.", - "name": "pConfig", - "type": "$s_fabric_port_config_t*" + "desc": "[in,out] The range between which the hardware can operate for the specified domain.", + "name": "pLimits", + "type": "$s_freq_range_t*" } ], "returns": [ @@ -72782,36 +86905,37 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hPort`" + "`nullptr == hFrequency`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pConfig`" + "`nullptr == pLimits`" ] } ], "type": "function" }, { - "class": "$sFabricPort", - "desc": "Set Fabric port configuration", + "class": "$sFrequency", + "desc": "Set frequency range between which the hardware can operate.", "details": [ + "The application may call this function with the frequency range min and max values set to `-1` to request the frequency be (re)set to the default values.", "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "42192be3f94acb29b90f3c2405d35dc74ef538f272549e9127f112946a2a9884", - "name": "SetConfig", + "hash": "e510f70acdcb9a652fda8f2d444a9c7d0c4fcd724de88d78b34d1ef7c4248a2d", + "name": "SetRange", "params": [ { "desc": "[in] Handle for the component.", - "name": "hPort", - "type": "$s_fabric_port_handle_t" + "name": "hFrequency", + "type": "$s_freq_handle_t" }, { - "desc": "[in] Contains new configuration of the Fabric Port.", - "name": "pConfig", - "type": "const $s_fabric_port_config_t*" + "desc": "[in] The limits between which the hardware can operate for the specified domain.", + "name": "pLimits", + "type": "const $s_freq_range_t*" } ], "returns": [ @@ -72832,12 +86956,12 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hPort`" + "`nullptr == hFrequency`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pConfig`" + "`nullptr == pLimits`" ] }, { @@ -72849,24 +86973,24 @@ "type": "function" }, { - "class": "$sFabricPort", - "desc": "Get Fabric port state - status (health/degraded/failed/disabled), reasons for link degradation or instability, current rx/tx speed", + "class": "$sFrequency", + "desc": "Get current frequency state - frequency request, actual frequency, TDP limits", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "3739f03de8c9a2903fff758a13d5837ea02e4af8855c832f298fadb60c5b2924", + "hash": "0a8367760c6f7743ec27243e8d9f022854995115c9a64ee172fe0db821b462f9", "name": "GetState", "params": [ { "desc": "[in] Handle for the component.", - "name": "hPort", - "type": "$s_fabric_port_handle_t" + "name": "hFrequency", + "type": "$s_freq_handle_t" }, { - "desc": "[in,out] Will contain the current state of the Fabric Port", + "desc": "[in,out] Frequency state for the specified domain.", "name": "pState", - "type": "$s_fabric_port_state_t*" + "type": "$s_freq_state_t*" } ], "returns": [ @@ -72887,7 +87011,7 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hPort`" + "`nullptr == hFrequency`" ] }, { @@ -72899,24 +87023,24 @@ "type": "function" }, { - "class": "$sFabricPort", - "desc": "Get Fabric port throughput", + "class": "$sFrequency", + "desc": "Get frequency throttle time", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "b624dbb1f8e689bd83898f312af1283e0d67d3606e5440a6dbff6351ab6556b4", - "name": "GetThroughput", + "hash": "cd622002168430e88f48dce3e9b1fb51c92f6ef41c9d4fa64b18bb4274f8236d", + "name": "GetThrottleTime", "params": [ { "desc": "[in] Handle for the component.", - "name": "hPort", - "type": "$s_fabric_port_handle_t" + "name": "hFrequency", + "type": "$s_freq_handle_t" }, { - "desc": "[in,out] Will contain the Fabric port throughput counters.", - "name": "pThroughput", - "type": "$s_fabric_port_throughput_t*" + "desc": "[in,out] Will contain a snapshot of the throttle time counters for the specified domain.", + "name": "pThrottleTime", + "type": "$s_freq_throttle_time_t*" } ], "returns": [ @@ -72937,42 +87061,37 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hPort`" + "`nullptr == hFrequency`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pThroughput`" - ] - }, - { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to query this telemetry." + "`nullptr == pThrottleTime`" ] } ], "type": "function" }, { - "class": "$sFabricPort", - "desc": "Get Fabric Port Error Counters", + "class": "$sFrequency", + "desc": "Get the overclocking capabilities.", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free.", - "The memory backing the arrays for phPorts and ppThroughputs must be allocated in system memory by the user who is also responsible for releasing them when they are no longer needed." + "[DEPRECATED] No longer supported." ], - "hash": "67d5b753e3b6f42b1997d5d3db8f20671924a2eee917e7a8147cef40cc6dfeb0", - "name": "GetFabricErrorCounters", + "hash": "27bf6388e5923bdaa0967f8e74b1675ffd0e7c82980c7974dda6e82d24efc5c2", + "name": "OcGetCapabilities", "params": [ { "desc": "[in] Handle for the component.", - "name": "hPort", - "type": "$s_fabric_port_handle_t" + "name": "hFrequency", + "type": "$s_freq_handle_t" }, { - "desc": "[in,out] Will contain the Fabric port Error counters.", - "name": "pErrors", - "type": "$s_fabric_port_error_counters_t*" + "desc": "[in,out] Pointer to the capabilities structure.", + "name": "pOcCapabilities", + "type": "$s_oc_capabilities_t*" } ], "returns": [ @@ -72993,52 +87112,37 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hPort`" + "`nullptr == hFrequency`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pErrors`" - ] - }, - { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to query this telemetry." + "`nullptr == pOcCapabilities`" ] } ], - "type": "function", - "version": "1.7" + "type": "function" }, { - "class": "$sFabricPort", - "desc": "Get Fabric port throughput from multiple ports in a single call", + "class": "$sFrequency", + "desc": "Get the current overclocking frequency target, if extended moded is supported, will returned in 1 Mhz granularity.", "details": [ "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The implementation of this function should be lock-free.", + "[DEPRECATED] No longer supported." ], - "hash": "b19183e0e5208c1c5bac396db4c5d36d7334fbfdc1a7eedd01031666a174a232", - "name": "GetMultiPortThroughput", + "hash": "a1fee7e08b70a9ff9017be269ccba56a321c80f2a1bd0f08f4bf25b80edb8e87", + "name": "OcGetFrequencyTarget", "params": [ { - "desc": "[in] Sysman handle of the device.", - "name": "hDevice", - "type": "$s_device_handle_t" - }, - { - "desc": "[in] Number of ports enumerated in function $sDeviceEnumFabricPorts", - "name": "numPorts", - "type": "uint32_t" - }, - { - "desc": "[in][range(0, numPorts)] array of fabric port handles provided by user to gather throughput values. \n", - "name": "phPort", - "type": "$s_fabric_port_handle_t*" + "desc": "[in] Handle for the component.", + "name": "hFrequency", + "type": "$s_freq_handle_t" }, { - "desc": "[out][range(0, numPorts)] array of fabric port throughput counters from multiple ports of type $s_fabric_port_throughput_t.\n", - "name": "pThroughput", - "type": "$s_fabric_port_throughput_t**" + "desc": "[out] Overclocking Frequency in MHz, if extended moded is supported, will returned in 1 Mhz granularity, else, in multiples of 50 Mhz. This cannot be greater than the `maxOcFrequency` member of $s_oc_capabilities_t.", + "name": "pCurrentOcFrequency", + "type": "double*" } ], "returns": [ @@ -73059,265 +87163,196 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDevice`" + "`nullptr == hFrequency`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == phPort`", - "`nullptr == pThroughput`" + "`nullptr == pCurrentOcFrequency`" ] - } - ], - "type": "function", - "version": "1.7" - }, - { - "desc": "C++ wrapper for a Sysman device Fabric port", - "members": [ - { - "desc": "[in] handle of Sysman object", - "init": "nullptr", - "name": "handle", - "type": "$s_fabric_port_handle_t" - }, - { - "desc": "[in] pointer to owner object", - "name": "pDevice", - "type": "$sDevice*" - } - ], - "name": "$sFabricPort", - "owner": "$sDevice", - "type": "class" - } - ] - }, - { - "header": { - "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - Firmware management", - "ordinal": 1000, - "type": "header" - }, - "name": "fan", - "objects": [ - { - "class": "$sFan", - "desc": "Fan resource speed mode", - "etors": [ - { - "desc": "The fan speed is operating using the hardware default settings", - "name": "$S_FAN_SPEED_MODE_DEFAULT", - "value": "0" - }, - { - "desc": "The fan speed is currently set to a fixed value", - "name": "$S_FAN_SPEED_MODE_FIXED", - "value": "1" - }, - { - "desc": "The fan speed is currently controlled dynamically by hardware based on a temp/speed table", - "name": "$S_FAN_SPEED_MODE_TABLE", - "value": "2" - } - ], - "name": "$s_fan_speed_mode_t", - "type": "enum" - }, - { - "class": "$sFan", - "desc": "Fan speed units", - "etors": [ - { - "desc": "The fan speed is in units of revolutions per minute (rpm)", - "name": "$S_FAN_SPEED_UNITS_RPM", - "value": "0" }, { - "desc": "The fan speed is a percentage of the maximum speed of the fan", - "name": "$S_FAN_SPEED_UNITS_PERCENT", - "value": "1" - } - ], - "name": "$s_fan_speed_units_t", - "type": "enum" - }, - { - "class": "$sFan", - "desc": "Fan speed", - "members": [ - { - "desc": "[in,out] The speed of the fan. On output, a value of -1 indicates that there is no fixed fan speed setting.", - "name": "speed", - "type": "int32_t" + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "Overclocking is not supported on this frequency domain (see the `isOcSupported` member of $s_oc_capabilities_t).", + "The specified voltage and/or frequency overclock settings exceed the hardware values (see the `maxOcFrequency`, `maxOcVoltage`, `minOcVoltageOffset` and `maxOcVoltageOffset` members of $s_oc_capabilities_t).", + "Requested voltage overclock is very high but the `isHighVoltModeEnabled` member of $s_oc_capabilities_t is not enabled for the device." + ] }, { - "desc": "[in,out] The units that the fan speed is expressed in. On output, if fan speed is -1 then units should be ignored.", - "name": "units", - "type": "$s_fan_speed_units_t" - } - ], - "name": "$s_fan_speed_t", - "type": "struct" - }, - { - "class": "$sFan", - "desc": "Fan temperature/speed pair", - "members": [ - { - "desc": "[in,out] Temperature in degrees Celsius.", - "name": "temperature", - "type": "uint32_t" + "$X_RESULT_ERROR_NOT_AVAILABLE": [ + "Overclocking feature is locked on this frequency domain." + ] }, { - "desc": "[in,out] The speed of the fan", - "name": "speed", - "type": "$s_fan_speed_t" + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "User does not have permissions to make these modifications." + ] } ], - "name": "$s_fan_temp_speed_t", - "type": "struct" - }, - { - "desc": "Maximum number of fan temperature/speed pairs in the fan speed table.", - "name": "$S_FAN_TEMP_SPEED_PAIR_COUNT", - "type": "macro", - "value": "32" + "type": "function" }, { - "class": "$sFan", - "desc": "Fan speed table", - "members": [ + "class": "$sFrequency", + "desc": "Set the current overclocking frequency target, if extended moded is supported, can be set in 1 Mhz granularity.", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free.", + "[DEPRECATED] No longer supported." + ], + "hash": "3a6b01a51f459abd4b5094093ec355d270545a80ddac2792d06d29aee7463e1b", + "name": "OcSetFrequencyTarget", + "params": [ { - "desc": "[in,out] The number of valid points in the fan speed table. 0 means that there is no fan speed table configured. -1 means that a fan speed table is not supported by the hardware.", - "name": "numPoints", - "type": "int32_t" + "desc": "[in] Handle for the component.", + "name": "hFrequency", + "type": "$s_freq_handle_t" }, { - "desc": "[in,out] Array of temperature/fan speed pairs. The table is ordered based on temperature from lowest to highest.", - "name": "table[$S_FAN_TEMP_SPEED_PAIR_COUNT]", - "type": "$s_fan_temp_speed_t" + "desc": "[in] Overclocking Frequency in MHz, if extended moded is supported, it could be set in 1 Mhz granularity, else, in multiples of 50 Mhz. This cannot be greater than the `maxOcFrequency` member of $s_oc_capabilities_t.", + "name": "CurrentOcFrequency", + "type": "double" } ], - "name": "$s_fan_speed_table_t", - "type": "struct" - }, - { - "base": "$s_base_properties_t", - "class": "$sFan", - "desc": "Fan properties", - "members": [ + "returns": [ { - "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_FAN_PROPERTIES", - "name": "stype", - "type": "$s_structure_type_t" + "$X_RESULT_SUCCESS": [] }, { - "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "void*" + "$X_RESULT_ERROR_UNINITIALIZED": [] }, { - "desc": "[out] True if the resource is located on a sub-device; false means that the resource is on the device of the calling Sysman handle", - "name": "onSubdevice", - "type": "$x_bool_t" + "$X_RESULT_ERROR_DEVICE_LOST": [] }, { - "desc": "[out] If onSubdevice is true, this gives the ID of the sub-device", - "name": "subdeviceId", - "type": "uint32_t" + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] }, { - "desc": "[out] Indicates if software can control the fan speed assuming the user has permissions", - "name": "canControl", - "type": "$x_bool_t" + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] }, { - "desc": "[out] Bitfield of supported fan configuration modes (1<<$s_fan_speed_mode_t)", - "name": "supportedModes", - "type": "uint32_t" + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hFrequency`" + ] }, { - "desc": "[out] Bitfield of supported fan speed units (1<<$s_fan_speed_units_t)", - "name": "supportedUnits", - "type": "uint32_t" + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "Overclocking is not supported on this frequency domain (see the `isOcSupported` member of $s_oc_capabilities_t).", + "The specified voltage and/or frequency overclock settings exceed the hardware values (see the `maxOcFrequency`, `maxOcVoltage`, `minOcVoltageOffset` and `maxOcVoltageOffset` members of $s_oc_capabilities_t).", + "Requested voltage overclock is very high but the `isHighVoltModeEnabled` member of $s_oc_capabilities_t is not enabled for the device." + ] }, { - "desc": "[out] The maximum RPM of the fan. A value of -1 means that this property is unknown. ", - "name": "maxRPM", - "type": "int32_t" + "$X_RESULT_ERROR_NOT_AVAILABLE": [ + "Overclocking feature is locked on this frequency domain." + ] }, { - "desc": "[out] The maximum number of points in the fan temp/speed table. A value of -1 means that this fan doesn't support providing a temp/speed table.", - "name": "maxPoints", - "type": "int32_t" + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "User does not have permissions to make these modifications." + ] } ], - "name": "$s_fan_properties_t", - "type": "struct" + "type": "function" }, { - "base": "$s_base_config_t", - "class": "$sFan", - "desc": "Fan configuration", - "members": [ + "class": "$sFrequency", + "desc": "Get the current overclocking voltage settings.", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free.", + "[DEPRECATED] No longer supported." + ], + "hash": "f6a3671ccc34ac2d3e6af12869ff5edfc85e3cc20db0d48b61cfe96781198c94", + "name": "OcGetVoltageTarget", + "params": [ { - "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_FAN_CONFIG", - "name": "stype", - "type": "$s_structure_type_t" + "desc": "[in] Handle for the component.", + "name": "hFrequency", + "type": "$s_freq_handle_t" }, { - "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "const void*" + "desc": "[out] Overclock voltage in Volts. This cannot be greater than the `maxOcVoltage` member of $s_oc_capabilities_t.", + "name": "pCurrentVoltageTarget", + "type": "double*" }, { - "desc": "[in,out] The fan speed mode (fixed, temp-speed table)", - "name": "mode", - "type": "$s_fan_speed_mode_t" + "desc": "[out] This voltage offset is applied to all points on the voltage/frequency curve, including the new overclock voltageTarget. Valid range is between the `minOcVoltageOffset` and `maxOcVoltageOffset` members of $s_oc_capabilities_t.", + "name": "pCurrentVoltageOffset", + "type": "double*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] }, { - "desc": "[in,out] The current fixed fan speed setting", - "name": "speedFixed", - "type": "$s_fan_speed_t" + "$X_RESULT_ERROR_UNINITIALIZED": [] }, { - "desc": "[out] A table containing temperature/speed pairs", - "name": "speedTable", - "type": "$s_fan_speed_table_t" + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hFrequency`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCurrentVoltageTarget`", + "`nullptr == pCurrentVoltageOffset`" + ] + }, + { + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "Overclocking is not supported on this frequency domain (see the `isOcSupported` member of $s_oc_capabilities_t).", + "The specified voltage and/or frequency overclock settings exceed the hardware values (see the `maxOcFrequency`, `maxOcVoltage`, `minOcVoltageOffset` and `maxOcVoltageOffset` members of $s_oc_capabilities_t).", + "Requested voltage overclock is very high but the `isHighVoltModeEnabled` member of $s_oc_capabilities_t is not enabled for the device." + ] + }, + { + "$X_RESULT_ERROR_NOT_AVAILABLE": [ + "Overclocking feature is locked on this frequency domain." + ] + }, + { + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "User does not have permissions to make these modifications." + ] } ], - "name": "$s_fan_config_t", - "type": "struct" + "type": "function" }, { - "class": "$sDevice", - "desc": "Get handle of fans", + "class": "$sFrequency", + "desc": "Set the current overclocking voltage settings.", "details": [ "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The implementation of this function should be lock-free.", + "[DEPRECATED] No longer supported." ], - "hash": "cd402f983e5dc2e1f226dccb0609064e6bd118037410019a20723a8a58c6c4a5", - "name": "EnumFans", + "hash": "5f4c50d38e299212417f47798a74b4da436371eaee20c92098f13d3192b8b590", + "name": "OcSetVoltageTarget", "params": [ { - "desc": "[in] Sysman handle of the device.", - "name": "hDevice", - "type": "$s_device_handle_t" + "desc": "[in] Handle for the component.", + "name": "hFrequency", + "type": "$s_freq_handle_t" }, { - "desc": "[in,out] pointer to the number of components of this type.\nif count is zero, then the driver shall update the value with the total number of components of this type that are available.\nif count is greater than the number of components of this type that are available, then the driver shall update the value with the correct number of components.\n", - "name": "pCount", - "type": "uint32_t*" + "desc": "[in] Overclock voltage in Volts. This cannot be greater than the `maxOcVoltage` member of $s_oc_capabilities_t.", + "name": "CurrentVoltageTarget", + "type": "double" }, { - "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", - "name": "phFan", - "type": "$s_fan_handle_t*" + "desc": "[in] This voltage offset is applied to all points on the voltage/frequency curve, include the new overclock voltageTarget. Valid range is between the `minOcVoltageOffset` and `maxOcVoltageOffset` members of $s_oc_capabilities_t.", + "name": "CurrentVoltageOffset", + "type": "double" } ], "returns": [ @@ -73338,36 +87373,49 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDevice`" + "`nullptr == hFrequency`" ] }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pCount`" + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "Overclocking is not supported on this frequency domain (see the `isOcSupported` member of $s_oc_capabilities_t).", + "The specified voltage and/or frequency overclock settings exceed the hardware values (see the `maxOcFrequency`, `maxOcVoltage`, `minOcVoltageOffset` and `maxOcVoltageOffset` members of $s_oc_capabilities_t).", + "Requested voltage overclock is very high but the `isHighVoltModeEnabled` member of $s_oc_capabilities_t is not enabled for the device." + ] + }, + { + "$X_RESULT_ERROR_NOT_AVAILABLE": [ + "Overclocking feature is locked on this frequency domain." + ] + }, + { + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "User does not have permissions to make these modifications." ] } ], "type": "function" }, { - "class": "$sFan", - "desc": "Get fan properties", + "class": "$sFrequency", + "desc": "Set the current overclocking mode.", "details": [ "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The implementation of this function should be lock-free.", + "[DEPRECATED] No longer supported." ], - "hash": "0e96fab12a31e4d2266ddf46d5810c1f16c5e021efe80d5aab57b063de11a434", - "name": "GetProperties", + "hash": "309c17c47d975efe332fedbe4501950c7216615dbfaeec37f3de3576ee3d5407", + "name": "OcSetMode", "params": [ { "desc": "[in] Handle for the component.", - "name": "hFan", - "type": "$s_fan_handle_t" + "name": "hFrequency", + "type": "$s_freq_handle_t" }, { - "desc": "[in,out] Will contain the properties of the fan.", - "name": "pProperties", - "type": "$s_fan_properties_t*" + "desc": "[in] Current Overclocking Mode $s_oc_mode_t.", + "name": "CurrentOcMode", + "type": "$s_oc_mode_t" } ], "returns": [ @@ -73388,36 +87436,54 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hFan`" + "`nullptr == hFrequency`" ] }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pProperties`" + "$X_RESULT_ERROR_INVALID_ENUMERATION": [ + "`$S_OC_MODE_FIXED < CurrentOcMode`" + ] + }, + { + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "Overclocking is not supported on this frequency domain (see the `isOcSupported` member of $s_oc_capabilities_t).", + "The specified voltage and/or frequency overclock settings exceed the hardware values (see the `maxOcFrequency`, `maxOcVoltage`, `minOcVoltageOffset` and `maxOcVoltageOffset` members of $s_oc_capabilities_t).", + "Requested voltage overclock is very high but the `isHighVoltModeEnabled` member of $s_oc_capabilities_t is not enabled for the device." + ] + }, + { + "$X_RESULT_ERROR_NOT_AVAILABLE": [ + "Overclocking feature is locked on this frequency domain." + ] + }, + { + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "User does not have permissions to make these modifications." ] } ], "type": "function" }, { - "class": "$sFan", - "desc": "Get fan configurations and the current fan speed mode (default, fixed, temp-speed table)", + "class": "$sFrequency", + "desc": "Get the current overclocking mode.", "details": [ "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The implementation of this function should be lock-free.", + "[DEPRECATED] No longer supported." ], - "hash": "43951de8c82fdfc9dd54e3fe5219be6e9cca4baef47fa8dd07bef5e59840df82", - "name": "GetConfig", + "hash": "62c4575e249097bdec5d726201f5f1259da813d0d7c0045814a5b917ff6a1308", + "name": "OcGetMode", "params": [ { "desc": "[in] Handle for the component.", - "name": "hFan", - "type": "$s_fan_handle_t" + "name": "hFrequency", + "type": "$s_freq_handle_t" }, { - "desc": "[in,out] Will contain the current configuration of the fan.", - "name": "pConfig", - "type": "$s_fan_config_t*" + "desc": "[out] Current Overclocking Mode $s_oc_mode_t.", + "name": "pCurrentOcMode", + "type": "$s_oc_mode_t*" } ], "returns": [ @@ -73438,31 +87504,54 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hFan`" + "`nullptr == hFrequency`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pConfig`" + "`nullptr == pCurrentOcMode`" + ] + }, + { + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "Overclocking is not supported on this frequency domain (see the `isOcSupported` member of $s_oc_capabilities_t).", + "The specified voltage and/or frequency overclock settings exceed the hardware values (see the `maxOcFrequency`, `maxOcVoltage`, `minOcVoltageOffset` and `maxOcVoltageOffset` members of $s_oc_capabilities_t).", + "Requested voltage overclock is very high but the `isHighVoltModeEnabled` member of $s_oc_capabilities_t is not enabled for the device." + ] + }, + { + "$X_RESULT_ERROR_NOT_AVAILABLE": [ + "Overclocking feature is locked on this frequency domain." + ] + }, + { + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "User does not have permissions to make these modifications." ] } ], "type": "function" }, { - "class": "$sFan", - "desc": "Configure the fan to run with hardware factory settings (set mode to $S_FAN_SPEED_MODE_DEFAULT)", + "class": "$sFrequency", + "desc": "Get the maximum current limit setting.", "details": [ "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The implementation of this function should be lock-free.", + "[DEPRECATED] No longer supported." ], - "hash": "3f32c8b4c13c29cd9a801fb9abdb42c1b1e96c76465506d70a3c9b0a234997c5", - "name": "SetDefaultMode", + "hash": "dd3afa560c90667b89253d02e45759933e6ee6a5f4a4657c783e821f9b8d8660", + "name": "OcGetIccMax", "params": [ { "desc": "[in] Handle for the component.", - "name": "hFan", - "type": "$s_fan_handle_t" + "name": "hFrequency", + "type": "$s_freq_handle_t" + }, + { + "desc": "[in,out] Will contain the maximum current limit in Amperes on successful return.", + "name": "pOcIccMax", + "type": "double*" } ], "returns": [ @@ -73483,36 +87572,44 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hFan`" + "`nullptr == hFrequency`" ] }, { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to make these modifications." + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pOcIccMax`" + ] + }, + { + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "Overclocking is not supported on this frequency domain (see the `isOcSupported` member of $s_oc_capabilities_t).", + "Capability the `isIccMaxSupported` member of $s_oc_capabilities_t is false for this frequency domain." ] } ], "type": "function" }, { - "class": "$sFan", - "desc": "Configure the fan to rotate at a fixed speed (set mode to $S_FAN_SPEED_MODE_FIXED)", + "class": "$sFrequency", + "desc": "Change the maximum current limit setting.", "details": [ + "Setting ocIccMax to 0.0 will return the value to the factory default.", "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The implementation of this function should be lock-free.", + "[DEPRECATED] No longer supported." ], - "hash": "398f43a1f432602ccfac89afb43dfcb063e4d3b17e473a0e486fcfed9bae3945", - "name": "SetFixedSpeedMode", + "hash": "e75fd6668d4a7b5f10fc95f5830293547df215abe25c798afb1b88def4360fe6", + "name": "OcSetIccMax", "params": [ { "desc": "[in] Handle for the component.", - "name": "hFan", - "type": "$s_fan_handle_t" + "name": "hFrequency", + "type": "$s_freq_handle_t" }, { - "desc": "[in] The fixed fan speed setting", - "name": "speed", - "type": "const $s_fan_speed_t*" + "desc": "[in] The new maximum current limit in Amperes.", + "name": "ocIccMax", + "type": "double" } ], "returns": [ @@ -73533,46 +87630,53 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hFan`" + "`nullptr == hFrequency`" ] }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == speed`" + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "Overclocking is not supported on this frequency domain (see the `isOcSupported` member of $s_oc_capabilities_t).", + "The `isIccMaxSupported` member of $s_oc_capabilities_t is false for this frequency domain." ] }, { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to make these modifications." + "$X_RESULT_ERROR_NOT_AVAILABLE": [ + "Overclocking feature is locked on this frequency domain." ] }, { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "Fixing the fan speed not supported by the hardware or the fan speed units are not supported. See the `supportedModes` and `supportedUnits` members of $s_fan_properties_t." + "$X_RESULT_ERROR_INVALID_ARGUMENT": [ + "The specified current limit is too low or too high." + ] + }, + { + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "User does not have permissions to make these modifications." ] } ], "type": "function" }, { - "class": "$sFan", - "desc": "Configure the fan to adjust speed based on a temperature/speed table (set mode to $S_FAN_SPEED_MODE_TABLE)", + "class": "$sFrequency", + "desc": "Get the maximum temperature limit setting.", "details": [ "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The implementation of this function should be lock-free.", + "[DEPRECATED] No longer supported." ], - "hash": "4a3133b6a3f27db154819ab2a6b881355cad632a0ef1c30235d89948bf2273c8", - "name": "SetSpeedTableMode", + "hash": "c1758ddfd68bb1988d3753bb71636b3b666c3f011d35cd830c8d0434c777d5e3", + "name": "OcGetTjMax", "params": [ { "desc": "[in] Handle for the component.", - "name": "hFan", - "type": "$s_fan_handle_t" + "name": "hFrequency", + "type": "$s_freq_handle_t" }, { - "desc": "[in] A table containing temperature/speed pairs.", - "name": "speedTable", - "type": "const $s_fan_speed_table_t*" + "desc": "[in,out] Will contain the maximum temperature limit in degrees Celsius on successful return.", + "name": "pOcTjMax", + "type": "double*" } ], "returns": [ @@ -73593,56 +87697,43 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hFan`" + "`nullptr == hFrequency`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == speedTable`" - ] - }, - { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to make these modifications." - ] - }, - { - "$X_RESULT_ERROR_INVALID_ARGUMENT": [ - "The temperature/speed pairs in the array are not sorted on temperature from lowest to highest." + "`nullptr == pOcTjMax`" ] }, { "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "Fan speed table not supported by the hardware or the fan speed units are not supported. See the `supportedModes` and `supportedUnits` members of $s_fan_properties_t." + "Overclocking is not supported on this frequency domain (see the `isOcSupported` member of $s_oc_capabilities_t)." ] } ], "type": "function" }, { - "class": "$sFan", - "desc": "Get current state of a fan - current mode and speed", + "class": "$sFrequency", + "desc": "Change the maximum temperature limit setting.", "details": [ + "Setting ocTjMax to 0.0 will return the value to the factory default.", "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The implementation of this function should be lock-free.", + "[DEPRECATED] No longer supported." ], - "hash": "337b9820995404b2f3e61231b0396074ccf89065c86f1e223fd07365483735f0", - "name": "GetState", + "hash": "742e421c8ae9294b2993a07eab549a060b678d7a5c74c5c71ce6e012f22d50aa", + "name": "OcSetTjMax", "params": [ { "desc": "[in] Handle for the component.", - "name": "hFan", - "type": "$s_fan_handle_t" - }, - { - "desc": "[in] The units in which the fan speed should be returned.", - "name": "units", - "type": "$s_fan_speed_units_t" + "name": "hFrequency", + "type": "$s_freq_handle_t" }, { - "desc": "[in,out] Will contain the current speed of the fan in the units requested. A value of -1 indicates that the fan speed cannot be measured.", - "name": "pSpeed", - "type": "int32_t*" + "desc": "[in] The new maximum temperature limit in degrees Celsius.", + "name": "ocTjMax", + "type": "double" } ], "returns": [ @@ -73663,35 +87754,41 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hFan`" + "`nullptr == hFrequency`" ] }, { - "$X_RESULT_ERROR_INVALID_ENUMERATION": [ - "`$S_FAN_SPEED_UNITS_PERCENT < units`" + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "Overclocking is not supported on this frequency domain (see the `isOcSupported` member of $s_oc_capabilities_t).", + "The `isTjMaxSupported` member of $s_oc_capabilities_t is false for this frequency domain." ] }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pSpeed`" + "$X_RESULT_ERROR_NOT_AVAILABLE": [ + "Overclocking feature is locked on this frequency domain." ] }, { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "The requested fan speed units are not supported. See the `supportedUnits` member of $s_fan_properties_t." + "$X_RESULT_ERROR_INVALID_ARGUMENT": [ + "The specified temperature limit is too high." + ] + }, + { + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "User does not have permissions to make these modifications." ] } ], "type": "function" }, { - "desc": "C++ wrapper for a Sysman device fan", + "desc": "C++ wrapper for a Sysman device frequency domain", "members": [ { "desc": "[in] handle of Sysman object", "init": "nullptr", "name": "handle", - "type": "$s_fan_handle_t" + "type": "$s_freq_handle_t" }, { "desc": "[in] pointer to owner object", @@ -73699,7 +87796,7 @@ "type": "$sDevice*" } ], - "name": "$sFan", + "name": "$sFrequency", "owner": "$sDevice", "type": "class" } @@ -73711,16 +87808,16 @@ "ordinal": 1000, "type": "header" }, - "name": "firmware", + "name": "led", "objects": [ { "base": "$s_base_properties_t", - "class": "$sFirmware", - "desc": "Firmware properties", + "class": "$sLed", + "desc": "LED properties", "members": [ { "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_FIRMWARE_PROPERTIES", + "init": "$S_STRUCTURE_TYPE_LED_PROPERTIES", "name": "stype", "type": "$s_structure_type_t" }, @@ -73736,38 +87833,87 @@ "type": "$x_bool_t" }, { - "desc": "[out] If onSubdevice is true, this gives the ID of the sub-device", - "name": "subdeviceId", - "type": "uint32_t" + "desc": "[out] If onSubdevice is true, this gives the ID of the sub-device", + "name": "subdeviceId", + "type": "uint32_t" + }, + { + "desc": "[out] Indicates if software can control the LED assuming the user has permissions", + "name": "canControl", + "type": "$x_bool_t" + }, + { + "desc": "[out] Indicates if the LED is RGB capable", + "name": "haveRGB", + "type": "$x_bool_t" + } + ], + "name": "$s_led_properties_t", + "type": "struct" + }, + { + "class": "$sLed", + "desc": "LED color", + "members": [ + { + "desc": "[in,out][range(0.0, 1.0)] The LED red value. On output, a value less than 0.0 indicates that the color is not known.", + "name": "red", + "type": "double" + }, + { + "desc": "[in,out][range(0.0, 1.0)] The LED green value. On output, a value less than 0.0 indicates that the color is not known.", + "name": "green", + "type": "double" + }, + { + "desc": "[in,out][range(0.0, 1.0)] The LED blue value. On output, a value less than 0.0 indicates that the color is not known.", + "name": "blue", + "type": "double" + } + ], + "name": "$s_led_color_t", + "type": "struct" + }, + { + "base": "$s_base_state_t", + "class": "$sLed", + "desc": "LED state", + "members": [ + { + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_LED_STATE", + "name": "stype", + "type": "$s_structure_type_t" + }, + { + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" }, { - "desc": "[out] Indicates if software can flash the firmware assuming the user has permissions", - "name": "canControl", + "desc": "[out] Indicates if the LED is on or off", + "name": "isOn", "type": "$x_bool_t" }, { - "desc": "[out] NULL terminated string value. The string \"unknown\" will be returned if this property cannot be determined.", - "name": "name[$S_STRING_PROPERTY_SIZE]", - "type": "char" - }, - { - "desc": "[out] NULL terminated string value. The string \"unknown\" will be returned if this property cannot be determined.", - "name": "version[$S_STRING_PROPERTY_SIZE]", - "type": "char" + "desc": "[out] Color of the LED", + "name": "color", + "type": "$s_led_color_t" } ], - "name": "$s_firmware_properties_t", + "name": "$s_led_state_t", "type": "struct" }, { "class": "$sDevice", - "desc": "Get handle of firmwares", + "desc": "Get handle of LEDs", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "9ba0753daddbd3a471d4b8ecb7290ed7990b77741e191e3498fd13a8961ca8bf", - "name": "EnumFirmwares", + "hash": "8c338f22d1047a3079b9f4adf6b0598674b17ba06e0605b1aaa547b901ecae6a", + "name": "EnumLeds", "params": [ { "desc": "[in] Sysman handle of the device.", @@ -73781,8 +87927,8 @@ }, { "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", - "name": "phFirmware", - "type": "$s_firmware_handle_t*" + "name": "phLed", + "type": "$s_led_handle_t*" } ], "returns": [ @@ -73815,24 +87961,24 @@ "type": "function" }, { - "class": "$sFirmware", - "desc": "Get firmware properties", + "class": "$sLed", + "desc": "Get LED properties", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "11f91797bbbaac14954b82406293fb175c9081593e31494018c8487316177204", + "hash": "82a7ff7d95623a38fdcea5fc8c1de9b334a8ccf9c29c9e97328ab519e132c890", "name": "GetProperties", "params": [ { "desc": "[in] Handle for the component.", - "name": "hFirmware", - "type": "$s_firmware_handle_t" + "name": "hLed", + "type": "$s_led_handle_t" }, { - "desc": "[in,out] Pointer to an array that will hold the properties of the firmware", + "desc": "[in,out] Will contain the properties of the LED.", "name": "pProperties", - "type": "$s_firmware_properties_t*" + "type": "$s_led_properties_t*" } ], "returns": [ @@ -73853,7 +87999,7 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hFirmware`" + "`nullptr == hLed`" ] }, { @@ -73865,29 +88011,24 @@ "type": "function" }, { - "class": "$sFirmware", - "desc": "Flash a new firmware image", + "class": "$sLed", + "desc": "Get current state of a LED - on/off, color", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "a6cc43172f030767262ce409a236ed03fd2f41a4abb336ece7e0e1bd642004b4", - "name": "Flash", + "hash": "d66be9cc597cbc060f0cd3592d6e15bbccb1be0823781f22c5746d2e64c460f1", + "name": "GetState", "params": [ { "desc": "[in] Handle for the component.", - "name": "hFirmware", - "type": "$s_firmware_handle_t" - }, - { - "desc": "[in] Image of the new firmware to flash.", - "name": "pImage", - "type": "void*" + "name": "hLed", + "type": "$s_led_handle_t" }, { - "desc": "[in] Size of the flash image.", - "name": "size", - "type": "uint32_t" + "desc": "[in,out] Will contain the current state of the LED.", + "name": "pState", + "type": "$s_led_state_t*" } ], "returns": [ @@ -73908,675 +88049,486 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hFirmware`" + "`nullptr == hLed`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pImage`" - ] - }, - { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to perform this operation." + "`nullptr == pState`" ] } ], "type": "function" }, { - "desc": "C++ wrapper for a Sysman device firmware", - "members": [ - { - "desc": "[in] handle of Sysman object", - "init": "nullptr", - "name": "handle", - "type": "$s_firmware_handle_t" - }, - { - "desc": "[in] pointer to owner object", - "name": "pDevice", - "type": "$sDevice*" - } + "class": "$sLed", + "desc": "Turn the LED on/off", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." ], - "name": "$sFirmware", - "owner": "$sDevice", - "type": "class" - } - ] - }, - { - "header": { - "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - Frequency domains", - "ordinal": 1000, - "type": "header" - }, - "name": "frequency", - "objects": [ - { - "class": "$sDevice", - "desc": "Frequency domains.", - "etors": [ - { - "desc": "GPU Core Domain.", - "name": "$S_FREQ_DOMAIN_GPU", - "value": "0" - }, + "hash": "a227391f6b01ac4e31857dbfd585f48e43d9382186521f55039c197a6b6eb54e", + "name": "SetState", + "params": [ { - "desc": "Local Memory Domain.", - "name": "$S_FREQ_DOMAIN_MEMORY", - "value": "1" + "desc": "[in] Handle for the component.", + "name": "hLed", + "type": "$s_led_handle_t" }, { - "desc": "GPU Media Domain.", - "name": "$S_FREQ_DOMAIN_MEDIA", - "value": "2", - "version": "1.6" + "desc": "[in] Set to TRUE to turn the LED on, FALSE to turn off.", + "name": "enable", + "type": "$x_bool_t" } ], - "name": "$s_freq_domain_t", - "type": "enum" - }, - { - "base": "$s_base_properties_t", - "class": "$sFrequency", - "desc": "Frequency properties", - "details": [ - "Indicates if this frequency domain can be overclocked (if true, functions such as $sFrequencyOcSetFrequencyTarget() are supported).", - "The min/max hardware frequencies are specified for non-overclock configurations. For overclock configurations, use $sFrequencyOcGetFrequencyTarget() to determine the maximum frequency that can be requested." - ], - "members": [ - { - "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_FREQ_PROPERTIES", - "name": "stype", - "type": "$s_structure_type_t" - }, - { - "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "void*" - }, + "returns": [ { - "desc": "[out] The hardware block that this frequency domain controls (GPU, memory, ...)", - "name": "type", - "type": "$s_freq_domain_t" + "$X_RESULT_SUCCESS": [] }, { - "desc": "[out] True if this resource is located on a sub-device; false means that the resource is on the device of the calling Sysman handle", - "name": "onSubdevice", - "type": "$x_bool_t" + "$X_RESULT_ERROR_UNINITIALIZED": [] }, { - "desc": "[out] If onSubdevice is true, this gives the ID of the sub-device", - "name": "subdeviceId", - "type": "uint32_t" + "$X_RESULT_ERROR_DEVICE_LOST": [] }, { - "desc": "[out] Indicates if software can control the frequency of this domain assuming the user has permissions", - "name": "canControl", - "type": "$x_bool_t" + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] }, { - "desc": "[out] Indicates if software can register to receive event $S_EVENT_TYPE_FLAG_FREQ_THROTTLED", - "name": "isThrottleEventSupported", - "type": "$x_bool_t" + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] }, { - "desc": "[out] The minimum hardware clock frequency in units of MHz.", - "name": "min", - "type": "double" + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hLed`" + ] }, { - "desc": "[out] The maximum non-overclock hardware clock frequency in units of MHz.", - "name": "max", - "type": "double" + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "User does not have permissions to make these modifications." + ] } ], - "name": "$s_freq_properties_t", - "type": "struct" + "type": "function" }, { - "class": "$sFrequency", - "desc": "Frequency range between which the hardware can operate.", + "class": "$sLed", + "desc": "Set the color of the LED", "details": [ - "When setting limits, they will be clamped to the hardware limits.", - "When setting limits, ensure that the max frequency is greater than or equal to the min frequency specified.", - "When setting limits to return to factory settings, specify -1 for both the min and max limit." + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." ], - "members": [ + "hash": "311a39222a3cb1343b3a126fb769defe80f38e4f6c2b3fe6bd438a3bad613a8e", + "name": "SetColor", + "params": [ { - "desc": "[in,out] The min frequency in MHz below which hardware frequency management will not request frequencies. On input, setting to 0 will permit the frequency to go down to the hardware minimum while setting to -1 will return the min frequency limit to the factory value (can be larger than the hardware min). On output, a negative value indicates that no external minimum frequency limit is in effect.", - "name": "min", - "type": "double" + "desc": "[in] Handle for the component.", + "name": "hLed", + "type": "$s_led_handle_t" }, { - "desc": "[in,out] The max frequency in MHz above which hardware frequency management will not request frequencies. On input, setting to 0 or a very big number will permit the frequency to go all the way up to the hardware maximum while setting to -1 will return the max frequency to the factory value (which can be less than the hardware max). On output, a negative number indicates that no external maximum frequency limit is in effect.", - "name": "max", - "type": "double" + "desc": "[in] New color of the LED.", + "name": "pColor", + "type": "const $s_led_color_t*" } ], - "name": "$s_freq_range_t", - "type": "struct" - }, - { - "class": "$sFrequency", - "desc": "Frequency throttle reasons", - "etors": [ - { - "desc": "frequency throttled due to average power excursion (PL1)", - "name": "$S_FREQ_THROTTLE_REASON_FLAG_AVE_PWR_CAP", - "value": "$X_BIT(0)" - }, - { - "desc": "frequency throttled due to burst power excursion (PL2)", - "name": "$S_FREQ_THROTTLE_REASON_FLAG_BURST_PWR_CAP", - "value": "$X_BIT(1)" - }, - { - "desc": "frequency throttled due to current excursion (PL4)", - "name": "$S_FREQ_THROTTLE_REASON_FLAG_CURRENT_LIMIT", - "value": "$X_BIT(2)" - }, - { - "desc": "frequency throttled due to thermal excursion (T > TjMax)", - "name": "$S_FREQ_THROTTLE_REASON_FLAG_THERMAL_LIMIT", - "value": "$X_BIT(3)" - }, - { - "desc": "frequency throttled due to power supply assertion", - "name": "$S_FREQ_THROTTLE_REASON_FLAG_PSU_ALERT", - "value": "$X_BIT(4)" - }, + "returns": [ { - "desc": "frequency throttled due to software supplied frequency range", - "name": "$S_FREQ_THROTTLE_REASON_FLAG_SW_RANGE", - "value": "$X_BIT(5)" + "$X_RESULT_SUCCESS": [] }, { - "desc": "frequency throttled due to a sub block that has a lower frequency range when it receives clocks", - "name": "$S_FREQ_THROTTLE_REASON_FLAG_HW_RANGE", - "value": "$X_BIT(6)" - } - ], - "name": "$s_freq_throttle_reason_flags_t", - "type": "enum" - }, - { - "base": "$s_base_state_t", - "class": "$sFrequency", - "desc": "Frequency state", - "members": [ - { - "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_FREQ_STATE", - "name": "stype", - "type": "$s_structure_type_t" + "$X_RESULT_ERROR_UNINITIALIZED": [] }, { - "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "const void*" + "$X_RESULT_ERROR_DEVICE_LOST": [] }, { - "desc": "[out] Current voltage in Volts. A negative value indicates that this property is not known.", - "name": "currentVoltage", - "type": "double" + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] }, { - "desc": "[out] The current frequency request in MHz. A negative value indicates that this property is not known.", - "name": "request", - "type": "double" + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] }, { - "desc": "[out] The maximum frequency in MHz supported under the current TDP conditions. This fluctuates dynamically based on the power and thermal limits of the part. A negative value indicates that this property is not known.", - "name": "tdp", - "type": "double" + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hLed`" + ] }, { - "desc": "[out] The efficient minimum frequency in MHz. A negative value indicates that this property is not known.", - "name": "efficient", - "type": "double" + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pColor`" + ] }, { - "desc": "[out] The resolved frequency in MHz. A negative value indicates that this property is not known.", - "name": "actual", - "type": "double" + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "User does not have permissions to make these modifications." + ] }, { - "desc": "[out] The reasons that the frequency is being limited by the hardware.\nReturns 0 (frequency not throttled) or a combination of $s_freq_throttle_reason_flag_t.\n", - "name": "throttleReasons", - "type": "$s_freq_throttle_reason_flags_t" + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "This LED doesn't not support color changes. See the `haveRGB` member of $s_led_properties_t." + ] } ], - "name": "$s_freq_state_t", - "type": "struct" + "type": "function" }, { - "class": "$sFrequency", - "desc": "Frequency throttle time snapshot", - "details": [ - "Percent time throttled is calculated by taking two snapshots (s1, s2) and using the equation: %throttled = (s2.throttleTime - s1.throttleTime) / (s2.timestamp - s1.timestamp)" - ], + "desc": "C++ wrapper for a Sysman device LED", "members": [ { - "desc": "[out] The monotonic counter of time in microseconds that the frequency has been limited by the hardware.", - "name": "throttleTime", - "type": "uint64_t" + "desc": "[in] handle of Sysman object", + "init": "nullptr", + "name": "handle", + "type": "$s_led_handle_t" }, { - "desc": "[out] Microsecond timestamp when throttleTime was captured.\nThis timestamp should only be used to calculate delta time between snapshots of this structure.\nNever take the delta of this timestamp with the timestamp from a different structure since they are not guaranteed to have the same base.\nThe absolute value of the timestamp is only valid during within the application and may be different on the next execution.\n", - "name": "timestamp", - "type": "uint64_t" + "desc": "[in] pointer to owner object", + "name": "pDevice", + "type": "$sDevice*" } ], - "name": "$s_freq_throttle_time_t", - "type": "struct" - }, + "name": "$sLed", + "owner": "$sDevice", + "type": "class" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - Memory management", + "ordinal": 1000, + "type": "header" + }, + "name": "memory", + "objects": [ { - "class": "$sFrequency", - "desc": "Overclocking modes", + "class": "$sMemory", + "desc": "Memory module types", "etors": [ { - "desc": "Overclocking if off - hardware is running using factory default voltages/frequencies.", - "name": "$S_OC_MODE_OFF", + "desc": "HBM memory", + "name": "$S_MEM_TYPE_HBM", "value": "0" }, { - "desc": "Overclock override mode - In this mode, a fixed user-supplied voltage is applied independent of the frequency request. The maximum permitted frequency can also be increased. This mode disables INTERPOLATIVE and FIXED modes.", - "name": "$S_OC_MODE_OVERRIDE", + "desc": "DDR memory", + "name": "$S_MEM_TYPE_DDR", "value": "1" }, { - "desc": "Overclock interpolative mode - In this mode, the voltage/frequency curve can be extended with a new voltage/frequency point that will be interpolated. The existing voltage/frequency points can also be offset (up or down) by a fixed voltage. This mode disables FIXED and OVERRIDE modes.", - "name": "$S_OC_MODE_INTERPOLATIVE", + "desc": "DDR3 memory", + "name": "$S_MEM_TYPE_DDR3", "value": "2" }, { - "desc": "Overclocking fixed Mode - In this mode, hardware will disable most frequency throttling and lock the frequency and voltage at the specified overclock values. This mode disables OVERRIDE and INTERPOLATIVE modes. This mode can damage the part, most of the protections are disabled on this mode.", - "name": "$S_OC_MODE_FIXED", + "desc": "DDR4 memory", + "name": "$S_MEM_TYPE_DDR4", "value": "3" - } - ], - "name": "$s_oc_mode_t", - "type": "enum" - }, - { - "base": "$s_base_capability_t", - "class": "$sFrequency", - "desc": "Overclocking properties", - "details": [ - "Provides all the overclocking capabilities and properties supported by the device for the frequency domain." - ], - "members": [ - { - "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_OC_CAPABILITIES", - "name": "stype", - "type": "$s_structure_type_t" - }, - { - "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "const void*" - }, - { - "desc": "[out] Indicates if any overclocking features are supported on this frequency domain.", - "name": "isOcSupported", - "type": "$x_bool_t" - }, - { - "desc": "[out] Factory default non-overclock maximum frequency in Mhz.", - "name": "maxFactoryDefaultFrequency", - "type": "double" - }, - { - "desc": "[out] Factory default voltage used for the non-overclock maximum frequency in MHz.", - "name": "maxFactoryDefaultVoltage", - "type": "double" - }, - { - "desc": "[out] Maximum hardware overclocking frequency limit in Mhz.", - "name": "maxOcFrequency", - "type": "double" - }, - { - "desc": "[out] The minimum voltage offset that can be applied to the voltage/frequency curve. Note that this number can be negative.", - "name": "minOcVoltageOffset", - "type": "double" }, { - "desc": "[out] The maximum voltage offset that can be applied to the voltage/frequency curve.", - "name": "maxOcVoltageOffset", - "type": "double" + "desc": "DDR5 memory", + "name": "$S_MEM_TYPE_DDR5", + "value": "4" }, { - "desc": "[out] The maximum overclock voltage that hardware supports.", - "name": "maxOcVoltage", - "type": "double" + "desc": "LPDDR memory", + "name": "$S_MEM_TYPE_LPDDR", + "value": "5" }, { - "desc": "[out] Indicates if the maximum temperature limit (TjMax) can be changed for this frequency domain.", - "name": "isTjMaxSupported", - "type": "$x_bool_t" + "desc": "LPDDR3 memory", + "name": "$S_MEM_TYPE_LPDDR3", + "value": "6" }, { - "desc": "[out] Indicates if the maximum current (IccMax) can be changed for this frequency domain.", - "name": "isIccMaxSupported", - "type": "$x_bool_t" + "desc": "LPDDR4 memory", + "name": "$S_MEM_TYPE_LPDDR4", + "value": "7" }, { - "desc": "[out] Indicates if this frequency domains supports a feature to set very high voltages.", - "name": "isHighVoltModeCapable", - "type": "$x_bool_t" + "desc": "LPDDR5 memory", + "name": "$S_MEM_TYPE_LPDDR5", + "value": "8" }, { - "desc": "[out] Indicates if very high voltages are permitted on this frequency domain.", - "name": "isHighVoltModeEnabled", - "type": "$x_bool_t" + "desc": "SRAM memory", + "name": "$S_MEM_TYPE_SRAM", + "value": "9" }, { - "desc": "[out] Indicates if the extended overclocking features are supported. If this is supported, increments are on 1 Mhz basis.", - "name": "isExtendedModeSupported", - "type": "$x_bool_t" + "desc": "L1 cache", + "name": "$S_MEM_TYPE_L1", + "value": "10" }, { - "desc": "[out] Indicates if the fixed mode is supported. In this mode, hardware will disable most frequency throttling and lock the frequency and voltage at the specified overclock values.", - "name": "isFixedModeSupported", - "type": "$x_bool_t" - } - ], - "name": "$s_oc_capabilities_t", - "type": "struct" - }, - { - "class": "$sDevice", - "desc": "Get handle of frequency domains", - "details": [ - "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." - ], - "hash": "3a4d3adfa79bc56aef50d3cd79d36487a13688f3b3c2bf544441d95b1271691a", - "name": "EnumFrequencyDomains", - "params": [ - { - "desc": "[in] Sysman handle of the device.", - "name": "hDevice", - "type": "$s_device_handle_t" + "desc": "L3 cache", + "name": "$S_MEM_TYPE_L3", + "value": "11" }, { - "desc": "[in,out] pointer to the number of components of this type.\nif count is zero, then the driver shall update the value with the total number of components of this type that are available.\nif count is greater than the number of components of this type that are available, then the driver shall update the value with the correct number of components.\n", - "name": "pCount", - "type": "uint32_t*" + "desc": "Execution unit register file", + "name": "$S_MEM_TYPE_GRF", + "value": "12" }, { - "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", - "name": "phFrequency", - "type": "$s_freq_handle_t*" - } - ], - "returns": [ - { - "$X_RESULT_SUCCESS": [] + "desc": "Execution unit shared local memory", + "name": "$S_MEM_TYPE_SLM", + "value": "13" }, { - "$X_RESULT_ERROR_UNINITIALIZED": [] + "desc": "GDDR4 memory", + "name": "$S_MEM_TYPE_GDDR4", + "value": "14" }, { - "$X_RESULT_ERROR_DEVICE_LOST": [] + "desc": "GDDR5 memory", + "name": "$S_MEM_TYPE_GDDR5", + "value": "15" }, { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "desc": "GDDR5X memory", + "name": "$S_MEM_TYPE_GDDR5X", + "value": "16" }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + "desc": "GDDR6 memory", + "name": "$S_MEM_TYPE_GDDR6", + "value": "17" }, { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDevice`" - ] + "desc": "GDDR6X memory", + "name": "$S_MEM_TYPE_GDDR6X", + "value": "18" }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pCount`" - ] + "desc": "GDDR7 memory", + "name": "$S_MEM_TYPE_GDDR7", + "value": "19" } ], - "type": "function" + "name": "$s_mem_type_t", + "type": "enum" }, { - "class": "$sFrequency", - "desc": "Get frequency properties - available frequencies", - "details": [ - "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." - ], - "hash": "b210e5b5cec54e67a85b2332aea68467458e3b15a971322b850426200f3aa94d", - "name": "GetProperties", - "params": [ + "class": "$sMemory", + "desc": "Memory module location", + "etors": [ { - "desc": "[in] Handle for the component.", - "name": "hFrequency", - "type": "$s_freq_handle_t" + "desc": "System memory", + "name": "$S_MEM_LOC_SYSTEM", + "value": "0" }, { - "desc": "[in,out] The frequency properties for the specified domain.", - "name": "pProperties", - "type": "$s_freq_properties_t*" + "desc": "On board local device memory", + "name": "$S_MEM_LOC_DEVICE", + "value": "1" } ], - "returns": [ - { - "$X_RESULT_SUCCESS": [] - }, - { - "$X_RESULT_ERROR_UNINITIALIZED": [] - }, + "name": "$s_mem_loc_t", + "type": "enum" + }, + { + "class": "$sMemory", + "desc": "Memory health", + "etors": [ { - "$X_RESULT_ERROR_DEVICE_LOST": [] + "desc": "The memory health cannot be determined.", + "name": "$S_MEM_HEALTH_UNKNOWN", + "value": "0" }, { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "desc": "All memory channels are healthy.", + "name": "$S_MEM_HEALTH_OK", + "value": "1" }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + "desc": "Excessive correctable errors have been detected on one or more channels. Device should be reset.", + "name": "$S_MEM_HEALTH_DEGRADED", + "value": "2" }, { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hFrequency`" - ] + "desc": "Operating with reduced memory to cover banks with too many uncorrectable errors.", + "name": "$S_MEM_HEALTH_CRITICAL", + "value": "3" }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pProperties`" - ] + "desc": "Device should be replaced due to excessive uncorrectable errors.", + "name": "$S_MEM_HEALTH_REPLACE", + "value": "4" } ], - "type": "function" + "name": "$s_mem_health_t", + "type": "enum" }, { - "class": "$sFrequency", - "desc": "Get available non-overclocked hardware clock frequencies for the frequency domain", - "details": [ - "The list of available frequencies is returned in order of slowest to fastest.", - "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." - ], - "hash": "1e3eebd0166a83daf2ae65a559bf765664cd393e3e131aa4e983f538ba8baf64", - "name": "GetAvailableClocks", - "params": [ + "base": "$s_base_properties_t", + "class": "$sMemory", + "desc": "Memory properties", + "members": [ { - "desc": "[in] Sysman handle of the device.", - "name": "hFrequency", - "type": "$s_freq_handle_t" + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_MEM_PROPERTIES", + "name": "stype", + "type": "$s_structure_type_t" }, { - "desc": "[in,out] pointer to the number of frequencies.\nif count is zero, then the driver shall update the value with the total number of frequencies that are available.\nif count is greater than the number of frequencies that are available, then the driver shall update the value with the correct number of frequencies.\n", - "name": "pCount", - "type": "uint32_t*" + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" }, { - "desc": "[in,out][optional][range(0, *pCount)] array of frequencies in units of MHz and sorted from slowest to fastest.\nif count is less than the number of frequencies that are available, then the driver shall only retrieve that number of frequencies.\n", - "name": "phFrequency", - "type": "double*" - } - ], - "returns": [ - { - "$X_RESULT_SUCCESS": [] + "desc": "[out] The memory type", + "name": "type", + "type": "$s_mem_type_t" }, { - "$X_RESULT_ERROR_UNINITIALIZED": [] + "desc": "[out] True if this resource is located on a sub-device; false means that the resource is on the device of the calling Sysman handle", + "name": "onSubdevice", + "type": "$x_bool_t" }, { - "$X_RESULT_ERROR_DEVICE_LOST": [] + "desc": "[out] If onSubdevice is true, this gives the ID of the sub-device", + "name": "subdeviceId", + "type": "uint32_t" }, { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "desc": "[out] Location of this memory (system, device)", + "name": "location", + "type": "$s_mem_loc_t" }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + "desc": "[out] Physical memory size in bytes. A value of 0 indicates that this property is not known. However, a call to $sMemoryGetState() will correctly return the total size of usable memory.", + "name": "physicalSize", + "type": "uint64_t" }, { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hFrequency`" - ] + "desc": "[out] Width of the memory bus. A value of -1 means that this property is unknown.", + "name": "busWidth", + "type": "int32_t" }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pCount`" - ] + "desc": "[out] The number of memory channels. A value of -1 means that this property is unknown.", + "name": "numChannels", + "type": "int32_t" } ], - "type": "function" + "name": "$s_mem_properties_t", + "type": "struct" }, { - "class": "$sFrequency", - "desc": "Get current frequency limits", + "base": "$s_base_state_t", + "class": "$sMemory", + "desc": "Memory state - health, allocated", "details": [ - "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." - ], - "hash": "a9d1984f6ba89157405380e202cbd1031171726de90f2ed76f1c3ae3c1c5ec15", - "name": "GetRange", - "params": [ - { - "desc": "[in] Handle for the component.", - "name": "hFrequency", - "type": "$s_freq_handle_t" - }, - { - "desc": "[in,out] The range between which the hardware can operate for the specified domain.", - "name": "pLimits", - "type": "$s_freq_range_t*" - } + "Percent allocation is given by 100 * (size - free / size.", + "Percent free is given by 100 * free / size." ], - "returns": [ - { - "$X_RESULT_SUCCESS": [] - }, - { - "$X_RESULT_ERROR_UNINITIALIZED": [] - }, + "members": [ { - "$X_RESULT_ERROR_DEVICE_LOST": [] + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_MEM_STATE", + "name": "stype", + "type": "$s_structure_type_t" }, { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + "desc": "[out] Indicates the health of the memory", + "name": "health", + "type": "$s_mem_health_t" }, { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hFrequency`" - ] + "desc": "[out] The free memory in bytes", + "name": "free", + "type": "uint64_t" }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pLimits`" - ] + "desc": "[out] The total allocatable memory in bytes (can be less than the `physicalSize` member of $s_mem_properties_t)", + "name": "size", + "type": "uint64_t" } ], - "type": "function" + "name": "$s_mem_state_t", + "type": "struct" }, { - "class": "$sFrequency", - "desc": "Set frequency range between which the hardware can operate.", + "class": "$sMemory", + "desc": "Memory bandwidth", "details": [ - "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." - ], - "hash": "e510f70acdcb9a652fda8f2d444a9c7d0c4fcd724de88d78b34d1ef7c4248a2d", - "name": "SetRange", - "params": [ - { - "desc": "[in] Handle for the component.", - "name": "hFrequency", - "type": "$s_freq_handle_t" - }, - { - "desc": "[in] The limits between which the hardware can operate for the specified domain.", - "name": "pLimits", - "type": "const $s_freq_range_t*" - } + "Percent bandwidth is calculated by taking two snapshots (s1, s2) and using the equation: %bw = 10^6 * ((s2.readCounter - s1.readCounter) + (s2.writeCounter - s1.writeCounter)) / (s2.maxBandwidth * (s2.timestamp - s1.timestamp))", + "Counter can roll over and rollover needs to be handled by comparing the current read against the previous read", + "Counter is a 32 byte transaction count, which means the calculated delta (delta = current_value - previous_value or delta = 2^32 - previous_value + current_value in case of rollover) needs to be multiplied by 32 to get delta between samples in actual byte count" ], - "returns": [ - { - "$X_RESULT_SUCCESS": [] - }, - { - "$X_RESULT_ERROR_UNINITIALIZED": [] - }, - { - "$X_RESULT_ERROR_DEVICE_LOST": [] - }, + "members": [ { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "desc": "[out] Total bytes read from memory", + "name": "readCounter", + "type": "uint64_t" }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + "desc": "[out] Total bytes written to memory", + "name": "writeCounter", + "type": "uint64_t" }, { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hFrequency`" - ] + "desc": "[out] Current maximum bandwidth in units of bytes/sec", + "name": "maxBandwidth", + "type": "uint64_t" }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pLimits`" - ] - }, + "desc": "[out] The timestamp in microseconds when these measurements were sampled.\nThis timestamp should only be used to calculate delta time between snapshots of this structure.\nNever take the delta of this timestamp with the timestamp from a different structure since they are not guaranteed to have the same base.\nThe absolute value of the timestamp is only valid during within the application and may be different on the next execution.\n", + "name": "timestamp", + "type": "uint64_t" + } + ], + "name": "$s_mem_bandwidth_t", + "type": "struct" + }, + { + "class": "$sMemory", + "desc": "Extension properties for Memory bandwidth", + "details": [ + "Number of counter bits", + "[DEPRECATED] No longer supported." + ], + "members": [ { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to make these modifications." - ] + "desc": "[out] Returns the number of valid bits in the timestamp values", + "name": "memoryTimestampValidBits", + "type": "uint32_t" } ], - "type": "function" + "name": "$s_mem_ext_bandwidth_t", + "type": "struct", + "version": "1.7" }, { - "class": "$sFrequency", - "desc": "Get current frequency state - frequency request, actual frequency, TDP limits", + "class": "$sDevice", + "desc": "Get handle of memory modules", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "0a8367760c6f7743ec27243e8d9f022854995115c9a64ee172fe0db821b462f9", - "name": "GetState", + "hash": "dfed3a82c29b73a59785c50f0149f1e08aa7664d6df89896aded435611614784", + "name": "EnumMemoryModules", "params": [ { - "desc": "[in] Handle for the component.", - "name": "hFrequency", - "type": "$s_freq_handle_t" + "desc": "[in] Sysman handle of the device.", + "name": "hDevice", + "type": "$s_device_handle_t" }, { - "desc": "[in,out] Frequency state for the specified domain.", - "name": "pState", - "type": "$s_freq_state_t*" + "desc": "[in,out] pointer to the number of components of this type.\nif count is zero, then the driver shall update the value with the total number of components of this type that are available.\nif count is greater than the number of components of this type that are available, then the driver shall update the value with the correct number of components.\n", + "name": "pCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", + "name": "phMemory", + "type": "$s_mem_handle_t*" } ], "returns": [ @@ -74597,36 +88549,36 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hFrequency`" + "`nullptr == hDevice`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pState`" + "`nullptr == pCount`" ] } ], "type": "function" }, { - "class": "$sFrequency", - "desc": "Get frequency throttle time", + "class": "$sMemory", + "desc": "Get memory properties", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "cd622002168430e88f48dce3e9b1fb51c92f6ef41c9d4fa64b18bb4274f8236d", - "name": "GetThrottleTime", + "hash": "2edc52add98a0827d5a70353b50c8f94609e0b73407dc2e4c3728c3c40d81171", + "name": "GetProperties", "params": [ { "desc": "[in] Handle for the component.", - "name": "hFrequency", - "type": "$s_freq_handle_t" + "name": "hMemory", + "type": "$s_mem_handle_t" }, { - "desc": "[in,out] Will contain a snapshot of the throttle time counters for the specified domain.", - "name": "pThrottleTime", - "type": "$s_freq_throttle_time_t*" + "desc": "[in,out] Will contain memory properties.", + "name": "pProperties", + "type": "$s_mem_properties_t*" } ], "returns": [ @@ -74647,36 +88599,36 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hFrequency`" + "`nullptr == hMemory`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pThrottleTime`" + "`nullptr == pProperties`" ] } ], "type": "function" }, { - "class": "$sFrequency", - "desc": "Get the overclocking capabilities.", + "class": "$sMemory", + "desc": "Get memory state - health, allocated", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "27bf6388e5923bdaa0967f8e74b1675ffd0e7c82980c7974dda6e82d24efc5c2", - "name": "OcGetCapabilities", + "hash": "2e80e3e679d031450d2f08847fc0d6b6b1fdebb2dcf8981271258777d4d0e83c", + "name": "GetState", "params": [ { "desc": "[in] Handle for the component.", - "name": "hFrequency", - "type": "$s_freq_handle_t" + "name": "hMemory", + "type": "$s_mem_handle_t" }, { - "desc": "[in,out] Pointer to the capabilities structure.", - "name": "pOcCapabilities", - "type": "$s_oc_capabilities_t*" + "desc": "[in,out] Will contain the current health and allocated memory.", + "name": "pState", + "type": "$s_mem_state_t*" } ], "returns": [ @@ -74697,36 +88649,36 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hFrequency`" + "`nullptr == hMemory`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pOcCapabilities`" + "`nullptr == pState`" ] } ], "type": "function" }, { - "class": "$sFrequency", - "desc": "Get the current overclocking frequency target, if extended moded is supported, will returned in 1 Mhz granularity.", + "class": "$sMemory", + "desc": "Get memory bandwidth", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "a1fee7e08b70a9ff9017be269ccba56a321c80f2a1bd0f08f4bf25b80edb8e87", - "name": "OcGetFrequencyTarget", + "hash": "659bc6516bf56722790d5d4dd35f93c8e4194e20157b93f6428bb63a2a1c71f5", + "name": "GetBandwidth", "params": [ { "desc": "[in] Handle for the component.", - "name": "hFrequency", - "type": "$s_freq_handle_t" + "name": "hMemory", + "type": "$s_mem_handle_t" }, { - "desc": "[out] Overclocking Frequency in MHz, if extended moded is supported, will returned in 1 Mhz granularity, else, in multiples of 50 Mhz. This cannot be greater than the `maxOcFrequency` member of $s_oc_capabilities_t.", - "name": "pCurrentOcFrequency", - "type": "double*" + "desc": "[in,out] Will contain the total number of bytes read from and written to memory, as well as the current maximum bandwidth.", + "name": "pBandwidth", + "type": "$s_mem_bandwidth_t*" } ], "returns": [ @@ -74747,120 +88699,112 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hFrequency`" + "`nullptr == hMemory`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pCurrentOcFrequency`" - ] - }, - { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "Overclocking is not supported on this frequency domain (see the `isOcSupported` member of $s_oc_capabilities_t).", - "The specified voltage and/or frequency overclock settings exceed the hardware values (see the `maxOcFrequency`, `maxOcVoltage`, `minOcVoltageOffset` and `maxOcVoltageOffset` members of $s_oc_capabilities_t).", - "Requested voltage overclock is very high but the `isHighVoltModeEnabled` member of $s_oc_capabilities_t is not enabled for the device." - ] - }, - { - "$X_RESULT_ERROR_NOT_AVAILABLE": [ - "Overclocking feature is locked on this frequency domain." + "`nullptr == pBandwidth`" ] }, { "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to make these modifications." + "User does not have permissions to query this telemetry." ] } ], "type": "function" }, { - "class": "$sFrequency", - "desc": "Set the current overclocking frequency target, if extended moded is supported, can be set in 1 Mhz granularity.", - "details": [ - "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." - ], - "hash": "3a6b01a51f459abd4b5094093ec355d270545a80ddac2792d06d29aee7463e1b", - "name": "OcSetFrequencyTarget", - "params": [ + "desc": "C++ wrapper for a Sysman device memory module", + "members": [ { - "desc": "[in] Handle for the component.", - "name": "hFrequency", - "type": "$s_freq_handle_t" + "desc": "[in] handle of Sysman object", + "init": "nullptr", + "name": "handle", + "type": "$s_mem_handle_t" }, { - "desc": "[in] Overclocking Frequency in MHz, if extended moded is supported, it could be set in 1 Mhz granularity, else, in multiples of 50 Mhz. This cannot be greater than the `maxOcFrequency` member of $s_oc_capabilities_t.", - "name": "CurrentOcFrequency", - "type": "double" + "desc": "[in] pointer to owner object", + "name": "pDevice", + "type": "$sDevice*" } ], - "returns": [ - { - "$X_RESULT_SUCCESS": [] - }, - { - "$X_RESULT_ERROR_UNINITIALIZED": [] - }, - { - "$X_RESULT_ERROR_DEVICE_LOST": [] - }, - { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] - }, + "name": "$sMemory", + "owner": "$sDevice", + "type": "class" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - Performance factor", + "ordinal": 1000, + "type": "header" + }, + "name": "performance", + "objects": [ + { + "base": "$s_base_properties_t", + "class": "$sPerformanceFactor", + "desc": "Static information about a Performance Factor domain", + "members": [ { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_PERF_PROPERTIES", + "name": "stype", + "type": "$s_structure_type_t" }, { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hFrequency`" - ] + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" }, { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "Overclocking is not supported on this frequency domain (see the `isOcSupported` member of $s_oc_capabilities_t).", - "The specified voltage and/or frequency overclock settings exceed the hardware values (see the `maxOcFrequency`, `maxOcVoltage`, `minOcVoltageOffset` and `maxOcVoltageOffset` members of $s_oc_capabilities_t).", - "Requested voltage overclock is very high but the `isHighVoltModeEnabled` member of $s_oc_capabilities_t is not enabled for the device." - ] + "desc": "[out] True if this Performance Factor affects accelerators located on a sub-device", + "name": "onSubdevice", + "type": "$x_bool_t" }, { - "$X_RESULT_ERROR_NOT_AVAILABLE": [ - "Overclocking feature is locked on this frequency domain." - ] + "desc": "[out] If onSubdevice is true, this gives the ID of the sub-device", + "name": "subdeviceId", + "type": "uint32_t" }, { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to make these modifications." - ] + "desc": "[out] Bitfield of accelerator engine types that are affected by this Performance Factor.", + "name": "engines", + "type": "$s_engine_type_flags_t" } ], - "type": "function" + "name": "$s_perf_properties_t", + "type": "struct" }, { - "class": "$sFrequency", - "desc": "Get the current overclocking voltage settings.", + "class": "$sDevice", + "desc": "Get handles to accelerator domains whose performance can be optimized via a Performance Factor", "details": [ + "A Performance Factor should be tuned for each workload.", "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "f6a3671ccc34ac2d3e6af12869ff5edfc85e3cc20db0d48b61cfe96781198c94", - "name": "OcGetVoltageTarget", - "params": [ - { - "desc": "[in] Handle for the component.", - "name": "hFrequency", - "type": "$s_freq_handle_t" + "hash": "5fa2bb283f8afdf882e8b81ff0c3eaf65ddf3aa1a473a6ec8e6d3a734f577a49", + "name": "EnumPerformanceFactorDomains", + "params": [ + { + "desc": "[in] Sysman handle of the device.", + "name": "hDevice", + "type": "$s_device_handle_t" }, { - "desc": "[out] Overclock voltage in Volts. This cannot be greater than the `maxOcVoltage` member of $s_oc_capabilities_t.", - "name": "pCurrentVoltageTarget", - "type": "double*" + "desc": "[in,out] pointer to the number of components of this type.\nif count is zero, then the driver shall update the value with the total number of components of this type that are available.\nif count is greater than the number of components of this type that are available, then the driver shall update the value with the correct number of components.\n", + "name": "pCount", + "type": "uint32_t*" }, { - "desc": "[out] This voltage offset is applied to all points on the voltage/frequency curve, including the new overclock voltageTarget. Valid range is between the `minOcVoltageOffset` and `maxOcVoltageOffset` members of $s_oc_capabilities_t.", - "name": "pCurrentVoltageOffset", - "type": "double*" + "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", + "name": "phPerf", + "type": "$s_perf_handle_t*" } ], "returns": [ @@ -74881,59 +88825,36 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hFrequency`" + "`nullptr == hDevice`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pCurrentVoltageTarget`", - "`nullptr == pCurrentVoltageOffset`" - ] - }, - { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "Overclocking is not supported on this frequency domain (see the `isOcSupported` member of $s_oc_capabilities_t).", - "The specified voltage and/or frequency overclock settings exceed the hardware values (see the `maxOcFrequency`, `maxOcVoltage`, `minOcVoltageOffset` and `maxOcVoltageOffset` members of $s_oc_capabilities_t).", - "Requested voltage overclock is very high but the `isHighVoltModeEnabled` member of $s_oc_capabilities_t is not enabled for the device." - ] - }, - { - "$X_RESULT_ERROR_NOT_AVAILABLE": [ - "Overclocking feature is locked on this frequency domain." - ] - }, - { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to make these modifications." + "`nullptr == pCount`" ] } ], "type": "function" }, { - "class": "$sFrequency", - "desc": "Set the current overclocking voltage settings.", + "class": "$sPerformanceFactor", + "desc": "Get properties about a Performance Factor domain", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "5f4c50d38e299212417f47798a74b4da436371eaee20c92098f13d3192b8b590", - "name": "OcSetVoltageTarget", + "hash": "7a0cdafa08fa973d82b00b017b910bc3eb5502945844c43b3172732f4c0fa849", + "name": "GetProperties", "params": [ { - "desc": "[in] Handle for the component.", - "name": "hFrequency", - "type": "$s_freq_handle_t" - }, - { - "desc": "[in] Overclock voltage in Volts. This cannot be greater than the `maxOcVoltage` member of $s_oc_capabilities_t.", - "name": "CurrentVoltageTarget", - "type": "double" + "desc": "[in] Handle for the Performance Factor domain.", + "name": "hPerf", + "type": "$s_perf_handle_t" }, { - "desc": "[in] This voltage offset is applied to all points on the voltage/frequency curve, include the new overclock voltageTarget. Valid range is between the `minOcVoltageOffset` and `maxOcVoltageOffset` members of $s_oc_capabilities_t.", - "name": "CurrentVoltageOffset", - "type": "double" + "desc": "[in,out] Will contain information about the specified Performance Factor domain.", + "name": "pProperties", + "type": "$s_perf_properties_t*" } ], "returns": [ @@ -74954,48 +88875,36 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hFrequency`" - ] - }, - { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "Overclocking is not supported on this frequency domain (see the `isOcSupported` member of $s_oc_capabilities_t).", - "The specified voltage and/or frequency overclock settings exceed the hardware values (see the `maxOcFrequency`, `maxOcVoltage`, `minOcVoltageOffset` and `maxOcVoltageOffset` members of $s_oc_capabilities_t).", - "Requested voltage overclock is very high but the `isHighVoltModeEnabled` member of $s_oc_capabilities_t is not enabled for the device." - ] - }, - { - "$X_RESULT_ERROR_NOT_AVAILABLE": [ - "Overclocking feature is locked on this frequency domain." + "`nullptr == hPerf`" ] }, { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to make these modifications." + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pProperties`" ] } ], "type": "function" }, { - "class": "$sFrequency", - "desc": "Set the current overclocking mode.", + "class": "$sPerformanceFactor", + "desc": "Get current Performance Factor for a given domain", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "309c17c47d975efe332fedbe4501950c7216615dbfaeec37f3de3576ee3d5407", - "name": "OcSetMode", + "hash": "15b340fe44c9a82cac4b502b676604cf2112dd781c8ffa759cfe2b6c60384b4f", + "name": "GetConfig", "params": [ { - "desc": "[in] Handle for the component.", - "name": "hFrequency", - "type": "$s_freq_handle_t" + "desc": "[in] Handle for the Performance Factor domain.", + "name": "hPerf", + "type": "$s_perf_handle_t" }, { - "desc": "[in] Current Overclocking Mode $s_oc_mode_t.", - "name": "CurrentOcMode", - "type": "$s_oc_mode_t" + "desc": "[in,out] Will contain the actual Performance Factor being used by the hardware (may not be the same as the requested Performance Factor).", + "name": "pFactor", + "type": "double*" } ], "returns": [ @@ -75016,53 +88925,38 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hFrequency`" - ] - }, - { - "$X_RESULT_ERROR_INVALID_ENUMERATION": [ - "`$S_OC_MODE_FIXED < CurrentOcMode`" - ] - }, - { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "Overclocking is not supported on this frequency domain (see the `isOcSupported` member of $s_oc_capabilities_t).", - "The specified voltage and/or frequency overclock settings exceed the hardware values (see the `maxOcFrequency`, `maxOcVoltage`, `minOcVoltageOffset` and `maxOcVoltageOffset` members of $s_oc_capabilities_t).", - "Requested voltage overclock is very high but the `isHighVoltModeEnabled` member of $s_oc_capabilities_t is not enabled for the device." - ] - }, - { - "$X_RESULT_ERROR_NOT_AVAILABLE": [ - "Overclocking feature is locked on this frequency domain." + "`nullptr == hPerf`" ] }, { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to make these modifications." + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pFactor`" ] } ], "type": "function" }, { - "class": "$sFrequency", - "desc": "Get the current overclocking mode.", + "class": "$sPerformanceFactor", + "desc": "Change the performance factor for a domain", "details": [ + "The Performance Factor is a number between 0 and 100.", + "A Performance Factor is a hint to the hardware. Depending on the hardware, the request may not be granted. Follow up this function with a call to $sPerformanceFactorGetConfig() to determine the actual factor being used by the hardware.", "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "62c4575e249097bdec5d726201f5f1259da813d0d7c0045814a5b917ff6a1308", - "name": "OcGetMode", + "hash": "f48ab4af9334abc338efe7f1d6ce41a38029af7fe3dac0affe6c8849b3eeb013", + "name": "SetConfig", "params": [ { - "desc": "[in] Handle for the component.", - "name": "hFrequency", - "type": "$s_freq_handle_t" + "desc": "[in] Handle for the Performance Factor domain.", + "name": "hPerf", + "type": "$s_perf_handle_t" }, { - "desc": "[out] Current Overclocking Mode $s_oc_mode_t.", - "name": "pCurrentOcMode", - "type": "$s_oc_mode_t*" + "desc": "[in] The new Performance Factor.", + "name": "factor", + "type": "double" } ], "returns": [ @@ -75083,176 +88977,363 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hFrequency`" + "`nullptr == hPerf`" ] + } + ], + "type": "function" + }, + { + "desc": "C++ wrapper for a Sysman device performance factor", + "members": [ + { + "desc": "[in] handle of Sysman object", + "init": "nullptr", + "name": "handle", + "type": "$s_perf_handle_t" }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pCurrentOcMode`" - ] + "desc": "[in] pointer to owner object", + "name": "pDevice", + "type": "$sDevice*" + } + ], + "name": "$sPerformanceFactor", + "owner": "$sDevice", + "type": "class" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - Scheduler management", + "ordinal": 1000, + "type": "header" + }, + "name": "power", + "objects": [ + { + "class": "$sPower", + "desc": "Power Domain", + "etors": [ + { + "desc": "The PUnit power domain level cannot be determined.", + "name": "$S_POWER_DOMAIN_UNKNOWN", + "value": "0" }, { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "Overclocking is not supported on this frequency domain (see the `isOcSupported` member of $s_oc_capabilities_t).", - "The specified voltage and/or frequency overclock settings exceed the hardware values (see the `maxOcFrequency`, `maxOcVoltage`, `minOcVoltageOffset` and `maxOcVoltageOffset` members of $s_oc_capabilities_t).", - "Requested voltage overclock is very high but the `isHighVoltModeEnabled` member of $s_oc_capabilities_t is not enabled for the device." - ] + "desc": "The PUnit power domain is a card-level power domain.", + "name": "$S_POWER_DOMAIN_CARD", + "value": "1" }, { - "$X_RESULT_ERROR_NOT_AVAILABLE": [ - "Overclocking feature is locked on this frequency domain." - ] + "desc": "The PUnit power domain is a package-level power domain.", + "name": "$S_POWER_DOMAIN_PACKAGE", + "value": "2" }, { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to make these modifications." - ] + "desc": "The PUnit power domain is a stack-level power domain.", + "name": "$S_POWER_DOMAIN_STACK", + "value": "3" + }, + { + "desc": "The PUnit power domain is a memory-level power domain.", + "name": "$S_POWER_DOMAIN_MEMORY", + "value": "4", + "version": "1.8" + }, + { + "desc": "The PUnit power domain is a GPU-level power domain.", + "name": "$S_POWER_DOMAIN_GPU", + "value": "5", + "version": "1.8" } ], - "type": "function" + "name": "$s_power_domain_t", + "type": "enum", + "version": "1.4" }, { - "class": "$sFrequency", - "desc": "Get the maximum current limit setting.", - "details": [ - "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "class": "$sPower", + "desc": "Power Level Type", + "etors": [ + { + "desc": "The PUnit power monitoring duration cannot be determined.", + "name": "$S_POWER_LEVEL_UNKNOWN", + "value": "0" + }, + { + "desc": "The PUnit determines effective power draw by computing a moving average of the actual power draw over a time interval (longer than BURST).", + "name": "$S_POWER_LEVEL_SUSTAINED", + "value": "1" + }, + { + "desc": "The PUnit determines effective power draw by computing a moving average of the actual power draw over a time interval (longer than PEAK).", + "name": "$S_POWER_LEVEL_BURST", + "value": "2" + }, + { + "desc": "The PUnit determines effective power draw by computing a moving average of the actual power draw over a very short time interval.", + "name": "$S_POWER_LEVEL_PEAK", + "value": "3" + }, + { + "desc": "The PUnit predicts effective power draw using the current device configuration (frequency, voltage, etc...) & throttles proactively to stay within the specified limit.", + "name": "$S_POWER_LEVEL_INSTANTANEOUS", + "value": "4" + } ], - "hash": "dd3afa560c90667b89253d02e45759933e6ee6a5f4a4657c783e821f9b8d8660", - "name": "OcGetIccMax", - "params": [ + "name": "$s_power_level_t", + "type": "enum", + "version": "1.4" + }, + { + "class": "$sPower", + "desc": "Power Source Type", + "etors": [ { - "desc": "[in] Handle for the component.", - "name": "hFrequency", - "type": "$s_freq_handle_t" + "desc": "Limit active no matter whether the power source is mains powered or battery powered.", + "name": "$S_POWER_SOURCE_ANY", + "value": "0" }, { - "desc": "[in,out] Will contain the maximum current limit in Amperes on successful return.", - "name": "pOcIccMax", - "type": "double*" + "desc": "Limit active only when the device is mains powered.", + "name": "$S_POWER_SOURCE_MAINS", + "value": "1" + }, + { + "desc": "Limit active only when the device is battery powered.", + "name": "$S_POWER_SOURCE_BATTERY", + "value": "2" } ], - "returns": [ + "name": "$s_power_source_t", + "type": "enum", + "version": "1.4" + }, + { + "class": "$sPower", + "desc": "Limit Unit", + "etors": [ { - "$X_RESULT_SUCCESS": [] + "desc": "The PUnit power monitoring unit cannot be determined.", + "name": "$S_LIMIT_UNIT_UNKNOWN", + "value": "0" }, { - "$X_RESULT_ERROR_UNINITIALIZED": [] + "desc": "The limit is specified in milliamperes of current drawn.", + "name": "$S_LIMIT_UNIT_CURRENT", + "value": "1" }, { - "$X_RESULT_ERROR_DEVICE_LOST": [] + "desc": "The limit is specified in milliwatts of power generated.", + "name": "$S_LIMIT_UNIT_POWER", + "value": "2" + } + ], + "name": "$s_limit_unit_t", + "type": "enum", + "version": "1.4" + }, + { + "base": "$s_base_properties_t", + "class": "$sPower", + "desc": "Properties related to device power settings", + "members": [ + { + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_POWER_PROPERTIES", + "name": "stype", + "type": "$s_structure_type_t" }, { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + "desc": "[out] True if this resource is located on a sub-device; false means that the resource is on the device of the calling Sysman handle", + "name": "onSubdevice", + "type": "$x_bool_t" }, { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hFrequency`" - ] + "desc": "[out] If onSubdevice is true, this gives the ID of the sub-device", + "name": "subdeviceId", + "type": "uint32_t" }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pOcIccMax`" - ] + "desc": "[out] Software can change the power limits of this domain assuming the user has permissions.", + "name": "canControl", + "type": "$x_bool_t" }, { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "Overclocking is not supported on this frequency domain (see the `isOcSupported` member of $s_oc_capabilities_t).", - "Capability the `isIccMaxSupported` member of $s_oc_capabilities_t is false for this frequency domain." - ] + "desc": "[out] Indicates if this power domain supports the energy threshold event ($S_EVENT_TYPE_FLAG_ENERGY_THRESHOLD_CROSSED).", + "name": "isEnergyThresholdSupported", + "type": "$x_bool_t" + }, + { + "desc": "[out] (Deprecated) The factory default TDP power limit of the part in milliwatts. A value of -1 means that this is not known.", + "name": "defaultLimit", + "type": "int32_t" + }, + { + "desc": "[out] (Deprecated) The minimum power limit in milliwatts that can be requested. A value of -1 means that this is not known.", + "name": "minLimit", + "type": "int32_t" + }, + { + "desc": "[out] (Deprecated) The maximum power limit in milliwatts that can be requested. A value of -1 means that this is not known.", + "name": "maxLimit", + "type": "int32_t" } ], - "type": "function" + "name": "$s_power_properties_t", + "type": "struct" }, { - "class": "$sFrequency", - "desc": "Change the maximum current limit setting.", + "class": "$sPower", + "desc": "Energy counter snapshot", "details": [ - "Setting ocIccMax to 0.0 will return the value to the factory default.", - "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "Average power is calculated by taking two snapshots (s1, s2) and using the equation: PowerWatts = (s2.energy - s1.energy) / (s2.timestamp - s1.timestamp)" ], - "hash": "e75fd6668d4a7b5f10fc95f5830293547df215abe25c798afb1b88def4360fe6", - "name": "OcSetIccMax", - "params": [ + "members": [ { - "desc": "[in] Handle for the component.", - "name": "hFrequency", - "type": "$s_freq_handle_t" + "desc": "[out] The monotonic energy counter in microjoules.", + "name": "energy", + "type": "uint64_t" }, { - "desc": "[in] The new maximum current limit in Amperes.", - "name": "ocIccMax", - "type": "double" + "desc": "[out] Microsecond timestamp when energy was captured.\nThis timestamp should only be used to calculate delta time between snapshots of this structure.\nNever take the delta of this timestamp with the timestamp from a different structure since they are not guaranteed to have the same base.\nThe absolute value of the timestamp is only valid during within the application and may be different on the next execution.\n", + "name": "timestamp", + "type": "uint64_t" } ], - "returns": [ + "name": "$s_power_energy_counter_t", + "type": "struct" + }, + { + "class": "$sPower", + "desc": "Sustained power limits", + "details": [ + "The power controller (Punit) will throttle the operating frequency if the power averaged over a window (typically seconds) exceeds this limit.", + "[DEPRECATED] No longer supported." + ], + "members": [ { - "$X_RESULT_SUCCESS": [] + "desc": "[in,out] indicates if the limit is enabled (true) or ignored (false)", + "name": "enabled", + "type": "$x_bool_t" }, { - "$X_RESULT_ERROR_UNINITIALIZED": [] + "desc": "[in,out] power limit in milliwatts", + "name": "power", + "type": "int32_t" }, { - "$X_RESULT_ERROR_DEVICE_LOST": [] - }, + "desc": "[in,out] power averaging window (Tau) in milliseconds", + "name": "interval", + "type": "int32_t" + } + ], + "name": "$s_power_sustained_limit_t", + "type": "struct" + }, + { + "class": "$sPower", + "desc": "Burst power limit", + "details": [ + "The power controller (Punit) will throttle the operating frequency of the device if the power averaged over a few milliseconds exceeds a limit known as PL2. Typically PL2 > PL1 so that it permits the frequency to burst higher for short periods than would be otherwise permitted by PL1.", + "[DEPRECATED] No longer supported." + ], + "members": [ { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "desc": "[in,out] indicates if the limit is enabled (true) or ignored (false)", + "name": "enabled", + "type": "$x_bool_t" }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] - }, + "desc": "[in,out] power limit in milliwatts", + "name": "power", + "type": "int32_t" + } + ], + "name": "$s_power_burst_limit_t", + "type": "struct" + }, + { + "class": "$sPower", + "desc": "Peak power limit", + "details": [ + "The power controller (Punit) will reactively/proactively throttle the operating frequency of the device when the instantaneous/100usec power exceeds this limit. The limit is known as PL4 or Psys. It expresses the maximum power that can be drawn from the power supply.", + "If this power limit is removed or set too high, the power supply will generate an interrupt when it detects an overcurrent condition and the power controller will throttle the device frequencies down to min. It is thus better to tune the PL4 value in order to avoid such excursions.", + "[DEPRECATED] No longer supported." + ], + "members": [ { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hFrequency`" - ] + "desc": "[in,out] power limit in milliwatts for the AC power source.", + "name": "powerAC", + "type": "int32_t" }, { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "Overclocking is not supported on this frequency domain (see the `isOcSupported` member of $s_oc_capabilities_t).", - "The `isIccMaxSupported` member of $s_oc_capabilities_t is false for this frequency domain." - ] - }, + "desc": "[in,out] power limit in milliwatts for the DC power source. On input, this is ignored if the product does not have a battery. On output, this will be -1 if the product does not have a battery.", + "name": "powerDC", + "type": "int32_t" + } + ], + "name": "$s_power_peak_limit_t", + "type": "struct" + }, + { + "class": "$sPower", + "desc": "Energy threshold", + "details": [ + "." + ], + "members": [ { - "$X_RESULT_ERROR_NOT_AVAILABLE": [ - "Overclocking feature is locked on this frequency domain." - ] + "desc": "[in,out] Indicates if the energy threshold is enabled.", + "name": "enable", + "type": "$x_bool_t" }, { - "$X_RESULT_ERROR_INVALID_ARGUMENT": [ - "The specified current limit is too low or too high." - ] + "desc": "[in,out] The energy threshold in Joules. Will be 0.0 if no threshold has been set.", + "name": "threshold", + "type": "double" }, { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to make these modifications." - ] + "desc": "[in,out] The host process ID that set the energy threshold. Will be 0xFFFFFFFF if no threshold has been set.", + "name": "processId", + "type": "uint32_t" } ], - "type": "function" + "name": "$s_energy_threshold_t", + "type": "struct" }, { - "class": "$sFrequency", - "desc": "Get the maximum temperature limit setting.", + "class": "$sDevice", + "desc": "Get handle of power domains", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "c1758ddfd68bb1988d3753bb71636b3b666c3f011d35cd830c8d0434c777d5e3", - "name": "OcGetTjMax", + "hash": "a162fab77909ff04da2e08eef1e2cf17487f31ae5a2f4c1a25555f6bf56bc60e", + "name": "EnumPowerDomains", "params": [ { - "desc": "[in] Handle for the component.", - "name": "hFrequency", - "type": "$s_freq_handle_t" + "desc": "[in] Sysman handle of the device.", + "name": "hDevice", + "type": "$s_device_handle_t" }, { - "desc": "[in,out] Will contain the maximum temperature limit in degrees Celsius on successful return.", - "name": "pOcTjMax", - "type": "double*" + "desc": "[in,out] pointer to the number of components of this type.\nif count is zero, then the driver shall update the value with the total number of components of this type that are available.\nif count is greater than the number of components of this type that are available, then the driver shall update the value with the correct number of components.\n", + "name": "pCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", + "name": "phPower", + "type": "$s_pwr_handle_t*" } ], "returns": [ @@ -75273,42 +89354,37 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hFrequency`" + "`nullptr == hDevice`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pOcTjMax`" - ] - }, - { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "Overclocking is not supported on this frequency domain (see the `isOcSupported` member of $s_oc_capabilities_t)." + "`nullptr == pCount`" ] } ], "type": "function" }, { - "class": "$sFrequency", - "desc": "Change the maximum temperature limit setting.", + "class": "$sDevice", + "desc": "Get handle of the PCIe card-level power", "details": [ - "Setting ocTjMax to 0.0 will return the value to the factory default.", "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The implementation of this function should be lock-free.", + "[DEPRECATED] No longer supported." ], - "hash": "742e421c8ae9294b2993a07eab549a060b678d7a5c74c5c71ce6e012f22d50aa", - "name": "OcSetTjMax", + "hash": "047ca99995666fe5cefd48dde4b5e5262fd4ac1916c75723f18649b25c4e6942", + "name": "GetCardPowerDomain", "params": [ { - "desc": "[in] Handle for the component.", - "name": "hFrequency", - "type": "$s_freq_handle_t" + "desc": "[in] Sysman handle of the device.", + "name": "hDevice", + "type": "$s_device_handle_t" }, { - "desc": "[in] The new maximum temperature limit in degrees Celsius.", - "name": "ocTjMax", - "type": "double" + "desc": "[in,out] power domain handle for the entire PCIe card.", + "name": "phPower", + "type": "$s_pwr_handle_t*" } ], "returns": [ @@ -75329,181 +89405,91 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hFrequency`" - ] - }, - { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "Overclocking is not supported on this frequency domain (see the `isOcSupported` member of $s_oc_capabilities_t).", - "The `isTjMaxSupported` member of $s_oc_capabilities_t is false for this frequency domain." - ] - }, - { - "$X_RESULT_ERROR_NOT_AVAILABLE": [ - "Overclocking feature is locked on this frequency domain." + "`nullptr == hDevice`" ] }, { - "$X_RESULT_ERROR_INVALID_ARGUMENT": [ - "The specified temperature limit is too high." + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == phPower`" ] }, { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to make these modifications." + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "The device does not provide access to card level power controls or telemetry. An invalid power domain handle will be returned in phPower." ] } ], "type": "function" }, { - "desc": "C++ wrapper for a Sysman device frequency domain", - "members": [ - { - "desc": "[in] handle of Sysman object", - "init": "nullptr", - "name": "handle", - "type": "$s_freq_handle_t" - }, - { - "desc": "[in] pointer to owner object", - "name": "pDevice", - "type": "$sDevice*" - } + "class": "$sPower", + "desc": "Get properties related to a power domain", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." ], - "name": "$sFrequency", - "owner": "$sDevice", - "type": "class" - } - ] - }, - { - "header": { - "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - Firmware management", - "ordinal": 1000, - "type": "header" - }, - "name": "led", - "objects": [ - { - "base": "$s_base_properties_t", - "class": "$sLed", - "desc": "LED properties", - "members": [ - { - "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_LED_PROPERTIES", - "name": "stype", - "type": "$s_structure_type_t" - }, - { - "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "void*" - }, - { - "desc": "[out] True if the resource is located on a sub-device; false means that the resource is on the device of the calling Sysman handle", - "name": "onSubdevice", - "type": "$x_bool_t" - }, - { - "desc": "[out] If onSubdevice is true, this gives the ID of the sub-device", - "name": "subdeviceId", - "type": "uint32_t" - }, + "hash": "0ac3a4c1fa7cf470238a28cc3775ee610214b99c270555dca72f975199288995", + "name": "GetProperties", + "params": [ { - "desc": "[out] Indicates if software can control the LED assuming the user has permissions", - "name": "canControl", - "type": "$x_bool_t" + "desc": "[in] Handle for the component.", + "name": "hPower", + "type": "$s_pwr_handle_t" }, { - "desc": "[out] Indicates if the LED is RGB capable", - "name": "haveRGB", - "type": "$x_bool_t" + "desc": "[in,out] Structure that will contain property data.", + "name": "pProperties", + "type": "$s_power_properties_t*" } ], - "name": "$s_led_properties_t", - "type": "struct" - }, - { - "class": "$sLed", - "desc": "LED color", - "members": [ + "returns": [ { - "desc": "[in,out][range(0.0, 1.0)] The LED red value. On output, a value less than 0.0 indicates that the color is not known.", - "name": "red", - "type": "double" + "$X_RESULT_SUCCESS": [] }, { - "desc": "[in,out][range(0.0, 1.0)] The LED green value. On output, a value less than 0.0 indicates that the color is not known.", - "name": "green", - "type": "double" + "$X_RESULT_ERROR_UNINITIALIZED": [] }, { - "desc": "[in,out][range(0.0, 1.0)] The LED blue value. On output, a value less than 0.0 indicates that the color is not known.", - "name": "blue", - "type": "double" - } - ], - "name": "$s_led_color_t", - "type": "struct" - }, - { - "base": "$s_base_state_t", - "class": "$sLed", - "desc": "LED state", - "members": [ + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, { - "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_LED_STATE", - "name": "stype", - "type": "$s_structure_type_t" + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] }, { - "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "const void*" + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] }, { - "desc": "[out] Indicates if the LED is on or off", - "name": "isOn", - "type": "$x_bool_t" + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hPower`" + ] }, { - "desc": "[out] Color of the LED", - "name": "color", - "type": "$s_led_color_t" + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pProperties`" + ] } ], - "name": "$s_led_state_t", - "type": "struct" + "type": "function" }, { - "class": "$sDevice", - "desc": "Get handle of LEDs", + "class": "$sPower", + "desc": "Get energy counter", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "8c338f22d1047a3079b9f4adf6b0598674b17ba06e0605b1aaa547b901ecae6a", - "name": "EnumLeds", + "hash": "55238b643e181150dd35ae06a62b397c7488fdda9c500a0b999b95d00fa07311", + "name": "GetEnergyCounter", "params": [ { - "desc": "[in] Sysman handle of the device.", - "name": "hDevice", - "type": "$s_device_handle_t" - }, - { - "desc": "[in,out] pointer to the number of components of this type.\nif count is zero, then the driver shall update the value with the total number of components of this type that are available.\nif count is greater than the number of components of this type that are available, then the driver shall update the value with the correct number of components.\n", - "name": "pCount", - "type": "uint32_t*" + "desc": "[in] Handle for the component.", + "name": "hPower", + "type": "$s_pwr_handle_t" }, { - "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", - "name": "phLed", - "type": "$s_led_handle_t*" + "desc": "[in,out] Will contain the latest snapshot of the energy counter and timestamp when the last counter value was measured.", + "name": "pEnergy", + "type": "$s_power_energy_counter_t*" } ], "returns": [ @@ -75524,36 +89510,47 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDevice`" + "`nullptr == hPower`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pCount`" + "`nullptr == pEnergy`" ] } ], "type": "function" }, { - "class": "$sLed", - "desc": "Get LED properties", + "class": "$sPower", + "desc": "Get power limits", "details": [ "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The implementation of this function should be lock-free.", + "[DEPRECATED] Use $sPowerGetLimitsExt." ], - "hash": "82a7ff7d95623a38fdcea5fc8c1de9b334a8ccf9c29c9e97328ab519e132c890", - "name": "GetProperties", + "hash": "ed0462ffcd8d44a95439a0ea86fbb1bc0e13e357c0d73fabd1d3322abd658e18", + "name": "GetLimits", "params": [ { "desc": "[in] Handle for the component.", - "name": "hLed", - "type": "$s_led_handle_t" + "name": "hPower", + "type": "$s_pwr_handle_t" }, { - "desc": "[in,out] Will contain the properties of the LED.", - "name": "pProperties", - "type": "$s_led_properties_t*" + "desc": "[in,out][optional] The sustained power limit. If this is null, the current sustained power limits will not be returned.", + "name": "pSustained", + "type": "$s_power_sustained_limit_t*" + }, + { + "desc": "[in,out][optional] The burst power limit. If this is null, the current peak power limits will not be returned.", + "name": "pBurst", + "type": "$s_power_burst_limit_t*" + }, + { + "desc": "[in,out][optional] The peak power limit. If this is null, the peak power limits will not be returned.", + "name": "pPeak", + "type": "$s_power_peak_limit_t*" } ], "returns": [ @@ -75574,36 +89571,42 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hLed`" - ] - }, - { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pProperties`" + "`nullptr == hPower`" ] } ], "type": "function" }, { - "class": "$sLed", - "desc": "Get current state of a LED - on/off, color", + "class": "$sPower", + "desc": "Set power limits", "details": [ "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The implementation of this function should be lock-free.", + "[DEPRECATED] Use $sPowerSetLimitsExt." ], - "hash": "d66be9cc597cbc060f0cd3592d6e15bbccb1be0823781f22c5746d2e64c460f1", - "name": "GetState", + "hash": "adfce6f8e5ca88571ca8d3c876751c1de2ba0acca3d52639c128be64a18c4550", + "name": "SetLimits", "params": [ { "desc": "[in] Handle for the component.", - "name": "hLed", - "type": "$s_led_handle_t" + "name": "hPower", + "type": "$s_pwr_handle_t" }, { - "desc": "[in,out] Will contain the current state of the LED.", - "name": "pState", - "type": "$s_led_state_t*" + "desc": "[in][optional] The sustained power limit. If this is null, no changes will be made to the sustained power limits.", + "name": "pSustained", + "type": "const $s_power_sustained_limit_t*" + }, + { + "desc": "[in][optional] The burst power limit. If this is null, no changes will be made to the burst power limits.", + "name": "pBurst", + "type": "const $s_power_burst_limit_t*" + }, + { + "desc": "[in][optional] The peak power limit. If this is null, no changes will be made to the peak power limits.", + "name": "pPeak", + "type": "const $s_power_peak_limit_t*" } ], "returns": [ @@ -75624,36 +89627,41 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hLed`" + "`nullptr == hPower`" ] }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pState`" + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "User does not have permissions to make these modifications." + ] + }, + { + "$X_RESULT_ERROR_NOT_AVAILABLE": [ + "The device is in use, meaning that the GPU is under Over clocking, applying power limits under overclocking is not supported." ] } ], "type": "function" }, { - "class": "$sLed", - "desc": "Turn the LED on/off", + "class": "$sPower", + "desc": "Get energy threshold", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "a227391f6b01ac4e31857dbfd585f48e43d9382186521f55039c197a6b6eb54e", - "name": "SetState", + "hash": "11e5666d7a95676691c797e7d12570dba7a301c7b51b07fc5e6550764a071806", + "name": "GetEnergyThreshold", "params": [ { "desc": "[in] Handle for the component.", - "name": "hLed", - "type": "$s_led_handle_t" + "name": "hPower", + "type": "$s_pwr_handle_t" }, { - "desc": "[in] Set to TRUE to turn the LED on, FALSE to turn off.", - "name": "enable", - "type": "$x_bool_t" + "desc": "[in,out] Returns information about the energy threshold setting - enabled/energy threshold/process ID.", + "name": "pThreshold", + "type": "$s_energy_threshold_t*" } ], "returns": [ @@ -75674,36 +89682,50 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hLed`" + "`nullptr == hPower`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pThreshold`" + ] + }, + { + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "Energy threshold not supported on this power domain (check the `isEnergyThresholdSupported` member of $s_power_properties_t)." ] }, { "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to make these modifications." + "User does not have permissions to request this feature." ] } ], "type": "function" }, { - "class": "$sLed", - "desc": "Set the color of the LED", + "class": "$sPower", + "desc": "Set energy threshold", "details": [ + "An event $S_EVENT_TYPE_FLAG_ENERGY_THRESHOLD_CROSSED will be generated when the delta energy consumed starting from this call exceeds the specified threshold. Use the function $sDeviceEventRegister() to start receiving the event.", + "Only one running process can control the energy threshold at a given time. If another process attempts to change the energy threshold, the error $X_RESULT_ERROR_NOT_AVAILABLE will be returned. The function $sPowerGetEnergyThreshold() to determine the process ID currently controlling this setting.", + "Calling this function will remove any pending energy thresholds and start counting from the time of this call.", + "Once the energy threshold has been reached and the event generated, the threshold is automatically removed. It is up to the application to request a new threshold.", "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "311a39222a3cb1343b3a126fb769defe80f38e4f6c2b3fe6bd438a3bad613a8e", - "name": "SetColor", + "hash": "ef52d53f78f5e95a24faf530e9ee0bb353cff7d607cec5a27376f4dd4ebf2255", + "name": "SetEnergyThreshold", "params": [ { "desc": "[in] Handle for the component.", - "name": "hLed", - "type": "$s_led_handle_t" + "name": "hPower", + "type": "$s_pwr_handle_t" }, { - "desc": "[in] New color of the LED.", - "name": "pColor", - "type": "const $s_led_color_t*" + "desc": "[in] The energy threshold to be set in joules.", + "name": "threshold", + "type": "double" } ], "returns": [ @@ -75724,35 +89746,35 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hLed`" + "`nullptr == hPower`" ] }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pColor`" + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "Energy threshold not supported on this power domain (check the `isEnergyThresholdSupported` member of $s_power_properties_t)." ] }, { "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to make these modifications." + "User does not have permissions to request this feature." ] }, { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "This LED doesn't not support color changes. See the `haveRGB` member of $s_led_properties_t." + "$X_RESULT_ERROR_NOT_AVAILABLE": [ + "Another running process has set the energy threshold." ] } ], "type": "function" }, { - "desc": "C++ wrapper for a Sysman device LED", + "desc": "C++ wrapper for a Sysman device power domain", "members": [ { "desc": "[in] handle of Sysman object", "init": "nullptr", "name": "handle", - "type": "$s_led_handle_t" + "type": "$s_pwr_handle_t" }, { "desc": "[in] pointer to owner object", @@ -75760,7 +89782,7 @@ "type": "$sDevice*" } ], - "name": "$sLed", + "name": "$sPower", "owner": "$sDevice", "type": "class" } @@ -75768,179 +89790,48 @@ }, { "header": { - "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - Memory management", + "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - Firmware management", "ordinal": 1000, "type": "header" }, - "name": "memory", + "name": "psu", "objects": [ { - "class": "$sMemory", - "desc": "Memory module types", - "etors": [ - { - "desc": "HBM memory", - "name": "$S_MEM_TYPE_HBM", - "value": "0" - }, - { - "desc": "DDR memory", - "name": "$S_MEM_TYPE_DDR", - "value": "1" - }, - { - "desc": "DDR3 memory", - "name": "$S_MEM_TYPE_DDR3", - "value": "2" - }, - { - "desc": "DDR4 memory", - "name": "$S_MEM_TYPE_DDR4", - "value": "3" - }, - { - "desc": "DDR5 memory", - "name": "$S_MEM_TYPE_DDR5", - "value": "4" - }, - { - "desc": "LPDDR memory", - "name": "$S_MEM_TYPE_LPDDR", - "value": "5" - }, - { - "desc": "LPDDR3 memory", - "name": "$S_MEM_TYPE_LPDDR3", - "value": "6" - }, - { - "desc": "LPDDR4 memory", - "name": "$S_MEM_TYPE_LPDDR4", - "value": "7" - }, - { - "desc": "LPDDR5 memory", - "name": "$S_MEM_TYPE_LPDDR5", - "value": "8" - }, - { - "desc": "SRAM memory", - "name": "$S_MEM_TYPE_SRAM", - "value": "9" - }, - { - "desc": "L1 cache", - "name": "$S_MEM_TYPE_L1", - "value": "10" - }, - { - "desc": "L3 cache", - "name": "$S_MEM_TYPE_L3", - "value": "11" - }, - { - "desc": "Execution unit register file", - "name": "$S_MEM_TYPE_GRF", - "value": "12" - }, - { - "desc": "Execution unit shared local memory", - "name": "$S_MEM_TYPE_SLM", - "value": "13" - }, - { - "desc": "GDDR4 memory", - "name": "$S_MEM_TYPE_GDDR4", - "value": "14" - }, - { - "desc": "GDDR5 memory", - "name": "$S_MEM_TYPE_GDDR5", - "value": "15" - }, - { - "desc": "GDDR5X memory", - "name": "$S_MEM_TYPE_GDDR5X", - "value": "16" - }, - { - "desc": "GDDR6 memory", - "name": "$S_MEM_TYPE_GDDR6", - "value": "17" - }, - { - "desc": "GDDR6X memory", - "name": "$S_MEM_TYPE_GDDR6X", - "value": "18" - }, - { - "desc": "GDDR7 memory", - "name": "$S_MEM_TYPE_GDDR7", - "value": "19" - } - ], - "name": "$s_mem_type_t", - "type": "enum" - }, - { - "class": "$sMemory", - "desc": "Memory module location", - "etors": [ - { - "desc": "System memory", - "name": "$S_MEM_LOC_SYSTEM", - "value": "0" - }, - { - "desc": "On board local device memory", - "name": "$S_MEM_LOC_DEVICE", - "value": "1" - } - ], - "name": "$s_mem_loc_t", - "type": "enum" - }, - { - "class": "$sMemory", - "desc": "Memory health", + "class": "$sPsu", + "desc": "PSU voltage status", "etors": [ { - "desc": "The memory health cannot be determined.", - "name": "$S_MEM_HEALTH_UNKNOWN", + "desc": "The status of the power supply voltage controllers cannot be determined", + "name": "$S_PSU_VOLTAGE_STATUS_UNKNOWN", "value": "0" }, { - "desc": "All memory channels are healthy.", - "name": "$S_MEM_HEALTH_OK", + "desc": "No unusual voltages have been detected", + "name": "$S_PSU_VOLTAGE_STATUS_NORMAL", "value": "1" }, { - "desc": "Excessive correctable errors have been detected on one or more channels. Device should be reset.", - "name": "$S_MEM_HEALTH_DEGRADED", + "desc": "Over-voltage has occurred", + "name": "$S_PSU_VOLTAGE_STATUS_OVER", "value": "2" }, { - "desc": "Operating with reduced memory to cover banks with too many uncorrectable errors.", - "name": "$S_MEM_HEALTH_CRITICAL", + "desc": "Under-voltage has occurred", + "name": "$S_PSU_VOLTAGE_STATUS_UNDER", "value": "3" - }, - { - "desc": "Device should be replaced due to excessive uncorrectable errors.", - "name": "$S_MEM_HEALTH_REPLACE", - "value": "4" } ], - "name": "$s_mem_health_t", + "name": "$s_psu_voltage_status_t", "type": "enum" }, { "base": "$s_base_properties_t", - "class": "$sMemory", - "desc": "Memory properties", + "class": "$sPsu", + "desc": "Static properties of the power supply", "members": [ { "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_MEM_PROPERTIES", + "init": "$S_STRUCTURE_TYPE_PSU_PROPERTIES", "name": "stype", "type": "$s_structure_type_t" }, @@ -75951,12 +89842,7 @@ "type": "void*" }, { - "desc": "[out] The memory type", - "name": "type", - "type": "$s_mem_type_t" - }, - { - "desc": "[out] True if this resource is located on a sub-device; false means that the resource is on the device of the calling Sysman handle", + "desc": "[out] True if the resource is located on a sub-device; false means that the resource is on the device of the calling Sysman handle", "name": "onSubdevice", "type": "$x_bool_t" }, @@ -75966,41 +89852,27 @@ "type": "uint32_t" }, { - "desc": "[out] Location of this memory (system, device)", - "name": "location", - "type": "$s_mem_loc_t" - }, - { - "desc": "[out] Physical memory size in bytes. A value of 0 indicates that this property is not known. However, a call to $sMemoryGetState() will correctly return the total size of usable memory.", - "name": "physicalSize", - "type": "uint64_t" - }, - { - "desc": "[out] Width of the memory bus. A value of -1 means that this property is unknown.", - "name": "busWidth", - "type": "int32_t" + "desc": "[out] True if the power supply has a fan", + "name": "haveFan", + "type": "$x_bool_t" }, { - "desc": "[out] The number of memory channels. A value of -1 means that this property is unknown.", - "name": "numChannels", + "desc": "[out] The maximum electrical current in milliamperes that can be drawn. A value of -1 indicates that this property cannot be determined.", + "name": "ampLimit", "type": "int32_t" } ], - "name": "$s_mem_properties_t", + "name": "$s_psu_properties_t", "type": "struct" }, { "base": "$s_base_state_t", - "class": "$sMemory", - "desc": "Memory state - health, allocated", - "details": [ - "Percent allocation is given by 100 * (size - free / size.", - "Percent free is given by 100 * free / size." - ], + "class": "$sPsu", + "desc": "Dynamic state of the power supply", "members": [ { "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_MEM_STATE", + "init": "$S_STRUCTURE_TYPE_PSU_STATE", "name": "stype", "type": "$s_structure_type_t" }, @@ -76011,83 +89883,38 @@ "type": "const void*" }, { - "desc": "[out] Indicates the health of the memory", - "name": "health", - "type": "$s_mem_health_t" - }, - { - "desc": "[out] The free memory in bytes", - "name": "free", - "type": "uint64_t" - }, - { - "desc": "[out] The total allocatable memory in bytes (can be less than the `physicalSize` member of $s_mem_properties_t)", - "name": "size", - "type": "uint64_t" - } - ], - "name": "$s_mem_state_t", - "type": "struct" - }, - { - "class": "$sMemory", - "desc": "Memory bandwidth", - "details": [ - "Percent bandwidth is calculated by taking two snapshots (s1, s2) and using the equation: %bw = 10^6 * ((s2.readCounter - s1.readCounter) + (s2.writeCounter - s1.writeCounter)) / (s2.maxBandwidth * (s2.timestamp - s1.timestamp))", - "Counter can roll over and rollover needs to be handled by comparing the current read against the previous read", - "Counter is a 32 byte transaction count, which means the calculated delta (delta = current_value - previous_value or delta = 2^32 - previous_value + current_value in case of rollover) needs to be multiplied by 32 to get delta between samples in actual byte count" - ], - "members": [ - { - "desc": "[out] Total bytes read from memory", - "name": "readCounter", - "type": "uint64_t" + "desc": "[out] The current PSU voltage status", + "name": "voltStatus", + "type": "$s_psu_voltage_status_t" }, { - "desc": "[out] Total bytes written to memory", - "name": "writeCounter", - "type": "uint64_t" + "desc": "[out] Indicates if the fan has failed", + "name": "fanFailed", + "type": "$x_bool_t" }, { - "desc": "[out] Current maximum bandwidth in units of bytes/sec", - "name": "maxBandwidth", - "type": "uint64_t" + "desc": "[out] Read the current heatsink temperature in degrees Celsius. A value of -1 indicates that this property cannot be determined.", + "name": "temperature", + "type": "int32_t" }, { - "desc": "[out] The timestamp in microseconds when these measurements were sampled.\nThis timestamp should only be used to calculate delta time between snapshots of this structure.\nNever take the delta of this timestamp with the timestamp from a different structure since they are not guaranteed to have the same base.\nThe absolute value of the timestamp is only valid during within the application and may be different on the next execution.\n", - "name": "timestamp", - "type": "uint64_t" + "desc": "[out] The amps being drawn in milliamperes. A value of -1 indicates that this property cannot be determined.", + "name": "current", + "type": "int32_t" } ], - "name": "$s_mem_bandwidth_t", + "name": "$s_psu_state_t", "type": "struct" }, - { - "class": "$sMemory", - "desc": "Extension properties for Memory bandwidth", - "details": [ - "Number of counter bits" - ], - "members": [ - { - "desc": "[out] Returns the number of valid bits in the timestamp values", - "name": "memoryTimestampValidBits", - "type": "uint32_t" - } - ], - "name": "$s_mem_ext_bandwidth_t", - "type": "struct", - "version": "1.7" - }, { "class": "$sDevice", - "desc": "Get handle of memory modules", + "desc": "Get handle of power supplies", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "dfed3a82c29b73a59785c50f0149f1e08aa7664d6df89896aded435611614784", - "name": "EnumMemoryModules", + "hash": "3a4d1abb6eece0119fee707bcd6098ceb8c5cf4a72f955e268dde6b4e94a741c", + "name": "EnumPsus", "params": [ { "desc": "[in] Sysman handle of the device.", @@ -76101,8 +89928,8 @@ }, { "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", - "name": "phMemory", - "type": "$s_mem_handle_t*" + "name": "phPsu", + "type": "$s_psu_handle_t*" } ], "returns": [ @@ -76135,24 +89962,24 @@ "type": "function" }, { - "class": "$sMemory", - "desc": "Get memory properties", + "class": "$sPsu", + "desc": "Get power supply properties", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "2edc52add98a0827d5a70353b50c8f94609e0b73407dc2e4c3728c3c40d81171", + "hash": "8d0cf92b0e7647a92d9edffb0a8076d51cd65838300a01acc786e379faf65d92", "name": "GetProperties", "params": [ { "desc": "[in] Handle for the component.", - "name": "hMemory", - "type": "$s_mem_handle_t" + "name": "hPsu", + "type": "$s_psu_handle_t" }, { - "desc": "[in,out] Will contain memory properties.", + "desc": "[in,out] Will contain the properties of the power supply.", "name": "pProperties", - "type": "$s_mem_properties_t*" + "type": "$s_psu_properties_t*" } ], "returns": [ @@ -76173,7 +90000,7 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hMemory`" + "`nullptr == hPsu`" ] }, { @@ -76185,24 +90012,24 @@ "type": "function" }, { - "class": "$sMemory", - "desc": "Get memory state - health, allocated", + "class": "$sPsu", + "desc": "Get current power supply state", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "2e80e3e679d031450d2f08847fc0d6b6b1fdebb2dcf8981271258777d4d0e83c", + "hash": "453129fa23bfb6ed587d17b79b631cfe976944dabb190f60efb69d4f4bc7049d", "name": "GetState", "params": [ { "desc": "[in] Handle for the component.", - "name": "hMemory", - "type": "$s_mem_handle_t" + "name": "hPsu", + "type": "$s_psu_handle_t" }, { - "desc": "[in,out] Will contain the current health and allocated memory.", + "desc": "[in,out] Will contain the current state of the power supply.", "name": "pState", - "type": "$s_mem_state_t*" + "type": "$s_psu_state_t*" } ], "returns": [ @@ -76223,7 +90050,7 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hMemory`" + "`nullptr == hPsu`" ] }, { @@ -76235,97 +90062,109 @@ "type": "function" }, { - "class": "$sMemory", - "desc": "Get memory bandwidth", - "details": [ - "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." - ], - "hash": "659bc6516bf56722790d5d4dd35f93c8e4194e20157b93f6428bb63a2a1c71f5", - "name": "GetBandwidth", - "params": [ + "desc": "C++ wrapper for a Sysman device power supply", + "members": [ { - "desc": "[in] Handle for the component.", - "name": "hMemory", - "type": "$s_mem_handle_t" + "desc": "[in] handle of Sysman object", + "init": "nullptr", + "name": "handle", + "type": "$s_psu_handle_t" }, { - "desc": "[in,out] Will contain the total number of bytes read from and written to memory, as well as the current maximum bandwidth.", - "name": "pBandwidth", - "type": "$s_mem_bandwidth_t*" + "desc": "[in] pointer to owner object", + "name": "pDevice", + "type": "$sDevice*" } ], - "returns": [ + "name": "$sPsu", + "owner": "$sDevice", + "type": "class" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - Firmware management", + "ordinal": 1000, + "type": "header" + }, + "name": "ras", + "objects": [ + { + "class": "$sRas", + "desc": "RAS error type", + "etors": [ { - "$X_RESULT_SUCCESS": [] + "desc": "Errors were corrected by hardware", + "name": "$S_RAS_ERROR_TYPE_CORRECTABLE", + "value": "0" }, { - "$X_RESULT_ERROR_UNINITIALIZED": [] + "desc": "Error were not corrected", + "name": "$S_RAS_ERROR_TYPE_UNCORRECTABLE", + "value": "1" + } + ], + "name": "$s_ras_error_type_t", + "type": "enum" + }, + { + "class": "$sRas", + "desc": "RAS error categories", + "etors": [ + { + "desc": "The number of accelerator engine resets attempted by the driver", + "name": "$S_RAS_ERROR_CAT_RESET", + "value": "0" }, { - "$X_RESULT_ERROR_DEVICE_LOST": [] + "desc": "The number of hardware exceptions generated by the way workloads have programmed the hardware", + "name": "$S_RAS_ERROR_CAT_PROGRAMMING_ERRORS", + "value": "1" }, { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "desc": "The number of low level driver communication errors have occurred", + "name": "$S_RAS_ERROR_CAT_DRIVER_ERRORS", + "value": "2" }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + "desc": "The number of errors that have occurred in the compute accelerator hardware", + "name": "$S_RAS_ERROR_CAT_COMPUTE_ERRORS", + "value": "3" }, { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hMemory`" - ] + "desc": "The number of errors that have occurred in the fixed-function accelerator hardware", + "name": "$S_RAS_ERROR_CAT_NON_COMPUTE_ERRORS", + "value": "4" }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pBandwidth`" - ] + "desc": "The number of errors that have occurred in caches (L1/L3/register file/shared local memory/sampler)", + "name": "$S_RAS_ERROR_CAT_CACHE_ERRORS", + "value": "5" }, { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to query this telemetry." - ] + "desc": "The number of errors that have occurred in the display", + "name": "$S_RAS_ERROR_CAT_DISPLAY_ERRORS", + "value": "6" } ], - "type": "function" + "name": "$s_ras_error_cat_t", + "type": "enum" }, { - "desc": "C++ wrapper for a Sysman device memory module", - "members": [ - { - "desc": "[in] handle of Sysman object", - "init": "nullptr", - "name": "handle", - "type": "$s_mem_handle_t" - }, - { - "desc": "[in] pointer to owner object", - "name": "pDevice", - "type": "$sDevice*" - } - ], - "name": "$sMemory", - "owner": "$sDevice", - "type": "class" - } - ] - }, - { - "header": { - "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - Performance factor", - "ordinal": 1000, - "type": "header" - }, - "name": "performance", - "objects": [ + "desc": "The maximum number of categories", + "name": "$S_MAX_RAS_ERROR_CATEGORY_COUNT", + "type": "macro", + "value": "7" + }, { "base": "$s_base_properties_t", - "class": "$sPerformanceFactor", - "desc": "Static information about a Performance Factor domain", + "class": "$sRas", + "desc": "RAS properties", "members": [ { "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_PERF_PROPERTIES", + "init": "$S_STRUCTURE_TYPE_RAS_PROPERTIES", "name": "stype", "type": "$s_structure_type_t" }, @@ -76336,7 +90175,12 @@ "type": "void*" }, { - "desc": "[out] True if this Performance Factor affects accelerators located on a sub-device", + "desc": "[out] The type of RAS error", + "name": "type", + "type": "$s_ras_error_type_t" + }, + { + "desc": "[out] True if the resource is located on a sub-device; false means that the resource is on the device of the calling Sysman handle", "name": "onSubdevice", "type": "$x_bool_t" }, @@ -76344,26 +90188,85 @@ "desc": "[out] If onSubdevice is true, this gives the ID of the sub-device", "name": "subdeviceId", "type": "uint32_t" + } + ], + "name": "$s_ras_properties_t", + "type": "struct" + }, + { + "base": "$s_base_state_t", + "class": "$sRas", + "desc": "RAS error details", + "members": [ + { + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_RAS_STATE", + "name": "stype", + "type": "$s_structure_type_t" }, { - "desc": "[out] Bitfield of accelerator engine types that are affected by this Performance Factor.", - "name": "engines", - "type": "$s_engine_type_flags_t" + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, + { + "desc": "[in][out] Breakdown of error by category", + "name": "category[$S_MAX_RAS_ERROR_CATEGORY_COUNT]", + "type": "uint64_t" } ], - "name": "$s_perf_properties_t", + "name": "$s_ras_state_t", + "type": "struct" + }, + { + "base": "$s_base_config_t", + "class": "$sRas", + "desc": "RAS error configuration - thresholds used for triggering RAS events ($S_EVENT_TYPE_FLAG_RAS_CORRECTABLE_ERRORS, $S_EVENT_TYPE_FLAG_RAS_UNCORRECTABLE_ERRORS)", + "details": [ + "The driver maintains a total counter which is updated every time a hardware block covered by the corresponding RAS error set notifies that an error has occurred. When this total count goes above the totalThreshold specified below, a RAS event is triggered.", + "The driver also maintains a counter for each category of RAS error (see $s_ras_state_t for a breakdown). Each time a hardware block of that category notifies that an error has occurred, that corresponding category counter is updated. When it goes above the threshold specified in detailedThresholds, a RAS event is triggered." + ], + "members": [ + { + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_RAS_CONFIG", + "name": "stype", + "type": "$s_structure_type_t" + }, + { + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, + { + "desc": "[in,out] If the total RAS errors exceeds this threshold, the event will be triggered. A value of 0ULL disables triggering the event based on the total counter.", + "name": "totalThreshold", + "type": "uint64_t" + }, + { + "desc": "[in,out] If the RAS errors for each category exceed the threshold for that category, the event will be triggered. A value of 0ULL will disable an event being triggered for that category.", + "name": "detailedThresholds", + "type": "$s_ras_state_t" + } + ], + "name": "$s_ras_config_t", "type": "struct" }, { "class": "$sDevice", - "desc": "Get handles to accelerator domains whose performance can be optimized via a Performance Factor", + "desc": "Get handle of all RAS error sets on a device", "details": [ - "A Performance Factor should be tuned for each workload.", + "A RAS error set is a collection of RAS error counters of a given type (correctable/uncorrectable) from hardware blocks contained within a sub-device or within the device.", + "A device without sub-devices will typically return two handles, one for correctable errors sets and one for uncorrectable error sets.", + "A device with sub-devices will return RAS error sets for each sub-device and possibly RAS error sets for hardware blocks outside the sub-devices.", + "If the function completes successfully but pCount is set to 0, RAS features are not available/enabled on this device.", "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "5fa2bb283f8afdf882e8b81ff0c3eaf65ddf3aa1a473a6ec8e6d3a734f577a49", - "name": "EnumPerformanceFactorDomains", + "hash": "937766bf395b256301368c368e0d399cb0aee34dfdd044da3c2cdb7b29be97a3", + "name": "EnumRasErrorSets", "params": [ { "desc": "[in] Sysman handle of the device.", @@ -76377,8 +90280,8 @@ }, { "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", - "name": "phPerf", - "type": "$s_perf_handle_t*" + "name": "phRas", + "type": "$s_ras_handle_t*" } ], "returns": [ @@ -76411,24 +90314,24 @@ "type": "function" }, { - "class": "$sPerformanceFactor", - "desc": "Get properties about a Performance Factor domain", + "class": "$sRas", + "desc": "Get RAS properties of a given RAS error set - this enables discovery of the type of RAS error set (correctable/uncorrectable) and if located on a sub-device", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "7a0cdafa08fa973d82b00b017b910bc3eb5502945844c43b3172732f4c0fa849", + "hash": "f30bca24c015dcc7e4609790f05e46643da44e1fa1c9b0341cf1d8078c6ed5e4", "name": "GetProperties", "params": [ { - "desc": "[in] Handle for the Performance Factor domain.", - "name": "hPerf", - "type": "$s_perf_handle_t" + "desc": "[in] Handle for the component.", + "name": "hRas", + "type": "$s_ras_handle_t" }, { - "desc": "[in,out] Will contain information about the specified Performance Factor domain.", + "desc": "[in,out] Structure describing RAS properties", "name": "pProperties", - "type": "$s_perf_properties_t*" + "type": "$s_ras_properties_t*" } ], "returns": [ @@ -76449,7 +90352,7 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hPerf`" + "`nullptr == hRas`" ] }, { @@ -76461,24 +90364,27 @@ "type": "function" }, { - "class": "$sPerformanceFactor", - "desc": "Get current Performance Factor for a given domain", + "class": "$sRas", + "desc": "Get RAS error thresholds that control when RAS events are generated", "details": [ + "The driver maintains counters for all RAS error sets and error categories. Events are generated when errors occur. The configuration enables setting thresholds to limit when events are sent.", + "When a particular RAS correctable error counter exceeds the configured threshold, the event $S_EVENT_TYPE_FLAG_RAS_CORRECTABLE_ERRORS will be triggered.", + "When a particular RAS uncorrectable error counter exceeds the configured threshold, the event $S_EVENT_TYPE_FLAG_RAS_UNCORRECTABLE_ERRORS will be triggered.", "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "15b340fe44c9a82cac4b502b676604cf2112dd781c8ffa759cfe2b6c60384b4f", + "hash": "0086e397045debf8637442b51b3f13dfbb950573bb08e0fc20ab2473e5470355", "name": "GetConfig", "params": [ { - "desc": "[in] Handle for the Performance Factor domain.", - "name": "hPerf", - "type": "$s_perf_handle_t" + "desc": "[in] Handle for the component.", + "name": "hRas", + "type": "$s_ras_handle_t" }, { - "desc": "[in,out] Will contain the actual Performance Factor being used by the hardware (may not be the same as the requested Performance Factor).", - "name": "pFactor", - "type": "double*" + "desc": "[in,out] Will be populed with the current RAS configuration - thresholds used to trigger events", + "name": "pConfig", + "type": "$s_ras_config_t*" } ], "returns": [ @@ -76499,38 +90405,107 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hPerf`" + "`nullptr == hRas`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pFactor`" + "`nullptr == pConfig`" ] } ], "type": "function" }, { - "class": "$sPerformanceFactor", - "desc": "Change the performance factor for a domain", + "class": "$sRas", + "desc": "Set RAS error thresholds that control when RAS events are generated", "details": [ - "The Performance Factor is a number between 0 and 100.", - "A Performance Factor is a hint to the hardware. Depending on the hardware, the request may not be granted. Follow up this function with a call to $sPerformanceFactorGetConfig() to determine the actual factor being used by the hardware.", + "The driver maintains counters for all RAS error sets and error categories. Events are generated when errors occur. The configuration enables setting thresholds to limit when events are sent.", + "When a particular RAS correctable error counter exceeds the specified threshold, the event $S_EVENT_TYPE_FLAG_RAS_CORRECTABLE_ERRORS will be generated.", + "When a particular RAS uncorrectable error counter exceeds the specified threshold, the event $S_EVENT_TYPE_FLAG_RAS_UNCORRECTABLE_ERRORS will be generated.", + "Call $sRasGetState() and set the clear flag to true to restart event generation once counters have exceeded thresholds.", "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "f48ab4af9334abc338efe7f1d6ce41a38029af7fe3dac0affe6c8849b3eeb013", + "hash": "8d4a05aa119e4379d2b65308164870f616a1286d64c8a8e02580aa2ac4d673b5", "name": "SetConfig", "params": [ { - "desc": "[in] Handle for the Performance Factor domain.", - "name": "hPerf", - "type": "$s_perf_handle_t" + "desc": "[in] Handle for the component.", + "name": "hRas", + "type": "$s_ras_handle_t" + }, + { + "desc": "[in] Change the RAS configuration - thresholds used to trigger events", + "name": "pConfig", + "type": "const $s_ras_config_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hRas`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pConfig`" + ] + }, + { + "$X_RESULT_ERROR_NOT_AVAILABLE": [ + "Another running process is controlling these settings." + ] + }, + { + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "Don't have permissions to set thresholds." + ] + } + ], + "type": "function" + }, + { + "class": "$sRas", + "desc": "Get the current value of RAS error counters for a particular error set", + "details": [ + "Clearing errors will affect other threads/applications - the counter values will start from zero.", + "Clearing errors requires write permissions.", + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "99b4653180947ca4b2026e02bea89ec5916e928aae1c6b20016a07c3657bc134", + "name": "GetState", + "params": [ + { + "desc": "[in] Handle for the component.", + "name": "hRas", + "type": "$s_ras_handle_t" + }, + { + "desc": "[in] Set to 1 to clear the counters of this type", + "name": "clear", + "type": "$x_bool_t" }, { - "desc": "[in] The new Performance Factor.", - "name": "factor", - "type": "double" + "desc": "[in,out] Breakdown of where errors have occurred", + "name": "pState", + "type": "$s_ras_state_t*" } ], "returns": [ @@ -76551,20 +90526,30 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hPerf`" + "`nullptr == hRas`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pState`" + ] + }, + { + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "Don't have permissions to clear error counters." ] } ], "type": "function" }, { - "desc": "C++ wrapper for a Sysman device performance factor", + "desc": "C++ wrapper for a Sysman device RAS error set", "members": [ { "desc": "[in] handle of Sysman object", "init": "nullptr", "name": "handle", - "type": "$s_perf_handle_t" + "type": "$s_ras_handle_t" }, { "desc": "[in] pointer to owner object", @@ -76572,7 +90557,7 @@ "type": "$sDevice*" } ], - "name": "$sPerformanceFactor", + "name": "$sRas", "owner": "$sDevice", "type": "class" } @@ -76584,127 +90569,44 @@ "ordinal": 1000, "type": "header" }, - "name": "power", + "name": "scheduler", "objects": [ { - "class": "$sPower", - "desc": "Power Domain", - "etors": [ - { - "desc": "The PUnit power domain level cannot be determined.", - "name": "$S_POWER_DOMAIN_UNKNOWN", - "value": "0" - }, - { - "desc": "The PUnit power domain is a card-level power domain.", - "name": "$S_POWER_DOMAIN_CARD", - "value": "1" - }, - { - "desc": "The PUnit power domain is a package-level power domain.", - "name": "$S_POWER_DOMAIN_PACKAGE", - "value": "2" - }, - { - "desc": "The PUnit power domain is a stack-level power domain.", - "name": "$S_POWER_DOMAIN_STACK", - "value": "3" - } - ], - "name": "$s_power_domain_t", - "type": "enum", - "version": "1.4" - }, - { - "class": "$sPower", - "desc": "Power Level Type", + "class": "$sDevice", + "desc": "Scheduler mode", "etors": [ { - "desc": "The PUnit power monitoring duration cannot be determined.", - "name": "$S_POWER_LEVEL_UNKNOWN", + "desc": "Multiple applications or contexts are submitting work to the hardware. When higher priority work arrives, the scheduler attempts to pause the current executing work within some timeout interval, then submits the other work.", + "name": "$S_SCHED_MODE_TIMEOUT", "value": "0" }, { - "desc": "The PUnit determines effective power draw by computing a moving average of the actual power draw over a time interval (longer than BURST).", - "name": "$S_POWER_LEVEL_SUSTAINED", + "desc": "The scheduler attempts to fairly timeslice hardware execution time between multiple contexts submitting work to the hardware concurrently.", + "name": "$S_SCHED_MODE_TIMESLICE", "value": "1" }, { - "desc": "The PUnit determines effective power draw by computing a moving average of the actual power draw over a time interval (longer than PEAK).", - "name": "$S_POWER_LEVEL_BURST", + "desc": "Any application or context can run indefinitely on the hardware without being preempted or terminated. All pending work for other contexts must wait until the running context completes with no further submitted work.", + "name": "$S_SCHED_MODE_EXCLUSIVE", "value": "2" }, { - "desc": "The PUnit determines effective power draw by computing a moving average of the actual power draw over a very short time interval.", - "name": "$S_POWER_LEVEL_PEAK", + "desc": "[DEPRECATED] No longer supported.", + "name": "$S_SCHED_MODE_COMPUTE_UNIT_DEBUG", "value": "3" - }, - { - "desc": "The PUnit predicts effective power draw using the current device configuration (frequency, voltage, etc...) & throttles proactively to stay within the specified limit.", - "name": "$S_POWER_LEVEL_INSTANTANEOUS", - "value": "4" - } - ], - "name": "$s_power_level_t", - "type": "enum", - "version": "1.4" - }, - { - "class": "$sPower", - "desc": "Power Source Type", - "etors": [ - { - "desc": "Limit active no matter whether the power source is mains powered or battery powered.", - "name": "$S_POWER_SOURCE_ANY", - "value": "0" - }, - { - "desc": "Limit active only when the device is mains powered.", - "name": "$S_POWER_SOURCE_MAINS", - "value": "1" - }, - { - "desc": "Limit active only when the device is battery powered.", - "name": "$S_POWER_SOURCE_BATTERY", - "value": "2" - } - ], - "name": "$s_power_source_t", - "type": "enum", - "version": "1.4" - }, - { - "class": "$sPower", - "desc": "Limit Unit", - "etors": [ - { - "desc": "The PUnit power monitoring unit cannot be determined.", - "name": "$S_LIMIT_UNIT_UNKNOWN", - "value": "0" - }, - { - "desc": "The limit is specified in milliamperes of current drawn.", - "name": "$S_LIMIT_UNIT_CURRENT", - "value": "1" - }, - { - "desc": "The limit is specified in milliwatts of power generated.", - "name": "$S_LIMIT_UNIT_POWER", - "value": "2" } ], - "name": "$s_limit_unit_t", - "type": "enum", - "version": "1.4" + "name": "$s_sched_mode_t", + "type": "enum" }, { "base": "$s_base_properties_t", - "class": "$sPower", - "desc": "Properties related to device power settings", + "class": "$sScheduler", + "desc": "Properties related to scheduler component", "members": [ { "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_POWER_PROPERTIES", + "init": "$S_STRUCTURE_TYPE_SCHED_PROPERTIES", "name": "stype", "type": "$s_structure_type_t" }, @@ -76725,174 +90627,163 @@ "type": "uint32_t" }, { - "desc": "[out] Software can change the power limits of this domain assuming the user has permissions.", + "desc": "[out] Software can change the scheduler component configuration assuming the user has permissions.", "name": "canControl", "type": "$x_bool_t" }, { - "desc": "[out] Indicates if this power domain supports the energy threshold event ($S_EVENT_TYPE_FLAG_ENERGY_THRESHOLD_CROSSED).", - "name": "isEnergyThresholdSupported", - "type": "$x_bool_t" - }, - { - "desc": "[out] (Deprecated) The factory default TDP power limit of the part in milliwatts. A value of -1 means that this is not known.", - "name": "defaultLimit", - "type": "int32_t" - }, - { - "desc": "[out] (Deprecated) The minimum power limit in milliwatts that can be requested. A value of -1 means that this is not known.", - "name": "minLimit", - "type": "int32_t" + "desc": "[out] Bitfield of accelerator engine types that are managed by this scheduler component. Note that there can be more than one scheduler component for the same type of accelerator engine.", + "name": "engines", + "type": "$s_engine_type_flags_t" }, { - "desc": "[out] (Deprecated) The maximum power limit in milliwatts that can be requested. A value of -1 means that this is not known.", - "name": "maxLimit", - "type": "int32_t" + "desc": "[out] Bitfield of scheduler modes that can be configured for this scheduler component (bitfield of 1<<$s_sched_mode_t).", + "name": "supportedModes", + "type": "uint32_t" } ], - "name": "$s_power_properties_t", + "name": "$s_sched_properties_t", "type": "struct" }, { - "class": "$sPower", - "desc": "Energy counter snapshot", - "details": [ - "Average power is calculated by taking two snapshots (s1, s2) and using the equation: PowerWatts = (s2.energy - s1.energy) / (s2.timestamp - s1.timestamp)" - ], + "desc": "Disable forward progress guard timeout.", + "name": "$S_SCHED_WATCHDOG_DISABLE", + "type": "macro", + "value": "(~(0ULL))" + }, + { + "base": "$s_base_properties_t", + "class": "$sDevice", + "desc": "Configuration for timeout scheduler mode ($S_SCHED_MODE_TIMEOUT)", "members": [ { - "desc": "[out] The monotonic energy counter in microjoules.", - "name": "energy", - "type": "uint64_t" + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_SCHED_TIMEOUT_PROPERTIES", + "name": "stype", + "type": "$s_structure_type_t" }, { - "desc": "[out] Microsecond timestamp when energy was captured.\nThis timestamp should only be used to calculate delta time between snapshots of this structure.\nNever take the delta of this timestamp with the timestamp from a different structure since they are not guaranteed to have the same base.\nThe absolute value of the timestamp is only valid during within the application and may be different on the next execution.\n", - "name": "timestamp", + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" + }, + { + "desc": "[in,out] The maximum time in microseconds that the scheduler will wait for a batch of work submitted to a hardware engine to complete or to be preempted so as to run another context.\nIf this time is exceeded, the hardware engine is reset and the context terminated.\nIf set to $S_SCHED_WATCHDOG_DISABLE, a running workload can run as long as it wants without being terminated, but preemption attempts to run other contexts are permitted but not enforced.\n", + "name": "watchdogTimeout", "type": "uint64_t" } ], - "name": "$s_power_energy_counter_t", + "name": "$s_sched_timeout_properties_t", "type": "struct" }, { - "class": "$sPower", - "desc": "Sustained power limits", - "details": [ - "The power controller (Punit) will throttle the operating frequency if the power averaged over a window (typically seconds) exceeds this limit." - ], + "base": "$s_base_properties_t", + "class": "$sDevice", + "desc": "Configuration for timeslice scheduler mode ($S_SCHED_MODE_TIMESLICE)", "members": [ { - "desc": "[in,out] indicates if the limit is enabled (true) or ignored (false)", - "name": "enabled", - "type": "$x_bool_t" + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_SCHED_TIMESLICE_PROPERTIES", + "name": "stype", + "type": "$s_structure_type_t" }, { - "desc": "[in,out] power limit in milliwatts", - "name": "power", - "type": "int32_t" + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" }, { - "desc": "[in,out] power averaging window (Tau) in milliseconds", + "desc": "[in,out] The average interval in microseconds that a submission for a context will run on a hardware engine before being preempted out to run a pending submission for another context.", "name": "interval", - "type": "int32_t" + "type": "uint64_t" + }, + { + "desc": "[in,out] The maximum time in microseconds that the scheduler will wait to preempt a workload running on an engine before deciding to reset the hardware engine and terminating the associated context.", + "name": "yieldTimeout", + "type": "uint64_t" } ], - "name": "$s_power_sustained_limit_t", + "name": "$s_sched_timeslice_properties_t", "type": "struct" }, { - "class": "$sPower", - "desc": "Burst power limit", + "class": "$sDevice", + "desc": "Returns handles to scheduler components.", "details": [ - "The power controller (Punit) will throttle the operating frequency of the device if the power averaged over a few milliseconds exceeds a limit known as PL2. Typically PL2 > PL1 so that it permits the frequency to burst higher for short periods than would be otherwise permitted by PL1." + "Each scheduler component manages the distribution of work across one or more accelerator engines.", + "If an application wishes to change the scheduler behavior for all accelerator engines of a specific type (e.g. compute), it should select all the handles where the `engines` member $s_sched_properties_t contains that type.", + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." ], - "members": [ + "hash": "fd37b138e4d455f525f8b29c80b71137e78d52c62615dfa008db1a0cc7b7d716", + "name": "EnumSchedulers", + "params": [ { - "desc": "[in,out] indicates if the limit is enabled (true) or ignored (false)", - "name": "enabled", - "type": "$x_bool_t" + "desc": "[in] Sysman handle of the device.", + "name": "hDevice", + "type": "$s_device_handle_t" }, { - "desc": "[in,out] power limit in milliwatts", - "name": "power", - "type": "int32_t" + "desc": "[in,out] pointer to the number of components of this type.\nif count is zero, then the driver shall update the value with the total number of components of this type that are available.\nif count is greater than the number of components of this type that are available, then the driver shall update the value with the correct number of components.\n", + "name": "pCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", + "name": "phScheduler", + "type": "$s_sched_handle_t*" } ], - "name": "$s_power_burst_limit_t", - "type": "struct" - }, - { - "class": "$sPower", - "desc": "Peak power limit", - "details": [ - "The power controller (Punit) will reactively/proactively throttle the operating frequency of the device when the instantaneous/100usec power exceeds this limit. The limit is known as PL4 or Psys. It expresses the maximum power that can be drawn from the power supply.", - "If this power limit is removed or set too high, the power supply will generate an interrupt when it detects an overcurrent condition and the power controller will throttle the device frequencies down to min. It is thus better to tune the PL4 value in order to avoid such excursions." - ], - "members": [ + "returns": [ { - "desc": "[in,out] power limit in milliwatts for the AC power source.", - "name": "powerAC", - "type": "int32_t" + "$X_RESULT_SUCCESS": [] }, { - "desc": "[in,out] power limit in milliwatts for the DC power source. On input, this is ignored if the product does not have a battery. On output, this will be -1 if the product does not have a battery.", - "name": "powerDC", - "type": "int32_t" - } - ], - "name": "$s_power_peak_limit_t", - "type": "struct" - }, - { - "class": "$sPower", - "desc": "Energy threshold", - "details": [ - "." - ], - "members": [ + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, { - "desc": "[in,out] Indicates if the energy threshold is enabled.", - "name": "enable", - "type": "$x_bool_t" + "$X_RESULT_ERROR_DEVICE_LOST": [] }, { - "desc": "[in,out] The energy threshold in Joules. Will be 0.0 if no threshold has been set.", - "name": "threshold", - "type": "double" + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] }, { - "desc": "[in,out] The host process ID that set the energy threshold. Will be 0xFFFFFFFF if no threshold has been set.", - "name": "processId", - "type": "uint32_t" + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDevice`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCount`" + ] } ], - "name": "$s_energy_threshold_t", - "type": "struct" + "type": "function" }, { - "class": "$sDevice", - "desc": "Get handle of power domains", + "class": "$sScheduler", + "desc": "Get properties related to a scheduler component", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "a162fab77909ff04da2e08eef1e2cf17487f31ae5a2f4c1a25555f6bf56bc60e", - "name": "EnumPowerDomains", + "hash": "65a7c80ec9d728805fb964d7fd96801b62d577461484aa2498ed29bc45b71364", + "name": "GetProperties", "params": [ { - "desc": "[in] Sysman handle of the device.", - "name": "hDevice", - "type": "$s_device_handle_t" - }, - { - "desc": "[in,out] pointer to the number of components of this type.\nif count is zero, then the driver shall update the value with the total number of components of this type that are available.\nif count is greater than the number of components of this type that are available, then the driver shall update the value with the correct number of components.\n", - "name": "pCount", - "type": "uint32_t*" + "desc": "[in] Handle for the component.", + "name": "hScheduler", + "type": "$s_sched_handle_t" }, { - "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", - "name": "phPower", - "type": "$s_pwr_handle_t*" + "desc": "[in,out] Structure that will contain property data.", + "name": "pProperties", + "type": "$s_sched_properties_t*" } ], "returns": [ @@ -76913,36 +90804,36 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDevice`" + "`nullptr == hScheduler`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pCount`" + "`nullptr == pProperties`" ] } ], "type": "function" }, { - "class": "$sDevice", - "desc": "Get handle of the PCIe card-level power", + "class": "$sScheduler", + "desc": "Get current scheduling mode in effect on a scheduler component.", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "047ca99995666fe5cefd48dde4b5e5262fd4ac1916c75723f18649b25c4e6942", - "name": "GetCardPowerDomain", + "hash": "ff8efe1877bfdddb8ab4c8a3c626ef2f4e6dfca3e49a05ff48fe2c08dc0aa05b", + "name": "GetCurrentMode", "params": [ { - "desc": "[in] Sysman handle of the device.", - "name": "hDevice", - "type": "$s_device_handle_t" + "desc": "[in] Sysman handle for the component.", + "name": "hScheduler", + "type": "$s_sched_handle_t" }, { - "desc": "[in,out] power domain handle for the entire PCIe card.", - "name": "phPower", - "type": "$s_pwr_handle_t*" + "desc": "[in,out] Will contain the current scheduler mode.", + "name": "pMode", + "type": "$s_sched_mode_t*" } ], "returns": [ @@ -76963,41 +90854,46 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDevice`" + "`nullptr == hScheduler`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == phPower`" + "`nullptr == pMode`" ] }, { "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "The device does not provide access to card level power controls or telemetry. An invalid power domain handle will be returned in phPower." + "This scheduler component does not support scheduler modes." ] } ], "type": "function" }, { - "class": "$sPower", - "desc": "Get properties related to a power domain", + "class": "$sScheduler", + "desc": "Get scheduler config for mode $S_SCHED_MODE_TIMEOUT", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "0ac3a4c1fa7cf470238a28cc3775ee610214b99c270555dca72f975199288995", - "name": "GetProperties", + "hash": "15bf9620651387ae69552ff0dfacf3fd96d7cd553599e0f549414c62aa97938f", + "name": "GetTimeoutModeProperties", "params": [ { - "desc": "[in] Handle for the component.", - "name": "hPower", - "type": "$s_pwr_handle_t" + "desc": "[in] Sysman handle for the component.", + "name": "hScheduler", + "type": "$s_sched_handle_t" }, { - "desc": "[in,out] Structure that will contain property data.", - "name": "pProperties", - "type": "$s_power_properties_t*" + "desc": "[in] If TRUE, the driver will return the system default properties for this mode, otherwise it will return the current properties.", + "name": "getDefaults", + "type": "$x_bool_t" + }, + { + "desc": "[in,out] Will contain the current parameters for this mode.", + "name": "pConfig", + "type": "$s_sched_timeout_properties_t*" } ], "returns": [ @@ -77018,36 +90914,46 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hPower`" + "`nullptr == hScheduler`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pProperties`" + "`nullptr == pConfig`" + ] + }, + { + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "This scheduler component does not support scheduler modes." ] } ], "type": "function" }, { - "class": "$sPower", - "desc": "Get energy counter", + "class": "$sScheduler", + "desc": "Get scheduler config for mode $S_SCHED_MODE_TIMESLICE", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "55238b643e181150dd35ae06a62b397c7488fdda9c500a0b999b95d00fa07311", - "name": "GetEnergyCounter", + "hash": "4cdaf9f11a323f15db5d9dfa4e9cc43cfc054832618dd32e37ca908c5ea1e348", + "name": "GetTimesliceModeProperties", "params": [ { - "desc": "[in] Handle for the component.", - "name": "hPower", - "type": "$s_pwr_handle_t" + "desc": "[in] Sysman handle for the component.", + "name": "hScheduler", + "type": "$s_sched_handle_t" }, { - "desc": "[in,out] Will contain the latest snapshot of the energy counter and timestamp when the last counter value was measured.", - "name": "pEnergy", - "type": "$s_power_energy_counter_t*" + "desc": "[in] If TRUE, the driver will return the system default properties for this mode, otherwise it will return the current properties.", + "name": "getDefaults", + "type": "$x_bool_t" + }, + { + "desc": "[in,out] Will contain the current parameters for this mode.", + "name": "pConfig", + "type": "$s_sched_timeslice_properties_t*" } ], "returns": [ @@ -77068,47 +90974,47 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hPower`" + "`nullptr == hScheduler`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pEnergy`" + "`nullptr == pConfig`" + ] + }, + { + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "This scheduler component does not support scheduler modes." ] } ], "type": "function" }, { - "class": "$sPower", - "desc": "Get power limits", + "class": "$sScheduler", + "desc": "Change scheduler mode to $S_SCHED_MODE_TIMEOUT or update scheduler mode parameters if already running in this mode.", "details": [ + "This mode is optimized for multiple applications or contexts submitting work to the hardware. When higher priority work arrives, the scheduler attempts to pause the current executing work within some timeout interval, then submits the other work.", "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free.", - "Note: This function is deprecated and replaced by $sPowerGetLimitsExt." + "The implementation of this function should be lock-free." ], - "hash": "ed0462ffcd8d44a95439a0ea86fbb1bc0e13e357c0d73fabd1d3322abd658e18", - "name": "GetLimits", + "hash": "3f9453cd11aa3272d37a2631c25d45a0f71a9ae27f29994148f76170753de50c", + "name": "SetTimeoutMode", "params": [ { - "desc": "[in] Handle for the component.", - "name": "hPower", - "type": "$s_pwr_handle_t" - }, - { - "desc": "[in,out][optional] The sustained power limit. If this is null, the current sustained power limits will not be returned.", - "name": "pSustained", - "type": "$s_power_sustained_limit_t*" + "desc": "[in] Sysman handle for the component.", + "name": "hScheduler", + "type": "$s_sched_handle_t" }, { - "desc": "[in,out][optional] The burst power limit. If this is null, the current peak power limits will not be returned.", - "name": "pBurst", - "type": "$s_power_burst_limit_t*" + "desc": "[in] The properties to use when configurating this mode.", + "name": "pProperties", + "type": "$s_sched_timeout_properties_t*" }, { - "desc": "[in,out][optional] The peak power limit. If this is null, the peak power limits will not be returned.", - "name": "pPeak", - "type": "$s_power_peak_limit_t*" + "desc": "[in,out] Will be set to TRUE if a device driver reload is needed to apply the new scheduler mode.", + "name": "pNeedReload", + "type": "$x_bool_t*" } ], "returns": [ @@ -77129,42 +91035,53 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hPower`" + "`nullptr == hScheduler`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pProperties`", + "`nullptr == pNeedReload`" + ] + }, + { + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "This scheduler component does not support scheduler modes." + ] + }, + { + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "User does not have permissions to make this modification." ] } ], "type": "function" }, { - "class": "$sPower", - "desc": "Set power limits", + "class": "$sScheduler", + "desc": "Change scheduler mode to $S_SCHED_MODE_TIMESLICE or update scheduler mode parameters if already running in this mode.", "details": [ + "This mode is optimized to provide fair sharing of hardware execution time between multiple contexts submitting work to the hardware concurrently.", "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free.", - "Note: This function is deprecated and replaced by $sPowerSetLimitsExt." - ], - "hash": "adfce6f8e5ca88571ca8d3c876751c1de2ba0acca3d52639c128be64a18c4550", - "name": "SetLimits", - "params": [ - { - "desc": "[in] Handle for the component.", - "name": "hPower", - "type": "$s_pwr_handle_t" - }, + "The implementation of this function should be lock-free." + ], + "hash": "11dedcf5e86b6e8f766178a724293a56c52026ebe98f4de0a7501aaf3d6246c0", + "name": "SetTimesliceMode", + "params": [ { - "desc": "[in][optional] The sustained power limit. If this is null, no changes will be made to the sustained power limits.", - "name": "pSustained", - "type": "const $s_power_sustained_limit_t*" + "desc": "[in] Sysman handle for the component.", + "name": "hScheduler", + "type": "$s_sched_handle_t" }, { - "desc": "[in][optional] The burst power limit. If this is null, no changes will be made to the burst power limits.", - "name": "pBurst", - "type": "const $s_power_burst_limit_t*" + "desc": "[in] The properties to use when configurating this mode.", + "name": "pProperties", + "type": "$s_sched_timeslice_properties_t*" }, { - "desc": "[in][optional] The peak power limit. If this is null, no changes will be made to the peak power limits.", - "name": "pPeak", - "type": "const $s_power_peak_limit_t*" + "desc": "[in,out] Will be set to TRUE if a device driver reload is needed to apply the new scheduler mode.", + "name": "pNeedReload", + "type": "$x_bool_t*" } ], "returns": [ @@ -77185,41 +91102,48 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hPower`" + "`nullptr == hScheduler`" ] }, { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to make these modifications." + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pProperties`", + "`nullptr == pNeedReload`" ] }, { - "$X_RESULT_ERROR_NOT_AVAILABLE": [ - "The device is in use, meaning that the GPU is under Over clocking, applying power limits under overclocking is not supported." + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "This scheduler component does not support scheduler modes." + ] + }, + { + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "User does not have permissions to make this modification." ] } ], "type": "function" }, { - "class": "$sPower", - "desc": "Get energy threshold", + "class": "$sScheduler", + "desc": "Change scheduler mode to $S_SCHED_MODE_EXCLUSIVE", "details": [ + "This mode is optimized for single application/context use-cases. It permits a context to run indefinitely on the hardware without being preempted or terminated. All pending work for other contexts must wait until the running context completes with no further submitted work.", "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "11e5666d7a95676691c797e7d12570dba7a301c7b51b07fc5e6550764a071806", - "name": "GetEnergyThreshold", + "hash": "b3ddcb66d6d358c372478f16c47c422e9b18e2acbd01923f385fd58f394c8a76", + "name": "SetExclusiveMode", "params": [ { - "desc": "[in] Handle for the component.", - "name": "hPower", - "type": "$s_pwr_handle_t" + "desc": "[in] Sysman handle for the component.", + "name": "hScheduler", + "type": "$s_sched_handle_t" }, { - "desc": "[in,out] Returns information about the energy threshold setting - enabled/energy threshold/process ID.", - "name": "pThreshold", - "type": "$s_energy_threshold_t*" + "desc": "[in,out] Will be set to TRUE if a device driver reload is needed to apply the new scheduler mode.", + "name": "pNeedReload", + "type": "$x_bool_t*" } ], "returns": [ @@ -77240,50 +91164,49 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hPower`" + "`nullptr == hScheduler`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pThreshold`" + "`nullptr == pNeedReload`" ] }, { "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "Energy threshold not supported on this power domain (check the `isEnergyThresholdSupported` member of $s_power_properties_t)." + "This scheduler component does not support scheduler modes." ] }, { "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to request this feature." + "User does not have permissions to make this modification." ] } ], "type": "function" }, { - "class": "$sPower", - "desc": "Set energy threshold", + "class": "$sScheduler", + "desc": "Change scheduler mode to $S_SCHED_MODE_COMPUTE_UNIT_DEBUG", "details": [ - "An event $S_EVENT_TYPE_FLAG_ENERGY_THRESHOLD_CROSSED will be generated when the delta energy consumed starting from this call exceeds the specified threshold. Use the function $sDeviceEventRegister() to start receiving the event.", - "Only one running process can control the energy threshold at a given time. If another process attempts to change the energy threshold, the error $X_RESULT_ERROR_NOT_AVAILABLE will be returned. The function $sPowerGetEnergyThreshold() to determine the process ID currently controlling this setting.", - "Calling this function will remove any pending energy thresholds and start counting from the time of this call.", - "Once the energy threshold has been reached and the event generated, the threshold is automatically removed. It is up to the application to request a new threshold.", + "This is a special mode that must ben enabled when debugging an application that uses this device e.g. using the Level0 Debug API.", + "It ensures that only one command queue can execute work on the hardware at a given time. Work is permitted to run as long as needed without enforcing any scheduler fairness policies.", "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The implementation of this function should be lock-free.", + "[DEPRECATED] No longer supported." ], - "hash": "ef52d53f78f5e95a24faf530e9ee0bb353cff7d607cec5a27376f4dd4ebf2255", - "name": "SetEnergyThreshold", + "hash": "20f2f46d786180d013bcdd048e18fa11689f100439628591f3d4d26a33d3d071", + "name": "SetComputeUnitDebugMode", "params": [ { - "desc": "[in] Handle for the component.", - "name": "hPower", - "type": "$s_pwr_handle_t" + "desc": "[in] Sysman handle for the component.", + "name": "hScheduler", + "type": "$s_sched_handle_t" }, { - "desc": "[in] The energy threshold to be set in joules.", - "name": "threshold", - "type": "double" + "desc": "[in,out] Will be set to TRUE if a device driver reload is needed to apply the new scheduler mode.", + "name": "pNeedReload", + "type": "$x_bool_t*" } ], "returns": [ @@ -77304,35 +91227,35 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hPower`" + "`nullptr == hScheduler`" ] }, { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "Energy threshold not supported on this power domain (check the `isEnergyThresholdSupported` member of $s_power_properties_t)." + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pNeedReload`" ] }, { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to request this feature." + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "This scheduler component does not support scheduler modes." ] }, { - "$X_RESULT_ERROR_NOT_AVAILABLE": [ - "Another running process has set the energy threshold." + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "User does not have permissions to make this modification." ] } ], "type": "function" }, { - "desc": "C++ wrapper for a Sysman device power domain", + "desc": "C++ wrapper for a Sysman device scheduler queue", "members": [ { "desc": "[in] handle of Sysman object", "init": "nullptr", "name": "handle", - "type": "$s_pwr_handle_t" + "type": "$s_sched_handle_t" }, { "desc": "[in] pointer to owner object", @@ -77340,7 +91263,7 @@ "type": "$sDevice*" } ], - "name": "$sPower", + "name": "$sScheduler", "owner": "$sDevice", "type": "class" } @@ -77348,48 +91271,33 @@ }, { "header": { - "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - Firmware management", + "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - Standby domains", "ordinal": 1000, "type": "header" }, - "name": "psu", + "name": "standby", "objects": [ { - "class": "$sPsu", - "desc": "PSU voltage status", + "class": "$sStandby", + "desc": "Standby hardware components", "etors": [ { - "desc": "The status of the power supply voltage controllers cannot be determined", - "name": "$S_PSU_VOLTAGE_STATUS_UNKNOWN", + "desc": "Control the overall standby policy of the device/sub-device", + "name": "$S_STANDBY_TYPE_GLOBAL", "value": "0" - }, - { - "desc": "No unusual voltages have been detected", - "name": "$S_PSU_VOLTAGE_STATUS_NORMAL", - "value": "1" - }, - { - "desc": "Over-voltage has occurred", - "name": "$S_PSU_VOLTAGE_STATUS_OVER", - "value": "2" - }, - { - "desc": "Under-voltage has occurred", - "name": "$S_PSU_VOLTAGE_STATUS_UNDER", - "value": "3" } ], - "name": "$s_psu_voltage_status_t", + "name": "$s_standby_type_t", "type": "enum" }, { "base": "$s_base_properties_t", - "class": "$sPsu", - "desc": "Static properties of the power supply", + "class": "$sStandby", + "desc": "Standby hardware component properties", "members": [ { "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_PSU_PROPERTIES", + "init": "$S_STRUCTURE_TYPE_STANDBY_PROPERTIES", "name": "stype", "type": "$s_structure_type_t" }, @@ -77399,6 +91307,11 @@ "name": "pNext", "type": "void*" }, + { + "desc": "[out] Which standby hardware component this controls", + "name": "type", + "type": "$s_standby_type_t" + }, { "desc": "[out] True if the resource is located on a sub-device; false means that the resource is on the device of the calling Sysman handle", "name": "onSubdevice", @@ -77408,71 +91321,38 @@ "desc": "[out] If onSubdevice is true, this gives the ID of the sub-device", "name": "subdeviceId", "type": "uint32_t" - }, - { - "desc": "[out] True if the power supply has a fan", - "name": "haveFan", - "type": "$x_bool_t" - }, - { - "desc": "[out] The maximum electrical current in milliamperes that can be drawn. A value of -1 indicates that this property cannot be determined.", - "name": "ampLimit", - "type": "int32_t" } ], - "name": "$s_psu_properties_t", + "name": "$s_standby_properties_t", "type": "struct" }, { - "base": "$s_base_state_t", - "class": "$sPsu", - "desc": "Dynamic state of the power supply", - "members": [ - { - "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_PSU_STATE", - "name": "stype", - "type": "$s_structure_type_t" - }, - { - "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "const void*" - }, - { - "desc": "[out] The current PSU voltage status", - "name": "voltStatus", - "type": "$s_psu_voltage_status_t" - }, - { - "desc": "[out] Indicates if the fan has failed", - "name": "fanFailed", - "type": "$x_bool_t" - }, + "class": "$sStandby", + "desc": "Standby promotion modes", + "etors": [ { - "desc": "[out] Read the current heatsink temperature in degrees Celsius. A value of -1 indicates that this property cannot be determined.", - "name": "temperature", - "type": "int32_t" + "desc": "Best compromise between performance and energy savings.", + "name": "$S_STANDBY_PROMO_MODE_DEFAULT", + "value": "0" }, { - "desc": "[out] The amps being drawn in milliamperes. A value of -1 indicates that this property cannot be determined.", - "name": "current", - "type": "int32_t" + "desc": "The device/component will never shutdown. This can improve performance but uses more energy.", + "name": "$S_STANDBY_PROMO_MODE_NEVER", + "value": "1" } ], - "name": "$s_psu_state_t", - "type": "struct" + "name": "$s_standby_promo_mode_t", + "type": "enum" }, { "class": "$sDevice", - "desc": "Get handle of power supplies", + "desc": "Get handle of standby controls", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "3a4d1abb6eece0119fee707bcd6098ceb8c5cf4a72f955e268dde6b4e94a741c", - "name": "EnumPsus", + "hash": "1321756521f332777fba5d6fd3fda68a156551a5378e0256522397b248e220f0", + "name": "EnumStandbyDomains", "params": [ { "desc": "[in] Sysman handle of the device.", @@ -77486,8 +91366,8 @@ }, { "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", - "name": "phPsu", - "type": "$s_psu_handle_t*" + "name": "phStandby", + "type": "$s_standby_handle_t*" } ], "returns": [ @@ -77520,24 +91400,24 @@ "type": "function" }, { - "class": "$sPsu", - "desc": "Get power supply properties", + "class": "$sStandby", + "desc": "Get standby hardware component properties", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "8d0cf92b0e7647a92d9edffb0a8076d51cd65838300a01acc786e379faf65d92", + "hash": "8c2ca72b71cb172ab9cf558824d44c9c1d0057532e84bc8b6d2ce9e3eedc7c10", "name": "GetProperties", "params": [ { "desc": "[in] Handle for the component.", - "name": "hPsu", - "type": "$s_psu_handle_t" + "name": "hStandby", + "type": "$s_standby_handle_t" }, { - "desc": "[in,out] Will contain the properties of the power supply.", + "desc": "[in,out] Will contain the standby hardware properties.", "name": "pProperties", - "type": "$s_psu_properties_t*" + "type": "$s_standby_properties_t*" } ], "returns": [ @@ -77558,7 +91438,7 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hPsu`" + "`nullptr == hStandby`" ] }, { @@ -77570,24 +91450,24 @@ "type": "function" }, { - "class": "$sPsu", - "desc": "Get current power supply state", + "class": "$sStandby", + "desc": "Get the current standby promotion mode", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "453129fa23bfb6ed587d17b79b631cfe976944dabb190f60efb69d4f4bc7049d", - "name": "GetState", + "hash": "5b35e78c5cabe67779534fa696ed6b8e877734f8e052462b4e2f0f25c9625092", + "name": "GetMode", "params": [ { "desc": "[in] Handle for the component.", - "name": "hPsu", - "type": "$s_psu_handle_t" + "name": "hStandby", + "type": "$s_standby_handle_t" }, { - "desc": "[in,out] Will contain the current state of the power supply.", - "name": "pState", - "type": "$s_psu_state_t*" + "desc": "[in,out] Will contain the current standby mode.", + "name": "pMode", + "type": "$s_standby_promo_mode_t*" } ], "returns": [ @@ -77608,25 +91488,80 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hPsu`" + "`nullptr == hStandby`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pState`" + "`nullptr == pMode`" ] } ], "type": "function" }, { - "desc": "C++ wrapper for a Sysman device power supply", + "class": "$sStandby", + "desc": "Set standby promotion mode", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "c7ed048761bf7be69e42f0cd80d79177b513cc831bce3fbffb9774c9da950e43", + "name": "SetMode", + "params": [ + { + "desc": "[in] Handle for the component.", + "name": "hStandby", + "type": "$s_standby_handle_t" + }, + { + "desc": "[in] New standby mode.", + "name": "mode", + "type": "$s_standby_promo_mode_t" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hStandby`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_ENUMERATION": [ + "`$S_STANDBY_PROMO_MODE_NEVER < mode`" + ] + }, + { + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "User does not have permissions to make these modifications." + ] + } + ], + "type": "function" + }, + { + "desc": "C++ wrapper for a Sysman standby control", "members": [ { "desc": "[in] handle of Sysman object", "init": "nullptr", "name": "handle", - "type": "$s_psu_handle_t" + "type": "$s_standby_handle_t" }, { "desc": "[in] pointer to owner object", @@ -77634,7 +91569,7 @@ "type": "$sDevice*" } ], - "name": "$sPsu", + "name": "$sStandby", "owner": "$sDevice", "type": "class" } @@ -77646,83 +91581,72 @@ "ordinal": 1000, "type": "header" }, - "name": "ras", + "name": "temperature", "objects": [ { - "class": "$sRas", - "desc": "RAS error type", - "etors": [ - { - "desc": "Errors were corrected by hardware", - "name": "$S_RAS_ERROR_TYPE_CORRECTABLE", - "value": "0" - }, - { - "desc": "Error were not corrected", - "name": "$S_RAS_ERROR_TYPE_UNCORRECTABLE", - "value": "1" - } - ], - "name": "$s_ras_error_type_t", - "type": "enum" - }, - { - "class": "$sRas", - "desc": "RAS error categories", + "class": "$sTemperature", + "desc": "Temperature sensors", "etors": [ { - "desc": "The number of accelerator engine resets attempted by the driver", - "name": "$S_RAS_ERROR_CAT_RESET", + "desc": "The maximum temperature across all device sensors", + "name": "$S_TEMP_SENSORS_GLOBAL", "value": "0" }, { - "desc": "The number of hardware exceptions generated by the way workloads have programmed the hardware", - "name": "$S_RAS_ERROR_CAT_PROGRAMMING_ERRORS", + "desc": "The maximum temperature across all sensors in the GPU", + "name": "$S_TEMP_SENSORS_GPU", "value": "1" }, { - "desc": "The number of low level driver communication errors have occurred", - "name": "$S_RAS_ERROR_CAT_DRIVER_ERRORS", + "desc": "The maximum temperature across all sensors in the local memory", + "name": "$S_TEMP_SENSORS_MEMORY", "value": "2" }, { - "desc": "The number of errors that have occurred in the compute accelerator hardware", - "name": "$S_RAS_ERROR_CAT_COMPUTE_ERRORS", + "desc": "The minimum temperature across all device sensors", + "name": "$S_TEMP_SENSORS_GLOBAL_MIN", "value": "3" }, { - "desc": "The number of errors that have occurred in the fixed-function accelerator hardware", - "name": "$S_RAS_ERROR_CAT_NON_COMPUTE_ERRORS", + "desc": "The minimum temperature across all sensors in the GPU", + "name": "$S_TEMP_SENSORS_GPU_MIN", "value": "4" }, { - "desc": "The number of errors that have occurred in caches (L1/L3/register file/shared local memory/sampler)", - "name": "$S_RAS_ERROR_CAT_CACHE_ERRORS", + "desc": "The minimum temperature across all sensors in the local device memory", + "name": "$S_TEMP_SENSORS_MEMORY_MIN", "value": "5" }, { - "desc": "The number of errors that have occurred in the display", - "name": "$S_RAS_ERROR_CAT_DISPLAY_ERRORS", - "value": "6" + "desc": "The maximum temperature across all sensors in the GPU Board", + "name": "$S_TEMP_SENSORS_GPU_BOARD", + "value": "6", + "version": "1.8" + }, + { + "desc": "The minimum temperature across all sensors in the GPU Board", + "name": "$S_TEMP_SENSORS_GPU_BOARD_MIN", + "value": "7", + "version": "1.8" + }, + { + "desc": "The maximum temperature across all sensors in the Voltage Regulator", + "name": "$S_TEMP_SENSORS_VOLTAGE_REGULATOR", + "value": "8", + "version": "1.10" } ], - "name": "$s_ras_error_cat_t", + "name": "$s_temp_sensors_t", "type": "enum" }, - { - "desc": "The maximum number of categories", - "name": "$S_MAX_RAS_ERROR_CATEGORY_COUNT", - "type": "macro", - "value": "7" - }, { "base": "$s_base_properties_t", - "class": "$sRas", - "desc": "RAS properties", + "class": "$sTemperature", + "desc": "Temperature sensor properties", "members": [ { "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_RAS_PROPERTIES", + "init": "$S_STRUCTURE_TYPE_TEMP_PROPERTIES", "name": "stype", "type": "$s_structure_type_t" }, @@ -77733,9 +91657,9 @@ "type": "void*" }, { - "desc": "[out] The type of RAS error", + "desc": "[out] Which part of the device the temperature sensor measures", "name": "type", - "type": "$s_ras_error_type_t" + "type": "$s_temp_sensors_t" }, { "desc": "[out] True if the resource is located on a sub-device; false means that the resource is on the device of the calling Sysman handle", @@ -77746,49 +91670,62 @@ "desc": "[out] If onSubdevice is true, this gives the ID of the sub-device", "name": "subdeviceId", "type": "uint32_t" + }, + { + "desc": "[out] Will contain the maximum temperature for the specific device in degrees Celsius.", + "name": "maxTemperature", + "type": "double" + }, + { + "desc": "[out] Indicates if the critical temperature event $S_EVENT_TYPE_FLAG_TEMP_CRITICAL is supported", + "name": "isCriticalTempSupported", + "type": "$x_bool_t" + }, + { + "desc": "[out] Indicates if the temperature threshold 1 event $S_EVENT_TYPE_FLAG_TEMP_THRESHOLD1 is supported", + "name": "isThreshold1Supported", + "type": "$x_bool_t" + }, + { + "desc": "[out] Indicates if the temperature threshold 2 event $S_EVENT_TYPE_FLAG_TEMP_THRESHOLD2 is supported", + "name": "isThreshold2Supported", + "type": "$x_bool_t" } ], - "name": "$s_ras_properties_t", + "name": "$s_temp_properties_t", "type": "struct" }, { - "base": "$s_base_state_t", - "class": "$sRas", - "desc": "RAS error details", + "class": "$sTemperature", + "desc": "Temperature sensor threshold", "members": [ { - "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_RAS_STATE", - "name": "stype", - "type": "$s_structure_type_t" + "desc": "[in,out] Trigger an event when the temperature crosses from below the threshold to above.", + "name": "enableLowToHigh", + "type": "$x_bool_t" }, { - "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "const void*" + "desc": "[in,out] Trigger an event when the temperature crosses from above the threshold to below.", + "name": "enableHighToLow", + "type": "$x_bool_t" }, { - "desc": "[in][out] Breakdown of error by category", - "name": "category[$S_MAX_RAS_ERROR_CATEGORY_COUNT]", - "type": "uint64_t" + "desc": "[in,out] The threshold in degrees Celsius.", + "name": "threshold", + "type": "double" } ], - "name": "$s_ras_state_t", + "name": "$s_temp_threshold_t", "type": "struct" }, { "base": "$s_base_config_t", - "class": "$sRas", - "desc": "RAS error configuration - thresholds used for triggering RAS events ($S_EVENT_TYPE_FLAG_RAS_CORRECTABLE_ERRORS, $S_EVENT_TYPE_FLAG_RAS_UNCORRECTABLE_ERRORS)", - "details": [ - "The driver maintains a total counter which is updated every time a hardware block covered by the corresponding RAS error set notifies that an error has occurred. When this total count goes above the totalThreshold specified below, a RAS event is triggered.", - "The driver also maintains a counter for each category of RAS error (see $s_ras_state_t for a breakdown). Each time a hardware block of that category notifies that an error has occurred, that corresponding category counter is updated. When it goes above the threshold specified in detailedThresholds, a RAS event is triggered." - ], + "class": "$sTemperature", + "desc": "Temperature configuration - which events should be triggered and the trigger conditions.", "members": [ { "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_RAS_CONFIG", + "init": "$S_STRUCTURE_TYPE_TEMP_CONFIG", "name": "stype", "type": "$s_structure_type_t" }, @@ -77799,32 +91736,33 @@ "type": "const void*" }, { - "desc": "[in,out] If the total RAS errors exceeds this threshold, the event will be triggered. A value of 0ULL disables triggering the event based on the total counter.", - "name": "totalThreshold", - "type": "uint64_t" + "desc": "[in,out] Indicates if event $S_EVENT_TYPE_FLAG_TEMP_CRITICAL should be triggered by the driver.", + "name": "enableCritical", + "type": "$x_bool_t" }, { - "desc": "[in,out] If the RAS errors for each category exceed the threshold for that category, the event will be triggered. A value of 0ULL will disable an event being triggered for that category.", - "name": "detailedThresholds", - "type": "$s_ras_state_t" + "desc": "[in,out] Configuration controlling if and when event $S_EVENT_TYPE_FLAG_TEMP_THRESHOLD1 should be triggered by the driver.", + "name": "threshold1", + "type": "$s_temp_threshold_t" + }, + { + "desc": "[in,out] Configuration controlling if and when event $S_EVENT_TYPE_FLAG_TEMP_THRESHOLD2 should be triggered by the driver.", + "name": "threshold2", + "type": "$s_temp_threshold_t" } ], - "name": "$s_ras_config_t", + "name": "$s_temp_config_t", "type": "struct" }, { "class": "$sDevice", - "desc": "Get handle of all RAS error sets on a device", + "desc": "Get handle of temperature sensors", "details": [ - "A RAS error set is a collection of RAS error counters of a given type (correctable/uncorrectable) from hardware blocks contained within a sub-device or within the device.", - "A device without sub-devices will typically return two handles, one for correctable errors sets and one for uncorrectable error sets.", - "A device with sub-devices will return RAS error sets for each sub-device and possibly RAS error sets for hardware blocks outside the sub-devices.", - "If the function completes successfully but pCount is set to 0, RAS features are not available/enabled on this device.", "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "937766bf395b256301368c368e0d399cb0aee34dfdd044da3c2cdb7b29be97a3", - "name": "EnumRasErrorSets", + "hash": "75a0cd6be102dba55222d44af450b6940f4bb4a186a27bc64844a76cbdbc39c6", + "name": "EnumTemperatureSensors", "params": [ { "desc": "[in] Sysman handle of the device.", @@ -77838,8 +91776,8 @@ }, { "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", - "name": "phRas", - "type": "$s_ras_handle_t*" + "name": "phTemperature", + "type": "$s_temp_handle_t*" } ], "returns": [ @@ -77872,24 +91810,24 @@ "type": "function" }, { - "class": "$sRas", - "desc": "Get RAS properties of a given RAS error set - this enables discovery of the type of RAS error set (correctable/uncorrectable) and if located on a sub-device", + "class": "$sTemperature", + "desc": "Get temperature sensor properties", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "f30bca24c015dcc7e4609790f05e46643da44e1fa1c9b0341cf1d8078c6ed5e4", + "hash": "aed86f68f316999523ed898037cdc44bb6e1a9447b9aed0c17792c9af3b44fef", "name": "GetProperties", "params": [ { "desc": "[in] Handle for the component.", - "name": "hRas", - "type": "$s_ras_handle_t" + "name": "hTemperature", + "type": "$s_temp_handle_t" }, { - "desc": "[in,out] Structure describing RAS properties", + "desc": "[in,out] Will contain the temperature sensor properties.", "name": "pProperties", - "type": "$s_ras_properties_t*" + "type": "$s_temp_properties_t*" } ], "returns": [ @@ -77910,7 +91848,7 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hRas`" + "`nullptr == hTemperature`" ] }, { @@ -77922,27 +91860,24 @@ "type": "function" }, { - "class": "$sRas", - "desc": "Get RAS error thresholds that control when RAS events are generated", + "class": "$sTemperature", + "desc": "Get temperature configuration for this sensor - which events are triggered and the trigger conditions", "details": [ - "The driver maintains counters for all RAS error sets and error categories. Events are generated when errors occur. The configuration enables setting thresholds to limit when events are sent.", - "When a particular RAS correctable error counter exceeds the configured threshold, the event $S_EVENT_TYPE_FLAG_RAS_CORRECTABLE_ERRORS will be triggered.", - "When a particular RAS uncorrectable error counter exceeds the configured threshold, the event $S_EVENT_TYPE_FLAG_RAS_UNCORRECTABLE_ERRORS will be triggered.", "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "0086e397045debf8637442b51b3f13dfbb950573bb08e0fc20ab2473e5470355", + "hash": "59b77f7353eacc0c25fea8df764d6ae44f6e0504dd349e8a92cb0db7c1003e9a", "name": "GetConfig", "params": [ { "desc": "[in] Handle for the component.", - "name": "hRas", - "type": "$s_ras_handle_t" + "name": "hTemperature", + "type": "$s_temp_handle_t" }, { - "desc": "[in,out] Will be populed with the current RAS configuration - thresholds used to trigger events", + "desc": "[in,out] Returns current configuration.", "name": "pConfig", - "type": "$s_ras_config_t*" + "type": "$s_temp_config_t*" } ], "returns": [ @@ -77963,40 +91898,50 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hRas`" + "`nullptr == hTemperature`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ "`nullptr == pConfig`" ] + }, + { + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "Temperature thresholds are not supported on this temperature sensor. Generally this is only supported for temperature sensor $S_TEMP_SENSORS_GLOBAL.", + "One or both of the thresholds is not supported. Check the `isThreshold1Supported` and `isThreshold2Supported` members of $s_temp_properties_t." + ] + }, + { + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "User does not have permissions to request this feature." + ] } ], "type": "function" }, { - "class": "$sRas", - "desc": "Set RAS error thresholds that control when RAS events are generated", + "class": "$sTemperature", + "desc": "Set temperature configuration for this sensor - indicates which events are triggered and the trigger conditions", "details": [ - "The driver maintains counters for all RAS error sets and error categories. Events are generated when errors occur. The configuration enables setting thresholds to limit when events are sent.", - "When a particular RAS correctable error counter exceeds the specified threshold, the event $S_EVENT_TYPE_FLAG_RAS_CORRECTABLE_ERRORS will be generated.", - "When a particular RAS uncorrectable error counter exceeds the specified threshold, the event $S_EVENT_TYPE_FLAG_RAS_UNCORRECTABLE_ERRORS will be generated.", - "Call $sRasGetState() and set the clear flag to true to restart event generation once counters have exceeded thresholds.", + "Events $S_EVENT_TYPE_FLAG_TEMP_CRITICAL will be triggered when temperature reaches the critical range. Use the function $sDeviceEventRegister() to start receiving this event.", + "Events $S_EVENT_TYPE_FLAG_TEMP_THRESHOLD1 and $S_EVENT_TYPE_FLAG_TEMP_THRESHOLD2 will be generated when temperature cross the thresholds set using this function. Use the function $sDeviceEventRegister() to start receiving these events.", + "Only one running process can set the temperature configuration at a time. If another process attempts to change the configuration, the error $X_RESULT_ERROR_NOT_AVAILABLE will be returned. The function $sTemperatureGetConfig() will return the process ID currently controlling these settings.", "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "8d4a05aa119e4379d2b65308164870f616a1286d64c8a8e02580aa2ac4d673b5", + "hash": "e7c1c15a3b996c73398851cf8822ce99c876e9b834540276ccf63243785b7e69", "name": "SetConfig", "params": [ { "desc": "[in] Handle for the component.", - "name": "hRas", - "type": "$s_ras_handle_t" + "name": "hTemperature", + "type": "$s_temp_handle_t" }, { - "desc": "[in] Change the RAS configuration - thresholds used to trigger events", + "desc": "[in] New configuration.", "name": "pConfig", - "type": "const $s_ras_config_t*" + "type": "const $s_temp_config_t*" } ], "returns": [ @@ -78017,7 +91962,7 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hRas`" + "`nullptr == hTemperature`" ] }, { @@ -78025,45 +91970,50 @@ "`nullptr == pConfig`" ] }, + { + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ + "Temperature thresholds are not supported on this temperature sensor. Generally they are only supported for temperature sensor $S_TEMP_SENSORS_GLOBAL.", + "Enabling the critical temperature event is not supported. Check the `isCriticalTempSupported` member of $s_temp_properties_t.", + "One or both of the thresholds is not supported. Check the `isThreshold1Supported` and `isThreshold2Supported` members of $s_temp_properties_t." + ] + }, + { + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "User does not have permissions to request this feature." + ] + }, { "$X_RESULT_ERROR_NOT_AVAILABLE": [ "Another running process is controlling these settings." ] }, { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "Don't have permissions to set thresholds." + "$X_RESULT_ERROR_INVALID_ARGUMENT": [ + "One or both the thresholds is above TjMax (see $sFrequencyOcGetTjMax()). Temperature thresholds must be below this value." ] } ], "type": "function" }, { - "class": "$sRas", - "desc": "Get the current value of RAS error counters for a particular error set", + "class": "$sTemperature", + "desc": "Get the temperature from a specified sensor", "details": [ - "Clearing errors will affect other threads/applications - the counter values will start from zero.", - "Clearing errors requires write permissions.", "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "99b4653180947ca4b2026e02bea89ec5916e928aae1c6b20016a07c3657bc134", + "hash": "6e03eadebfa90ec535691d9f5ee770f0838a4014177254ed824c0f9878e0c4d7", "name": "GetState", "params": [ { "desc": "[in] Handle for the component.", - "name": "hRas", - "type": "$s_ras_handle_t" - }, - { - "desc": "[in] Set to 1 to clear the counters of this type", - "name": "clear", - "type": "$x_bool_t" + "name": "hTemperature", + "type": "$s_temp_handle_t" }, { - "desc": "[in,out] Breakdown of where errors have occurred", - "name": "pState", - "type": "$s_ras_state_t*" + "desc": "[in,out] Will contain the temperature read from the specified sensor in degrees Celsius.", + "name": "pTemperature", + "type": "double*" } ], "returns": [ @@ -78084,30 +92034,25 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hRas`" + "`nullptr == hTemperature`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pState`" - ] - }, - { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "Don't have permissions to clear error counters." + "`nullptr == pTemperature`" ] } ], "type": "function" }, { - "desc": "C++ wrapper for a Sysman device RAS error set", + "desc": "C++ wrapper for a Sysman device temperature sensor", "members": [ { "desc": "[in] handle of Sysman object", "init": "nullptr", "name": "handle", - "type": "$s_ras_handle_t" + "type": "$s_temp_handle_t" }, { "desc": "[in] pointer to owner object", @@ -78115,7 +92060,7 @@ "type": "$sDevice*" } ], - "name": "$sRas", + "name": "$sTemperature", "owner": "$sDevice", "type": "class" } @@ -78123,126 +92068,118 @@ }, { "header": { - "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - Scheduler management", - "ordinal": 1000, - "type": "header" + "desc": "Intel $OneApi Level-Zero Sysman Extension APIs for Power Limits", + "ordinal": 1400, + "type": "header", + "version": "1.4" }, - "name": "scheduler", + "name": "powerLimits", "objects": [ { - "class": "$sDevice", - "desc": "Scheduler mode", + "desc": "Power Limits Extension Name", + "name": "$S_POWER_LIMITS_EXT_NAME", + "type": "macro", + "value": "\"$XS_extension_power_limits\"", + "version": "1.4" + }, + { + "desc": "Power Limits Extension Version(s)", "etors": [ { - "desc": "Multiple applications or contexts are submitting work to the hardware. When higher priority work arrives, the scheduler attempts to pause the current executing work within some timeout interval, then submits the other work.", - "name": "$S_SCHED_MODE_TIMEOUT", - "value": "0" - }, - { - "desc": "The scheduler attempts to fairly timeslice hardware execution time between multiple contexts submitting work to the hardware concurrently.", - "name": "$S_SCHED_MODE_TIMESLICE", - "value": "1" - }, - { - "desc": "Any application or context can run indefinitely on the hardware without being preempted or terminated. All pending work for other contexts must wait until the running context completes with no further submitted work.", - "name": "$S_SCHED_MODE_EXCLUSIVE", - "value": "2" + "desc": "version 1.0", + "name": "$S_POWER_LIMITS_EXT_VERSION_1_0", + "value": "$X_MAKE_VERSION( 1, 0 )" }, { - "desc": "This is a special mode that must ben enabled when debugging an application that uses this device e.g. using the Level0 Debug API. It has the effect of disabling any timeouts on workload execution time and will change workload scheduling to ensure debug accuracy.", - "name": "$S_SCHED_MODE_COMPUTE_UNIT_DEBUG", - "value": "3" + "desc": "latest known version", + "name": "$S_POWER_LIMITS_EXT_VERSION_CURRENT", + "value": "$X_MAKE_VERSION( 1, 0 )" } ], - "name": "$s_sched_mode_t", - "type": "enum" + "name": "$s_power_limits_ext_version_t", + "type": "enum", + "version": "1.4" }, { - "base": "$s_base_properties_t", - "class": "$sScheduler", - "desc": "Properties related to scheduler component", + "base": "$s_base_desc_t", + "class": "$sPower", + "desc": "Device power/current limit descriptor.", "members": [ { "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_SCHED_PROPERTIES", + "init": "$S_STRUCTURE_TYPE_POWER_LIMIT_EXT_DESC", "name": "stype", "type": "$s_structure_type_t" }, { - "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", "init": "nullptr", "name": "pNext", - "type": "void*" + "type": "const void*" }, { - "desc": "[out] True if this resource is located on a sub-device; false means that the resource is on the device of the calling Sysman handle", - "name": "onSubdevice", - "type": "$x_bool_t" + "desc": "[in,out] duration type over which the power draw is measured, i.e. sustained, burst, peak, or critical.", + "name": "level", + "type": "$s_power_level_t" }, { - "desc": "[out] If onSubdevice is true, this gives the ID of the sub-device", - "name": "subdeviceId", - "type": "uint32_t" + "desc": "[out] source of power used by the system, i.e. AC or DC.", + "name": "source", + "type": "$s_power_source_t" }, { - "desc": "[out] Software can change the scheduler component configuration assuming the user has permissions.", - "name": "canControl", - "type": "$x_bool_t" + "desc": "[out] unit used for specifying limit, i.e. current units (milliamps) or power units (milliwatts).", + "name": "limitUnit", + "type": "$s_limit_unit_t" }, { - "desc": "[out] Bitfield of accelerator engine types that are managed by this scheduler component. Note that there can be more than one scheduler component for the same type of accelerator engine.", - "name": "engines", - "type": "$s_engine_type_flags_t" + "desc": "[out] indicates if the power limit state (enabled/ignored) can be set (false) or is locked (true).", + "name": "enabledStateLocked", + "type": "ze_bool_t" }, { - "desc": "[out] Bitfield of scheduler modes that can be configured for this scheduler component (bitfield of 1<<$s_sched_mode_t).", - "name": "supportedModes", - "type": "uint32_t" - } - ], - "name": "$s_sched_properties_t", - "type": "struct" - }, - { - "desc": "Disable forward progress guard timeout.", - "name": "$S_SCHED_WATCHDOG_DISABLE", - "type": "macro", - "value": "(~(0ULL))" - }, - { - "base": "$s_base_properties_t", - "class": "$sDevice", - "desc": "Configuration for timeout scheduler mode ($S_SCHED_MODE_TIMEOUT)", - "members": [ + "desc": "[in,out] indicates if the limit is enabled (true) or ignored (false). If enabledStateIsLocked is True, this value is ignored.", + "name": "enabled", + "type": "ze_bool_t" + }, { - "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_SCHED_TIMEOUT_PROPERTIES", - "name": "stype", - "type": "$s_structure_type_t" + "desc": "[out] indicates if the interval can be modified (false) or is fixed (true).", + "name": "intervalValueLocked", + "type": "ze_bool_t" }, { - "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "void*" + "desc": "[in,out] power averaging window in milliseconds. If intervalValueLocked is true, this value is ignored.", + "name": "interval", + "type": "int32_t" }, { - "desc": "[in,out] The maximum time in microseconds that the scheduler will wait for a batch of work submitted to a hardware engine to complete or to be preempted so as to run another context.\nIf this time is exceeded, the hardware engine is reset and the context terminated.\nIf set to $S_SCHED_WATCHDOG_DISABLE, a running workload can run as long as it wants without being terminated, but preemption attempts to run other contexts are permitted but not enforced.\n", - "name": "watchdogTimeout", - "type": "uint64_t" + "desc": "[out] indicates if the limit can be set (false) or if the limit is fixed (true).", + "name": "limitValueLocked", + "type": "ze_bool_t" + }, + { + "desc": "[in,out] limit value. If limitValueLocked is true, this value is ignored. The value should be provided in the unit specified by limitUnit.", + "name": "limit", + "type": "int32_t" } ], - "name": "$s_sched_timeout_properties_t", - "type": "struct" + "name": "$s_power_limit_ext_desc_t", + "type": "struct", + "version": "1.4" }, { "base": "$s_base_properties_t", - "class": "$sDevice", - "desc": "Configuration for timeslice scheduler mode ($S_SCHED_MODE_TIMESLICE)", + "class": "$sPower", + "desc": "Extension properties related to device power settings", + "details": [ + "This structure may be returned from $sPowerGetProperties via the `pNext` member of $s_power_properties_t.", + "This structure may also be returned from $sPowerGetProperties via the `pNext` member of $s_power_ext_properties_t", + "Used for determining the power domain level, i.e. card-level v/s package-level v/s stack-level & the factory default power limits." + ], "members": [ { "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_SCHED_TIMESLICE_PROPERTIES", + "init": "$S_STRUCTURE_TYPE_POWER_EXT_PROPERTIES", "name": "stype", "type": "$s_structure_type_t" }, @@ -78253,45 +92190,45 @@ "type": "void*" }, { - "desc": "[in,out] The average interval in microseconds that a submission for a context will run on a hardware engine before being preempted out to run a pending submission for another context.", - "name": "interval", - "type": "uint64_t" + "desc": "[out] domain that the power limit belongs to.", + "name": "domain", + "type": "$s_power_domain_t" }, { - "desc": "[in,out] The maximum time in microseconds that the scheduler will wait to preempt a workload running on an engine before deciding to reset the hardware engine and terminating the associated context.", - "name": "yieldTimeout", - "type": "uint64_t" + "desc": "[out] the factory default limit of the part.", + "name": "defaultLimit", + "type": "$s_power_limit_ext_desc_t*" } ], - "name": "$s_sched_timeslice_properties_t", - "type": "struct" + "name": "$s_power_ext_properties_t", + "type": "struct", + "version": "1.4" }, { - "class": "$sDevice", - "desc": "Returns handles to scheduler components.", + "class": "$sPower", + "desc": "Get power limits", "details": [ - "Each scheduler component manages the distribution of work across one or more accelerator engines.", - "If an application wishes to change the scheduler behavior for all accelerator engines of a specific type (e.g. compute), it should select all the handles where the `engines` member $s_sched_properties_t contains that type.", "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The implementation of this function should be lock-free.", + "This function returns all the power limits associated with the supplied power domain." ], - "hash": "fd37b138e4d455f525f8b29c80b71137e78d52c62615dfa008db1a0cc7b7d716", - "name": "EnumSchedulers", + "hash": "68f318093a420db4811cba53835f34da4a4fa9ffb3b98d7793765842d0424b8c", + "name": "GetLimitsExt", "params": [ { - "desc": "[in] Sysman handle of the device.", - "name": "hDevice", - "type": "$s_device_handle_t" + "desc": "[in] Power domain handle instance.", + "name": "hPower", + "type": "$s_pwr_handle_t" }, { - "desc": "[in,out] pointer to the number of components of this type.\nif count is zero, then the driver shall update the value with the total number of components of this type that are available.\nif count is greater than the number of components of this type that are available, then the driver shall update the value with the correct number of components.\n", + "desc": "[in,out] Pointer to the number of power limit descriptors. If count is zero, then the driver shall update the value with the total number of components of this type that are available. If count is greater than the number of components of this type that are available, then the driver shall update the value with the correct number of components.", "name": "pCount", "type": "uint32_t*" }, { - "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", - "name": "phScheduler", - "type": "$s_sched_handle_t*" + "desc": "[in,out][optional][range(0, *pCount)] Array of query results for power limit descriptors. If count is less than the number of components of this type that are available, then the driver shall only retrieve that number of components.", + "name": "pSustained", + "type": "$s_power_limit_ext_desc_t*" } ], "returns": [ @@ -78312,7 +92249,7 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDevice`" + "`nullptr == hPower`" ] }, { @@ -78324,24 +92261,33 @@ "type": "function" }, { - "class": "$sScheduler", - "desc": "Get properties related to a scheduler component", + "class": "$sPower", + "desc": "Set power limits", "details": [ + "The application can only modify unlocked members of the limit descriptors returned by $sPowerGetLimitsExt.", + "Not all the limits returned by $sPowerGetLimitsExt need to be supplied to this function.", + "Limits do not have to be supplied in the same order as returned by $sPowerGetLimitsExt.", + "The same limit can be supplied multiple times. Limits are applied in the order in which they are supplied.", "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "65a7c80ec9d728805fb964d7fd96801b62d577461484aa2498ed29bc45b71364", - "name": "GetProperties", + "hash": "c3fd274f580f2e3476b92eaf271f4bb46b76ab91842dd1c8af90981870e5098c", + "name": "SetLimitsExt", "params": [ { "desc": "[in] Handle for the component.", - "name": "hScheduler", - "type": "$s_sched_handle_t" + "name": "hPower", + "type": "$s_pwr_handle_t" }, { - "desc": "[in,out] Structure that will contain property data.", - "name": "pProperties", - "type": "$s_sched_properties_t*" + "desc": "[in] Pointer to the number of power limit descriptors.", + "name": "pCount", + "type": "uint32_t*" + }, + { + "desc": "[in][optional][range(0, *pCount)] Array of power limit descriptors.", + "name": "pSustained", + "type": "$s_power_limit_ext_desc_t*" } ], "returns": [ @@ -78362,217 +92308,118 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hScheduler`" + "`nullptr == hPower`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pProperties`" - ] - } - ], - "type": "function" - }, - { - "class": "$sScheduler", - "desc": "Get current scheduling mode in effect on a scheduler component.", - "details": [ - "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." - ], - "hash": "ff8efe1877bfdddb8ab4c8a3c626ef2f4e6dfca3e49a05ff48fe2c08dc0aa05b", - "name": "GetCurrentMode", - "params": [ - { - "desc": "[in] Sysman handle for the component.", - "name": "hScheduler", - "type": "$s_sched_handle_t" - }, - { - "desc": "[in,out] Will contain the current scheduler mode.", - "name": "pMode", - "type": "$s_sched_mode_t*" - } - ], - "returns": [ - { - "$X_RESULT_SUCCESS": [] - }, - { - "$X_RESULT_ERROR_UNINITIALIZED": [] - }, - { - "$X_RESULT_ERROR_DEVICE_LOST": [] - }, - { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] - }, - { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] - }, - { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hScheduler`" + "`nullptr == pCount`" ] }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pMode`" + "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ + "User does not have permissions to make these modifications." ] }, { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "This scheduler component does not support scheduler modes." + "$X_RESULT_ERROR_NOT_AVAILABLE": [ + "The device is in use, meaning that the GPU is under Over clocking, applying power limits under overclocking is not supported." ] } ], "type": "function" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Sysman Extension APIs for Engine Activity", + "ordinal": 1700, + "type": "header", + "version": "1.7" + }, + "name": "engineActivity", + "objects": [ + { + "desc": "Engine Activity Extension Name", + "name": "$S_ENGINE_ACTIVITY_EXT_NAME", + "type": "macro", + "value": "\"$XS_extension_engine_activity\"", + "version": "1.7" }, { - "class": "$sScheduler", - "desc": "Get scheduler config for mode $S_SCHED_MODE_TIMEOUT", - "details": [ - "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." - ], - "hash": "15bf9620651387ae69552ff0dfacf3fd96d7cd553599e0f549414c62aa97938f", - "name": "GetTimeoutModeProperties", - "params": [ - { - "desc": "[in] Sysman handle for the component.", - "name": "hScheduler", - "type": "$s_sched_handle_t" - }, - { - "desc": "[in] If TRUE, the driver will return the system default properties for this mode, otherwise it will return the current properties.", - "name": "getDefaults", - "type": "$x_bool_t" - }, - { - "desc": "[in,out] Will contain the current parameters for this mode.", - "name": "pConfig", - "type": "$s_sched_timeout_properties_t*" - } - ], - "returns": [ - { - "$X_RESULT_SUCCESS": [] - }, - { - "$X_RESULT_ERROR_UNINITIALIZED": [] - }, - { - "$X_RESULT_ERROR_DEVICE_LOST": [] - }, - { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] - }, - { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] - }, - { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hScheduler`" - ] - }, + "desc": "Engine Activity Extension Version(s)", + "etors": [ { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pConfig`" - ] + "desc": "version 1.0", + "name": "$S_ENGINE_ACTIVITY_EXT_VERSION_1_0", + "value": "$X_MAKE_VERSION( 1, 0 )" }, { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "This scheduler component does not support scheduler modes." - ] + "desc": "latest known version", + "name": "$S_ENGINE_ACTIVITY_EXT_VERSION_CURRENT", + "value": "$X_MAKE_VERSION( 1, 0 )" } ], - "type": "function" + "name": "$s_engine_activity_ext_version_t", + "type": "enum", + "version": "1.7" }, { - "class": "$sScheduler", - "desc": "Get scheduler config for mode $S_SCHED_MODE_TIMESLICE", + "base": "$s_base_properties_t", + "class": "$sEngine", + "desc": "Extension properties related to Engine Groups", "details": [ - "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." - ], - "hash": "4cdaf9f11a323f15db5d9dfa4e9cc43cfc054832618dd32e37ca908c5ea1e348", - "name": "GetTimesliceModeProperties", - "params": [ - { - "desc": "[in] Sysman handle for the component.", - "name": "hScheduler", - "type": "$s_sched_handle_t" - }, - { - "desc": "[in] If TRUE, the driver will return the system default properties for this mode, otherwise it will return the current properties.", - "name": "getDefaults", - "type": "$x_bool_t" - }, - { - "desc": "[in,out] Will contain the current parameters for this mode.", - "name": "pConfig", - "type": "$s_sched_timeslice_properties_t*" - } + "This structure may be passed to $sEngineGetProperties by having the pNext member of $s_engine_properties_t point at this struct.", + "Used for SRIOV per Virtual Function device utilization by $s_engine_group_t" ], - "returns": [ - { - "$X_RESULT_SUCCESS": [] - }, - { - "$X_RESULT_ERROR_UNINITIALIZED": [] - }, - { - "$X_RESULT_ERROR_DEVICE_LOST": [] - }, - { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] - }, - { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] - }, + "members": [ { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hScheduler`" - ] + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_ENGINE_EXT_PROPERTIES", + "name": "stype", + "type": "$s_structure_type_t" }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pConfig`" - ] + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" }, { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "This scheduler component does not support scheduler modes." - ] + "desc": "[out] Number of Virtual Function(VF) instances associated with engine to monitor the utilization of hardware across all Virtual Function from a Physical Function (PF) instance.\nThese VF-by-VF views should provide engine group and individual engine level granularity.\nThis count represents the number of VF instances that are actively using the resource represented by the engine handle.\n", + "name": "countOfVirtualFunctionInstance", + "type": "uint32_t" } ], - "type": "function" + "name": "$s_engine_ext_properties_t", + "type": "struct", + "version": "1.7" }, { - "class": "$sScheduler", - "desc": "Change scheduler mode to $S_SCHED_MODE_TIMEOUT or update scheduler mode parameters if already running in this mode.", + "class": "$sEngine", + "desc": "Get activity stats for Physical Function (PF) and each Virtual Function (VF) associated with engine group.", "details": [ - "This mode is optimized for multiple applications or contexts submitting work to the hardware. When higher priority work arrives, the scheduler attempts to pause the current executing work within some timeout interval, then submits the other work.", "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "3f9453cd11aa3272d37a2631c25d45a0f71a9ae27f29994148f76170753de50c", - "name": "SetTimeoutMode", + "hash": "7c7eb1843ce9221ba257b856861d9929463cc144d7c4bbad5350c04491413ccd", + "name": "GetActivityExt", "params": [ { - "desc": "[in] Sysman handle for the component.", - "name": "hScheduler", - "type": "$s_sched_handle_t" + "desc": "[in] Handle for the component.", + "name": "hEngine", + "type": "$s_engine_handle_t" }, { - "desc": "[in] The properties to use when configurating this mode.", - "name": "pProperties", - "type": "$s_sched_timeout_properties_t*" + "desc": "[in,out] Pointer to the number of VF engine stats descriptors.\n - if count is zero, the driver shall update the value with the total number of engine stats available.\n - if count is greater than the total number of engine stats available, the driver shall update the value with the correct number of engine stats available.\n - The count returned is the sum of number of VF instances currently available and the PF instance.\n", + "name": "pCount", + "type": "uint32_t*" }, { - "desc": "[in,out] Will be set to TRUE if a device driver reload is needed to apply the new scheduler mode.", - "name": "pNeedReload", - "type": "$x_bool_t*" + "desc": "[in,out][optional][range(0, *pCount)] array of engine group activity counters.\n - if count is less than the total number of engine stats available, then driver shall only retrieve that number of stats.\n - the implementation shall populate the vector with engine stat for PF at index 0 of the vector followed by user provided pCount-1 number of VF engine stats.\n", + "name": "pStats", + "type": "$s_engine_stats_t*" } ], "returns": [ @@ -78593,115 +92440,170 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hScheduler`" + "`nullptr == hEngine`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pProperties`", - "`nullptr == pNeedReload`" + "`nullptr == pCount`" ] }, { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "This scheduler component does not support scheduler modes." - ] + "$X_RESULT_ERROR_UNSUPPORTED_FEATURE - \"Engine activity extension is not supported in the environment.\"": [] + } + ], + "type": "function", + "version": "1.7" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Sysman Extension APIs for RAS Get State and Clear State", + "ordinal": 1700, + "type": "header", + "version": "1.7" + }, + "name": "rasState", + "objects": [ + { + "desc": "RAS Get State Extension Name", + "name": "$S_RAS_GET_STATE_EXP_NAME", + "type": "macro", + "value": "\"$XS_extension_ras_state\"", + "version": "1.7" + }, + { + "desc": "RAS Get State Extension Version(s)", + "etors": [ + { + "desc": "version 1.0", + "name": "$S_RAS_STATE_EXP_VERSION_1_0", + "value": "$X_MAKE_VERSION( 1, 0 )" }, { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to make this modification." - ] + "desc": "latest known version", + "name": "$S_RAS_STATE_EXP_VERSION_CURRENT", + "value": "$X_MAKE_VERSION( 1, 0 )" } ], - "type": "function" + "name": "$s_ras_state_exp_version_t", + "type": "enum", + "version": "1.7" }, { - "class": "$sScheduler", - "desc": "Change scheduler mode to $S_SCHED_MODE_TIMESLICE or update scheduler mode parameters if already running in this mode.", - "details": [ - "This mode is optimized to provide fair sharing of hardware execution time between multiple contexts submitting work to the hardware concurrently.", - "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." - ], - "hash": "11dedcf5e86b6e8f766178a724293a56c52026ebe98f4de0a7501aaf3d6246c0", - "name": "SetTimesliceMode", - "params": [ + "class": "$sRas", + "desc": "RAS error categories", + "etors": [ { - "desc": "[in] Sysman handle for the component.", - "name": "hScheduler", - "type": "$s_sched_handle_t" + "desc": "The number of accelerator engine resets attempted by the driver", + "name": "$S_RAS_ERROR_CATEGORY_EXP_RESET", + "value": "0", + "version": "1.7" }, { - "desc": "[in] The properties to use when configurating this mode.", - "name": "pProperties", - "type": "$s_sched_timeslice_properties_t*" + "desc": "The number of hardware exceptions generated by the way workloads have programmed the hardware", + "name": "$S_RAS_ERROR_CATEGORY_EXP_PROGRAMMING_ERRORS", + "value": "1", + "version": "1.7" }, { - "desc": "[in,out] Will be set to TRUE if a device driver reload is needed to apply the new scheduler mode.", - "name": "pNeedReload", - "type": "$x_bool_t*" - } - ], - "returns": [ - { - "$X_RESULT_SUCCESS": [] + "desc": "The number of low level driver communication errors have occurred", + "name": "$S_RAS_ERROR_CATEGORY_EXP_DRIVER_ERRORS", + "value": "2", + "version": "1.7" }, { - "$X_RESULT_ERROR_UNINITIALIZED": [] + "desc": "The number of errors that have occurred in the compute accelerator hardware", + "name": "$S_RAS_ERROR_CATEGORY_EXP_COMPUTE_ERRORS", + "value": "3", + "version": "1.7" }, { - "$X_RESULT_ERROR_DEVICE_LOST": [] + "desc": "The number of errors that have occurred in the fixed-function accelerator hardware", + "name": "$S_RAS_ERROR_CATEGORY_EXP_NON_COMPUTE_ERRORS", + "value": "4", + "version": "1.7" }, { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "desc": "The number of errors that have occurred in caches (L1/L3/register file/shared local memory/sampler)", + "name": "$S_RAS_ERROR_CATEGORY_EXP_CACHE_ERRORS", + "value": "5", + "version": "1.7" }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + "desc": "The number of errors that have occurred in the display", + "name": "$S_RAS_ERROR_CATEGORY_EXP_DISPLAY_ERRORS", + "value": "6", + "version": "1.7" }, { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hScheduler`" - ] + "desc": "The number of errors that have occurred in Memory", + "name": "$S_RAS_ERROR_CATEGORY_EXP_MEMORY_ERRORS", + "value": "7", + "version": "1.7" }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pProperties`", - "`nullptr == pNeedReload`" - ] + "desc": "The number of errors that have occurred in Scale Fabric", + "name": "$S_RAS_ERROR_CATEGORY_EXP_SCALE_ERRORS", + "value": "8", + "version": "1.7" }, { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "This scheduler component does not support scheduler modes." - ] + "desc": "The number of errors that have occurred in L3 Fabric", + "name": "$S_RAS_ERROR_CATEGORY_EXP_L3FABRIC_ERRORS", + "value": "9", + "version": "1.7" + } + ], + "name": "$s_ras_error_category_exp_t", + "type": "enum", + "version": "1.7" + }, + { + "class": "$sRas", + "desc": "Extension structure for providing RAS error counters for different error sets", + "members": [ + { + "desc": "[out] category for which error counter is provided.", + "name": "category", + "type": "$s_ras_error_category_exp_t" }, { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to make this modification." - ] + "desc": "[out] Current value of RAS counter for specific error category.", + "name": "errorCounter", + "type": "uint64_t" } ], - "type": "function" + "name": "$s_ras_state_exp_t", + "type": "struct", + "version": "1.7" }, { - "class": "$sScheduler", - "desc": "Change scheduler mode to $S_SCHED_MODE_EXCLUSIVE", + "class": "$sRas", + "desc": "Ras Get State", "details": [ - "This mode is optimized for single application/context use-cases. It permits a context to run indefinitely on the hardware without being preempted or terminated. All pending work for other contexts must wait until the running context completes with no further submitted work.", + "This function retrieves error counters for different RAS error categories.", "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "b3ddcb66d6d358c372478f16c47c422e9b18e2acbd01923f385fd58f394c8a76", - "name": "SetExclusiveMode", + "hash": "9e9e646c541c50da30308738da88832993b6df10556583499dff169f46e4b908", + "name": "GetStateExp", "params": [ { - "desc": "[in] Sysman handle for the component.", - "name": "hScheduler", - "type": "$s_sched_handle_t" + "desc": "[in] Handle for the component.", + "name": "hRas", + "type": "$s_ras_handle_t" }, { - "desc": "[in,out] Will be set to TRUE if a device driver reload is needed to apply the new scheduler mode.", - "name": "pNeedReload", - "type": "$x_bool_t*" + "desc": "[in,out] pointer to the number of RAS state structures that can be retrieved.\nif count is zero, then the driver shall update the value with the total number of error categories for which state can be retrieved.\nif count is greater than the number of RAS states available, then the driver shall update the value with the correct number of RAS states available.\n", + "name": "pCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pCount)] array of query results for RAS error states for different categories.\nif count is less than the number of RAS states available, then driver shall only retrieve that number of RAS states.\n", + "name": "pState", + "type": "$s_ras_state_exp_t*" } ], "returns": [ @@ -78722,48 +92624,39 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hScheduler`" + "`nullptr == hRas`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pNeedReload`" - ] - }, - { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "This scheduler component does not support scheduler modes." - ] - }, - { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to make this modification." + "`nullptr == pCount`" ] } ], "type": "function" }, { - "class": "$sScheduler", - "desc": "Change scheduler mode to $S_SCHED_MODE_COMPUTE_UNIT_DEBUG", + "class": "$sRas", + "desc": "Ras Clear State", "details": [ - "This is a special mode that must ben enabled when debugging an application that uses this device e.g. using the Level0 Debug API.", - "It ensures that only one command queue can execute work on the hardware at a given time. Work is permitted to run as long as needed without enforcing any scheduler fairness policies.", - "The application may call this function from simultaneous threads.", + "This function clears error counters for a RAS error category.", + "Clearing errors will affect other threads/applications - the counter values will start from zero.", + "Clearing errors requires write permissions.", + "The application should not call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "20f2f46d786180d013bcdd048e18fa11689f100439628591f3d4d26a33d3d071", - "name": "SetComputeUnitDebugMode", + "hash": "94c31ad19460e9ec5a14b5d704aa570c4b03bf09d0a0c48838190b0a3e50f362", + "name": "ClearStateExp", "params": [ { - "desc": "[in] Sysman handle for the component.", - "name": "hScheduler", - "type": "$s_sched_handle_t" + "desc": "[in] Handle for the component.", + "name": "hRas", + "type": "$s_ras_handle_t" }, { - "desc": "[in,out] Will be set to TRUE if a device driver reload is needed to apply the new scheduler mode.", - "name": "pNeedReload", - "type": "$x_bool_t*" + "desc": "[in] category for which error counter is to be cleared.", + "name": "category", + "type": "$s_ras_error_category_exp_t" } ], "returns": [ @@ -78784,247 +92677,285 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hScheduler`" - ] - }, - { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pNeedReload`" + "`nullptr == hRas`" ] }, { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "This scheduler component does not support scheduler modes." + "$X_RESULT_ERROR_INVALID_ENUMERATION": [ + "`$S_RAS_ERROR_CATEGORY_EXP_L3FABRIC_ERRORS < category`" ] }, { "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to make this modification." + "Don't have permissions to clear error counters." ] } ], "type": "function" - }, - { - "desc": "C++ wrapper for a Sysman device scheduler queue", - "members": [ - { - "desc": "[in] handle of Sysman object", - "init": "nullptr", - "name": "handle", - "type": "$s_sched_handle_t" - }, - { - "desc": "[in] pointer to owner object", - "name": "pDevice", - "type": "$sDevice*" - } - ], - "name": "$sScheduler", - "owner": "$sDevice", - "type": "class" } ] }, { "header": { - "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - Standby domains", - "ordinal": 1000, - "type": "header" + "desc": "Intel $OneApi Level-Zero Sysman Extension APIs for Memory State", + "ordinal": 1800, + "type": "header", + "version": "1.8" }, - "name": "standby", + "name": "memPageOfflineState", "objects": [ { - "class": "$sStandby", - "desc": "Standby hardware components", + "desc": "Memory State Extension Name", + "name": "$S_MEM_PAGE_OFFLINE_STATE_EXP_NAME", + "type": "macro", + "value": "\"$XS_extension_mem_state\"", + "version": "1.8" + }, + { + "desc": "Memory State Extension Version(s)", "etors": [ { - "desc": "Control the overall standby policy of the device/sub-device", - "name": "$S_STANDBY_TYPE_GLOBAL", - "value": "0" + "desc": "version 1.0", + "name": "$S_MEM_PAGE_OFFLINE_STATE_EXP_VERSION_1_0", + "value": "$X_MAKE_VERSION( 1, 0 )" + }, + { + "desc": "latest known version", + "name": "$S_MEM_PAGE_OFFLINE_STATE_EXP_VERSION_CURRENT", + "value": "$X_MAKE_VERSION( 1, 0 )" } ], - "name": "$s_standby_type_t", - "type": "enum" + "name": "$s_mem_page_offline_state_exp_version_t", + "type": "enum", + "version": "1.8" }, { - "base": "$s_base_properties_t", - "class": "$sStandby", - "desc": "Standby hardware component properties", + "base": "$s_base_state_t", + "class": "$sMemory", + "desc": "Extension properties for Memory State", + "details": [ + "This structure may be returned from $sMemoryGetState via the `pNext` member of $s_mem_state_t", + "These additional parameters get Memory Page Offline Metrics" + ], "members": [ { "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_STANDBY_PROPERTIES", + "init": "$S_STRUCTURE_TYPE_MEM_PAGE_OFFLINE_STATE_EXP", "name": "stype", "type": "$s_structure_type_t" }, { - "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", "init": "nullptr", "name": "pNext", - "type": "void*" - }, - { - "desc": "[out] Which standby hardware component this controls", - "name": "type", - "type": "$s_standby_type_t" + "type": "const void*" }, { - "desc": "[out] True if the resource is located on a sub-device; false means that the resource is on the device of the calling Sysman handle", - "name": "onSubdevice", - "type": "$x_bool_t" + "desc": "[out] Returns the number of Memory Pages Offline", + "name": "memoryPageOffline", + "type": "uint32_t" }, { - "desc": "[out] If onSubdevice is true, this gives the ID of the sub-device", - "name": "subdeviceId", + "desc": "[out] Returns the Allowed Memory Pages Offline", + "name": "maxMemoryPageOffline", "type": "uint32_t" } ], - "name": "$s_standby_properties_t", - "type": "struct" + "name": "$s_mem_page_offline_state_exp_t", + "type": "struct", + "version": "1.8" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Sysman Extension APIs for Memory Bandwidth Counter Valid Bits", + "ordinal": 1800, + "type": "header", + "version": "1.8" + }, + "name": "memoryBwCounterValidBits", + "objects": [ + { + "desc": "Memory Bandwidth Counter Valid Bits Extension Name", + "name": "$S_MEMORY_BANDWIDTH_COUNTER_BITS_EXP_PROPERTIES_NAME", + "type": "macro", + "value": "\"$XS_extension_mem_bandwidth_counter_bits_properties\"", + "version": "1.8" }, { - "class": "$sStandby", - "desc": "Standby promotion modes", + "desc": "Memory Bandwidth Counter Valid Bits Extension Version(s)", "etors": [ { - "desc": "Best compromise between performance and energy savings.", - "name": "$S_STANDBY_PROMO_MODE_DEFAULT", - "value": "0" + "desc": "version 1.0", + "name": "$S_MEM_BANDWIDTH_COUNTER_BITS_EXP_VERSION_1_0", + "value": "$X_MAKE_VERSION( 1, 0 )" }, { - "desc": "The device/component will never shutdown. This can improve performance but uses more energy.", - "name": "$S_STANDBY_PROMO_MODE_NEVER", - "value": "1" + "desc": "latest known version", + "name": "$S_MEM_BANDWIDTH_COUNTER_BITS_EXP_VERSION_CURRENT", + "value": "$X_MAKE_VERSION( 1, 0 )" } ], - "name": "$s_standby_promo_mode_t", - "type": "enum" + "name": "$s_mem_bandwidth_counter_bits_exp_version_t", + "type": "enum", + "version": "1.8" }, { - "class": "$sDevice", - "desc": "Get handle of standby controls", + "base": "$s_base_properties_t", + "class": "$sMemory", + "desc": "Extension properties for reporting valid bit count for memory bandwidth counter value", "details": [ - "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "Number of valid read and write counter bits of memory bandwidth", + "This structure may be returned from $sMemoryGetProperties via the `pNext` member of $s_mem_properties_t.", + "Used for denoting number of valid bits in the counter value returned in $s_mem_bandwidth_t." ], - "hash": "1321756521f332777fba5d6fd3fda68a156551a5378e0256522397b248e220f0", - "name": "EnumStandbyDomains", - "params": [ + "members": [ { - "desc": "[in] Sysman handle of the device.", - "name": "hDevice", - "type": "$s_device_handle_t" + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_MEM_BANDWIDTH_COUNTER_BITS_EXP_PROPERTIES", + "name": "stype", + "type": "$s_structure_type_t" }, { - "desc": "[in,out] pointer to the number of components of this type.\nif count is zero, then the driver shall update the value with the total number of components of this type that are available.\nif count is greater than the number of components of this type that are available, then the driver shall update the value with the correct number of components.\n", - "name": "pCount", - "type": "uint32_t*" + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" }, { - "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", - "name": "phStandby", - "type": "$s_standby_handle_t*" + "desc": "[out] Returns the number of valid bits in the counter values", + "name": "validBitsCount", + "type": "uint32_t" } ], - "returns": [ - { - "$X_RESULT_SUCCESS": [] - }, - { - "$X_RESULT_ERROR_UNINITIALIZED": [] - }, - { - "$X_RESULT_ERROR_DEVICE_LOST": [] - }, - { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] - }, - { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] - }, + "name": "$s_mem_bandwidth_counter_bits_exp_properties_t", + "type": "struct", + "version": "1.8" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Sysman Extension APIs for Power Domain Properties", + "ordinal": 1800, + "type": "header", + "version": "1.8" + }, + "name": "powerDomainProperties", + "objects": [ + { + "desc": "Power Domain Properties Name", + "name": "$S_POWER_DOMAIN_PROPERTIES_EXP_NAME", + "type": "macro", + "value": "\"$XS_extension_power_domain_properties\"", + "version": "1.8" + }, + { + "desc": "Power Domain Properties Extension Version(s)", + "etors": [ { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hDevice`" - ] + "desc": "version 1.0", + "name": "$S_POWER_DOMAIN_PROPERTIES_EXP_VERSION_1_0", + "value": "$X_MAKE_VERSION( 1, 0 )" }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pCount`" - ] + "desc": "latest known version", + "name": "$S_POWER_DOMAIN_PROPERTIES_EXP_VERSION_CURRENT", + "value": "$X_MAKE_VERSION( 1, 0 )" } ], - "type": "function" + "name": "$s_power_domain_properties_exp_version_t", + "type": "enum", + "version": "1.8" }, { - "class": "$sStandby", - "desc": "Get standby hardware component properties", + "base": "$s_base_properties_t", + "class": "$sPower", + "desc": "Extension structure for providing power domain information associated with a power handle", "details": [ - "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." - ], - "hash": "8c2ca72b71cb172ab9cf558824d44c9c1d0057532e84bc8b6d2ce9e3eedc7c10", - "name": "GetProperties", - "params": [ - { - "desc": "[in] Handle for the component.", - "name": "hStandby", - "type": "$s_standby_handle_t" - }, - { - "desc": "[in,out] Will contain the standby hardware properties.", - "name": "pProperties", - "type": "$s_standby_properties_t*" - } + "This structure may be returned from $sPowerGetProperties via the `pNext` member of $s_power_properties_t.", + "Used for associating a power handle with a power domain." ], - "returns": [ - { - "$X_RESULT_SUCCESS": [] - }, - { - "$X_RESULT_ERROR_UNINITIALIZED": [] - }, + "members": [ { - "$X_RESULT_ERROR_DEVICE_LOST": [] + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_POWER_DOMAIN_EXP_PROPERTIES", + "name": "stype", + "type": "$s_structure_type_t" }, { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] - }, + "desc": "[out] Power domain associated with the power handle.", + "name": "powerDomain", + "type": "$s_power_domain_t" + } + ], + "name": "$s_power_domain_exp_properties_t", + "type": "struct", + "version": "1.8" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Sysman Extension APIs for firmware security version", + "ordinal": 1900, + "type": "header", + "version": "1.9" + }, + "name": "firmwareSecurityVersion", + "objects": [ + { + "desc": "Firmware security version", + "name": "$S_FIRMWARE_SECURITY_VERSION_EXP_NAME", + "type": "macro", + "value": "\"$XS_experimental_firmware_security_version\"", + "version": "1.9" + }, + { + "desc": "Firmware security version Extension Version(s)", + "etors": [ { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hStandby`" - ] + "desc": "version 1.0", + "name": "$S_FIRMWARE_SECURITY_EXP_VERSION_1_0", + "value": "$X_MAKE_VERSION( 1, 0 )" }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pProperties`" - ] + "desc": "latest known version", + "name": "$S_FIRMWARE_SECURITY_EXP_VERSION_CURRENT", + "value": "$X_MAKE_VERSION( 1, 0 )" } ], - "type": "function" + "name": "$s_firmware_security_exp_version_t", + "type": "enum", + "version": "1.9" }, { - "class": "$sStandby", - "desc": "Get the current standby promotion mode", + "class": "$sFirmware", + "desc": "Get the firmware security version number of the currently running firmware", "details": [ + "The application should create a character array of size $S_STRING_PROPERTY_SIZE and reference it for the `pVersion` parameter.", "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." - ], - "hash": "5b35e78c5cabe67779534fa696ed6b8e877734f8e052462b4e2f0f25c9625092", - "name": "GetMode", + ], + "hash": "8bfb2f51442d4d44ac783eca20b0571cf2ec53eae8d980c0d6563a27fceb3621", + "name": "GetSecurityVersionExp", "params": [ { "desc": "[in] Handle for the component.", - "name": "hStandby", - "type": "$s_standby_handle_t" + "name": "hFirmware", + "type": "$s_firmware_handle_t" }, { - "desc": "[in,out] Will contain the current standby mode.", - "name": "pMode", - "type": "$s_standby_promo_mode_t*" + "desc": "[in,out] NULL terminated string value. The string \"unknown\" will be returned if this property cannot be determined.", + "name": "pVersion", + "type": "char*" } ], "returns": [ @@ -79045,36 +92976,32 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hStandby`" + "`nullptr == hFirmware`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pMode`" + "`nullptr == pVersion`" ] } ], - "type": "function" + "type": "function", + "version": "1.9" }, { - "class": "$sStandby", - "desc": "Set standby promotion mode", + "class": "$sFirmware", + "desc": "Set the firmware security version number", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "c7ed048761bf7be69e42f0cd80d79177b513cc831bce3fbffb9774c9da950e43", - "name": "SetMode", + "hash": "a91c856e491e2efea9ee77674c05a32792102c8a9407553ac3fd45346e8de534", + "name": "SetSecurityVersionExp", "params": [ { "desc": "[in] Handle for the component.", - "name": "hStandby", - "type": "$s_standby_handle_t" - }, - { - "desc": "[in] New standby mode.", - "name": "mode", - "type": "$s_standby_promo_mode_t" + "name": "hFirmware", + "type": "$s_firmware_handle_t" } ], "returns": [ @@ -79095,97 +93022,57 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hStandby`" - ] - }, - { - "$X_RESULT_ERROR_INVALID_ENUMERATION": [ - "`$S_STANDBY_PROMO_MODE_NEVER < mode`" - ] - }, - { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to make these modifications." + "`nullptr == hFirmware`" ] } ], - "type": "function" - }, - { - "desc": "C++ wrapper for a Sysman standby control", - "members": [ - { - "desc": "[in] handle of Sysman object", - "init": "nullptr", - "name": "handle", - "type": "$s_standby_handle_t" - }, - { - "desc": "[in] pointer to owner object", - "name": "pDevice", - "type": "$sDevice*" - } - ], - "name": "$sStandby", - "owner": "$sDevice", - "type": "class" + "type": "function", + "version": "1.9" } ] }, { "header": { - "desc": "Intel $OneApi Level-Zero Tool APIs for System Resource Management (Sysman) - Firmware management", - "ordinal": 1000, - "type": "header" + "desc": "Intel $OneApi Level-Zero Sysman Extension APIs for Sysman Device Mapping", + "ordinal": 1900, + "type": "header", + "version": "1.9" }, - "name": "temperature", + "name": "sysmanDeviceMapping", "objects": [ { - "class": "$sTemperature", - "desc": "Temperature sensors", + "desc": "Sysman Device Mapping Extension Name", + "name": "$S_SYSMAN_DEVICE_MAPPING_EXP_NAME", + "type": "macro", + "value": "\"$XS_experimental_sysman_device_mapping\"", + "version": "1.9" + }, + { + "desc": "Sysman Device Mapping Extension Version(s)", "etors": [ { - "desc": "The maximum temperature across all device sensors", - "name": "$S_TEMP_SENSORS_GLOBAL", - "value": "0" - }, - { - "desc": "The maximum temperature across all sensors in the GPU", - "name": "$S_TEMP_SENSORS_GPU", - "value": "1" - }, - { - "desc": "The maximum temperature across all sensors in the local memory", - "name": "$S_TEMP_SENSORS_MEMORY", - "value": "2" - }, - { - "desc": "The minimum temperature across all device sensors", - "name": "$S_TEMP_SENSORS_GLOBAL_MIN", - "value": "3" - }, - { - "desc": "The minimum temperature across all sensors in the GPU", - "name": "$S_TEMP_SENSORS_GPU_MIN", - "value": "4" + "desc": "version 1.0", + "name": "$S_SYSMAN_DEVICE_MAPPING_EXP_VERSION_1_0", + "value": "$X_MAKE_VERSION( 1, 0 )" }, { - "desc": "The minimum temperature across all sensors in the local device memory", - "name": "$S_TEMP_SENSORS_MEMORY_MIN", - "value": "5" + "desc": "latest known version", + "name": "$S_SYSMAN_DEVICE_MAPPING_EXP_VERSION_CURRENT", + "value": "$X_MAKE_VERSION( 1, 0 )" } ], - "name": "$s_temp_sensors_t", - "type": "enum" + "name": "$s_sysman_device_mapping_exp_version_t", + "type": "enum", + "version": "1.9" }, { "base": "$s_base_properties_t", - "class": "$sTemperature", - "desc": "Temperature sensor properties", + "class": "$sDevice", + "desc": "Sub Device Properties", "members": [ { "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_TEMP_PROPERTIES", + "init": "$S_STRUCTURE_TYPE_SUBDEVICE_EXP_PROPERTIES", "name": "stype", "type": "$s_structure_type_t" }, @@ -79196,112 +93083,29 @@ "type": "void*" }, { - "desc": "[out] Which part of the device the temperature sensor measures", - "name": "type", - "type": "$s_temp_sensors_t" - }, - { - "desc": "[out] True if the resource is located on a sub-device; false means that the resource is on the device of the calling Sysman handle", - "name": "onSubdevice", - "type": "$x_bool_t" - }, - { - "desc": "[out] If onSubdevice is true, this gives the ID of the sub-device", + "desc": "[out] this gives the ID of the sub device", "name": "subdeviceId", "type": "uint32_t" }, { - "desc": "[out] Will contain the maximum temperature for the specific device in degrees Celsius.", - "name": "maxTemperature", - "type": "double" - }, - { - "desc": "[out] Indicates if the critical temperature event $S_EVENT_TYPE_FLAG_TEMP_CRITICAL is supported", - "name": "isCriticalTempSupported", - "type": "$x_bool_t" - }, - { - "desc": "[out] Indicates if the temperature threshold 1 event $S_EVENT_TYPE_FLAG_TEMP_THRESHOLD1 is supported", - "name": "isThreshold1Supported", - "type": "$x_bool_t" - }, - { - "desc": "[out] Indicates if the temperature threshold 2 event $S_EVENT_TYPE_FLAG_TEMP_THRESHOLD2 is supported", - "name": "isThreshold2Supported", - "type": "$x_bool_t" - } - ], - "name": "$s_temp_properties_t", - "type": "struct" - }, - { - "class": "$sTemperature", - "desc": "Temperature sensor threshold", - "members": [ - { - "desc": "[in,out] Trigger an event when the temperature crosses from below the threshold to above.", - "name": "enableLowToHigh", - "type": "$x_bool_t" - }, - { - "desc": "[in,out] Trigger an event when the temperature crosses from above the threshold to below.", - "name": "enableHighToLow", - "type": "$x_bool_t" - }, - { - "desc": "[in,out] The threshold in degrees Celsius.", - "name": "threshold", - "type": "double" - } - ], - "name": "$s_temp_threshold_t", - "type": "struct" - }, - { - "base": "$s_base_config_t", - "class": "$sTemperature", - "desc": "Temperature configuration - which events should be triggered and the trigger conditions.", - "members": [ - { - "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_TEMP_CONFIG", - "name": "stype", - "type": "$s_structure_type_t" - }, - { - "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "const void*" - }, - { - "desc": "[in,out] Indicates if event $S_EVENT_TYPE_FLAG_TEMP_CRITICAL should be triggered by the driver.", - "name": "enableCritical", - "type": "$x_bool_t" - }, - { - "desc": "[in,out] Configuration controlling if and when event $S_EVENT_TYPE_FLAG_TEMP_THRESHOLD1 should be triggered by the driver.", - "name": "threshold1", - "type": "$s_temp_threshold_t" - }, - { - "desc": "[in,out] Configuration controlling if and when event $S_EVENT_TYPE_FLAG_TEMP_THRESHOLD2 should be triggered by the driver.", - "name": "threshold2", - "type": "$s_temp_threshold_t" + "desc": "[out] universal unique identifier of the sub device.", + "name": "uuid", + "type": "$s_uuid_t" } ], - "name": "$s_temp_config_t", - "type": "struct" + "name": "$s_subdevice_exp_properties_t", + "type": "struct", + "version": "1.9" }, { "class": "$sDevice", - "desc": "Get handle of temperature sensors", + "desc": "Retrieves sub device properties for the given sysman device handle", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "75a0cd6be102dba55222d44af450b6940f4bb4a186a27bc64844a76cbdbc39c6", - "name": "EnumTemperatureSensors", + "hash": "b70947b84c614acc4479f10069c7ca7e74ecdaa8cd88f460dbaddc7a823ed5d8", + "name": "GetSubDevicePropertiesExp", "params": [ { "desc": "[in] Sysman handle of the device.", @@ -79309,14 +93113,14 @@ "type": "$s_device_handle_t" }, { - "desc": "[in,out] pointer to the number of components of this type.\nif count is zero, then the driver shall update the value with the total number of components of this type that are available.\nif count is greater than the number of components of this type that are available, then the driver shall update the value with the correct number of components.\n", + "desc": "[in,out] pointer to the number of sub devices.\nif count is zero, then the driver shall update the value with the total number of sub devices currently attached to the device.\nif count is greater than the number of sub devices currently attached to the device, then the driver shall update the value with the correct number of sub devices.\n", "name": "pCount", "type": "uint32_t*" }, { - "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", - "name": "phTemperature", - "type": "$s_temp_handle_t*" + "desc": "[in,out][optional][range(0, *pCount)] array of sub device property structures.\nif count is less than the number of sysman sub devices available, then the driver shall only retrieve that number of sub device property structures.\n", + "name": "pSubdeviceProps", + "type": "$s_subdevice_exp_properties_t*" } ], "returns": [ @@ -79346,27 +93150,43 @@ ] } ], - "type": "function" + "type": "function", + "version": "1.9" }, { - "class": "$sTemperature", - "desc": "Get temperature sensor properties", + "class": "$sDriver", + "desc": "Retrieves sysman device and subdevice index for the given UUID and sysman driver", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "aed86f68f316999523ed898037cdc44bb6e1a9447b9aed0c17792c9af3b44fef", - "name": "GetProperties", + "hash": "602d4db6503d6bd7f5fc359621651cf2632c93a3ea12d3c68070ee245ccd67cd", + "name": "GetDeviceByUuidExp", "params": [ { - "desc": "[in] Handle for the component.", - "name": "hTemperature", - "type": "$s_temp_handle_t" + "desc": "[in] handle of the sysman driver instance", + "name": "hDriver", + "type": "$s_driver_handle_t" }, { - "desc": "[in,out] Will contain the temperature sensor properties.", - "name": "pProperties", - "type": "$s_temp_properties_t*" + "desc": "[in] universal unique identifier.", + "name": "uuid", + "type": "$s_uuid_t" + }, + { + "desc": "[out] Sysman handle of the device.", + "name": "phDevice", + "type": "$s_device_handle_t*" + }, + { + "desc": "[out] True if the UUID belongs to the sub-device; false means that UUID belongs to the root device.", + "name": "onSubdevice", + "type": "$x_bool_t*" + }, + { + "desc": "[out] If onSubdevice is true, this gives the ID of the sub-device", + "name": "subdeviceId", + "type": "uint32_t*" } ], "returns": [ @@ -79387,266 +93207,315 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hTemperature`" + "`nullptr == hDriver`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pProperties`" + "`nullptr == phDevice`", + "`nullptr == onSubdevice`", + "`nullptr == subdeviceId`" ] } ], - "type": "function" + "type": "function", + "version": "1.9" + } + ] + }, + { + "header": { + "desc": "Intel $OneApi Level-Zero Sysman Extension APIs for Virtual Function Management Properties", + "ordinal": 1900, + "type": "header", + "version": "1.9" + }, + "name": "virtualFunctionManagement", + "objects": [ + { + "desc": "Virtual Function Management Extension Name", + "name": "$S_VIRTUAL_FUNCTION_MANAGEMENT_EXP_NAME", + "type": "macro", + "value": "\"$XS_experimental_virtual_function_management\"", + "version": "1.9" }, { - "class": "$sTemperature", - "desc": "Get temperature configuration for this sensor - which events are triggered and the trigger conditions", - "details": [ - "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." - ], - "hash": "59b77f7353eacc0c25fea8df764d6ae44f6e0504dd349e8a92cb0db7c1003e9a", - "name": "GetConfig", - "params": [ + "desc": "Virtual Function Management Extension Version(s)", + "etors": [ { - "desc": "[in] Handle for the component.", - "name": "hTemperature", - "type": "$s_temp_handle_t" + "desc": "version 1.0 (deprecated)", + "name": "$S_VF_MANAGEMENT_EXP_VERSION_1_0", + "value": "$X_MAKE_VERSION( 1, 0 )" }, { - "desc": "[in,out] Returns current configuration.", - "name": "pConfig", - "type": "$s_temp_config_t*" - } - ], - "returns": [ - { - "$X_RESULT_SUCCESS": [] + "desc": "version 1.1 (deprecated)", + "name": "$S_VF_MANAGEMENT_EXP_VERSION_1_1", + "value": "$X_MAKE_VERSION( 1, 1 )" }, { - "$X_RESULT_ERROR_UNINITIALIZED": [] + "desc": "version 1.2", + "name": "$S_VF_MANAGEMENT_EXP_VERSION_1_2", + "value": "$X_MAKE_VERSION( 1, 2 )" }, { - "$X_RESULT_ERROR_DEVICE_LOST": [] - }, + "desc": "latest known version", + "name": "$S_VF_MANAGEMENT_EXP_VERSION_CURRENT", + "value": "$X_MAKE_VERSION( 1, 2 )" + } + ], + "name": "$s_vf_management_exp_version_t", + "type": "enum", + "version": "1.9" + }, + { + "class": "$sVFManagement", + "desc": "Virtual function memory types (deprecated)", + "etors": [ { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "desc": "System memory", + "name": "$S_VF_INFO_MEM_TYPE_EXP_FLAG_MEM_TYPE_SYSTEM", + "value": "$X_BIT(0)" }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] - }, + "desc": "Device local memory", + "name": "$S_VF_INFO_MEM_TYPE_EXP_FLAG_MEM_TYPE_DEVICE", + "value": "$X_BIT(1)" + } + ], + "name": "$s_vf_info_mem_type_exp_flags_t", + "type": "enum", + "version": "1.9" + }, + { + "class": "$sVFManagement", + "desc": "Virtual function utilization flag bit fields (deprecated)", + "etors": [ { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hTemperature`" - ] + "desc": "No info associated with virtual function", + "name": "$S_VF_INFO_UTIL_EXP_FLAG_INFO_NONE", + "value": "$X_BIT(0)" }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pConfig`" - ] + "desc": "System memory utilization associated with virtual function", + "name": "$S_VF_INFO_UTIL_EXP_FLAG_INFO_MEM_CPU", + "value": "$X_BIT(1)" }, { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "Temperature thresholds are not supported on this temperature sensor. Generally this is only supported for temperature sensor $S_TEMP_SENSORS_GLOBAL.", - "One or both of the thresholds is not supported. Check the `isThreshold1Supported` and `isThreshold2Supported` members of $s_temp_properties_t." - ] + "desc": "Device memory utilization associated with virtual function", + "name": "$S_VF_INFO_UTIL_EXP_FLAG_INFO_MEM_GPU", + "value": "$X_BIT(2)" }, { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to request this feature." - ] + "desc": "Engine utilization associated with virtual function", + "name": "$S_VF_INFO_UTIL_EXP_FLAG_INFO_ENGINE", + "value": "$X_BIT(3)" } ], - "type": "function" + "name": "$s_vf_info_util_exp_flags_t", + "type": "enum", + "version": "1.9" }, { - "class": "$sTemperature", - "desc": "Set temperature configuration for this sensor - indicates which events are triggered and the trigger conditions", - "details": [ - "Events $S_EVENT_TYPE_FLAG_TEMP_CRITICAL will be triggered when temperature reaches the critical range. Use the function $sDeviceEventRegister() to start receiving this event.", - "Events $S_EVENT_TYPE_FLAG_TEMP_THRESHOLD1 and $S_EVENT_TYPE_FLAG_TEMP_THRESHOLD2 will be generated when temperature cross the thresholds set using this function. Use the function $sDeviceEventRegister() to start receiving these events.", - "Only one running process can set the temperature configuration at a time. If another process attempts to change the configuration, the error $X_RESULT_ERROR_NOT_AVAILABLE will be returned. The function $sTemperatureGetConfig() will return the process ID currently controlling these settings.", - "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." - ], - "hash": "e7c1c15a3b996c73398851cf8822ce99c876e9b834540276ccf63243785b7e69", - "name": "SetConfig", - "params": [ - { - "desc": "[in] Handle for the component.", - "name": "hTemperature", - "type": "$s_temp_handle_t" - }, - { - "desc": "[in] New configuration.", - "name": "pConfig", - "type": "const $s_temp_config_t*" - } - ], - "returns": [ + "base": "$s_base_properties_t", + "class": "$sVFManagement", + "desc": "Virtual function management properties (deprecated)", + "members": [ { - "$X_RESULT_SUCCESS": [] + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_VF_EXP_PROPERTIES", + "name": "stype", + "type": "$s_structure_type_t" }, { - "$X_RESULT_ERROR_UNINITIALIZED": [] + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "void*" }, { - "$X_RESULT_ERROR_DEVICE_LOST": [] + "desc": "[out] Virtual function BDF address", + "name": "address", + "type": "$s_pci_address_t" }, { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "desc": "[out] universal unique identifier of the device", + "name": "uuid", + "type": "$s_uuid_t" }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] - }, + "desc": "[out] utilization flags available. May be 0 or a valid combination of $s_vf_info_util_exp_flag_t.", + "name": "flags", + "type": "$s_vf_info_util_exp_flags_t" + } + ], + "name": "$s_vf_exp_properties_t", + "type": "struct", + "version": "1.9" + }, + { + "base": "$s_base_state_t", + "class": "$sVFManagement", + "desc": "Provides memory utilization values for a virtual function (deprecated)", + "members": [ { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hTemperature`" - ] + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_VF_UTIL_MEM_EXP", + "name": "stype", + "type": "$s_structure_type_t" }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pConfig`" - ] + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" }, { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE": [ - "Temperature thresholds are not supported on this temperature sensor. Generally they are only supported for temperature sensor $S_TEMP_SENSORS_GLOBAL.", - "Enabling the critical temperature event is not supported. Check the `isCriticalTempSupported` member of $s_temp_properties_t.", - "One or both of the thresholds is not supported. Check the `isThreshold1Supported` and `isThreshold2Supported` members of $s_temp_properties_t." - ] + "desc": "[out] Memory type flags.", + "name": "memTypeFlags", + "type": "$s_vf_info_mem_type_exp_flags_t" }, { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to request this feature." - ] + "desc": "[out] Free memory size in bytes.", + "name": "free", + "type": "uint64_t" }, { - "$X_RESULT_ERROR_NOT_AVAILABLE": [ - "Another running process is controlling these settings." - ] + "desc": "[out] Total allocatable memory in bytes.", + "name": "size", + "type": "uint64_t" }, { - "$X_RESULT_ERROR_INVALID_ARGUMENT": [ - "One or both the thresholds is above TjMax (see $sFrequencyOcGetTjMax()). Temperature thresholds must be below this value." - ] + "desc": "[out] Wall clock time from VF when value was sampled.", + "name": "timestamp", + "type": "uint64_t" } ], - "type": "function" + "name": "$s_vf_util_mem_exp_t", + "type": "struct", + "version": "1.9" }, { - "class": "$sTemperature", - "desc": "Get the temperature from a specified sensor", - "details": [ - "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." - ], - "hash": "6e03eadebfa90ec535691d9f5ee770f0838a4014177254ed824c0f9878e0c4d7", - "name": "GetState", - "params": [ - { - "desc": "[in] Handle for the component.", - "name": "hTemperature", - "type": "$s_temp_handle_t" - }, - { - "desc": "[in,out] Will contain the temperature read from the specified sensor in degrees Celsius.", - "name": "pTemperature", - "type": "double*" - } - ], - "returns": [ - { - "$X_RESULT_SUCCESS": [] - }, + "base": "$s_base_state_t", + "class": "$sVFManagement", + "desc": "Provides engine utilization values for a virtual function (deprecated)", + "members": [ { - "$X_RESULT_ERROR_UNINITIALIZED": [] + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_VF_UTIL_ENGINE_EXP", + "name": "stype", + "type": "$s_structure_type_t" }, { - "$X_RESULT_ERROR_DEVICE_LOST": [] + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" }, { - "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + "desc": "[out] The engine group.", + "name": "type", + "type": "$s_engine_group_t" }, { - "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + "desc": "[out] Represents active counter.", + "name": "activeCounterValue", + "type": "uint64_t" }, { - "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hTemperature`" - ] + "desc": "[out] Represents counter value when activeCounterValue was sampled.", + "name": "samplingCounterValue", + "type": "uint64_t" }, { - "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ - "`nullptr == pTemperature`" - ] + "desc": "[out] Wall clock time when the activeCounterValue was sampled.", + "name": "timestamp", + "type": "uint64_t" } ], - "type": "function" + "name": "$s_vf_util_engine_exp_t", + "type": "struct", + "version": "1.9" }, { - "desc": "C++ wrapper for a Sysman device temperature sensor", + "base": "$s_base_properties_t", + "class": "$sVFManagement", + "desc": "Virtual function management capabilities", "members": [ { - "desc": "[in] handle of Sysman object", + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_VF_EXP_CAPABILITIES", + "name": "stype", + "type": "$s_structure_type_t" + }, + { + "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", "init": "nullptr", - "name": "handle", - "type": "$s_temp_handle_t" + "name": "pNext", + "type": "void*" }, { - "desc": "[in] pointer to owner object", - "name": "pDevice", - "type": "$sDevice*" + "desc": "[out] Virtual function BDF address", + "name": "address", + "type": "$s_pci_address_t" + }, + { + "desc": "[out] Virtual function memory size in bytes", + "name": "vfDeviceMemSize", + "type": "uint32_t" + }, + { + "desc": "[out] Virtual Function ID", + "name": "vfID", + "type": "uint32_t" } ], - "name": "$sTemperature", - "owner": "$sDevice", - "type": "class" - } - ] - }, - { - "header": { - "desc": "Intel $OneApi Level-Zero Sysman Extension APIs for Power Limits", - "ordinal": 1400, - "type": "header", - "version": "1.4" - }, - "name": "powerLimits", - "objects": [ - { - "desc": "Power Limits Extension Name", - "name": "$S_POWER_LIMITS_EXT_NAME", - "type": "macro", - "value": "\"$XS_extension_power_limits\"", - "version": "1.4" + "name": "$s_vf_exp_capabilities_t", + "type": "struct", + "version": "1.10" }, { - "desc": "Power Limits Extension Version(s)", - "etors": [ + "base": "$s_base_state_t", + "class": "$sVFManagement", + "desc": "Provides memory utilization values for a virtual function", + "members": [ + { + "desc": "[in] type of this structure", + "init": "$S_STRUCTURE_TYPE_VF_UTIL_MEM_EXP2", + "name": "stype", + "type": "$s_structure_type_t" + }, + { + "desc": "[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", + "init": "nullptr", + "name": "pNext", + "type": "const void*" + }, { - "desc": "version 1.0", - "name": "$S_POWER_LIMITS_EXT_VERSION_1_0", - "value": "$X_MAKE_VERSION( 1, 0 )" + "desc": "[out] Location of this memory (system, device)", + "name": "vfMemLocation", + "type": "$s_mem_loc_t" }, { - "desc": "latest known version", - "name": "$S_POWER_LIMITS_EXT_VERSION_CURRENT", - "value": "$X_MAKE_VERSION( 1, 0 )" + "desc": "[out] Free memory size in bytes.", + "name": "vfMemUtilized", + "type": "uint64_t" } ], - "name": "$s_power_limits_ext_version_t", - "type": "enum", - "version": "1.4" + "name": "$s_vf_util_mem_exp2_t", + "type": "struct", + "version": "1.10" }, { - "base": "$s_base_desc_t", - "class": "$sPower", - "desc": "Device power/current limit descriptor.", + "base": "$s_base_state_t", + "class": "$sVFManagement", + "desc": "Provides engine utilization values for a virtual function", + "details": [ + "Percent utilization is calculated by taking two snapshots (s1, s2) and using the equation: %util = (s2.activeCounterValue - s1.activeCounterValue) / (s2.samplingCounterValue - s1.samplingCounterValue)" + ], "members": [ { "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_POWER_LIMIT_EXT_DESC", + "init": "$S_STRUCTURE_TYPE_VF_UTIL_ENGINE_EXP2", "name": "stype", "type": "$s_structure_type_t" }, @@ -79657,117 +93526,159 @@ "type": "const void*" }, { - "desc": "[in,out] duration type over which the power draw is measured, i.e. sustained, burst, peak, or critical.", - "name": "level", - "type": "$s_power_level_t" + "desc": "[out] The engine group.", + "name": "vfEngineType", + "type": "$s_engine_group_t" }, { - "desc": "[out] source of power used by the system, i.e. AC or DC.", - "name": "source", - "type": "$s_power_source_t" + "desc": "[out] Represents active counter.", + "name": "activeCounterValue", + "type": "uint64_t" }, { - "desc": "[out] unit used for specifying limit, i.e. current units (milliamps) or power units (milliwatts).", - "name": "limitUnit", - "type": "$s_limit_unit_t" + "desc": "[out] Represents counter value when activeCounterValue was sampled. Refer to the formulae above for calculating the utilization percent", + "name": "samplingCounterValue", + "type": "uint64_t" + } + ], + "name": "$s_vf_util_engine_exp2_t", + "type": "struct", + "version": "1.10" + }, + { + "class": "$sDevice", + "desc": "Get handle of virtual function modules", + "details": [ + "[DEPRECATED] No longer supported. Use $sDeviceEnumEnabledVFExp.", + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "ad00f044ce01e761f48e29a6a5d305df3d362dc8bb0dfe6b707e698b6dc392d7", + "name": "EnumActiveVFExp", + "params": [ + { + "desc": "[in] Sysman handle of the device.", + "name": "hDevice", + "type": "$s_device_handle_t" }, { - "desc": "[out] indicates if the power limit state (enabled/ignored) can be set (false) or is locked (true).", - "name": "enabledStateLocked", - "type": "ze_bool_t" + "desc": "[in,out] pointer to the number of components of this type.\nif count is zero, then the driver shall update the value with the total number of components of this type that are available.\nif count is greater than the number of components of this type that are available, then the driver shall update the value with the correct number of components.\n", + "name": "pCount", + "type": "uint32_t*" }, { - "desc": "[in,out] indicates if the limit is enabled (true) or ignored (false). If enabledStateIsLocked is True, this value is ignored.", - "name": "enabled", - "type": "ze_bool_t" + "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", + "name": "phVFhandle", + "type": "$s_vf_handle_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] }, { - "desc": "[out] indicates if the interval can be modified (false) or is fixed (true).", - "name": "intervalValueLocked", - "type": "ze_bool_t" + "$X_RESULT_ERROR_UNINITIALIZED": [] }, { - "desc": "[in,out] power averaging window in milliseconds. If intervalValueLocked is true, this value is ignored.", - "name": "interval", - "type": "int32_t" + "$X_RESULT_ERROR_DEVICE_LOST": [] }, { - "desc": "[out] indicates if the limit can be set (false) or if the limit is fixed (true).", - "name": "limitValueLocked", - "type": "ze_bool_t" + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] }, { - "desc": "[in,out] limit value. If limitValueLocked is true, this value is ignored. The value should be provided in the unit specified by limitUnit.", - "name": "limit", - "type": "int32_t" + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hDevice`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCount`" + ] } ], - "name": "$s_power_limit_ext_desc_t", - "type": "struct", - "version": "1.4" + "type": "function", + "version": "1.9" }, { - "base": "$s_base_properties_t", - "class": "$sPower", - "desc": "Extension properties related to device power settings", + "class": "$sVFManagement", + "desc": "Get virtual function management properties", "details": [ - "This structure may be returned from $sPowerGetProperties via the `pNext` member of $s_power_properties_t.", - "This structure may also be returned from $sPowerGetProperties via the `pNext` member of $s_power_ext_properties_t", - "Used for determining the power domain level, i.e. card-level v/s package-level v/s stack-level & the factory default power limits." + "[DEPRECATED] No longer supported. Use $sVFManagementGetVFCapabilitiesExp.", + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." ], - "members": [ + "hash": "75432f3511889072076423640ab99950187fc2a2fa38769aae5dddbe094e6a1a", + "name": "GetVFPropertiesExp", + "params": [ { - "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_POWER_EXT_PROPERTIES", - "name": "stype", - "type": "$s_structure_type_t" + "desc": "[in] Sysman handle for the VF component.", + "name": "hVFhandle", + "type": "$s_vf_handle_t" }, { - "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "void*" + "desc": "[in,out] Will contain VF properties.", + "name": "pProperties", + "type": "$s_vf_exp_properties_t*" + } + ], + "returns": [ + { + "$X_RESULT_SUCCESS": [] }, { - "desc": "[out] domain that the power limit belongs to.", - "name": "domain", - "type": "$s_power_domain_t" + "$X_RESULT_ERROR_UNINITIALIZED": [] }, { - "desc": "[out] the factory default limit of the part.", - "name": "defaultLimit", - "type": "$s_power_limit_ext_desc_t*" + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hVFhandle`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pProperties`" + ] } ], - "name": "$s_power_ext_properties_t", - "type": "struct", - "version": "1.4" + "type": "function", + "version": "1.9" }, { - "class": "$sPower", - "desc": "Get power limits", + "class": "$sVFManagement", + "desc": "Get memory activity stats for each available memory types associated with Virtual Function (VF)", "details": [ + "[DEPRECATED] No longer supported. Use $sVFManagementGetVFMemoryUtilizationExp2.", "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free.", - "This function returns all the power limits associated with the supplied power domain." + "The implementation of this function should be lock-free." ], - "hash": "68f318093a420db4811cba53835f34da4a4fa9ffb3b98d7793765842d0424b8c", - "name": "GetLimitsExt", + "hash": "50945d884fd1b8fbaef5d6a67253a9f11828433790a8a752661a2a41575bd7f2", + "name": "GetVFMemoryUtilizationExp", "params": [ { - "desc": "[in] Power domain handle instance.", - "name": "hPower", - "type": "$s_pwr_handle_t" + "desc": "[in] Sysman handle for the component.", + "name": "hVFhandle", + "type": "$s_vf_handle_t" }, { - "desc": "[in,out] Pointer to the number of power limit descriptors. If count is zero, then the driver shall update the value with the total number of components of this type that are available. If count is greater than the number of components of this type that are available, then the driver shall update the value with the correct number of components.", + "desc": "[in,out] Pointer to the number of VF memory stats descriptors.\n - if count is zero, the driver shall update the value with the total number of memory stats available.\n - if count is greater than the total number of memory stats available, the driver shall update the value with the correct number of memory stats available.\n - The count returned is the sum of number of VF instances currently available and the PF instance.\n", "name": "pCount", "type": "uint32_t*" }, { - "desc": "[in,out][optional][range(0, *pCount)] Array of query results for power limit descriptors. If count is less than the number of components of this type that are available, then the driver shall only retrieve that number of components.", - "name": "pSustained", - "type": "$s_power_limit_ext_desc_t*" + "desc": "[in,out][optional][range(0, *pCount)] array of memory group activity counters.\n - if count is less than the total number of memory stats available, then driver shall only retrieve that number of stats.\n - the implementation shall populate the vector pCount-1 number of VF memory stats.\n", + "name": "pMemUtil", + "type": "$s_vf_util_mem_exp_t*" } ], "returns": [ @@ -79788,7 +93699,7 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hPower`" + "`nullptr == hVFhandle`" ] }, { @@ -79797,36 +93708,34 @@ ] } ], - "type": "function" + "type": "function", + "version": "1.9" }, { - "class": "$sPower", - "desc": "Set power limits", + "class": "$sVFManagement", + "desc": "Get engine activity stats for each available engine group associated with Virtual Function (VF)", "details": [ - "The application can only modify unlocked members of the limit descriptors returned by $sPowerGetLimitsExt.", - "Not all the limits returned by $sPowerGetLimitsExt need to be supplied to this function.", - "Limits do not have to be supplied in the same order as returned by $sPowerGetLimitsExt.", - "The same limit can be supplied multiple times. Limits are applied in the order in which they are supplied.", + "[DEPRECATED] No longer supported. Use $sVFManagementGetVFEngineUtilizationExp2.", "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "c3fd274f580f2e3476b92eaf271f4bb46b76ab91842dd1c8af90981870e5098c", - "name": "SetLimitsExt", + "hash": "fa212c5c1badd54bea1e467b77401545e8b539ed4aaba4231c8287790c8784ad", + "name": "GetVFEngineUtilizationExp", "params": [ { - "desc": "[in] Handle for the component.", - "name": "hPower", - "type": "$s_pwr_handle_t" + "desc": "[in] Sysman handle for the component.", + "name": "hVFhandle", + "type": "$s_vf_handle_t" }, { - "desc": "[in] Pointer to the number of power limit descriptors.", + "desc": "[in,out] Pointer to the number of VF engine stats descriptors.\n - if count is zero, the driver shall update the value with the total number of engine stats available.\n - if count is greater than the total number of engine stats available, the driver shall update the value with the correct number of engine stats available.\n - The count returned is the sum of number of VF instances currently available and the PF instance.\n", "name": "pCount", "type": "uint32_t*" }, { - "desc": "[in][optional][range(0, *pCount)] Array of power limit descriptors.", - "name": "pSustained", - "type": "$s_power_limit_ext_desc_t*" + "desc": "[in,out][optional][range(0, *pCount)] array of engine group activity counters.\n - if count is less than the total number of engine stats available, then driver shall only retrieve that number of stats.\n - the implementation shall populate the vector pCount-1 number of VF engine stats.\n", + "name": "pEngineUtil", + "type": "$s_vf_util_engine_exp_t*" } ], "returns": [ @@ -79847,118 +93756,156 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hPower`" + "`nullptr == hVFhandle`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ "`nullptr == pCount`" ] + } + ], + "type": "function", + "version": "1.9" + }, + { + "class": "$sVFManagement", + "desc": "Configure utilization telemetry enabled or disabled associated with Virtual Function (VF)", + "details": [ + "[DEPRECATED] No longer supported.", + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "2b7409e8dbea86bf1bb7d1552880fd2f3eab20773a39bcacf875ff30e742fcf4", + "name": "SetVFTelemetryModeExp", + "params": [ + { + "desc": "[in] Sysman handle for the component.", + "name": "hVFhandle", + "type": "$s_vf_handle_t" }, { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "User does not have permissions to make these modifications." - ] + "desc": "[in] utilization flags to enable or disable. May be 0 or a valid combination of $s_vf_info_util_exp_flag_t.", + "name": "flags", + "type": "$s_vf_info_util_exp_flags_t" }, { - "$X_RESULT_ERROR_NOT_AVAILABLE": [ - "The device is in use, meaning that the GPU is under Over clocking, applying power limits under overclocking is not supported." - ] + "desc": "[in] Enable utilization telemetry.", + "name": "enable", + "type": "$x_bool_t" } ], - "type": "function" - } - ] - }, - { - "header": { - "desc": "Intel $OneApi Level-Zero Sysman Extension APIs for Engine Activity", - "ordinal": 1700, - "type": "header", - "version": "1.7" - }, - "name": "engineActivity", - "objects": [ - { - "desc": "Engine Activity Extension Name", - "name": "$S_ENGINE_ACTIVITY_EXT_NAME", - "type": "macro", - "value": "\"$XS_extension_engine_activity\"", - "version": "1.7" - }, - { - "desc": "Engine Activity Extension Version(s)", - "etors": [ + "returns": [ { - "desc": "version 1.0", - "name": "$S_ENGINE_ACTIVITY_EXT_VERSION_1_0", - "value": "$X_MAKE_VERSION( 1, 0 )" + "$X_RESULT_SUCCESS": [] }, { - "desc": "latest known version", - "name": "$S_ENGINE_ACTIVITY_EXT_VERSION_CURRENT", - "value": "$X_MAKE_VERSION( 1, 0 )" + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hVFhandle`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_ENUMERATION": [ + "`0xf < flags`" + ] } ], - "name": "$s_engine_activity_ext_version_t", - "type": "enum", - "version": "1.7" + "type": "function", + "version": "1.9" }, { - "base": "$s_base_properties_t", - "class": "$sEngine", - "desc": "Extension properties related to Engine Groups", + "class": "$sVFManagement", + "desc": "Set sampling interval to monitor for a particular utilization telemetry associated with Virtual Function (VF)", "details": [ - "This structure may be passed to $sEngineGetProperties by having the pNext member of $s_engine_properties_t point at this struct.", - "Used for SRIOV per Virtual Function device utilization by $s_engine_group_t" + "[DEPRECATED] No longer supported.", + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." ], - "members": [ + "hash": "15215d47c7c50ee6f92ecced859d742286cd66e2fdeae6e88419fc4abd7d08dc", + "name": "SetVFTelemetrySamplingIntervalExp", + "params": [ { - "desc": "[in] type of this structure", - "init": "$S_STRUCTURE_TYPE_ENGINE_EXT_PROPERTIES", - "name": "stype", - "type": "$s_structure_type_t" + "desc": "[in] Sysman handle for the component.", + "name": "hVFhandle", + "type": "$s_vf_handle_t" }, { - "desc": "[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).", - "init": "nullptr", - "name": "pNext", - "type": "void*" + "desc": "[in] utilization flags to set sampling interval. May be 0 or a valid combination of $s_vf_info_util_exp_flag_t.", + "name": "flag", + "type": "$s_vf_info_util_exp_flags_t" }, { - "desc": "[out] Number of Virtual Function(VF) instances associated with engine to monitor the utilization of hardware across all Virtual Function from a Physical Function (PF) instance.\nThese VF-by-VF views should provide engine group and individual engine level granularity.\nThis count represents the number of VF instances that are actively using the resource represented by the engine handle.\n", - "name": "countOfVirtualFunctionInstance", - "type": "uint32_t" + "desc": "[in] Sampling interval value.", + "name": "samplingInterval", + "type": "uint64_t" } ], - "name": "$s_engine_ext_properties_t", - "type": "struct", - "version": "1.7" + "returns": [ + { + "$X_RESULT_SUCCESS": [] + }, + { + "$X_RESULT_ERROR_UNINITIALIZED": [] + }, + { + "$X_RESULT_ERROR_DEVICE_LOST": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] + }, + { + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] + }, + { + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hVFhandle`" + ] + }, + { + "$X_RESULT_ERROR_INVALID_ENUMERATION": [ + "`0xf < flag`" + ] + } + ], + "type": "function", + "version": "1.9" }, { - "class": "$sEngine", - "desc": "Get activity stats for Physical Function (PF) and each Virtual Function (VF) associated with engine group.", + "class": "$sDevice", + "desc": "Get handle of virtual function modules", "details": [ "The application may call this function from simultaneous threads.", "The implementation of this function should be lock-free." ], - "hash": "7c7eb1843ce9221ba257b856861d9929463cc144d7c4bbad5350c04491413ccd", - "name": "GetActivityExt", + "hash": "3bda6a79097a23aa3e3ea29bbe7201d2cf0ce2d2e24feff71563a4bcbfefb1fa", + "name": "EnumEnabledVFExp", "params": [ { - "desc": "[in] Handle for the component.", - "name": "hEngine", - "type": "$s_engine_handle_t" + "desc": "[in] Sysman handle of the device.", + "name": "hDevice", + "type": "$s_device_handle_t" }, { - "desc": "[in,out] Pointer to the number of VF engine stats descriptors.\n - if count is zero, the driver shall update the value with the total number of engine stats available.\n - if count is greater than the total number of engine stats available, the driver shall update the value with the correct number of engine stats available.\n - The count returned is the sum of number of VF instances currently available and the PF instance.\n", + "desc": "[in,out] pointer to the number of components of this type.\nif count is zero, then the driver shall update the value with the total number of components of this type that are available.\nif count is greater than the number of components of this type that are available, then the driver shall update the value with the correct number of components.\n", "name": "pCount", "type": "uint32_t*" }, { - "desc": "[in,out][optional][range(0, *pCount)] array of engine group activity counters.\n - if count is less than the total number of engine stats available, then driver shall only retrieve that number of stats.\n - the implementation shall populate the vector with engine stat for PF at index 0 of the vector followed by user provided pCount-1 number of VF engine stats.\n", - "name": "pStats", - "type": "$s_engine_stats_t*" + "desc": "[in,out][optional][range(0, *pCount)] array of handle of components of this type.\nif count is less than the number of components of this type that are available, then the driver shall only retrieve that number of component handles.\n", + "name": "phVFhandle", + "type": "$s_vf_handle_t*" } ], "returns": [ @@ -79979,170 +93926,94 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hEngine`" + "`nullptr == hDevice`" ] }, { "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ "`nullptr == pCount`" ] - }, - { - "$X_RESULT_ERROR_UNSUPPORTED_FEATURE - \"Engine activity extension is not supported in the environment.\"": [] } ], "type": "function", - "version": "1.7" - } - ] - }, - { - "header": { - "desc": "Intel $OneApi Level-Zero Sysman Extension APIs for RAS Get State and Clear State", - "ordinal": 1700, - "type": "header", - "version": "1.7" - }, - "name": "rasState", - "objects": [ - { - "desc": "RAS Get State Extension Name", - "name": "$S_RAS_GET_STATE_EXP_NAME", - "type": "macro", - "value": "\"$XS_extension_ras_state\"", - "version": "1.7" + "version": "1.10" }, { - "desc": "RAS Get State Extension Version(s)", - "etors": [ + "class": "$sVFManagement", + "desc": "Get virtual function management capabilities", + "details": [ + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free." + ], + "hash": "22600193b186ac613b617456cf8b8137226ed86c7fa0bd3e678f002ebc8924a4", + "name": "GetVFCapabilitiesExp", + "params": [ { - "desc": "version 1.0", - "name": "$S_RAS_STATE_EXP_VERSION_1_0", - "value": "$X_MAKE_VERSION( 1, 0 )" + "desc": "[in] Sysman handle for the VF component.", + "name": "hVFhandle", + "type": "$s_vf_handle_t" }, { - "desc": "latest known version", - "name": "$S_RAS_STATE_EXP_VERSION_CURRENT", - "value": "$X_MAKE_VERSION( 1, 0 )" + "desc": "[in,out] Will contain VF capability.", + "name": "pCapability", + "type": "$s_vf_exp_capabilities_t*" } ], - "name": "$s_ras_state_exp_version_t", - "type": "enum", - "version": "1.7" - }, - { - "class": "$sRas", - "desc": "RAS error categories", - "etors": [ - { - "desc": "The number of accelerator engine resets attempted by the driver", - "name": "$S_RAS_ERROR_CATEGORY_EXP_RESET", - "value": "0", - "version": "1.7" - }, - { - "desc": "The number of hardware exceptions generated by the way workloads have programmed the hardware", - "name": "$S_RAS_ERROR_CATEGORY_EXP_PROGRAMMING_ERRORS", - "value": "1", - "version": "1.7" - }, - { - "desc": "The number of low level driver communication errors have occurred", - "name": "$S_RAS_ERROR_CATEGORY_EXP_DRIVER_ERRORS", - "value": "2", - "version": "1.7" - }, - { - "desc": "The number of errors that have occurred in the compute accelerator hardware", - "name": "$S_RAS_ERROR_CATEGORY_EXP_COMPUTE_ERRORS", - "value": "3", - "version": "1.7" - }, + "returns": [ { - "desc": "The number of errors that have occurred in the fixed-function accelerator hardware", - "name": "$S_RAS_ERROR_CATEGORY_EXP_NON_COMPUTE_ERRORS", - "value": "4", - "version": "1.7" + "$X_RESULT_SUCCESS": [] }, { - "desc": "The number of errors that have occurred in caches (L1/L3/register file/shared local memory/sampler)", - "name": "$S_RAS_ERROR_CATEGORY_EXP_CACHE_ERRORS", - "value": "5", - "version": "1.7" + "$X_RESULT_ERROR_UNINITIALIZED": [] }, { - "desc": "The number of errors that have occurred in the display", - "name": "$S_RAS_ERROR_CATEGORY_EXP_DISPLAY_ERRORS", - "value": "6", - "version": "1.7" + "$X_RESULT_ERROR_DEVICE_LOST": [] }, { - "desc": "The number of errors that have occurred in Memory", - "name": "$S_RAS_ERROR_CATEGORY_EXP_MEMORY_ERRORS", - "value": "7", - "version": "1.7" + "$X_RESULT_ERROR_OUT_OF_HOST_MEMORY": [] }, { - "desc": "The number of errors that have occurred in Scale Fabric", - "name": "$S_RAS_ERROR_CATEGORY_EXP_SCALE_ERRORS", - "value": "8", - "version": "1.7" + "$X_RESULT_ERROR_OUT_OF_DEVICE_MEMORY": [] }, { - "desc": "The number of errors that have occurred in L3 Fabric", - "name": "$S_RAS_ERROR_CATEGORY_EXP_L3FABRIC_ERRORS", - "value": "9", - "version": "1.7" - } - ], - "name": "$s_ras_error_category_exp_t", - "type": "enum", - "version": "1.7" - }, - { - "class": "$sRas", - "desc": "Extension structure for providing RAS error counters for different error sets", - "members": [ - { - "desc": "[out] category for which error counter is provided.", - "name": "category", - "type": "$s_ras_error_category_exp_t" + "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ + "`nullptr == hVFhandle`" + ] }, { - "desc": "[out] Current value of RAS counter for specific error category.", - "name": "errorCounter", - "type": "uint64_t" + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCapability`" + ] } ], - "name": "$s_ras_state_exp_t", - "type": "struct", - "version": "1.7" + "type": "function", + "version": "1.10" }, { - "class": "$sRas", - "desc": "Ras Get State", + "class": "$sVFManagement", + "desc": "Get memory activity stats for each available memory types associated with Virtual Function (VF)", "details": [ - "This function retrieves error counters for different RAS error categories.", "The application may call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The implementation of this function should be lock-free.", + "If VF is disable/pause/not active, utilization will give zero value." ], - "hash": "9e9e646c541c50da30308738da88832993b6df10556583499dff169f46e4b908", - "name": "GetStateExp", + "hash": "d25a77106be7eeb28f474e755cd6dfa7521b603ae2983e133f4aeb441c3b2dc1", + "name": "GetVFMemoryUtilizationExp2", "params": [ { - "desc": "[in] Handle for the component.", - "name": "hRas", - "type": "$s_ras_handle_t" + "desc": "[in] Sysman handle for the component.", + "name": "hVFhandle", + "type": "$s_vf_handle_t" }, { - "desc": "[in,out] pointer to the number of RAS state structures that can be retrieved.\nif count is zero, then the driver shall update the value with the total number of error categories for which state can be retrieved.\nif count is greater than the number of RAS states available, then the driver shall update the value with the correct number of RAS states available.\n", + "desc": "[in,out] Pointer to the number of VF memory stats descriptors.\n - if count is zero, the driver shall update the value with the total number of memory stats available.\n - if count is greater than the total number of memory stats available, the driver shall update the value with the correct number of memory stats available.\n", "name": "pCount", "type": "uint32_t*" }, { - "desc": "[in,out][optional][range(0, *pCount)] array of query results for RAS error states for different categories.\nif count is less than the number of RAS states available, then driver shall only retrieve that number of RAS states.\n", - "name": "pState", - "type": "$s_ras_state_exp_t*" + "desc": "[in,out][optional][range(0, *pCount)] array of memory group activity counters.\n - if count is less than the total number of memory stats available, then driver shall only retrieve that number of stats.\n - the implementation shall populate the vector pCount-1 number of VF memory stats.\n", + "name": "pMemUtil", + "type": "$s_vf_util_mem_exp2_t*" } ], "returns": [ @@ -80163,7 +94034,7 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hRas`" + "`nullptr == hVFhandle`" ] }, { @@ -80172,30 +94043,34 @@ ] } ], - "type": "function" + "type": "function", + "version": "1.10" }, { - "class": "$sRas", - "desc": "Ras Clear State", + "class": "$sVFManagement", + "desc": "Get engine activity stats for each available engine group associated with Virtual Function (VF)", "details": [ - "This function clears error counters for a RAS error category.", - "Clearing errors will affect other threads/applications - the counter values will start from zero.", - "Clearing errors requires write permissions.", - "The application should not call this function from simultaneous threads.", - "The implementation of this function should be lock-free." + "The application may call this function from simultaneous threads.", + "The implementation of this function should be lock-free.", + "If VF is disable/pause/not active, utilization will give zero value." ], - "hash": "94c31ad19460e9ec5a14b5d704aa570c4b03bf09d0a0c48838190b0a3e50f362", - "name": "ClearStateExp", + "hash": "b25cb052495243ec02a18cbbe9ab6c1a6c6e787700508fb90109b76bb5e6757a", + "name": "GetVFEngineUtilizationExp2", "params": [ { - "desc": "[in] Handle for the component.", - "name": "hRas", - "type": "$s_ras_handle_t" + "desc": "[in] Sysman handle for the component.", + "name": "hVFhandle", + "type": "$s_vf_handle_t" }, { - "desc": "[in] category for which error counter is to be cleared.", - "name": "category", - "type": "$s_ras_error_category_exp_t" + "desc": "[in,out] Pointer to the number of VF engine stats descriptors.\n - if count is zero, the driver shall update the value with the total number of engine stats available.\n - if count is greater than the total number of engine stats available, the driver shall update the value with the correct number of engine stats available.\n", + "name": "pCount", + "type": "uint32_t*" + }, + { + "desc": "[in,out][optional][range(0, *pCount)] array of engine group activity counters.\n - if count is less than the total number of engine stats available, then driver shall only retrieve that number of stats.\n - the implementation shall populate the vector pCount-1 number of VF engine stats.\n", + "name": "pEngineUtil", + "type": "$s_vf_util_engine_exp2_t*" } ], "returns": [ @@ -80216,21 +94091,37 @@ }, { "$X_RESULT_ERROR_INVALID_NULL_HANDLE": [ - "`nullptr == hRas`" + "`nullptr == hVFhandle`" ] }, { - "$X_RESULT_ERROR_INVALID_ENUMERATION": [ - "`$S_RAS_ERROR_CATEGORY_EXP_L3FABRIC_ERRORS < category`" + "$X_RESULT_ERROR_INVALID_NULL_POINTER": [ + "`nullptr == pCount`" ] + } + ], + "type": "function", + "version": "1.10" + }, + { + "desc": "C++ wrapper for a Sysman virtual function management group", + "members": [ + { + "desc": "[in] handle of Sysman virtual function object", + "init": "nullptr", + "name": "handle", + "type": "$s_vf_handle_t" }, { - "$X_RESULT_ERROR_INSUFFICIENT_PERMISSIONS": [ - "Don't have permissions to clear error counters." - ] + "desc": "[in] pointer to owner object", + "name": "pDevice", + "type": "$sDevice*" } ], - "type": "function" + "name": "$sVFManagement", + "owner": "$sDevice", + "type": "class", + "version": "1.9" } ] } diff --git a/scripts/templates/libapi.cpp.mako b/scripts/templates/libapi.cpp.mako index db511935..d0f8487c 100644 --- a/scripts/templates/libapi.cpp.mako +++ b/scripts/templates/libapi.cpp.mako @@ -81,12 +81,8 @@ ${th.make_func_name(n, tags, obj)}( } %else: %if re.match("InitDrivers", obj['name']): - std::call_once(${x}_lib::context->initOnceDrivers, []() { - ze_init_flags_t all_enabled = UINT32_MAX; - ze_init_driver_type_desc_t all_enabled_desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC}; - all_enabled_desc.pNext = nullptr; - all_enabled_desc.flags = UINT32_MAX; - result = ${x}_lib::context->Init(all_enabled, false, &all_enabled_desc); + std::call_once(${x}_lib::context->initOnceDrivers, [desc]() { + result = ${x}_lib::context->Init(0, false, desc); return result; }); diff --git a/source/drivers/null/ze_nullddi.cpp b/source/drivers/null/ze_nullddi.cpp index 8541b077..a0e7e30c 100644 --- a/source/drivers/null/ze_nullddi.cpp +++ b/source/drivers/null/ze_nullddi.cpp @@ -3969,164 +3969,6 @@ namespace driver return result; } - /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeCommandListGetNextCommandIdExp - __zedlllocal ze_result_t ZE_APICALL - zeCommandListGetNextCommandIdExp( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - const ze_mutable_command_id_exp_desc_t* desc, ///< [in] pointer to mutable command identifier descriptor - uint64_t* pCommandId ///< [out] pointer to mutable command identifier to be written - ) - { - ze_result_t result = ZE_RESULT_SUCCESS; - - // if the driver has created a custom function, then call it instead of using the generic path - auto pfnGetNextCommandIdExp = context.zeDdiTable.CommandListExp.pfnGetNextCommandIdExp; - if( nullptr != pfnGetNextCommandIdExp ) - { - result = pfnGetNextCommandIdExp( hCommandList, desc, pCommandId ); - } - else - { - // generic implementation - } - - return result; - } - - /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeCommandListGetNextCommandIdWithKernelsExp - __zedlllocal ze_result_t ZE_APICALL - zeCommandListGetNextCommandIdWithKernelsExp( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - const ze_mutable_command_id_exp_desc_t* desc, ///< [in][out] pointer to mutable command identifier descriptor - uint32_t numKernels, ///< [in][optional] number of entries on phKernels list - ze_kernel_handle_t* phKernels, ///< [in][optional][range(0, numKernels)] list of kernels that user can - ///< switch between using ::zeCommandListUpdateMutableCommandKernelsExp - ///< call - uint64_t* pCommandId ///< [out] pointer to mutable command identifier to be written - ) - { - ze_result_t result = ZE_RESULT_SUCCESS; - - // if the driver has created a custom function, then call it instead of using the generic path - auto pfnGetNextCommandIdWithKernelsExp = context.zeDdiTable.CommandListExp.pfnGetNextCommandIdWithKernelsExp; - if( nullptr != pfnGetNextCommandIdWithKernelsExp ) - { - result = pfnGetNextCommandIdWithKernelsExp( hCommandList, desc, numKernels, phKernels, pCommandId ); - } - else - { - // generic implementation - } - - return result; - } - - /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeCommandListUpdateMutableCommandsExp - __zedlllocal ze_result_t ZE_APICALL - zeCommandListUpdateMutableCommandsExp( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - const ze_mutable_commands_exp_desc_t* desc ///< [in] pointer to mutable commands descriptor; multiple descriptors may - ///< be chained via `pNext` member - ) - { - ze_result_t result = ZE_RESULT_SUCCESS; - - // if the driver has created a custom function, then call it instead of using the generic path - auto pfnUpdateMutableCommandsExp = context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandsExp; - if( nullptr != pfnUpdateMutableCommandsExp ) - { - result = pfnUpdateMutableCommandsExp( hCommandList, desc ); - } - else - { - // generic implementation - } - - return result; - } - - /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeCommandListUpdateMutableCommandSignalEventExp - __zedlllocal ze_result_t ZE_APICALL - zeCommandListUpdateMutableCommandSignalEventExp( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - uint64_t commandId, ///< [in] command identifier - ze_event_handle_t hSignalEvent ///< [in][optional] handle of the event to signal on completion - ) - { - ze_result_t result = ZE_RESULT_SUCCESS; - - // if the driver has created a custom function, then call it instead of using the generic path - auto pfnUpdateMutableCommandSignalEventExp = context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandSignalEventExp; - if( nullptr != pfnUpdateMutableCommandSignalEventExp ) - { - result = pfnUpdateMutableCommandSignalEventExp( hCommandList, commandId, hSignalEvent ); - } - else - { - // generic implementation - } - - return result; - } - - /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeCommandListUpdateMutableCommandWaitEventsExp - __zedlllocal ze_result_t ZE_APICALL - zeCommandListUpdateMutableCommandWaitEventsExp( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - uint64_t commandId, ///< [in] command identifier - uint32_t numWaitEvents, ///< [in][optional] the number of wait events - ze_event_handle_t* phWaitEvents ///< [in][optional][range(0, numWaitEvents)] handle of the events to wait - ///< on before launching - ) - { - ze_result_t result = ZE_RESULT_SUCCESS; - - // if the driver has created a custom function, then call it instead of using the generic path - auto pfnUpdateMutableCommandWaitEventsExp = context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandWaitEventsExp; - if( nullptr != pfnUpdateMutableCommandWaitEventsExp ) - { - result = pfnUpdateMutableCommandWaitEventsExp( hCommandList, commandId, numWaitEvents, phWaitEvents ); - } - else - { - // generic implementation - } - - return result; - } - - /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeCommandListUpdateMutableCommandKernelsExp - __zedlllocal ze_result_t ZE_APICALL - zeCommandListUpdateMutableCommandKernelsExp( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - uint32_t numKernels, ///< [in] the number of kernels to update - uint64_t* pCommandId, ///< [in][range(0, numKernels)] command identifier - ze_kernel_handle_t* phKernels ///< [in][range(0, numKernels)] handle of the kernel for a command - ///< identifier to switch to - ) - { - ze_result_t result = ZE_RESULT_SUCCESS; - - // if the driver has created a custom function, then call it instead of using the generic path - auto pfnUpdateMutableCommandKernelsExp = context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandKernelsExp; - if( nullptr != pfnUpdateMutableCommandKernelsExp ) - { - result = pfnUpdateMutableCommandKernelsExp( hCommandList, numKernels, pCommandId, phKernels ); - } - else - { - // generic implementation - } - - return result; - } - /////////////////////////////////////////////////////////////////////////////// /// @brief Intercept function for zeDeviceReserveCacheExt __zedlllocal ze_result_t ZE_APICALL @@ -5112,6 +4954,164 @@ namespace driver return result; } + /////////////////////////////////////////////////////////////////////////////// + /// @brief Intercept function for zeCommandListGetNextCommandIdExp + __zedlllocal ze_result_t ZE_APICALL + zeCommandListGetNextCommandIdExp( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + const ze_mutable_command_id_exp_desc_t* desc, ///< [in] pointer to mutable command identifier descriptor + uint64_t* pCommandId ///< [out] pointer to mutable command identifier to be written + ) + { + ze_result_t result = ZE_RESULT_SUCCESS; + + // if the driver has created a custom function, then call it instead of using the generic path + auto pfnGetNextCommandIdExp = context.zeDdiTable.CommandListExp.pfnGetNextCommandIdExp; + if( nullptr != pfnGetNextCommandIdExp ) + { + result = pfnGetNextCommandIdExp( hCommandList, desc, pCommandId ); + } + else + { + // generic implementation + } + + return result; + } + + /////////////////////////////////////////////////////////////////////////////// + /// @brief Intercept function for zeCommandListGetNextCommandIdWithKernelsExp + __zedlllocal ze_result_t ZE_APICALL + zeCommandListGetNextCommandIdWithKernelsExp( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + const ze_mutable_command_id_exp_desc_t* desc, ///< [in][out] pointer to mutable command identifier descriptor + uint32_t numKernels, ///< [in][optional] number of entries on phKernels list + ze_kernel_handle_t* phKernels, ///< [in][optional][range(0, numKernels)] list of kernels that user can + ///< switch between using ::zeCommandListUpdateMutableCommandKernelsExp + ///< call + uint64_t* pCommandId ///< [out] pointer to mutable command identifier to be written + ) + { + ze_result_t result = ZE_RESULT_SUCCESS; + + // if the driver has created a custom function, then call it instead of using the generic path + auto pfnGetNextCommandIdWithKernelsExp = context.zeDdiTable.CommandListExp.pfnGetNextCommandIdWithKernelsExp; + if( nullptr != pfnGetNextCommandIdWithKernelsExp ) + { + result = pfnGetNextCommandIdWithKernelsExp( hCommandList, desc, numKernels, phKernels, pCommandId ); + } + else + { + // generic implementation + } + + return result; + } + + /////////////////////////////////////////////////////////////////////////////// + /// @brief Intercept function for zeCommandListUpdateMutableCommandsExp + __zedlllocal ze_result_t ZE_APICALL + zeCommandListUpdateMutableCommandsExp( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + const ze_mutable_commands_exp_desc_t* desc ///< [in] pointer to mutable commands descriptor; multiple descriptors may + ///< be chained via `pNext` member + ) + { + ze_result_t result = ZE_RESULT_SUCCESS; + + // if the driver has created a custom function, then call it instead of using the generic path + auto pfnUpdateMutableCommandsExp = context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandsExp; + if( nullptr != pfnUpdateMutableCommandsExp ) + { + result = pfnUpdateMutableCommandsExp( hCommandList, desc ); + } + else + { + // generic implementation + } + + return result; + } + + /////////////////////////////////////////////////////////////////////////////// + /// @brief Intercept function for zeCommandListUpdateMutableCommandSignalEventExp + __zedlllocal ze_result_t ZE_APICALL + zeCommandListUpdateMutableCommandSignalEventExp( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + uint64_t commandId, ///< [in] command identifier + ze_event_handle_t hSignalEvent ///< [in][optional] handle of the event to signal on completion + ) + { + ze_result_t result = ZE_RESULT_SUCCESS; + + // if the driver has created a custom function, then call it instead of using the generic path + auto pfnUpdateMutableCommandSignalEventExp = context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandSignalEventExp; + if( nullptr != pfnUpdateMutableCommandSignalEventExp ) + { + result = pfnUpdateMutableCommandSignalEventExp( hCommandList, commandId, hSignalEvent ); + } + else + { + // generic implementation + } + + return result; + } + + /////////////////////////////////////////////////////////////////////////////// + /// @brief Intercept function for zeCommandListUpdateMutableCommandWaitEventsExp + __zedlllocal ze_result_t ZE_APICALL + zeCommandListUpdateMutableCommandWaitEventsExp( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + uint64_t commandId, ///< [in] command identifier + uint32_t numWaitEvents, ///< [in][optional] the number of wait events + ze_event_handle_t* phWaitEvents ///< [in][optional][range(0, numWaitEvents)] handle of the events to wait + ///< on before launching + ) + { + ze_result_t result = ZE_RESULT_SUCCESS; + + // if the driver has created a custom function, then call it instead of using the generic path + auto pfnUpdateMutableCommandWaitEventsExp = context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandWaitEventsExp; + if( nullptr != pfnUpdateMutableCommandWaitEventsExp ) + { + result = pfnUpdateMutableCommandWaitEventsExp( hCommandList, commandId, numWaitEvents, phWaitEvents ); + } + else + { + // generic implementation + } + + return result; + } + + /////////////////////////////////////////////////////////////////////////////// + /// @brief Intercept function for zeCommandListUpdateMutableCommandKernelsExp + __zedlllocal ze_result_t ZE_APICALL + zeCommandListUpdateMutableCommandKernelsExp( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + uint32_t numKernels, ///< [in] the number of kernels to update + uint64_t* pCommandId, ///< [in][range(0, numKernels)] command identifier + ze_kernel_handle_t* phKernels ///< [in][range(0, numKernels)] handle of the kernel for a command + ///< identifier to switch to + ) + { + ze_result_t result = ZE_RESULT_SUCCESS; + + // if the driver has created a custom function, then call it instead of using the generic path + auto pfnUpdateMutableCommandKernelsExp = context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandKernelsExp; + if( nullptr != pfnUpdateMutableCommandKernelsExp ) + { + result = pfnUpdateMutableCommandKernelsExp( hCommandList, numKernels, pCommandId, phKernels ); + } + else + { + // generic implementation + } + + return result; + } + } // namespace driver #if defined(__cplusplus) @@ -5566,19 +5566,19 @@ zeGetCommandListExpProcAddrTable( pDdiTable->pfnGetNextCommandIdWithKernelsExp = driver::zeCommandListGetNextCommandIdWithKernelsExp; - pDdiTable->pfnUpdateMutableCommandsExp = driver::zeCommandListUpdateMutableCommandsExp; - - pDdiTable->pfnUpdateMutableCommandSignalEventExp = driver::zeCommandListUpdateMutableCommandSignalEventExp; - pDdiTable->pfnUpdateMutableCommandKernelsExp = driver::zeCommandListUpdateMutableCommandKernelsExp; pDdiTable->pfnCreateCloneExp = driver::zeCommandListCreateCloneExp; + pDdiTable->pfnImmediateAppendCommandListsExp = driver::zeCommandListImmediateAppendCommandListsExp; + pDdiTable->pfnGetNextCommandIdExp = driver::zeCommandListGetNextCommandIdExp; - pDdiTable->pfnUpdateMutableCommandWaitEventsExp = driver::zeCommandListUpdateMutableCommandWaitEventsExp; + pDdiTable->pfnUpdateMutableCommandsExp = driver::zeCommandListUpdateMutableCommandsExp; - pDdiTable->pfnImmediateAppendCommandListsExp = driver::zeCommandListImmediateAppendCommandListsExp; + pDdiTable->pfnUpdateMutableCommandSignalEventExp = driver::zeCommandListUpdateMutableCommandSignalEventExp; + + pDdiTable->pfnUpdateMutableCommandWaitEventsExp = driver::zeCommandListUpdateMutableCommandWaitEventsExp; return result; } diff --git a/source/drivers/null/zet_nullddi.cpp b/source/drivers/null/zet_nullddi.cpp index 800f27f1..b17a3b9f 100644 --- a/source/drivers/null/zet_nullddi.cpp +++ b/source/drivers/null/zet_nullddi.cpp @@ -2395,8 +2395,6 @@ zetGetMetricGroupExpProcAddrTable( ze_result_t result = ZE_RESULT_SUCCESS; - pDdiTable->pfnCreateExp = driver::zetMetricGroupCreateExp; - pDdiTable->pfnCalculateMultipleMetricValuesExp = driver::zetMetricGroupCalculateMultipleMetricValuesExp; pDdiTable->pfnGetGlobalTimestampsExp = driver::zetMetricGroupGetGlobalTimestampsExp; @@ -2405,6 +2403,8 @@ zetGetMetricGroupExpProcAddrTable( pDdiTable->pfnCalculateMetricExportDataExp = driver::zetMetricGroupCalculateMetricExportDataExp; + pDdiTable->pfnCreateExp = driver::zetMetricGroupCreateExp; + pDdiTable->pfnAddMetricExp = driver::zetMetricGroupAddMetricExp; pDdiTable->pfnRemoveMetricExp = driver::zetMetricGroupRemoveMetricExp; diff --git a/source/layers/tracing/ze_tracing_cb_structs.h b/source/layers/tracing/ze_tracing_cb_structs.h index 8eac2548..26ab1632 100644 --- a/source/layers/tracing/ze_tracing_cb_structs.h +++ b/source/layers/tracing/ze_tracing_cb_structs.h @@ -144,8 +144,6 @@ typedef struct _zel_command_list_callbacks_t ze_pfnCommandListAppendLaunchKernelIndirectCb_t pfnAppendLaunchKernelIndirectCb; ze_pfnCommandListAppendLaunchMultipleKernelsIndirectCb_t pfnAppendLaunchMultipleKernelsIndirectCb; ze_pfnCommandListGetNextCommandIdWithKernelsExpCb_t pfnGetNextCommandIdWithKernelsExpCb; - ze_pfnCommandListUpdateMutableCommandsExpCb_t pfnUpdateMutableCommandsExpCb; - ze_pfnCommandListUpdateMutableCommandSignalEventExpCb_t pfnUpdateMutableCommandSignalEventExpCb; ze_pfnCommandListUpdateMutableCommandKernelsExpCb_t pfnUpdateMutableCommandKernelsExpCb; ze_pfnCommandListAppendImageCopyToMemoryExtCb_t pfnAppendImageCopyToMemoryExtCb; ze_pfnCommandListAppendImageCopyFromMemoryExtCb_t pfnAppendImageCopyFromMemoryExtCb; @@ -156,9 +154,11 @@ typedef struct _zel_command_list_callbacks_t ze_pfnCommandListGetOrdinalCb_t pfnGetOrdinalCb; ze_pfnCommandListImmediateGetIndexCb_t pfnImmediateGetIndexCb; ze_pfnCommandListIsImmediateCb_t pfnIsImmediateCb; + ze_pfnCommandListImmediateAppendCommandListsExpCb_t pfnImmediateAppendCommandListsExpCb; ze_pfnCommandListGetNextCommandIdExpCb_t pfnGetNextCommandIdExpCb; + ze_pfnCommandListUpdateMutableCommandsExpCb_t pfnUpdateMutableCommandsExpCb; + ze_pfnCommandListUpdateMutableCommandSignalEventExpCb_t pfnUpdateMutableCommandSignalEventExpCb; ze_pfnCommandListUpdateMutableCommandWaitEventsExpCb_t pfnUpdateMutableCommandWaitEventsExpCb; - ze_pfnCommandListImmediateAppendCommandListsExpCb_t pfnImmediateAppendCommandListsExpCb; } zel_command_list_callbacks_t; /////////////////////////////////////////////////////////////////////////////// diff --git a/source/layers/tracing/ze_tracing_register_cb.cpp b/source/layers/tracing/ze_tracing_register_cb.cpp index fe6e308f..7eb97a2f 100644 --- a/source/layers/tracing/ze_tracing_register_cb.cpp +++ b/source/layers/tracing/ze_tracing_register_cb.cpp @@ -2355,102 +2355,6 @@ zelTracerKernelSetGlobalOffsetExpRegisterCallback( } -ZE_DLLEXPORT ze_result_t ZE_APICALL -zelTracerCommandListGetNextCommandIdExpRegisterCallback( - zel_tracer_handle_t hTracer, - zel_tracer_reg_t callback_type, - ze_pfnCommandListGetNextCommandIdExpCb_t pfnGetNextCommandIdExpCb - ) { - - ze_result_t result; - auto& cbs = tracing_layer::APITracer::fromHandle(hTracer)->getProEpilogues(callback_type, result); - if (result == ZE_RESULT_SUCCESS) - cbs.CommandList.pfnGetNextCommandIdExpCb = pfnGetNextCommandIdExpCb; - - return result; -} - - -ZE_DLLEXPORT ze_result_t ZE_APICALL -zelTracerCommandListGetNextCommandIdWithKernelsExpRegisterCallback( - zel_tracer_handle_t hTracer, - zel_tracer_reg_t callback_type, - ze_pfnCommandListGetNextCommandIdWithKernelsExpCb_t pfnGetNextCommandIdWithKernelsExpCb - ) { - - ze_result_t result; - auto& cbs = tracing_layer::APITracer::fromHandle(hTracer)->getProEpilogues(callback_type, result); - if (result == ZE_RESULT_SUCCESS) - cbs.CommandList.pfnGetNextCommandIdWithKernelsExpCb = pfnGetNextCommandIdWithKernelsExpCb; - - return result; -} - - -ZE_DLLEXPORT ze_result_t ZE_APICALL -zelTracerCommandListUpdateMutableCommandsExpRegisterCallback( - zel_tracer_handle_t hTracer, - zel_tracer_reg_t callback_type, - ze_pfnCommandListUpdateMutableCommandsExpCb_t pfnUpdateMutableCommandsExpCb - ) { - - ze_result_t result; - auto& cbs = tracing_layer::APITracer::fromHandle(hTracer)->getProEpilogues(callback_type, result); - if (result == ZE_RESULT_SUCCESS) - cbs.CommandList.pfnUpdateMutableCommandsExpCb = pfnUpdateMutableCommandsExpCb; - - return result; -} - - -ZE_DLLEXPORT ze_result_t ZE_APICALL -zelTracerCommandListUpdateMutableCommandSignalEventExpRegisterCallback( - zel_tracer_handle_t hTracer, - zel_tracer_reg_t callback_type, - ze_pfnCommandListUpdateMutableCommandSignalEventExpCb_t pfnUpdateMutableCommandSignalEventExpCb - ) { - - ze_result_t result; - auto& cbs = tracing_layer::APITracer::fromHandle(hTracer)->getProEpilogues(callback_type, result); - if (result == ZE_RESULT_SUCCESS) - cbs.CommandList.pfnUpdateMutableCommandSignalEventExpCb = pfnUpdateMutableCommandSignalEventExpCb; - - return result; -} - - -ZE_DLLEXPORT ze_result_t ZE_APICALL -zelTracerCommandListUpdateMutableCommandWaitEventsExpRegisterCallback( - zel_tracer_handle_t hTracer, - zel_tracer_reg_t callback_type, - ze_pfnCommandListUpdateMutableCommandWaitEventsExpCb_t pfnUpdateMutableCommandWaitEventsExpCb - ) { - - ze_result_t result; - auto& cbs = tracing_layer::APITracer::fromHandle(hTracer)->getProEpilogues(callback_type, result); - if (result == ZE_RESULT_SUCCESS) - cbs.CommandList.pfnUpdateMutableCommandWaitEventsExpCb = pfnUpdateMutableCommandWaitEventsExpCb; - - return result; -} - - -ZE_DLLEXPORT ze_result_t ZE_APICALL -zelTracerCommandListUpdateMutableCommandKernelsExpRegisterCallback( - zel_tracer_handle_t hTracer, - zel_tracer_reg_t callback_type, - ze_pfnCommandListUpdateMutableCommandKernelsExpCb_t pfnUpdateMutableCommandKernelsExpCb - ) { - - ze_result_t result; - auto& cbs = tracing_layer::APITracer::fromHandle(hTracer)->getProEpilogues(callback_type, result); - if (result == ZE_RESULT_SUCCESS) - cbs.CommandList.pfnUpdateMutableCommandKernelsExpCb = pfnUpdateMutableCommandKernelsExpCb; - - return result; -} - - ZE_DLLEXPORT ze_result_t ZE_APICALL zelTracerDeviceReserveCacheExtRegisterCallback( zel_tracer_handle_t hTracer, @@ -3011,5 +2915,101 @@ zelTracerCommandListImmediateAppendCommandListsExpRegisterCallback( } +ZE_DLLEXPORT ze_result_t ZE_APICALL +zelTracerCommandListGetNextCommandIdExpRegisterCallback( + zel_tracer_handle_t hTracer, + zel_tracer_reg_t callback_type, + ze_pfnCommandListGetNextCommandIdExpCb_t pfnGetNextCommandIdExpCb + ) { + + ze_result_t result; + auto& cbs = tracing_layer::APITracer::fromHandle(hTracer)->getProEpilogues(callback_type, result); + if (result == ZE_RESULT_SUCCESS) + cbs.CommandList.pfnGetNextCommandIdExpCb = pfnGetNextCommandIdExpCb; + + return result; +} + + +ZE_DLLEXPORT ze_result_t ZE_APICALL +zelTracerCommandListGetNextCommandIdWithKernelsExpRegisterCallback( + zel_tracer_handle_t hTracer, + zel_tracer_reg_t callback_type, + ze_pfnCommandListGetNextCommandIdWithKernelsExpCb_t pfnGetNextCommandIdWithKernelsExpCb + ) { + + ze_result_t result; + auto& cbs = tracing_layer::APITracer::fromHandle(hTracer)->getProEpilogues(callback_type, result); + if (result == ZE_RESULT_SUCCESS) + cbs.CommandList.pfnGetNextCommandIdWithKernelsExpCb = pfnGetNextCommandIdWithKernelsExpCb; + + return result; +} + + +ZE_DLLEXPORT ze_result_t ZE_APICALL +zelTracerCommandListUpdateMutableCommandsExpRegisterCallback( + zel_tracer_handle_t hTracer, + zel_tracer_reg_t callback_type, + ze_pfnCommandListUpdateMutableCommandsExpCb_t pfnUpdateMutableCommandsExpCb + ) { + + ze_result_t result; + auto& cbs = tracing_layer::APITracer::fromHandle(hTracer)->getProEpilogues(callback_type, result); + if (result == ZE_RESULT_SUCCESS) + cbs.CommandList.pfnUpdateMutableCommandsExpCb = pfnUpdateMutableCommandsExpCb; + + return result; +} + + +ZE_DLLEXPORT ze_result_t ZE_APICALL +zelTracerCommandListUpdateMutableCommandSignalEventExpRegisterCallback( + zel_tracer_handle_t hTracer, + zel_tracer_reg_t callback_type, + ze_pfnCommandListUpdateMutableCommandSignalEventExpCb_t pfnUpdateMutableCommandSignalEventExpCb + ) { + + ze_result_t result; + auto& cbs = tracing_layer::APITracer::fromHandle(hTracer)->getProEpilogues(callback_type, result); + if (result == ZE_RESULT_SUCCESS) + cbs.CommandList.pfnUpdateMutableCommandSignalEventExpCb = pfnUpdateMutableCommandSignalEventExpCb; + + return result; +} + + +ZE_DLLEXPORT ze_result_t ZE_APICALL +zelTracerCommandListUpdateMutableCommandWaitEventsExpRegisterCallback( + zel_tracer_handle_t hTracer, + zel_tracer_reg_t callback_type, + ze_pfnCommandListUpdateMutableCommandWaitEventsExpCb_t pfnUpdateMutableCommandWaitEventsExpCb + ) { + + ze_result_t result; + auto& cbs = tracing_layer::APITracer::fromHandle(hTracer)->getProEpilogues(callback_type, result); + if (result == ZE_RESULT_SUCCESS) + cbs.CommandList.pfnUpdateMutableCommandWaitEventsExpCb = pfnUpdateMutableCommandWaitEventsExpCb; + + return result; +} + + +ZE_DLLEXPORT ze_result_t ZE_APICALL +zelTracerCommandListUpdateMutableCommandKernelsExpRegisterCallback( + zel_tracer_handle_t hTracer, + zel_tracer_reg_t callback_type, + ze_pfnCommandListUpdateMutableCommandKernelsExpCb_t pfnUpdateMutableCommandKernelsExpCb + ) { + + ze_result_t result; + auto& cbs = tracing_layer::APITracer::fromHandle(hTracer)->getProEpilogues(callback_type, result); + if (result == ZE_RESULT_SUCCESS) + cbs.CommandList.pfnUpdateMutableCommandKernelsExpCb = pfnUpdateMutableCommandKernelsExpCb; + + return result; +} + + } //extern C \ No newline at end of file diff --git a/source/layers/tracing/ze_trcddi.cpp b/source/layers/tracing/ze_trcddi.cpp index d721d32e..d4d16f3f 100644 --- a/source/layers/tracing/ze_trcddi.cpp +++ b/source/layers/tracing/ze_trcddi.cpp @@ -5827,248 +5827,6 @@ namespace tracing_layer *tracerParams.poffsetZ); } - /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeCommandListGetNextCommandIdExp - __zedlllocal ze_result_t ZE_APICALL - zeCommandListGetNextCommandIdExp( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - const ze_mutable_command_id_exp_desc_t* desc, ///< [in] pointer to mutable command identifier descriptor - uint64_t* pCommandId ///< [out] pointer to mutable command identifier to be written - ) - { - auto pfnGetNextCommandIdExp = context.zeDdiTable.CommandListExp.pfnGetNextCommandIdExp; - - if( nullptr == pfnGetNextCommandIdExp) - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; - - ZE_HANDLE_TRACER_RECURSION(context.zeDdiTable.CommandListExp.pfnGetNextCommandIdExp, hCommandList, desc, pCommandId); - - // capture parameters - ze_command_list_get_next_command_id_exp_params_t tracerParams = { - &hCommandList, - &desc, - &pCommandId - }; - - tracing_layer::APITracerCallbackDataImp apiCallbackData; - - ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListGetNextCommandIdExpCb_t, CommandList, pfnGetNextCommandIdExpCb); - - - return tracing_layer::APITracerWrapperImp(context.zeDdiTable.CommandListExp.pfnGetNextCommandIdExp, - &tracerParams, - apiCallbackData.apiOrdinal, - apiCallbackData.prologCallbacks, - apiCallbackData.epilogCallbacks, - *tracerParams.phCommandList, - *tracerParams.pdesc, - *tracerParams.ppCommandId); - } - - /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeCommandListGetNextCommandIdWithKernelsExp - __zedlllocal ze_result_t ZE_APICALL - zeCommandListGetNextCommandIdWithKernelsExp( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - const ze_mutable_command_id_exp_desc_t* desc, ///< [in][out] pointer to mutable command identifier descriptor - uint32_t numKernels, ///< [in][optional] number of entries on phKernels list - ze_kernel_handle_t* phKernels, ///< [in][optional][range(0, numKernels)] list of kernels that user can - ///< switch between using ::zeCommandListUpdateMutableCommandKernelsExp - ///< call - uint64_t* pCommandId ///< [out] pointer to mutable command identifier to be written - ) - { - auto pfnGetNextCommandIdWithKernelsExp = context.zeDdiTable.CommandListExp.pfnGetNextCommandIdWithKernelsExp; - - if( nullptr == pfnGetNextCommandIdWithKernelsExp) - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; - - ZE_HANDLE_TRACER_RECURSION(context.zeDdiTable.CommandListExp.pfnGetNextCommandIdWithKernelsExp, hCommandList, desc, numKernels, phKernels, pCommandId); - - // capture parameters - ze_command_list_get_next_command_id_with_kernels_exp_params_t tracerParams = { - &hCommandList, - &desc, - &numKernels, - &phKernels, - &pCommandId - }; - - tracing_layer::APITracerCallbackDataImp apiCallbackData; - - ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListGetNextCommandIdWithKernelsExpCb_t, CommandList, pfnGetNextCommandIdWithKernelsExpCb); - - - return tracing_layer::APITracerWrapperImp(context.zeDdiTable.CommandListExp.pfnGetNextCommandIdWithKernelsExp, - &tracerParams, - apiCallbackData.apiOrdinal, - apiCallbackData.prologCallbacks, - apiCallbackData.epilogCallbacks, - *tracerParams.phCommandList, - *tracerParams.pdesc, - *tracerParams.pnumKernels, - *tracerParams.pphKernels, - *tracerParams.ppCommandId); - } - - /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeCommandListUpdateMutableCommandsExp - __zedlllocal ze_result_t ZE_APICALL - zeCommandListUpdateMutableCommandsExp( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - const ze_mutable_commands_exp_desc_t* desc ///< [in] pointer to mutable commands descriptor; multiple descriptors may - ///< be chained via `pNext` member - ) - { - auto pfnUpdateMutableCommandsExp = context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandsExp; - - if( nullptr == pfnUpdateMutableCommandsExp) - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; - - ZE_HANDLE_TRACER_RECURSION(context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandsExp, hCommandList, desc); - - // capture parameters - ze_command_list_update_mutable_commands_exp_params_t tracerParams = { - &hCommandList, - &desc - }; - - tracing_layer::APITracerCallbackDataImp apiCallbackData; - - ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListUpdateMutableCommandsExpCb_t, CommandList, pfnUpdateMutableCommandsExpCb); - - - return tracing_layer::APITracerWrapperImp(context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandsExp, - &tracerParams, - apiCallbackData.apiOrdinal, - apiCallbackData.prologCallbacks, - apiCallbackData.epilogCallbacks, - *tracerParams.phCommandList, - *tracerParams.pdesc); - } - - /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeCommandListUpdateMutableCommandSignalEventExp - __zedlllocal ze_result_t ZE_APICALL - zeCommandListUpdateMutableCommandSignalEventExp( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - uint64_t commandId, ///< [in] command identifier - ze_event_handle_t hSignalEvent ///< [in][optional] handle of the event to signal on completion - ) - { - auto pfnUpdateMutableCommandSignalEventExp = context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandSignalEventExp; - - if( nullptr == pfnUpdateMutableCommandSignalEventExp) - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; - - ZE_HANDLE_TRACER_RECURSION(context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandSignalEventExp, hCommandList, commandId, hSignalEvent); - - // capture parameters - ze_command_list_update_mutable_command_signal_event_exp_params_t tracerParams = { - &hCommandList, - &commandId, - &hSignalEvent - }; - - tracing_layer::APITracerCallbackDataImp apiCallbackData; - - ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListUpdateMutableCommandSignalEventExpCb_t, CommandList, pfnUpdateMutableCommandSignalEventExpCb); - - - return tracing_layer::APITracerWrapperImp(context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandSignalEventExp, - &tracerParams, - apiCallbackData.apiOrdinal, - apiCallbackData.prologCallbacks, - apiCallbackData.epilogCallbacks, - *tracerParams.phCommandList, - *tracerParams.pcommandId, - *tracerParams.phSignalEvent); - } - - /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeCommandListUpdateMutableCommandWaitEventsExp - __zedlllocal ze_result_t ZE_APICALL - zeCommandListUpdateMutableCommandWaitEventsExp( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - uint64_t commandId, ///< [in] command identifier - uint32_t numWaitEvents, ///< [in][optional] the number of wait events - ze_event_handle_t* phWaitEvents ///< [in][optional][range(0, numWaitEvents)] handle of the events to wait - ///< on before launching - ) - { - auto pfnUpdateMutableCommandWaitEventsExp = context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandWaitEventsExp; - - if( nullptr == pfnUpdateMutableCommandWaitEventsExp) - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; - - ZE_HANDLE_TRACER_RECURSION(context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandWaitEventsExp, hCommandList, commandId, numWaitEvents, phWaitEvents); - - // capture parameters - ze_command_list_update_mutable_command_wait_events_exp_params_t tracerParams = { - &hCommandList, - &commandId, - &numWaitEvents, - &phWaitEvents - }; - - tracing_layer::APITracerCallbackDataImp apiCallbackData; - - ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListUpdateMutableCommandWaitEventsExpCb_t, CommandList, pfnUpdateMutableCommandWaitEventsExpCb); - - - return tracing_layer::APITracerWrapperImp(context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandWaitEventsExp, - &tracerParams, - apiCallbackData.apiOrdinal, - apiCallbackData.prologCallbacks, - apiCallbackData.epilogCallbacks, - *tracerParams.phCommandList, - *tracerParams.pcommandId, - *tracerParams.pnumWaitEvents, - *tracerParams.pphWaitEvents); - } - - /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeCommandListUpdateMutableCommandKernelsExp - __zedlllocal ze_result_t ZE_APICALL - zeCommandListUpdateMutableCommandKernelsExp( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - uint32_t numKernels, ///< [in] the number of kernels to update - uint64_t* pCommandId, ///< [in][range(0, numKernels)] command identifier - ze_kernel_handle_t* phKernels ///< [in][range(0, numKernels)] handle of the kernel for a command - ///< identifier to switch to - ) - { - auto pfnUpdateMutableCommandKernelsExp = context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandKernelsExp; - - if( nullptr == pfnUpdateMutableCommandKernelsExp) - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; - - ZE_HANDLE_TRACER_RECURSION(context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandKernelsExp, hCommandList, numKernels, pCommandId, phKernels); - - // capture parameters - ze_command_list_update_mutable_command_kernels_exp_params_t tracerParams = { - &hCommandList, - &numKernels, - &pCommandId, - &phKernels - }; - - tracing_layer::APITracerCallbackDataImp apiCallbackData; - - ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListUpdateMutableCommandKernelsExpCb_t, CommandList, pfnUpdateMutableCommandKernelsExpCb); - - - return tracing_layer::APITracerWrapperImp(context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandKernelsExp, - &tracerParams, - apiCallbackData.apiOrdinal, - apiCallbackData.prologCallbacks, - apiCallbackData.epilogCallbacks, - *tracerParams.phCommandList, - *tracerParams.pnumKernels, - *tracerParams.ppCommandId, - *tracerParams.pphKernels); - } - /////////////////////////////////////////////////////////////////////////////// /// @brief Intercept function for zeDeviceReserveCacheExt __zedlllocal ze_result_t ZE_APICALL @@ -7512,6 +7270,248 @@ namespace tracing_layer *tracerParams.pphWaitEvents); } + /////////////////////////////////////////////////////////////////////////////// + /// @brief Intercept function for zeCommandListGetNextCommandIdExp + __zedlllocal ze_result_t ZE_APICALL + zeCommandListGetNextCommandIdExp( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + const ze_mutable_command_id_exp_desc_t* desc, ///< [in] pointer to mutable command identifier descriptor + uint64_t* pCommandId ///< [out] pointer to mutable command identifier to be written + ) + { + auto pfnGetNextCommandIdExp = context.zeDdiTable.CommandListExp.pfnGetNextCommandIdExp; + + if( nullptr == pfnGetNextCommandIdExp) + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + + ZE_HANDLE_TRACER_RECURSION(context.zeDdiTable.CommandListExp.pfnGetNextCommandIdExp, hCommandList, desc, pCommandId); + + // capture parameters + ze_command_list_get_next_command_id_exp_params_t tracerParams = { + &hCommandList, + &desc, + &pCommandId + }; + + tracing_layer::APITracerCallbackDataImp apiCallbackData; + + ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListGetNextCommandIdExpCb_t, CommandList, pfnGetNextCommandIdExpCb); + + + return tracing_layer::APITracerWrapperImp(context.zeDdiTable.CommandListExp.pfnGetNextCommandIdExp, + &tracerParams, + apiCallbackData.apiOrdinal, + apiCallbackData.prologCallbacks, + apiCallbackData.epilogCallbacks, + *tracerParams.phCommandList, + *tracerParams.pdesc, + *tracerParams.ppCommandId); + } + + /////////////////////////////////////////////////////////////////////////////// + /// @brief Intercept function for zeCommandListGetNextCommandIdWithKernelsExp + __zedlllocal ze_result_t ZE_APICALL + zeCommandListGetNextCommandIdWithKernelsExp( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + const ze_mutable_command_id_exp_desc_t* desc, ///< [in][out] pointer to mutable command identifier descriptor + uint32_t numKernels, ///< [in][optional] number of entries on phKernels list + ze_kernel_handle_t* phKernels, ///< [in][optional][range(0, numKernels)] list of kernels that user can + ///< switch between using ::zeCommandListUpdateMutableCommandKernelsExp + ///< call + uint64_t* pCommandId ///< [out] pointer to mutable command identifier to be written + ) + { + auto pfnGetNextCommandIdWithKernelsExp = context.zeDdiTable.CommandListExp.pfnGetNextCommandIdWithKernelsExp; + + if( nullptr == pfnGetNextCommandIdWithKernelsExp) + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + + ZE_HANDLE_TRACER_RECURSION(context.zeDdiTable.CommandListExp.pfnGetNextCommandIdWithKernelsExp, hCommandList, desc, numKernels, phKernels, pCommandId); + + // capture parameters + ze_command_list_get_next_command_id_with_kernels_exp_params_t tracerParams = { + &hCommandList, + &desc, + &numKernels, + &phKernels, + &pCommandId + }; + + tracing_layer::APITracerCallbackDataImp apiCallbackData; + + ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListGetNextCommandIdWithKernelsExpCb_t, CommandList, pfnGetNextCommandIdWithKernelsExpCb); + + + return tracing_layer::APITracerWrapperImp(context.zeDdiTable.CommandListExp.pfnGetNextCommandIdWithKernelsExp, + &tracerParams, + apiCallbackData.apiOrdinal, + apiCallbackData.prologCallbacks, + apiCallbackData.epilogCallbacks, + *tracerParams.phCommandList, + *tracerParams.pdesc, + *tracerParams.pnumKernels, + *tracerParams.pphKernels, + *tracerParams.ppCommandId); + } + + /////////////////////////////////////////////////////////////////////////////// + /// @brief Intercept function for zeCommandListUpdateMutableCommandsExp + __zedlllocal ze_result_t ZE_APICALL + zeCommandListUpdateMutableCommandsExp( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + const ze_mutable_commands_exp_desc_t* desc ///< [in] pointer to mutable commands descriptor; multiple descriptors may + ///< be chained via `pNext` member + ) + { + auto pfnUpdateMutableCommandsExp = context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandsExp; + + if( nullptr == pfnUpdateMutableCommandsExp) + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + + ZE_HANDLE_TRACER_RECURSION(context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandsExp, hCommandList, desc); + + // capture parameters + ze_command_list_update_mutable_commands_exp_params_t tracerParams = { + &hCommandList, + &desc + }; + + tracing_layer::APITracerCallbackDataImp apiCallbackData; + + ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListUpdateMutableCommandsExpCb_t, CommandList, pfnUpdateMutableCommandsExpCb); + + + return tracing_layer::APITracerWrapperImp(context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandsExp, + &tracerParams, + apiCallbackData.apiOrdinal, + apiCallbackData.prologCallbacks, + apiCallbackData.epilogCallbacks, + *tracerParams.phCommandList, + *tracerParams.pdesc); + } + + /////////////////////////////////////////////////////////////////////////////// + /// @brief Intercept function for zeCommandListUpdateMutableCommandSignalEventExp + __zedlllocal ze_result_t ZE_APICALL + zeCommandListUpdateMutableCommandSignalEventExp( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + uint64_t commandId, ///< [in] command identifier + ze_event_handle_t hSignalEvent ///< [in][optional] handle of the event to signal on completion + ) + { + auto pfnUpdateMutableCommandSignalEventExp = context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandSignalEventExp; + + if( nullptr == pfnUpdateMutableCommandSignalEventExp) + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + + ZE_HANDLE_TRACER_RECURSION(context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandSignalEventExp, hCommandList, commandId, hSignalEvent); + + // capture parameters + ze_command_list_update_mutable_command_signal_event_exp_params_t tracerParams = { + &hCommandList, + &commandId, + &hSignalEvent + }; + + tracing_layer::APITracerCallbackDataImp apiCallbackData; + + ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListUpdateMutableCommandSignalEventExpCb_t, CommandList, pfnUpdateMutableCommandSignalEventExpCb); + + + return tracing_layer::APITracerWrapperImp(context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandSignalEventExp, + &tracerParams, + apiCallbackData.apiOrdinal, + apiCallbackData.prologCallbacks, + apiCallbackData.epilogCallbacks, + *tracerParams.phCommandList, + *tracerParams.pcommandId, + *tracerParams.phSignalEvent); + } + + /////////////////////////////////////////////////////////////////////////////// + /// @brief Intercept function for zeCommandListUpdateMutableCommandWaitEventsExp + __zedlllocal ze_result_t ZE_APICALL + zeCommandListUpdateMutableCommandWaitEventsExp( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + uint64_t commandId, ///< [in] command identifier + uint32_t numWaitEvents, ///< [in][optional] the number of wait events + ze_event_handle_t* phWaitEvents ///< [in][optional][range(0, numWaitEvents)] handle of the events to wait + ///< on before launching + ) + { + auto pfnUpdateMutableCommandWaitEventsExp = context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandWaitEventsExp; + + if( nullptr == pfnUpdateMutableCommandWaitEventsExp) + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + + ZE_HANDLE_TRACER_RECURSION(context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandWaitEventsExp, hCommandList, commandId, numWaitEvents, phWaitEvents); + + // capture parameters + ze_command_list_update_mutable_command_wait_events_exp_params_t tracerParams = { + &hCommandList, + &commandId, + &numWaitEvents, + &phWaitEvents + }; + + tracing_layer::APITracerCallbackDataImp apiCallbackData; + + ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListUpdateMutableCommandWaitEventsExpCb_t, CommandList, pfnUpdateMutableCommandWaitEventsExpCb); + + + return tracing_layer::APITracerWrapperImp(context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandWaitEventsExp, + &tracerParams, + apiCallbackData.apiOrdinal, + apiCallbackData.prologCallbacks, + apiCallbackData.epilogCallbacks, + *tracerParams.phCommandList, + *tracerParams.pcommandId, + *tracerParams.pnumWaitEvents, + *tracerParams.pphWaitEvents); + } + + /////////////////////////////////////////////////////////////////////////////// + /// @brief Intercept function for zeCommandListUpdateMutableCommandKernelsExp + __zedlllocal ze_result_t ZE_APICALL + zeCommandListUpdateMutableCommandKernelsExp( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + uint32_t numKernels, ///< [in] the number of kernels to update + uint64_t* pCommandId, ///< [in][range(0, numKernels)] command identifier + ze_kernel_handle_t* phKernels ///< [in][range(0, numKernels)] handle of the kernel for a command + ///< identifier to switch to + ) + { + auto pfnUpdateMutableCommandKernelsExp = context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandKernelsExp; + + if( nullptr == pfnUpdateMutableCommandKernelsExp) + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + + ZE_HANDLE_TRACER_RECURSION(context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandKernelsExp, hCommandList, numKernels, pCommandId, phKernels); + + // capture parameters + ze_command_list_update_mutable_command_kernels_exp_params_t tracerParams = { + &hCommandList, + &numKernels, + &pCommandId, + &phKernels + }; + + tracing_layer::APITracerCallbackDataImp apiCallbackData; + + ZE_GEN_PER_API_CALLBACK_STATE(apiCallbackData, ze_pfnCommandListUpdateMutableCommandKernelsExpCb_t, CommandList, pfnUpdateMutableCommandKernelsExpCb); + + + return tracing_layer::APITracerWrapperImp(context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandKernelsExp, + &tracerParams, + apiCallbackData.apiOrdinal, + apiCallbackData.prologCallbacks, + apiCallbackData.epilogCallbacks, + *tracerParams.phCommandList, + *tracerParams.pnumKernels, + *tracerParams.ppCommandId, + *tracerParams.pphKernels); + } + } // namespace tracing_layer #if defined(__cplusplus) @@ -8087,27 +8087,27 @@ zeGetCommandListExpProcAddrTable( dditable.pfnGetNextCommandIdWithKernelsExp = pDdiTable->pfnGetNextCommandIdWithKernelsExp; pDdiTable->pfnGetNextCommandIdWithKernelsExp = tracing_layer::zeCommandListGetNextCommandIdWithKernelsExp; - dditable.pfnUpdateMutableCommandsExp = pDdiTable->pfnUpdateMutableCommandsExp; - pDdiTable->pfnUpdateMutableCommandsExp = tracing_layer::zeCommandListUpdateMutableCommandsExp; - - dditable.pfnUpdateMutableCommandSignalEventExp = pDdiTable->pfnUpdateMutableCommandSignalEventExp; - pDdiTable->pfnUpdateMutableCommandSignalEventExp = tracing_layer::zeCommandListUpdateMutableCommandSignalEventExp; - dditable.pfnUpdateMutableCommandKernelsExp = pDdiTable->pfnUpdateMutableCommandKernelsExp; pDdiTable->pfnUpdateMutableCommandKernelsExp = tracing_layer::zeCommandListUpdateMutableCommandKernelsExp; dditable.pfnCreateCloneExp = pDdiTable->pfnCreateCloneExp; pDdiTable->pfnCreateCloneExp = tracing_layer::zeCommandListCreateCloneExp; + dditable.pfnImmediateAppendCommandListsExp = pDdiTable->pfnImmediateAppendCommandListsExp; + pDdiTable->pfnImmediateAppendCommandListsExp = tracing_layer::zeCommandListImmediateAppendCommandListsExp; + dditable.pfnGetNextCommandIdExp = pDdiTable->pfnGetNextCommandIdExp; pDdiTable->pfnGetNextCommandIdExp = tracing_layer::zeCommandListGetNextCommandIdExp; + dditable.pfnUpdateMutableCommandsExp = pDdiTable->pfnUpdateMutableCommandsExp; + pDdiTable->pfnUpdateMutableCommandsExp = tracing_layer::zeCommandListUpdateMutableCommandsExp; + + dditable.pfnUpdateMutableCommandSignalEventExp = pDdiTable->pfnUpdateMutableCommandSignalEventExp; + pDdiTable->pfnUpdateMutableCommandSignalEventExp = tracing_layer::zeCommandListUpdateMutableCommandSignalEventExp; + dditable.pfnUpdateMutableCommandWaitEventsExp = pDdiTable->pfnUpdateMutableCommandWaitEventsExp; pDdiTable->pfnUpdateMutableCommandWaitEventsExp = tracing_layer::zeCommandListUpdateMutableCommandWaitEventsExp; - dditable.pfnImmediateAppendCommandListsExp = pDdiTable->pfnImmediateAppendCommandListsExp; - pDdiTable->pfnImmediateAppendCommandListsExp = tracing_layer::zeCommandListImmediateAppendCommandListsExp; - return result; } diff --git a/source/layers/validation/checkers/parameter_validation/ze_parameter_validation.cpp b/source/layers/validation/checkers/parameter_validation/ze_parameter_validation.cpp index efd009a8..a848bccf 100644 --- a/source/layers/validation/checkers/parameter_validation/ze_parameter_validation.cpp +++ b/source/layers/validation/checkers/parameter_validation/ze_parameter_validation.cpp @@ -3044,125 +3044,6 @@ namespace validation_layer } - ze_result_t - ZEParameterValidation::zeCommandListGetNextCommandIdExpPrologue( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - const ze_mutable_command_id_exp_desc_t* desc, ///< [in] pointer to mutable command identifier descriptor - uint64_t* pCommandId ///< [out] pointer to mutable command identifier to be written - ) - { - if( nullptr == hCommandList ) - return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; - - if( nullptr == desc ) - return ZE_RESULT_ERROR_INVALID_NULL_POINTER; - - if( nullptr == pCommandId ) - return ZE_RESULT_ERROR_INVALID_NULL_POINTER; - - if( 0xff < desc->flags ) - return ZE_RESULT_ERROR_INVALID_ENUMERATION; - - return ParameterValidation::validateExtensions(desc); - } - - - ze_result_t - ZEParameterValidation::zeCommandListGetNextCommandIdWithKernelsExpPrologue( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - const ze_mutable_command_id_exp_desc_t* desc, ///< [in][out] pointer to mutable command identifier descriptor - uint32_t numKernels, ///< [in][optional] number of entries on phKernels list - ze_kernel_handle_t* phKernels, ///< [in][optional][range(0, numKernels)] list of kernels that user can - ///< switch between using ::zeCommandListUpdateMutableCommandKernelsExp - ///< call - uint64_t* pCommandId ///< [out] pointer to mutable command identifier to be written - ) - { - if( nullptr == hCommandList ) - return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; - - if( nullptr == desc ) - return ZE_RESULT_ERROR_INVALID_NULL_POINTER; - - if( nullptr == pCommandId ) - return ZE_RESULT_ERROR_INVALID_NULL_POINTER; - - if( 0xff < desc->flags ) - return ZE_RESULT_ERROR_INVALID_ENUMERATION; - - return ParameterValidation::validateExtensions(desc); - } - - - ze_result_t - ZEParameterValidation::zeCommandListUpdateMutableCommandsExpPrologue( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - const ze_mutable_commands_exp_desc_t* desc ///< [in] pointer to mutable commands descriptor; multiple descriptors may - ///< be chained via `pNext` member - ) - { - if( nullptr == hCommandList ) - return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; - - if( nullptr == desc ) - return ZE_RESULT_ERROR_INVALID_NULL_POINTER; - - return ParameterValidation::validateExtensions(desc); - } - - - ze_result_t - ZEParameterValidation::zeCommandListUpdateMutableCommandSignalEventExpPrologue( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - uint64_t commandId, ///< [in] command identifier - ze_event_handle_t hSignalEvent ///< [in][optional] handle of the event to signal on completion - ) - { - if( nullptr == hCommandList ) - return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; - - return ZE_RESULT_SUCCESS; - } - - - ze_result_t - ZEParameterValidation::zeCommandListUpdateMutableCommandWaitEventsExpPrologue( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - uint64_t commandId, ///< [in] command identifier - uint32_t numWaitEvents, ///< [in][optional] the number of wait events - ze_event_handle_t* phWaitEvents ///< [in][optional][range(0, numWaitEvents)] handle of the events to wait - ///< on before launching - ) - { - if( nullptr == hCommandList ) - return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; - - return ZE_RESULT_SUCCESS; - } - - - ze_result_t - ZEParameterValidation::zeCommandListUpdateMutableCommandKernelsExpPrologue( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - uint32_t numKernels, ///< [in] the number of kernels to update - uint64_t* pCommandId, ///< [in][range(0, numKernels)] command identifier - ze_kernel_handle_t* phKernels ///< [in][range(0, numKernels)] handle of the kernel for a command - ///< identifier to switch to - ) - { - if( nullptr == hCommandList ) - return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; - - if( nullptr == pCommandId ) - return ZE_RESULT_ERROR_INVALID_NULL_POINTER; - - if( nullptr == phKernels ) - return ZE_RESULT_ERROR_INVALID_NULL_POINTER; - - return ZE_RESULT_SUCCESS; - } - - ze_result_t ZEParameterValidation::zeDeviceReserveCacheExtPrologue( ze_device_handle_t hDevice, ///< [in] handle of the device object @@ -3940,4 +3821,123 @@ namespace validation_layer return ZE_RESULT_SUCCESS; } + + ze_result_t + ZEParameterValidation::zeCommandListGetNextCommandIdExpPrologue( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + const ze_mutable_command_id_exp_desc_t* desc, ///< [in] pointer to mutable command identifier descriptor + uint64_t* pCommandId ///< [out] pointer to mutable command identifier to be written + ) + { + if( nullptr == hCommandList ) + return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; + + if( nullptr == desc ) + return ZE_RESULT_ERROR_INVALID_NULL_POINTER; + + if( nullptr == pCommandId ) + return ZE_RESULT_ERROR_INVALID_NULL_POINTER; + + if( 0xff < desc->flags ) + return ZE_RESULT_ERROR_INVALID_ENUMERATION; + + return ParameterValidation::validateExtensions(desc); + } + + + ze_result_t + ZEParameterValidation::zeCommandListGetNextCommandIdWithKernelsExpPrologue( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + const ze_mutable_command_id_exp_desc_t* desc, ///< [in][out] pointer to mutable command identifier descriptor + uint32_t numKernels, ///< [in][optional] number of entries on phKernels list + ze_kernel_handle_t* phKernels, ///< [in][optional][range(0, numKernels)] list of kernels that user can + ///< switch between using ::zeCommandListUpdateMutableCommandKernelsExp + ///< call + uint64_t* pCommandId ///< [out] pointer to mutable command identifier to be written + ) + { + if( nullptr == hCommandList ) + return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; + + if( nullptr == desc ) + return ZE_RESULT_ERROR_INVALID_NULL_POINTER; + + if( nullptr == pCommandId ) + return ZE_RESULT_ERROR_INVALID_NULL_POINTER; + + if( 0xff < desc->flags ) + return ZE_RESULT_ERROR_INVALID_ENUMERATION; + + return ParameterValidation::validateExtensions(desc); + } + + + ze_result_t + ZEParameterValidation::zeCommandListUpdateMutableCommandsExpPrologue( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + const ze_mutable_commands_exp_desc_t* desc ///< [in] pointer to mutable commands descriptor; multiple descriptors may + ///< be chained via `pNext` member + ) + { + if( nullptr == hCommandList ) + return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; + + if( nullptr == desc ) + return ZE_RESULT_ERROR_INVALID_NULL_POINTER; + + return ParameterValidation::validateExtensions(desc); + } + + + ze_result_t + ZEParameterValidation::zeCommandListUpdateMutableCommandSignalEventExpPrologue( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + uint64_t commandId, ///< [in] command identifier + ze_event_handle_t hSignalEvent ///< [in][optional] handle of the event to signal on completion + ) + { + if( nullptr == hCommandList ) + return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; + + return ZE_RESULT_SUCCESS; + } + + + ze_result_t + ZEParameterValidation::zeCommandListUpdateMutableCommandWaitEventsExpPrologue( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + uint64_t commandId, ///< [in] command identifier + uint32_t numWaitEvents, ///< [in][optional] the number of wait events + ze_event_handle_t* phWaitEvents ///< [in][optional][range(0, numWaitEvents)] handle of the events to wait + ///< on before launching + ) + { + if( nullptr == hCommandList ) + return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; + + return ZE_RESULT_SUCCESS; + } + + + ze_result_t + ZEParameterValidation::zeCommandListUpdateMutableCommandKernelsExpPrologue( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + uint32_t numKernels, ///< [in] the number of kernels to update + uint64_t* pCommandId, ///< [in][range(0, numKernels)] command identifier + ze_kernel_handle_t* phKernels ///< [in][range(0, numKernels)] handle of the kernel for a command + ///< identifier to switch to + ) + { + if( nullptr == hCommandList ) + return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; + + if( nullptr == pCommandId ) + return ZE_RESULT_ERROR_INVALID_NULL_POINTER; + + if( nullptr == phKernels ) + return ZE_RESULT_ERROR_INVALID_NULL_POINTER; + + return ZE_RESULT_SUCCESS; + } + } \ No newline at end of file diff --git a/source/layers/validation/checkers/parameter_validation/ze_parameter_validation.h b/source/layers/validation/checkers/parameter_validation/ze_parameter_validation.h index 355e11af..f84ed21f 100644 --- a/source/layers/validation/checkers/parameter_validation/ze_parameter_validation.h +++ b/source/layers/validation/checkers/parameter_validation/ze_parameter_validation.h @@ -166,12 +166,6 @@ namespace validation_layer ze_result_t zeVirtualMemSetAccessAttributePrologue( ze_context_handle_t hContext, const void* ptr, size_t size, ze_memory_access_attribute_t access ) override; ze_result_t zeVirtualMemGetAccessAttributePrologue( ze_context_handle_t hContext, const void* ptr, size_t size, ze_memory_access_attribute_t* access, size_t* outSize ) override; ze_result_t zeKernelSetGlobalOffsetExpPrologue( ze_kernel_handle_t hKernel, uint32_t offsetX, uint32_t offsetY, uint32_t offsetZ ) override; - ze_result_t zeCommandListGetNextCommandIdExpPrologue( ze_command_list_handle_t hCommandList, const ze_mutable_command_id_exp_desc_t* desc, uint64_t* pCommandId ) override; - ze_result_t zeCommandListGetNextCommandIdWithKernelsExpPrologue( ze_command_list_handle_t hCommandList, const ze_mutable_command_id_exp_desc_t* desc, uint32_t numKernels, ze_kernel_handle_t* phKernels, uint64_t* pCommandId ) override; - ze_result_t zeCommandListUpdateMutableCommandsExpPrologue( ze_command_list_handle_t hCommandList, const ze_mutable_commands_exp_desc_t* desc ) override; - ze_result_t zeCommandListUpdateMutableCommandSignalEventExpPrologue( ze_command_list_handle_t hCommandList, uint64_t commandId, ze_event_handle_t hSignalEvent ) override; - ze_result_t zeCommandListUpdateMutableCommandWaitEventsExpPrologue( ze_command_list_handle_t hCommandList, uint64_t commandId, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents ) override; - ze_result_t zeCommandListUpdateMutableCommandKernelsExpPrologue( ze_command_list_handle_t hCommandList, uint32_t numKernels, uint64_t* pCommandId, ze_kernel_handle_t* phKernels ) override; ze_result_t zeDeviceReserveCacheExtPrologue( ze_device_handle_t hDevice, size_t cacheLevel, size_t cacheReservationSize ) override; ze_result_t zeDeviceSetCacheAdviceExtPrologue( ze_device_handle_t hDevice, void* ptr, size_t regionSize, ze_cache_ext_region_t cacheRegion ) override; ze_result_t zeEventQueryTimestampsExpPrologue( ze_event_handle_t hEvent, ze_device_handle_t hDevice, uint32_t* pCount, ze_kernel_timestamp_result_t* pTimestamps ) override; @@ -207,5 +201,11 @@ namespace validation_layer ze_result_t zeImageGetDeviceOffsetExpPrologue( ze_image_handle_t hImage, uint64_t* pDeviceOffset ) override; ze_result_t zeCommandListCreateCloneExpPrologue( ze_command_list_handle_t hCommandList, ze_command_list_handle_t* phClonedCommandList ) override; ze_result_t zeCommandListImmediateAppendCommandListsExpPrologue( ze_command_list_handle_t hCommandListImmediate, uint32_t numCommandLists, ze_command_list_handle_t* phCommandLists, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents ) override; + ze_result_t zeCommandListGetNextCommandIdExpPrologue( ze_command_list_handle_t hCommandList, const ze_mutable_command_id_exp_desc_t* desc, uint64_t* pCommandId ) override; + ze_result_t zeCommandListGetNextCommandIdWithKernelsExpPrologue( ze_command_list_handle_t hCommandList, const ze_mutable_command_id_exp_desc_t* desc, uint32_t numKernels, ze_kernel_handle_t* phKernels, uint64_t* pCommandId ) override; + ze_result_t zeCommandListUpdateMutableCommandsExpPrologue( ze_command_list_handle_t hCommandList, const ze_mutable_commands_exp_desc_t* desc ) override; + ze_result_t zeCommandListUpdateMutableCommandSignalEventExpPrologue( ze_command_list_handle_t hCommandList, uint64_t commandId, ze_event_handle_t hSignalEvent ) override; + ze_result_t zeCommandListUpdateMutableCommandWaitEventsExpPrologue( ze_command_list_handle_t hCommandList, uint64_t commandId, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents ) override; + ze_result_t zeCommandListUpdateMutableCommandKernelsExpPrologue( ze_command_list_handle_t hCommandList, uint32_t numKernels, uint64_t* pCommandId, ze_kernel_handle_t* phKernels ) override; }; } \ No newline at end of file diff --git a/source/layers/validation/common/ze_entry_points.h b/source/layers/validation/common/ze_entry_points.h index 104e941d..539aaf0e 100644 --- a/source/layers/validation/common/ze_entry_points.h +++ b/source/layers/validation/common/ze_entry_points.h @@ -309,18 +309,6 @@ class ZEValidationEntryPoints { virtual ze_result_t zeVirtualMemGetAccessAttributeEpilogue( ze_context_handle_t hContext, const void* ptr, size_t size, ze_memory_access_attribute_t* access, size_t* outSize ) {return ZE_RESULT_SUCCESS;} virtual ze_result_t zeKernelSetGlobalOffsetExpPrologue( ze_kernel_handle_t hKernel, uint32_t offsetX, uint32_t offsetY, uint32_t offsetZ ) {return ZE_RESULT_SUCCESS;} virtual ze_result_t zeKernelSetGlobalOffsetExpEpilogue( ze_kernel_handle_t hKernel, uint32_t offsetX, uint32_t offsetY, uint32_t offsetZ ) {return ZE_RESULT_SUCCESS;} - virtual ze_result_t zeCommandListGetNextCommandIdExpPrologue( ze_command_list_handle_t hCommandList, const ze_mutable_command_id_exp_desc_t* desc, uint64_t* pCommandId ) {return ZE_RESULT_SUCCESS;} - virtual ze_result_t zeCommandListGetNextCommandIdExpEpilogue( ze_command_list_handle_t hCommandList, const ze_mutable_command_id_exp_desc_t* desc, uint64_t* pCommandId ) {return ZE_RESULT_SUCCESS;} - virtual ze_result_t zeCommandListGetNextCommandIdWithKernelsExpPrologue( ze_command_list_handle_t hCommandList, const ze_mutable_command_id_exp_desc_t* desc, uint32_t numKernels, ze_kernel_handle_t* phKernels, uint64_t* pCommandId ) {return ZE_RESULT_SUCCESS;} - virtual ze_result_t zeCommandListGetNextCommandIdWithKernelsExpEpilogue( ze_command_list_handle_t hCommandList, const ze_mutable_command_id_exp_desc_t* desc, uint32_t numKernels, ze_kernel_handle_t* phKernels, uint64_t* pCommandId ) {return ZE_RESULT_SUCCESS;} - virtual ze_result_t zeCommandListUpdateMutableCommandsExpPrologue( ze_command_list_handle_t hCommandList, const ze_mutable_commands_exp_desc_t* desc ) {return ZE_RESULT_SUCCESS;} - virtual ze_result_t zeCommandListUpdateMutableCommandsExpEpilogue( ze_command_list_handle_t hCommandList, const ze_mutable_commands_exp_desc_t* desc ) {return ZE_RESULT_SUCCESS;} - virtual ze_result_t zeCommandListUpdateMutableCommandSignalEventExpPrologue( ze_command_list_handle_t hCommandList, uint64_t commandId, ze_event_handle_t hSignalEvent ) {return ZE_RESULT_SUCCESS;} - virtual ze_result_t zeCommandListUpdateMutableCommandSignalEventExpEpilogue( ze_command_list_handle_t hCommandList, uint64_t commandId, ze_event_handle_t hSignalEvent ) {return ZE_RESULT_SUCCESS;} - virtual ze_result_t zeCommandListUpdateMutableCommandWaitEventsExpPrologue( ze_command_list_handle_t hCommandList, uint64_t commandId, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents ) {return ZE_RESULT_SUCCESS;} - virtual ze_result_t zeCommandListUpdateMutableCommandWaitEventsExpEpilogue( ze_command_list_handle_t hCommandList, uint64_t commandId, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents ) {return ZE_RESULT_SUCCESS;} - virtual ze_result_t zeCommandListUpdateMutableCommandKernelsExpPrologue( ze_command_list_handle_t hCommandList, uint32_t numKernels, uint64_t* pCommandId, ze_kernel_handle_t* phKernels ) {return ZE_RESULT_SUCCESS;} - virtual ze_result_t zeCommandListUpdateMutableCommandKernelsExpEpilogue( ze_command_list_handle_t hCommandList, uint32_t numKernels, uint64_t* pCommandId, ze_kernel_handle_t* phKernels ) {return ZE_RESULT_SUCCESS;} virtual ze_result_t zeDeviceReserveCacheExtPrologue( ze_device_handle_t hDevice, size_t cacheLevel, size_t cacheReservationSize ) {return ZE_RESULT_SUCCESS;} virtual ze_result_t zeDeviceReserveCacheExtEpilogue( ze_device_handle_t hDevice, size_t cacheLevel, size_t cacheReservationSize ) {return ZE_RESULT_SUCCESS;} virtual ze_result_t zeDeviceSetCacheAdviceExtPrologue( ze_device_handle_t hDevice, void* ptr, size_t regionSize, ze_cache_ext_region_t cacheRegion ) {return ZE_RESULT_SUCCESS;} @@ -391,6 +379,18 @@ class ZEValidationEntryPoints { virtual ze_result_t zeCommandListCreateCloneExpEpilogue( ze_command_list_handle_t hCommandList, ze_command_list_handle_t* phClonedCommandList ) {return ZE_RESULT_SUCCESS;} virtual ze_result_t zeCommandListImmediateAppendCommandListsExpPrologue( ze_command_list_handle_t hCommandListImmediate, uint32_t numCommandLists, ze_command_list_handle_t* phCommandLists, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents ) {return ZE_RESULT_SUCCESS;} virtual ze_result_t zeCommandListImmediateAppendCommandListsExpEpilogue( ze_command_list_handle_t hCommandListImmediate, uint32_t numCommandLists, ze_command_list_handle_t* phCommandLists, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents ) {return ZE_RESULT_SUCCESS;} + virtual ze_result_t zeCommandListGetNextCommandIdExpPrologue( ze_command_list_handle_t hCommandList, const ze_mutable_command_id_exp_desc_t* desc, uint64_t* pCommandId ) {return ZE_RESULT_SUCCESS;} + virtual ze_result_t zeCommandListGetNextCommandIdExpEpilogue( ze_command_list_handle_t hCommandList, const ze_mutable_command_id_exp_desc_t* desc, uint64_t* pCommandId ) {return ZE_RESULT_SUCCESS;} + virtual ze_result_t zeCommandListGetNextCommandIdWithKernelsExpPrologue( ze_command_list_handle_t hCommandList, const ze_mutable_command_id_exp_desc_t* desc, uint32_t numKernels, ze_kernel_handle_t* phKernels, uint64_t* pCommandId ) {return ZE_RESULT_SUCCESS;} + virtual ze_result_t zeCommandListGetNextCommandIdWithKernelsExpEpilogue( ze_command_list_handle_t hCommandList, const ze_mutable_command_id_exp_desc_t* desc, uint32_t numKernels, ze_kernel_handle_t* phKernels, uint64_t* pCommandId ) {return ZE_RESULT_SUCCESS;} + virtual ze_result_t zeCommandListUpdateMutableCommandsExpPrologue( ze_command_list_handle_t hCommandList, const ze_mutable_commands_exp_desc_t* desc ) {return ZE_RESULT_SUCCESS;} + virtual ze_result_t zeCommandListUpdateMutableCommandsExpEpilogue( ze_command_list_handle_t hCommandList, const ze_mutable_commands_exp_desc_t* desc ) {return ZE_RESULT_SUCCESS;} + virtual ze_result_t zeCommandListUpdateMutableCommandSignalEventExpPrologue( ze_command_list_handle_t hCommandList, uint64_t commandId, ze_event_handle_t hSignalEvent ) {return ZE_RESULT_SUCCESS;} + virtual ze_result_t zeCommandListUpdateMutableCommandSignalEventExpEpilogue( ze_command_list_handle_t hCommandList, uint64_t commandId, ze_event_handle_t hSignalEvent ) {return ZE_RESULT_SUCCESS;} + virtual ze_result_t zeCommandListUpdateMutableCommandWaitEventsExpPrologue( ze_command_list_handle_t hCommandList, uint64_t commandId, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents ) {return ZE_RESULT_SUCCESS;} + virtual ze_result_t zeCommandListUpdateMutableCommandWaitEventsExpEpilogue( ze_command_list_handle_t hCommandList, uint64_t commandId, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents ) {return ZE_RESULT_SUCCESS;} + virtual ze_result_t zeCommandListUpdateMutableCommandKernelsExpPrologue( ze_command_list_handle_t hCommandList, uint32_t numKernels, uint64_t* pCommandId, ze_kernel_handle_t* phKernels ) {return ZE_RESULT_SUCCESS;} + virtual ze_result_t zeCommandListUpdateMutableCommandKernelsExpEpilogue( ze_command_list_handle_t hCommandList, uint32_t numKernels, uint64_t* pCommandId, ze_kernel_handle_t* phKernels ) {return ZE_RESULT_SUCCESS;} virtual ~ZEValidationEntryPoints() {} }; } \ No newline at end of file diff --git a/source/layers/validation/handle_lifetime_tracking/ze_handle_lifetime.cpp b/source/layers/validation/handle_lifetime_tracking/ze_handle_lifetime.cpp index 5e2bd8e6..a36d224a 100644 --- a/source/layers/validation/handle_lifetime_tracking/ze_handle_lifetime.cpp +++ b/source/layers/validation/handle_lifetime_tracking/ze_handle_lifetime.cpp @@ -2497,110 +2497,6 @@ namespace validation_layer return ZE_RESULT_SUCCESS; } ze_result_t - ZEHandleLifetimeValidation::zeCommandListGetNextCommandIdExpPrologue( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - const ze_mutable_command_id_exp_desc_t* desc, ///< [in] pointer to mutable command identifier descriptor - uint64_t* pCommandId ///< [out] pointer to mutable command identifier to be written - ) - { - - if ( !context.handleLifetime->isHandleValid( hCommandList )){ - return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; - } - return ZE_RESULT_SUCCESS; - } - ze_result_t - ZEHandleLifetimeValidation::zeCommandListGetNextCommandIdWithKernelsExpPrologue( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - const ze_mutable_command_id_exp_desc_t* desc, ///< [in][out] pointer to mutable command identifier descriptor - uint32_t numKernels, ///< [in][optional] number of entries on phKernels list - ze_kernel_handle_t* phKernels, ///< [in][optional][range(0, numKernels)] list of kernels that user can - ///< switch between using ::zeCommandListUpdateMutableCommandKernelsExp - ///< call - uint64_t* pCommandId ///< [out] pointer to mutable command identifier to be written - ) - { - - if ( !context.handleLifetime->isHandleValid( hCommandList )){ - return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; - } - for (size_t i = 0; ( nullptr != phKernels) && (i < numKernels); ++i){ - if (!context.handleLifetime->isHandleValid( phKernels[i] )){ - return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; - } - } - return ZE_RESULT_SUCCESS; - } - ze_result_t - ZEHandleLifetimeValidation::zeCommandListUpdateMutableCommandsExpPrologue( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - const ze_mutable_commands_exp_desc_t* desc ///< [in] pointer to mutable commands descriptor; multiple descriptors may - ///< be chained via `pNext` member - ) - { - - if ( !context.handleLifetime->isHandleValid( hCommandList )){ - return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; - } - return ZE_RESULT_SUCCESS; - } - ze_result_t - ZEHandleLifetimeValidation::zeCommandListUpdateMutableCommandSignalEventExpPrologue( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - uint64_t commandId, ///< [in] command identifier - ze_event_handle_t hSignalEvent ///< [in][optional] handle of the event to signal on completion - ) - { - - if ( !context.handleLifetime->isHandleValid( hCommandList )){ - return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; - } - if (hSignalEvent && !context.handleLifetime->isHandleValid( hSignalEvent )){ - return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; - } - return ZE_RESULT_SUCCESS; - } - ze_result_t - ZEHandleLifetimeValidation::zeCommandListUpdateMutableCommandWaitEventsExpPrologue( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - uint64_t commandId, ///< [in] command identifier - uint32_t numWaitEvents, ///< [in][optional] the number of wait events - ze_event_handle_t* phWaitEvents ///< [in][optional][range(0, numWaitEvents)] handle of the events to wait - ///< on before launching - ) - { - - if ( !context.handleLifetime->isHandleValid( hCommandList )){ - return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; - } - for (size_t i = 0; ( nullptr != phWaitEvents) && (i < numWaitEvents); ++i){ - if (!context.handleLifetime->isHandleValid( phWaitEvents[i] )){ - return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; - } - } - return ZE_RESULT_SUCCESS; - } - ze_result_t - ZEHandleLifetimeValidation::zeCommandListUpdateMutableCommandKernelsExpPrologue( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - uint32_t numKernels, ///< [in] the number of kernels to update - uint64_t* pCommandId, ///< [in][range(0, numKernels)] command identifier - ze_kernel_handle_t* phKernels ///< [in][range(0, numKernels)] handle of the kernel for a command - ///< identifier to switch to - ) - { - - if ( !context.handleLifetime->isHandleValid( hCommandList )){ - return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; - } - for (size_t i = 0; ( nullptr != phKernels) && (i < numKernels); ++i){ - if (!context.handleLifetime->isHandleValid( phKernels[i] )){ - return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; - } - } - return ZE_RESULT_SUCCESS; - } - ze_result_t ZEHandleLifetimeValidation::zeDeviceReserveCacheExtPrologue( ze_device_handle_t hDevice, ///< [in] handle of the device object size_t cacheLevel, ///< [in] cache level where application want to reserve. If zero, then the @@ -3207,4 +3103,108 @@ namespace validation_layer } return ZE_RESULT_SUCCESS; } + ze_result_t + ZEHandleLifetimeValidation::zeCommandListGetNextCommandIdExpPrologue( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + const ze_mutable_command_id_exp_desc_t* desc, ///< [in] pointer to mutable command identifier descriptor + uint64_t* pCommandId ///< [out] pointer to mutable command identifier to be written + ) + { + + if ( !context.handleLifetime->isHandleValid( hCommandList )){ + return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; + } + return ZE_RESULT_SUCCESS; + } + ze_result_t + ZEHandleLifetimeValidation::zeCommandListGetNextCommandIdWithKernelsExpPrologue( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + const ze_mutable_command_id_exp_desc_t* desc, ///< [in][out] pointer to mutable command identifier descriptor + uint32_t numKernels, ///< [in][optional] number of entries on phKernels list + ze_kernel_handle_t* phKernels, ///< [in][optional][range(0, numKernels)] list of kernels that user can + ///< switch between using ::zeCommandListUpdateMutableCommandKernelsExp + ///< call + uint64_t* pCommandId ///< [out] pointer to mutable command identifier to be written + ) + { + + if ( !context.handleLifetime->isHandleValid( hCommandList )){ + return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; + } + for (size_t i = 0; ( nullptr != phKernels) && (i < numKernels); ++i){ + if (!context.handleLifetime->isHandleValid( phKernels[i] )){ + return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; + } + } + return ZE_RESULT_SUCCESS; + } + ze_result_t + ZEHandleLifetimeValidation::zeCommandListUpdateMutableCommandsExpPrologue( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + const ze_mutable_commands_exp_desc_t* desc ///< [in] pointer to mutable commands descriptor; multiple descriptors may + ///< be chained via `pNext` member + ) + { + + if ( !context.handleLifetime->isHandleValid( hCommandList )){ + return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; + } + return ZE_RESULT_SUCCESS; + } + ze_result_t + ZEHandleLifetimeValidation::zeCommandListUpdateMutableCommandSignalEventExpPrologue( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + uint64_t commandId, ///< [in] command identifier + ze_event_handle_t hSignalEvent ///< [in][optional] handle of the event to signal on completion + ) + { + + if ( !context.handleLifetime->isHandleValid( hCommandList )){ + return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; + } + if (hSignalEvent && !context.handleLifetime->isHandleValid( hSignalEvent )){ + return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; + } + return ZE_RESULT_SUCCESS; + } + ze_result_t + ZEHandleLifetimeValidation::zeCommandListUpdateMutableCommandWaitEventsExpPrologue( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + uint64_t commandId, ///< [in] command identifier + uint32_t numWaitEvents, ///< [in][optional] the number of wait events + ze_event_handle_t* phWaitEvents ///< [in][optional][range(0, numWaitEvents)] handle of the events to wait + ///< on before launching + ) + { + + if ( !context.handleLifetime->isHandleValid( hCommandList )){ + return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; + } + for (size_t i = 0; ( nullptr != phWaitEvents) && (i < numWaitEvents); ++i){ + if (!context.handleLifetime->isHandleValid( phWaitEvents[i] )){ + return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; + } + } + return ZE_RESULT_SUCCESS; + } + ze_result_t + ZEHandleLifetimeValidation::zeCommandListUpdateMutableCommandKernelsExpPrologue( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + uint32_t numKernels, ///< [in] the number of kernels to update + uint64_t* pCommandId, ///< [in][range(0, numKernels)] command identifier + ze_kernel_handle_t* phKernels ///< [in][range(0, numKernels)] handle of the kernel for a command + ///< identifier to switch to + ) + { + + if ( !context.handleLifetime->isHandleValid( hCommandList )){ + return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; + } + for (size_t i = 0; ( nullptr != phKernels) && (i < numKernels); ++i){ + if (!context.handleLifetime->isHandleValid( phKernels[i] )){ + return ZE_RESULT_ERROR_INVALID_NULL_HANDLE; + } + } + return ZE_RESULT_SUCCESS; + } } \ No newline at end of file diff --git a/source/layers/validation/handle_lifetime_tracking/ze_handle_lifetime.h b/source/layers/validation/handle_lifetime_tracking/ze_handle_lifetime.h index 43f41ad1..a19d057e 100644 --- a/source/layers/validation/handle_lifetime_tracking/ze_handle_lifetime.h +++ b/source/layers/validation/handle_lifetime_tracking/ze_handle_lifetime.h @@ -162,12 +162,6 @@ namespace validation_layer ze_result_t zeVirtualMemSetAccessAttributePrologue( ze_context_handle_t hContext, const void* ptr, size_t size, ze_memory_access_attribute_t access ) override; ze_result_t zeVirtualMemGetAccessAttributePrologue( ze_context_handle_t hContext, const void* ptr, size_t size, ze_memory_access_attribute_t* access, size_t* outSize ) override; ze_result_t zeKernelSetGlobalOffsetExpPrologue( ze_kernel_handle_t hKernel, uint32_t offsetX, uint32_t offsetY, uint32_t offsetZ ) override; - ze_result_t zeCommandListGetNextCommandIdExpPrologue( ze_command_list_handle_t hCommandList, const ze_mutable_command_id_exp_desc_t* desc, uint64_t* pCommandId ) override; - ze_result_t zeCommandListGetNextCommandIdWithKernelsExpPrologue( ze_command_list_handle_t hCommandList, const ze_mutable_command_id_exp_desc_t* desc, uint32_t numKernels, ze_kernel_handle_t* phKernels, uint64_t* pCommandId ) override; - ze_result_t zeCommandListUpdateMutableCommandsExpPrologue( ze_command_list_handle_t hCommandList, const ze_mutable_commands_exp_desc_t* desc ) override; - ze_result_t zeCommandListUpdateMutableCommandSignalEventExpPrologue( ze_command_list_handle_t hCommandList, uint64_t commandId, ze_event_handle_t hSignalEvent ) override; - ze_result_t zeCommandListUpdateMutableCommandWaitEventsExpPrologue( ze_command_list_handle_t hCommandList, uint64_t commandId, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents ) override; - ze_result_t zeCommandListUpdateMutableCommandKernelsExpPrologue( ze_command_list_handle_t hCommandList, uint32_t numKernels, uint64_t* pCommandId, ze_kernel_handle_t* phKernels ) override; ze_result_t zeDeviceReserveCacheExtPrologue( ze_device_handle_t hDevice, size_t cacheLevel, size_t cacheReservationSize ) override; ze_result_t zeDeviceSetCacheAdviceExtPrologue( ze_device_handle_t hDevice, void* ptr, size_t regionSize, ze_cache_ext_region_t cacheRegion ) override; ze_result_t zeEventQueryTimestampsExpPrologue( ze_event_handle_t hEvent, ze_device_handle_t hDevice, uint32_t* pCount, ze_kernel_timestamp_result_t* pTimestamps ) override; @@ -203,6 +197,12 @@ namespace validation_layer ze_result_t zeImageGetDeviceOffsetExpPrologue( ze_image_handle_t hImage, uint64_t* pDeviceOffset ) override; ze_result_t zeCommandListCreateCloneExpPrologue( ze_command_list_handle_t hCommandList, ze_command_list_handle_t* phClonedCommandList ) override; ze_result_t zeCommandListImmediateAppendCommandListsExpPrologue( ze_command_list_handle_t hCommandListImmediate, uint32_t numCommandLists, ze_command_list_handle_t* phCommandLists, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents ) override; + ze_result_t zeCommandListGetNextCommandIdExpPrologue( ze_command_list_handle_t hCommandList, const ze_mutable_command_id_exp_desc_t* desc, uint64_t* pCommandId ) override; + ze_result_t zeCommandListGetNextCommandIdWithKernelsExpPrologue( ze_command_list_handle_t hCommandList, const ze_mutable_command_id_exp_desc_t* desc, uint32_t numKernels, ze_kernel_handle_t* phKernels, uint64_t* pCommandId ) override; + ze_result_t zeCommandListUpdateMutableCommandsExpPrologue( ze_command_list_handle_t hCommandList, const ze_mutable_commands_exp_desc_t* desc ) override; + ze_result_t zeCommandListUpdateMutableCommandSignalEventExpPrologue( ze_command_list_handle_t hCommandList, uint64_t commandId, ze_event_handle_t hSignalEvent ) override; + ze_result_t zeCommandListUpdateMutableCommandWaitEventsExpPrologue( ze_command_list_handle_t hCommandList, uint64_t commandId, uint32_t numWaitEvents, ze_event_handle_t* phWaitEvents ) override; + ze_result_t zeCommandListUpdateMutableCommandKernelsExpPrologue( ze_command_list_handle_t hCommandList, uint32_t numKernels, uint64_t* pCommandId, ze_kernel_handle_t* phKernels ) override; }; } diff --git a/source/layers/validation/ze_valddi.cpp b/source/layers/validation/ze_valddi.cpp index 0505abae..42251228 100644 --- a/source/layers/validation/ze_valddi.cpp +++ b/source/layers/validation/ze_valddi.cpp @@ -6381,268 +6381,6 @@ namespace validation_layer return result; } - /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeCommandListGetNextCommandIdExp - __zedlllocal ze_result_t ZE_APICALL - zeCommandListGetNextCommandIdExp( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - const ze_mutable_command_id_exp_desc_t* desc, ///< [in] pointer to mutable command identifier descriptor - uint64_t* pCommandId ///< [out] pointer to mutable command identifier to be written - ) - { - auto pfnGetNextCommandIdExp = context.zeDdiTable.CommandListExp.pfnGetNextCommandIdExp; - - if( nullptr == pfnGetNextCommandIdExp ) - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; - - auto numValHandlers = context.validationHandlers.size(); - for (size_t i = 0; i < numValHandlers; i++) { - auto result = context.validationHandlers[i]->zeValidation->zeCommandListGetNextCommandIdExpPrologue( hCommandList, desc, pCommandId ); - if(result!=ZE_RESULT_SUCCESS) return result; - } - - - if( context.enableThreadingValidation ){ - //Unimplemented - } - - - if(context.enableHandleLifetime ){ - auto result = context.handleLifetime->zeHandleLifetime.zeCommandListGetNextCommandIdExpPrologue( hCommandList, desc, pCommandId ); - if(result!=ZE_RESULT_SUCCESS) return result; - } - - auto result = pfnGetNextCommandIdExp( hCommandList, desc, pCommandId ); - - for (size_t i = 0; i < numValHandlers; i++) { - auto result = context.validationHandlers[i]->zeValidation->zeCommandListGetNextCommandIdExpEpilogue( hCommandList, desc, pCommandId ); - if(result!=ZE_RESULT_SUCCESS) return result; - } - - - if( result == ZE_RESULT_SUCCESS && context.enableHandleLifetime ){ - - } - return result; - } - - /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeCommandListGetNextCommandIdWithKernelsExp - __zedlllocal ze_result_t ZE_APICALL - zeCommandListGetNextCommandIdWithKernelsExp( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - const ze_mutable_command_id_exp_desc_t* desc, ///< [in][out] pointer to mutable command identifier descriptor - uint32_t numKernels, ///< [in][optional] number of entries on phKernels list - ze_kernel_handle_t* phKernels, ///< [in][optional][range(0, numKernels)] list of kernels that user can - ///< switch between using ::zeCommandListUpdateMutableCommandKernelsExp - ///< call - uint64_t* pCommandId ///< [out] pointer to mutable command identifier to be written - ) - { - auto pfnGetNextCommandIdWithKernelsExp = context.zeDdiTable.CommandListExp.pfnGetNextCommandIdWithKernelsExp; - - if( nullptr == pfnGetNextCommandIdWithKernelsExp ) - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; - - auto numValHandlers = context.validationHandlers.size(); - for (size_t i = 0; i < numValHandlers; i++) { - auto result = context.validationHandlers[i]->zeValidation->zeCommandListGetNextCommandIdWithKernelsExpPrologue( hCommandList, desc, numKernels, phKernels, pCommandId ); - if(result!=ZE_RESULT_SUCCESS) return result; - } - - - if( context.enableThreadingValidation ){ - //Unimplemented - } - - - if(context.enableHandleLifetime ){ - auto result = context.handleLifetime->zeHandleLifetime.zeCommandListGetNextCommandIdWithKernelsExpPrologue( hCommandList, desc, numKernels, phKernels, pCommandId ); - if(result!=ZE_RESULT_SUCCESS) return result; - } - - auto result = pfnGetNextCommandIdWithKernelsExp( hCommandList, desc, numKernels, phKernels, pCommandId ); - - for (size_t i = 0; i < numValHandlers; i++) { - auto result = context.validationHandlers[i]->zeValidation->zeCommandListGetNextCommandIdWithKernelsExpEpilogue( hCommandList, desc, numKernels, phKernels, pCommandId ); - if(result!=ZE_RESULT_SUCCESS) return result; - } - - - if( result == ZE_RESULT_SUCCESS && context.enableHandleLifetime ){ - - } - return result; - } - - /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeCommandListUpdateMutableCommandsExp - __zedlllocal ze_result_t ZE_APICALL - zeCommandListUpdateMutableCommandsExp( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - const ze_mutable_commands_exp_desc_t* desc ///< [in] pointer to mutable commands descriptor; multiple descriptors may - ///< be chained via `pNext` member - ) - { - auto pfnUpdateMutableCommandsExp = context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandsExp; - - if( nullptr == pfnUpdateMutableCommandsExp ) - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; - - auto numValHandlers = context.validationHandlers.size(); - for (size_t i = 0; i < numValHandlers; i++) { - auto result = context.validationHandlers[i]->zeValidation->zeCommandListUpdateMutableCommandsExpPrologue( hCommandList, desc ); - if(result!=ZE_RESULT_SUCCESS) return result; - } - - - if( context.enableThreadingValidation ){ - //Unimplemented - } - - - if(context.enableHandleLifetime ){ - auto result = context.handleLifetime->zeHandleLifetime.zeCommandListUpdateMutableCommandsExpPrologue( hCommandList, desc ); - if(result!=ZE_RESULT_SUCCESS) return result; - } - - auto result = pfnUpdateMutableCommandsExp( hCommandList, desc ); - - for (size_t i = 0; i < numValHandlers; i++) { - auto result = context.validationHandlers[i]->zeValidation->zeCommandListUpdateMutableCommandsExpEpilogue( hCommandList, desc ); - if(result!=ZE_RESULT_SUCCESS) return result; - } - - return result; - } - - /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeCommandListUpdateMutableCommandSignalEventExp - __zedlllocal ze_result_t ZE_APICALL - zeCommandListUpdateMutableCommandSignalEventExp( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - uint64_t commandId, ///< [in] command identifier - ze_event_handle_t hSignalEvent ///< [in][optional] handle of the event to signal on completion - ) - { - auto pfnUpdateMutableCommandSignalEventExp = context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandSignalEventExp; - - if( nullptr == pfnUpdateMutableCommandSignalEventExp ) - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; - - auto numValHandlers = context.validationHandlers.size(); - for (size_t i = 0; i < numValHandlers; i++) { - auto result = context.validationHandlers[i]->zeValidation->zeCommandListUpdateMutableCommandSignalEventExpPrologue( hCommandList, commandId, hSignalEvent ); - if(result!=ZE_RESULT_SUCCESS) return result; - } - - - if( context.enableThreadingValidation ){ - //Unimplemented - } - - - if(context.enableHandleLifetime ){ - auto result = context.handleLifetime->zeHandleLifetime.zeCommandListUpdateMutableCommandSignalEventExpPrologue( hCommandList, commandId, hSignalEvent ); - if(result!=ZE_RESULT_SUCCESS) return result; - } - - auto result = pfnUpdateMutableCommandSignalEventExp( hCommandList, commandId, hSignalEvent ); - - for (size_t i = 0; i < numValHandlers; i++) { - auto result = context.validationHandlers[i]->zeValidation->zeCommandListUpdateMutableCommandSignalEventExpEpilogue( hCommandList, commandId, hSignalEvent ); - if(result!=ZE_RESULT_SUCCESS) return result; - } - - return result; - } - - /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeCommandListUpdateMutableCommandWaitEventsExp - __zedlllocal ze_result_t ZE_APICALL - zeCommandListUpdateMutableCommandWaitEventsExp( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - uint64_t commandId, ///< [in] command identifier - uint32_t numWaitEvents, ///< [in][optional] the number of wait events - ze_event_handle_t* phWaitEvents ///< [in][optional][range(0, numWaitEvents)] handle of the events to wait - ///< on before launching - ) - { - auto pfnUpdateMutableCommandWaitEventsExp = context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandWaitEventsExp; - - if( nullptr == pfnUpdateMutableCommandWaitEventsExp ) - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; - - auto numValHandlers = context.validationHandlers.size(); - for (size_t i = 0; i < numValHandlers; i++) { - auto result = context.validationHandlers[i]->zeValidation->zeCommandListUpdateMutableCommandWaitEventsExpPrologue( hCommandList, commandId, numWaitEvents, phWaitEvents ); - if(result!=ZE_RESULT_SUCCESS) return result; - } - - - if( context.enableThreadingValidation ){ - //Unimplemented - } - - - if(context.enableHandleLifetime ){ - auto result = context.handleLifetime->zeHandleLifetime.zeCommandListUpdateMutableCommandWaitEventsExpPrologue( hCommandList, commandId, numWaitEvents, phWaitEvents ); - if(result!=ZE_RESULT_SUCCESS) return result; - } - - auto result = pfnUpdateMutableCommandWaitEventsExp( hCommandList, commandId, numWaitEvents, phWaitEvents ); - - for (size_t i = 0; i < numValHandlers; i++) { - auto result = context.validationHandlers[i]->zeValidation->zeCommandListUpdateMutableCommandWaitEventsExpEpilogue( hCommandList, commandId, numWaitEvents, phWaitEvents ); - if(result!=ZE_RESULT_SUCCESS) return result; - } - - return result; - } - - /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeCommandListUpdateMutableCommandKernelsExp - __zedlllocal ze_result_t ZE_APICALL - zeCommandListUpdateMutableCommandKernelsExp( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - uint32_t numKernels, ///< [in] the number of kernels to update - uint64_t* pCommandId, ///< [in][range(0, numKernels)] command identifier - ze_kernel_handle_t* phKernels ///< [in][range(0, numKernels)] handle of the kernel for a command - ///< identifier to switch to - ) - { - auto pfnUpdateMutableCommandKernelsExp = context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandKernelsExp; - - if( nullptr == pfnUpdateMutableCommandKernelsExp ) - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; - - auto numValHandlers = context.validationHandlers.size(); - for (size_t i = 0; i < numValHandlers; i++) { - auto result = context.validationHandlers[i]->zeValidation->zeCommandListUpdateMutableCommandKernelsExpPrologue( hCommandList, numKernels, pCommandId, phKernels ); - if(result!=ZE_RESULT_SUCCESS) return result; - } - - - if( context.enableThreadingValidation ){ - //Unimplemented - } - - - if(context.enableHandleLifetime ){ - auto result = context.handleLifetime->zeHandleLifetime.zeCommandListUpdateMutableCommandKernelsExpPrologue( hCommandList, numKernels, pCommandId, phKernels ); - if(result!=ZE_RESULT_SUCCESS) return result; - } - - auto result = pfnUpdateMutableCommandKernelsExp( hCommandList, numKernels, pCommandId, phKernels ); - - for (size_t i = 0; i < numValHandlers; i++) { - auto result = context.validationHandlers[i]->zeValidation->zeCommandListUpdateMutableCommandKernelsExpEpilogue( hCommandList, numKernels, pCommandId, phKernels ); - if(result!=ZE_RESULT_SUCCESS) return result; - } - - return result; - } - /////////////////////////////////////////////////////////////////////////////// /// @brief Intercept function for zeDeviceReserveCacheExt __zedlllocal ze_result_t ZE_APICALL @@ -7916,36 +7654,295 @@ namespace validation_layer if(context.enableHandleLifetime ){ - auto result = context.handleLifetime->zeHandleLifetime.zeRTASBuilderDestroyExpPrologue( hBuilder ); + auto result = context.handleLifetime->zeHandleLifetime.zeRTASBuilderDestroyExpPrologue( hBuilder ); + if(result!=ZE_RESULT_SUCCESS) return result; + } + + auto result = pfnDestroyExp( hBuilder ); + + for (size_t i = 0; i < numValHandlers; i++) { + auto result = context.validationHandlers[i]->zeValidation->zeRTASBuilderDestroyExpEpilogue( hBuilder ); + if(result!=ZE_RESULT_SUCCESS) return result; + } + + return result; + } + + /////////////////////////////////////////////////////////////////////////////// + /// @brief Intercept function for zeRTASParallelOperationCreateExp + __zedlllocal ze_result_t ZE_APICALL + zeRTASParallelOperationCreateExp( + ze_driver_handle_t hDriver, ///< [in] handle of driver object + ze_rtas_parallel_operation_exp_handle_t* phParallelOperation///< [out] handle of parallel operation object + ) + { + auto pfnCreateExp = context.zeDdiTable.RTASParallelOperationExp.pfnCreateExp; + + if( nullptr == pfnCreateExp ) + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + + auto numValHandlers = context.validationHandlers.size(); + for (size_t i = 0; i < numValHandlers; i++) { + auto result = context.validationHandlers[i]->zeValidation->zeRTASParallelOperationCreateExpPrologue( hDriver, phParallelOperation ); + if(result!=ZE_RESULT_SUCCESS) return result; + } + + + if( context.enableThreadingValidation ){ + //Unimplemented + } + + + if(context.enableHandleLifetime ){ + auto result = context.handleLifetime->zeHandleLifetime.zeRTASParallelOperationCreateExpPrologue( hDriver, phParallelOperation ); + if(result!=ZE_RESULT_SUCCESS) return result; + } + + auto result = pfnCreateExp( hDriver, phParallelOperation ); + + for (size_t i = 0; i < numValHandlers; i++) { + auto result = context.validationHandlers[i]->zeValidation->zeRTASParallelOperationCreateExpEpilogue( hDriver, phParallelOperation ); + if(result!=ZE_RESULT_SUCCESS) return result; + } + + + if( result == ZE_RESULT_SUCCESS && context.enableHandleLifetime ){ + + if (phParallelOperation){ + context.handleLifetime->addHandle( *phParallelOperation ); + context.handleLifetime->addDependent( hDriver, *phParallelOperation ); + + } + } + return result; + } + + /////////////////////////////////////////////////////////////////////////////// + /// @brief Intercept function for zeRTASParallelOperationGetPropertiesExp + __zedlllocal ze_result_t ZE_APICALL + zeRTASParallelOperationGetPropertiesExp( + ze_rtas_parallel_operation_exp_handle_t hParallelOperation, ///< [in] handle of parallel operation object + ze_rtas_parallel_operation_exp_properties_t* pProperties///< [in,out] query result for parallel operation properties + ) + { + auto pfnGetPropertiesExp = context.zeDdiTable.RTASParallelOperationExp.pfnGetPropertiesExp; + + if( nullptr == pfnGetPropertiesExp ) + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + + auto numValHandlers = context.validationHandlers.size(); + for (size_t i = 0; i < numValHandlers; i++) { + auto result = context.validationHandlers[i]->zeValidation->zeRTASParallelOperationGetPropertiesExpPrologue( hParallelOperation, pProperties ); + if(result!=ZE_RESULT_SUCCESS) return result; + } + + + if( context.enableThreadingValidation ){ + //Unimplemented + } + + + if(context.enableHandleLifetime ){ + auto result = context.handleLifetime->zeHandleLifetime.zeRTASParallelOperationGetPropertiesExpPrologue( hParallelOperation, pProperties ); + if(result!=ZE_RESULT_SUCCESS) return result; + } + + auto result = pfnGetPropertiesExp( hParallelOperation, pProperties ); + + for (size_t i = 0; i < numValHandlers; i++) { + auto result = context.validationHandlers[i]->zeValidation->zeRTASParallelOperationGetPropertiesExpEpilogue( hParallelOperation, pProperties ); + if(result!=ZE_RESULT_SUCCESS) return result; + } + + + if( result == ZE_RESULT_SUCCESS && context.enableHandleLifetime ){ + + } + return result; + } + + /////////////////////////////////////////////////////////////////////////////// + /// @brief Intercept function for zeRTASParallelOperationJoinExp + __zedlllocal ze_result_t ZE_APICALL + zeRTASParallelOperationJoinExp( + ze_rtas_parallel_operation_exp_handle_t hParallelOperation ///< [in] handle of parallel operation object + ) + { + auto pfnJoinExp = context.zeDdiTable.RTASParallelOperationExp.pfnJoinExp; + + if( nullptr == pfnJoinExp ) + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + + auto numValHandlers = context.validationHandlers.size(); + for (size_t i = 0; i < numValHandlers; i++) { + auto result = context.validationHandlers[i]->zeValidation->zeRTASParallelOperationJoinExpPrologue( hParallelOperation ); + if(result!=ZE_RESULT_SUCCESS) return result; + } + + + if( context.enableThreadingValidation ){ + //Unimplemented + } + + + if(context.enableHandleLifetime ){ + auto result = context.handleLifetime->zeHandleLifetime.zeRTASParallelOperationJoinExpPrologue( hParallelOperation ); + if(result!=ZE_RESULT_SUCCESS) return result; + } + + auto result = pfnJoinExp( hParallelOperation ); + + for (size_t i = 0; i < numValHandlers; i++) { + auto result = context.validationHandlers[i]->zeValidation->zeRTASParallelOperationJoinExpEpilogue( hParallelOperation ); + if(result!=ZE_RESULT_SUCCESS) return result; + } + + return result; + } + + /////////////////////////////////////////////////////////////////////////////// + /// @brief Intercept function for zeRTASParallelOperationDestroyExp + __zedlllocal ze_result_t ZE_APICALL + zeRTASParallelOperationDestroyExp( + ze_rtas_parallel_operation_exp_handle_t hParallelOperation ///< [in][release] handle of parallel operation object to destroy + ) + { + auto pfnDestroyExp = context.zeDdiTable.RTASParallelOperationExp.pfnDestroyExp; + + if( nullptr == pfnDestroyExp ) + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + + auto numValHandlers = context.validationHandlers.size(); + for (size_t i = 0; i < numValHandlers; i++) { + auto result = context.validationHandlers[i]->zeValidation->zeRTASParallelOperationDestroyExpPrologue( hParallelOperation ); + if(result!=ZE_RESULT_SUCCESS) return result; + } + + + if( context.enableThreadingValidation ){ + //Unimplemented + } + + + if(context.enableHandleLifetime ){ + auto result = context.handleLifetime->zeHandleLifetime.zeRTASParallelOperationDestroyExpPrologue( hParallelOperation ); + if(result!=ZE_RESULT_SUCCESS) return result; + } + + auto result = pfnDestroyExp( hParallelOperation ); + + for (size_t i = 0; i < numValHandlers; i++) { + auto result = context.validationHandlers[i]->zeValidation->zeRTASParallelOperationDestroyExpEpilogue( hParallelOperation ); + if(result!=ZE_RESULT_SUCCESS) return result; + } + + return result; + } + + /////////////////////////////////////////////////////////////////////////////// + /// @brief Intercept function for zeMemGetPitchFor2dImage + __zedlllocal ze_result_t ZE_APICALL + zeMemGetPitchFor2dImage( + ze_context_handle_t hContext, ///< [in] handle of the context object + ze_device_handle_t hDevice, ///< [in] handle of the device + size_t imageWidth, ///< [in] imageWidth + size_t imageHeight, ///< [in] imageHeight + unsigned int elementSizeInBytes, ///< [in] Element size in bytes + size_t * rowPitch ///< [out] rowPitch + ) + { + auto pfnGetPitchFor2dImage = context.zeDdiTable.Mem.pfnGetPitchFor2dImage; + + if( nullptr == pfnGetPitchFor2dImage ) + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + + auto numValHandlers = context.validationHandlers.size(); + for (size_t i = 0; i < numValHandlers; i++) { + auto result = context.validationHandlers[i]->zeValidation->zeMemGetPitchFor2dImagePrologue( hContext, hDevice, imageWidth, imageHeight, elementSizeInBytes, rowPitch ); + if(result!=ZE_RESULT_SUCCESS) return result; + } + + + if( context.enableThreadingValidation ){ + //Unimplemented + } + + + if(context.enableHandleLifetime ){ + auto result = context.handleLifetime->zeHandleLifetime.zeMemGetPitchFor2dImagePrologue( hContext, hDevice, imageWidth, imageHeight, elementSizeInBytes, rowPitch ); + if(result!=ZE_RESULT_SUCCESS) return result; + } + + auto result = pfnGetPitchFor2dImage( hContext, hDevice, imageWidth, imageHeight, elementSizeInBytes, rowPitch ); + + for (size_t i = 0; i < numValHandlers; i++) { + auto result = context.validationHandlers[i]->zeValidation->zeMemGetPitchFor2dImageEpilogue( hContext, hDevice, imageWidth, imageHeight, elementSizeInBytes, rowPitch ); + if(result!=ZE_RESULT_SUCCESS) return result; + } + + return result; + } + + /////////////////////////////////////////////////////////////////////////////// + /// @brief Intercept function for zeImageGetDeviceOffsetExp + __zedlllocal ze_result_t ZE_APICALL + zeImageGetDeviceOffsetExp( + ze_image_handle_t hImage, ///< [in] handle of the image + uint64_t* pDeviceOffset ///< [out] bindless device offset for image + ) + { + auto pfnGetDeviceOffsetExp = context.zeDdiTable.ImageExp.pfnGetDeviceOffsetExp; + + if( nullptr == pfnGetDeviceOffsetExp ) + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + + auto numValHandlers = context.validationHandlers.size(); + for (size_t i = 0; i < numValHandlers; i++) { + auto result = context.validationHandlers[i]->zeValidation->zeImageGetDeviceOffsetExpPrologue( hImage, pDeviceOffset ); + if(result!=ZE_RESULT_SUCCESS) return result; + } + + + if( context.enableThreadingValidation ){ + //Unimplemented + } + + + if(context.enableHandleLifetime ){ + auto result = context.handleLifetime->zeHandleLifetime.zeImageGetDeviceOffsetExpPrologue( hImage, pDeviceOffset ); if(result!=ZE_RESULT_SUCCESS) return result; } - auto result = pfnDestroyExp( hBuilder ); + auto result = pfnGetDeviceOffsetExp( hImage, pDeviceOffset ); for (size_t i = 0; i < numValHandlers; i++) { - auto result = context.validationHandlers[i]->zeValidation->zeRTASBuilderDestroyExpEpilogue( hBuilder ); + auto result = context.validationHandlers[i]->zeValidation->zeImageGetDeviceOffsetExpEpilogue( hImage, pDeviceOffset ); if(result!=ZE_RESULT_SUCCESS) return result; } + + if( result == ZE_RESULT_SUCCESS && context.enableHandleLifetime ){ + + } return result; } /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeRTASParallelOperationCreateExp + /// @brief Intercept function for zeCommandListCreateCloneExp __zedlllocal ze_result_t ZE_APICALL - zeRTASParallelOperationCreateExp( - ze_driver_handle_t hDriver, ///< [in] handle of driver object - ze_rtas_parallel_operation_exp_handle_t* phParallelOperation///< [out] handle of parallel operation object + zeCommandListCreateCloneExp( + ze_command_list_handle_t hCommandList, ///< [in] handle to source command list (the command list to clone) + ze_command_list_handle_t* phClonedCommandList ///< [out] pointer to handle of the cloned command list ) { - auto pfnCreateExp = context.zeDdiTable.RTASParallelOperationExp.pfnCreateExp; + auto pfnCreateCloneExp = context.zeDdiTable.CommandListExp.pfnCreateCloneExp; - if( nullptr == pfnCreateExp ) + if( nullptr == pfnCreateCloneExp ) return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; auto numValHandlers = context.validationHandlers.size(); for (size_t i = 0; i < numValHandlers; i++) { - auto result = context.validationHandlers[i]->zeValidation->zeRTASParallelOperationCreateExpPrologue( hDriver, phParallelOperation ); + auto result = context.validationHandlers[i]->zeValidation->zeCommandListCreateCloneExpPrologue( hCommandList, phClonedCommandList ); if(result!=ZE_RESULT_SUCCESS) return result; } @@ -7956,23 +7953,23 @@ namespace validation_layer if(context.enableHandleLifetime ){ - auto result = context.handleLifetime->zeHandleLifetime.zeRTASParallelOperationCreateExpPrologue( hDriver, phParallelOperation ); + auto result = context.handleLifetime->zeHandleLifetime.zeCommandListCreateCloneExpPrologue( hCommandList, phClonedCommandList ); if(result!=ZE_RESULT_SUCCESS) return result; } - auto result = pfnCreateExp( hDriver, phParallelOperation ); + auto result = pfnCreateCloneExp( hCommandList, phClonedCommandList ); for (size_t i = 0; i < numValHandlers; i++) { - auto result = context.validationHandlers[i]->zeValidation->zeRTASParallelOperationCreateExpEpilogue( hDriver, phParallelOperation ); + auto result = context.validationHandlers[i]->zeValidation->zeCommandListCreateCloneExpEpilogue( hCommandList, phClonedCommandList ); if(result!=ZE_RESULT_SUCCESS) return result; } if( result == ZE_RESULT_SUCCESS && context.enableHandleLifetime ){ - if (phParallelOperation){ - context.handleLifetime->addHandle( *phParallelOperation ); - context.handleLifetime->addDependent( hDriver, *phParallelOperation ); + if (phClonedCommandList){ + context.handleLifetime->addHandle( *phClonedCommandList ); + context.handleLifetime->addDependent( hCommandList, *phClonedCommandList ); } } @@ -7980,21 +7977,31 @@ namespace validation_layer } /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeRTASParallelOperationGetPropertiesExp + /// @brief Intercept function for zeCommandListImmediateAppendCommandListsExp __zedlllocal ze_result_t ZE_APICALL - zeRTASParallelOperationGetPropertiesExp( - ze_rtas_parallel_operation_exp_handle_t hParallelOperation, ///< [in] handle of parallel operation object - ze_rtas_parallel_operation_exp_properties_t* pProperties///< [in,out] query result for parallel operation properties + zeCommandListImmediateAppendCommandListsExp( + ze_command_list_handle_t hCommandListImmediate, ///< [in] handle of the immediate command list + uint32_t numCommandLists, ///< [in] number of command lists + ze_command_list_handle_t* phCommandLists, ///< [in][range(0, numCommandLists)] handles of command lists + ze_event_handle_t hSignalEvent, ///< [in][optional] handle of the event to signal on completion + ///< - if not null, this event is signaled after the completion of all + ///< appended command lists + uint32_t numWaitEvents, ///< [in][optional] number of events to wait on before executing appended + ///< command lists; must be 0 if nullptr == phWaitEvents + ze_event_handle_t* phWaitEvents ///< [in][optional][range(0, numWaitEvents)] handle of the events to wait + ///< on before executing appended command lists. + ///< - if not null, all wait events must be satisfied prior to the start + ///< of any appended command list(s) ) { - auto pfnGetPropertiesExp = context.zeDdiTable.RTASParallelOperationExp.pfnGetPropertiesExp; + auto pfnImmediateAppendCommandListsExp = context.zeDdiTable.CommandListExp.pfnImmediateAppendCommandListsExp; - if( nullptr == pfnGetPropertiesExp ) + if( nullptr == pfnImmediateAppendCommandListsExp ) return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; auto numValHandlers = context.validationHandlers.size(); for (size_t i = 0; i < numValHandlers; i++) { - auto result = context.validationHandlers[i]->zeValidation->zeRTASParallelOperationGetPropertiesExpPrologue( hParallelOperation, pProperties ); + auto result = context.validationHandlers[i]->zeValidation->zeCommandListImmediateAppendCommandListsExpPrologue( hCommandListImmediate, numCommandLists, phCommandLists, hSignalEvent, numWaitEvents, phWaitEvents ); if(result!=ZE_RESULT_SUCCESS) return result; } @@ -8005,39 +8012,37 @@ namespace validation_layer if(context.enableHandleLifetime ){ - auto result = context.handleLifetime->zeHandleLifetime.zeRTASParallelOperationGetPropertiesExpPrologue( hParallelOperation, pProperties ); + auto result = context.handleLifetime->zeHandleLifetime.zeCommandListImmediateAppendCommandListsExpPrologue( hCommandListImmediate, numCommandLists, phCommandLists, hSignalEvent, numWaitEvents, phWaitEvents ); if(result!=ZE_RESULT_SUCCESS) return result; } - auto result = pfnGetPropertiesExp( hParallelOperation, pProperties ); + auto result = pfnImmediateAppendCommandListsExp( hCommandListImmediate, numCommandLists, phCommandLists, hSignalEvent, numWaitEvents, phWaitEvents ); for (size_t i = 0; i < numValHandlers; i++) { - auto result = context.validationHandlers[i]->zeValidation->zeRTASParallelOperationGetPropertiesExpEpilogue( hParallelOperation, pProperties ); + auto result = context.validationHandlers[i]->zeValidation->zeCommandListImmediateAppendCommandListsExpEpilogue( hCommandListImmediate, numCommandLists, phCommandLists, hSignalEvent, numWaitEvents, phWaitEvents ); if(result!=ZE_RESULT_SUCCESS) return result; } - - if( result == ZE_RESULT_SUCCESS && context.enableHandleLifetime ){ - - } return result; } /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeRTASParallelOperationJoinExp + /// @brief Intercept function for zeCommandListGetNextCommandIdExp __zedlllocal ze_result_t ZE_APICALL - zeRTASParallelOperationJoinExp( - ze_rtas_parallel_operation_exp_handle_t hParallelOperation ///< [in] handle of parallel operation object + zeCommandListGetNextCommandIdExp( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + const ze_mutable_command_id_exp_desc_t* desc, ///< [in] pointer to mutable command identifier descriptor + uint64_t* pCommandId ///< [out] pointer to mutable command identifier to be written ) { - auto pfnJoinExp = context.zeDdiTable.RTASParallelOperationExp.pfnJoinExp; + auto pfnGetNextCommandIdExp = context.zeDdiTable.CommandListExp.pfnGetNextCommandIdExp; - if( nullptr == pfnJoinExp ) + if( nullptr == pfnGetNextCommandIdExp ) return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; auto numValHandlers = context.validationHandlers.size(); for (size_t i = 0; i < numValHandlers; i++) { - auto result = context.validationHandlers[i]->zeValidation->zeRTASParallelOperationJoinExpPrologue( hParallelOperation ); + auto result = context.validationHandlers[i]->zeValidation->zeCommandListGetNextCommandIdExpPrologue( hCommandList, desc, pCommandId ); if(result!=ZE_RESULT_SUCCESS) return result; } @@ -8048,35 +8053,45 @@ namespace validation_layer if(context.enableHandleLifetime ){ - auto result = context.handleLifetime->zeHandleLifetime.zeRTASParallelOperationJoinExpPrologue( hParallelOperation ); + auto result = context.handleLifetime->zeHandleLifetime.zeCommandListGetNextCommandIdExpPrologue( hCommandList, desc, pCommandId ); if(result!=ZE_RESULT_SUCCESS) return result; } - auto result = pfnJoinExp( hParallelOperation ); + auto result = pfnGetNextCommandIdExp( hCommandList, desc, pCommandId ); for (size_t i = 0; i < numValHandlers; i++) { - auto result = context.validationHandlers[i]->zeValidation->zeRTASParallelOperationJoinExpEpilogue( hParallelOperation ); + auto result = context.validationHandlers[i]->zeValidation->zeCommandListGetNextCommandIdExpEpilogue( hCommandList, desc, pCommandId ); if(result!=ZE_RESULT_SUCCESS) return result; } + + if( result == ZE_RESULT_SUCCESS && context.enableHandleLifetime ){ + + } return result; } /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeRTASParallelOperationDestroyExp + /// @brief Intercept function for zeCommandListGetNextCommandIdWithKernelsExp __zedlllocal ze_result_t ZE_APICALL - zeRTASParallelOperationDestroyExp( - ze_rtas_parallel_operation_exp_handle_t hParallelOperation ///< [in][release] handle of parallel operation object to destroy + zeCommandListGetNextCommandIdWithKernelsExp( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + const ze_mutable_command_id_exp_desc_t* desc, ///< [in][out] pointer to mutable command identifier descriptor + uint32_t numKernels, ///< [in][optional] number of entries on phKernels list + ze_kernel_handle_t* phKernels, ///< [in][optional][range(0, numKernels)] list of kernels that user can + ///< switch between using ::zeCommandListUpdateMutableCommandKernelsExp + ///< call + uint64_t* pCommandId ///< [out] pointer to mutable command identifier to be written ) { - auto pfnDestroyExp = context.zeDdiTable.RTASParallelOperationExp.pfnDestroyExp; + auto pfnGetNextCommandIdWithKernelsExp = context.zeDdiTable.CommandListExp.pfnGetNextCommandIdWithKernelsExp; - if( nullptr == pfnDestroyExp ) + if( nullptr == pfnGetNextCommandIdWithKernelsExp ) return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; auto numValHandlers = context.validationHandlers.size(); for (size_t i = 0; i < numValHandlers; i++) { - auto result = context.validationHandlers[i]->zeValidation->zeRTASParallelOperationDestroyExpPrologue( hParallelOperation ); + auto result = context.validationHandlers[i]->zeValidation->zeCommandListGetNextCommandIdWithKernelsExpPrologue( hCommandList, desc, numKernels, phKernels, pCommandId ); if(result!=ZE_RESULT_SUCCESS) return result; } @@ -8087,40 +8102,41 @@ namespace validation_layer if(context.enableHandleLifetime ){ - auto result = context.handleLifetime->zeHandleLifetime.zeRTASParallelOperationDestroyExpPrologue( hParallelOperation ); + auto result = context.handleLifetime->zeHandleLifetime.zeCommandListGetNextCommandIdWithKernelsExpPrologue( hCommandList, desc, numKernels, phKernels, pCommandId ); if(result!=ZE_RESULT_SUCCESS) return result; } - auto result = pfnDestroyExp( hParallelOperation ); + auto result = pfnGetNextCommandIdWithKernelsExp( hCommandList, desc, numKernels, phKernels, pCommandId ); for (size_t i = 0; i < numValHandlers; i++) { - auto result = context.validationHandlers[i]->zeValidation->zeRTASParallelOperationDestroyExpEpilogue( hParallelOperation ); + auto result = context.validationHandlers[i]->zeValidation->zeCommandListGetNextCommandIdWithKernelsExpEpilogue( hCommandList, desc, numKernels, phKernels, pCommandId ); if(result!=ZE_RESULT_SUCCESS) return result; } + + if( result == ZE_RESULT_SUCCESS && context.enableHandleLifetime ){ + + } return result; } /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeMemGetPitchFor2dImage + /// @brief Intercept function for zeCommandListUpdateMutableCommandsExp __zedlllocal ze_result_t ZE_APICALL - zeMemGetPitchFor2dImage( - ze_context_handle_t hContext, ///< [in] handle of the context object - ze_device_handle_t hDevice, ///< [in] handle of the device - size_t imageWidth, ///< [in] imageWidth - size_t imageHeight, ///< [in] imageHeight - unsigned int elementSizeInBytes, ///< [in] Element size in bytes - size_t * rowPitch ///< [out] rowPitch + zeCommandListUpdateMutableCommandsExp( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + const ze_mutable_commands_exp_desc_t* desc ///< [in] pointer to mutable commands descriptor; multiple descriptors may + ///< be chained via `pNext` member ) { - auto pfnGetPitchFor2dImage = context.zeDdiTable.Mem.pfnGetPitchFor2dImage; + auto pfnUpdateMutableCommandsExp = context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandsExp; - if( nullptr == pfnGetPitchFor2dImage ) + if( nullptr == pfnUpdateMutableCommandsExp ) return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; auto numValHandlers = context.validationHandlers.size(); for (size_t i = 0; i < numValHandlers; i++) { - auto result = context.validationHandlers[i]->zeValidation->zeMemGetPitchFor2dImagePrologue( hContext, hDevice, imageWidth, imageHeight, elementSizeInBytes, rowPitch ); + auto result = context.validationHandlers[i]->zeValidation->zeCommandListUpdateMutableCommandsExpPrologue( hCommandList, desc ); if(result!=ZE_RESULT_SUCCESS) return result; } @@ -8131,14 +8147,14 @@ namespace validation_layer if(context.enableHandleLifetime ){ - auto result = context.handleLifetime->zeHandleLifetime.zeMemGetPitchFor2dImagePrologue( hContext, hDevice, imageWidth, imageHeight, elementSizeInBytes, rowPitch ); + auto result = context.handleLifetime->zeHandleLifetime.zeCommandListUpdateMutableCommandsExpPrologue( hCommandList, desc ); if(result!=ZE_RESULT_SUCCESS) return result; } - auto result = pfnGetPitchFor2dImage( hContext, hDevice, imageWidth, imageHeight, elementSizeInBytes, rowPitch ); + auto result = pfnUpdateMutableCommandsExp( hCommandList, desc ); for (size_t i = 0; i < numValHandlers; i++) { - auto result = context.validationHandlers[i]->zeValidation->zeMemGetPitchFor2dImageEpilogue( hContext, hDevice, imageWidth, imageHeight, elementSizeInBytes, rowPitch ); + auto result = context.validationHandlers[i]->zeValidation->zeCommandListUpdateMutableCommandsExpEpilogue( hCommandList, desc ); if(result!=ZE_RESULT_SUCCESS) return result; } @@ -8146,21 +8162,22 @@ namespace validation_layer } /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeImageGetDeviceOffsetExp + /// @brief Intercept function for zeCommandListUpdateMutableCommandSignalEventExp __zedlllocal ze_result_t ZE_APICALL - zeImageGetDeviceOffsetExp( - ze_image_handle_t hImage, ///< [in] handle of the image - uint64_t* pDeviceOffset ///< [out] bindless device offset for image + zeCommandListUpdateMutableCommandSignalEventExp( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + uint64_t commandId, ///< [in] command identifier + ze_event_handle_t hSignalEvent ///< [in][optional] handle of the event to signal on completion ) { - auto pfnGetDeviceOffsetExp = context.zeDdiTable.ImageExp.pfnGetDeviceOffsetExp; + auto pfnUpdateMutableCommandSignalEventExp = context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandSignalEventExp; - if( nullptr == pfnGetDeviceOffsetExp ) + if( nullptr == pfnUpdateMutableCommandSignalEventExp ) return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; auto numValHandlers = context.validationHandlers.size(); for (size_t i = 0; i < numValHandlers; i++) { - auto result = context.validationHandlers[i]->zeValidation->zeImageGetDeviceOffsetExpPrologue( hImage, pDeviceOffset ); + auto result = context.validationHandlers[i]->zeValidation->zeCommandListUpdateMutableCommandSignalEventExpPrologue( hCommandList, commandId, hSignalEvent ); if(result!=ZE_RESULT_SUCCESS) return result; } @@ -8171,40 +8188,39 @@ namespace validation_layer if(context.enableHandleLifetime ){ - auto result = context.handleLifetime->zeHandleLifetime.zeImageGetDeviceOffsetExpPrologue( hImage, pDeviceOffset ); + auto result = context.handleLifetime->zeHandleLifetime.zeCommandListUpdateMutableCommandSignalEventExpPrologue( hCommandList, commandId, hSignalEvent ); if(result!=ZE_RESULT_SUCCESS) return result; } - auto result = pfnGetDeviceOffsetExp( hImage, pDeviceOffset ); + auto result = pfnUpdateMutableCommandSignalEventExp( hCommandList, commandId, hSignalEvent ); for (size_t i = 0; i < numValHandlers; i++) { - auto result = context.validationHandlers[i]->zeValidation->zeImageGetDeviceOffsetExpEpilogue( hImage, pDeviceOffset ); + auto result = context.validationHandlers[i]->zeValidation->zeCommandListUpdateMutableCommandSignalEventExpEpilogue( hCommandList, commandId, hSignalEvent ); if(result!=ZE_RESULT_SUCCESS) return result; } - - if( result == ZE_RESULT_SUCCESS && context.enableHandleLifetime ){ - - } return result; } /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeCommandListCreateCloneExp + /// @brief Intercept function for zeCommandListUpdateMutableCommandWaitEventsExp __zedlllocal ze_result_t ZE_APICALL - zeCommandListCreateCloneExp( - ze_command_list_handle_t hCommandList, ///< [in] handle to source command list (the command list to clone) - ze_command_list_handle_t* phClonedCommandList ///< [out] pointer to handle of the cloned command list + zeCommandListUpdateMutableCommandWaitEventsExp( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + uint64_t commandId, ///< [in] command identifier + uint32_t numWaitEvents, ///< [in][optional] the number of wait events + ze_event_handle_t* phWaitEvents ///< [in][optional][range(0, numWaitEvents)] handle of the events to wait + ///< on before launching ) { - auto pfnCreateCloneExp = context.zeDdiTable.CommandListExp.pfnCreateCloneExp; + auto pfnUpdateMutableCommandWaitEventsExp = context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandWaitEventsExp; - if( nullptr == pfnCreateCloneExp ) + if( nullptr == pfnUpdateMutableCommandWaitEventsExp ) return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; auto numValHandlers = context.validationHandlers.size(); for (size_t i = 0; i < numValHandlers; i++) { - auto result = context.validationHandlers[i]->zeValidation->zeCommandListCreateCloneExpPrologue( hCommandList, phClonedCommandList ); + auto result = context.validationHandlers[i]->zeValidation->zeCommandListUpdateMutableCommandWaitEventsExpPrologue( hCommandList, commandId, numWaitEvents, phWaitEvents ); if(result!=ZE_RESULT_SUCCESS) return result; } @@ -8215,55 +8231,39 @@ namespace validation_layer if(context.enableHandleLifetime ){ - auto result = context.handleLifetime->zeHandleLifetime.zeCommandListCreateCloneExpPrologue( hCommandList, phClonedCommandList ); + auto result = context.handleLifetime->zeHandleLifetime.zeCommandListUpdateMutableCommandWaitEventsExpPrologue( hCommandList, commandId, numWaitEvents, phWaitEvents ); if(result!=ZE_RESULT_SUCCESS) return result; } - auto result = pfnCreateCloneExp( hCommandList, phClonedCommandList ); + auto result = pfnUpdateMutableCommandWaitEventsExp( hCommandList, commandId, numWaitEvents, phWaitEvents ); for (size_t i = 0; i < numValHandlers; i++) { - auto result = context.validationHandlers[i]->zeValidation->zeCommandListCreateCloneExpEpilogue( hCommandList, phClonedCommandList ); + auto result = context.validationHandlers[i]->zeValidation->zeCommandListUpdateMutableCommandWaitEventsExpEpilogue( hCommandList, commandId, numWaitEvents, phWaitEvents ); if(result!=ZE_RESULT_SUCCESS) return result; } - - if( result == ZE_RESULT_SUCCESS && context.enableHandleLifetime ){ - - if (phClonedCommandList){ - context.handleLifetime->addHandle( *phClonedCommandList ); - context.handleLifetime->addDependent( hCommandList, *phClonedCommandList ); - - } - } return result; } /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeCommandListImmediateAppendCommandListsExp + /// @brief Intercept function for zeCommandListUpdateMutableCommandKernelsExp __zedlllocal ze_result_t ZE_APICALL - zeCommandListImmediateAppendCommandListsExp( - ze_command_list_handle_t hCommandListImmediate, ///< [in] handle of the immediate command list - uint32_t numCommandLists, ///< [in] number of command lists - ze_command_list_handle_t* phCommandLists, ///< [in][range(0, numCommandLists)] handles of command lists - ze_event_handle_t hSignalEvent, ///< [in][optional] handle of the event to signal on completion - ///< - if not null, this event is signaled after the completion of all - ///< appended command lists - uint32_t numWaitEvents, ///< [in][optional] number of events to wait on before executing appended - ///< command lists; must be 0 if nullptr == phWaitEvents - ze_event_handle_t* phWaitEvents ///< [in][optional][range(0, numWaitEvents)] handle of the events to wait - ///< on before executing appended command lists. - ///< - if not null, all wait events must be satisfied prior to the start - ///< of any appended command list(s) + zeCommandListUpdateMutableCommandKernelsExp( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + uint32_t numKernels, ///< [in] the number of kernels to update + uint64_t* pCommandId, ///< [in][range(0, numKernels)] command identifier + ze_kernel_handle_t* phKernels ///< [in][range(0, numKernels)] handle of the kernel for a command + ///< identifier to switch to ) { - auto pfnImmediateAppendCommandListsExp = context.zeDdiTable.CommandListExp.pfnImmediateAppendCommandListsExp; + auto pfnUpdateMutableCommandKernelsExp = context.zeDdiTable.CommandListExp.pfnUpdateMutableCommandKernelsExp; - if( nullptr == pfnImmediateAppendCommandListsExp ) + if( nullptr == pfnUpdateMutableCommandKernelsExp ) return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; auto numValHandlers = context.validationHandlers.size(); for (size_t i = 0; i < numValHandlers; i++) { - auto result = context.validationHandlers[i]->zeValidation->zeCommandListImmediateAppendCommandListsExpPrologue( hCommandListImmediate, numCommandLists, phCommandLists, hSignalEvent, numWaitEvents, phWaitEvents ); + auto result = context.validationHandlers[i]->zeValidation->zeCommandListUpdateMutableCommandKernelsExpPrologue( hCommandList, numKernels, pCommandId, phKernels ); if(result!=ZE_RESULT_SUCCESS) return result; } @@ -8274,14 +8274,14 @@ namespace validation_layer if(context.enableHandleLifetime ){ - auto result = context.handleLifetime->zeHandleLifetime.zeCommandListImmediateAppendCommandListsExpPrologue( hCommandListImmediate, numCommandLists, phCommandLists, hSignalEvent, numWaitEvents, phWaitEvents ); + auto result = context.handleLifetime->zeHandleLifetime.zeCommandListUpdateMutableCommandKernelsExpPrologue( hCommandList, numKernels, pCommandId, phKernels ); if(result!=ZE_RESULT_SUCCESS) return result; } - auto result = pfnImmediateAppendCommandListsExp( hCommandListImmediate, numCommandLists, phCommandLists, hSignalEvent, numWaitEvents, phWaitEvents ); + auto result = pfnUpdateMutableCommandKernelsExp( hCommandList, numKernels, pCommandId, phKernels ); for (size_t i = 0; i < numValHandlers; i++) { - auto result = context.validationHandlers[i]->zeValidation->zeCommandListImmediateAppendCommandListsExpEpilogue( hCommandListImmediate, numCommandLists, phCommandLists, hSignalEvent, numWaitEvents, phWaitEvents ); + auto result = context.validationHandlers[i]->zeValidation->zeCommandListUpdateMutableCommandKernelsExpEpilogue( hCommandList, numKernels, pCommandId, phKernels ); if(result!=ZE_RESULT_SUCCESS) return result; } @@ -8863,27 +8863,27 @@ zeGetCommandListExpProcAddrTable( dditable.pfnGetNextCommandIdWithKernelsExp = pDdiTable->pfnGetNextCommandIdWithKernelsExp; pDdiTable->pfnGetNextCommandIdWithKernelsExp = validation_layer::zeCommandListGetNextCommandIdWithKernelsExp; - dditable.pfnUpdateMutableCommandsExp = pDdiTable->pfnUpdateMutableCommandsExp; - pDdiTable->pfnUpdateMutableCommandsExp = validation_layer::zeCommandListUpdateMutableCommandsExp; - - dditable.pfnUpdateMutableCommandSignalEventExp = pDdiTable->pfnUpdateMutableCommandSignalEventExp; - pDdiTable->pfnUpdateMutableCommandSignalEventExp = validation_layer::zeCommandListUpdateMutableCommandSignalEventExp; - dditable.pfnUpdateMutableCommandKernelsExp = pDdiTable->pfnUpdateMutableCommandKernelsExp; pDdiTable->pfnUpdateMutableCommandKernelsExp = validation_layer::zeCommandListUpdateMutableCommandKernelsExp; dditable.pfnCreateCloneExp = pDdiTable->pfnCreateCloneExp; pDdiTable->pfnCreateCloneExp = validation_layer::zeCommandListCreateCloneExp; + dditable.pfnImmediateAppendCommandListsExp = pDdiTable->pfnImmediateAppendCommandListsExp; + pDdiTable->pfnImmediateAppendCommandListsExp = validation_layer::zeCommandListImmediateAppendCommandListsExp; + dditable.pfnGetNextCommandIdExp = pDdiTable->pfnGetNextCommandIdExp; pDdiTable->pfnGetNextCommandIdExp = validation_layer::zeCommandListGetNextCommandIdExp; + dditable.pfnUpdateMutableCommandsExp = pDdiTable->pfnUpdateMutableCommandsExp; + pDdiTable->pfnUpdateMutableCommandsExp = validation_layer::zeCommandListUpdateMutableCommandsExp; + + dditable.pfnUpdateMutableCommandSignalEventExp = pDdiTable->pfnUpdateMutableCommandSignalEventExp; + pDdiTable->pfnUpdateMutableCommandSignalEventExp = validation_layer::zeCommandListUpdateMutableCommandSignalEventExp; + dditable.pfnUpdateMutableCommandWaitEventsExp = pDdiTable->pfnUpdateMutableCommandWaitEventsExp; pDdiTable->pfnUpdateMutableCommandWaitEventsExp = validation_layer::zeCommandListUpdateMutableCommandWaitEventsExp; - dditable.pfnImmediateAppendCommandListsExp = pDdiTable->pfnImmediateAppendCommandListsExp; - pDdiTable->pfnImmediateAppendCommandListsExp = validation_layer::zeCommandListImmediateAppendCommandListsExp; - return result; } diff --git a/source/layers/validation/zet_valddi.cpp b/source/layers/validation/zet_valddi.cpp index ec2132f9..71c3cfef 100644 --- a/source/layers/validation/zet_valddi.cpp +++ b/source/layers/validation/zet_valddi.cpp @@ -3643,9 +3643,6 @@ zetGetMetricGroupExpProcAddrTable( ze_result_t result = ZE_RESULT_SUCCESS; - dditable.pfnCreateExp = pDdiTable->pfnCreateExp; - pDdiTable->pfnCreateExp = validation_layer::zetMetricGroupCreateExp; - dditable.pfnCalculateMultipleMetricValuesExp = pDdiTable->pfnCalculateMultipleMetricValuesExp; pDdiTable->pfnCalculateMultipleMetricValuesExp = validation_layer::zetMetricGroupCalculateMultipleMetricValuesExp; @@ -3658,6 +3655,9 @@ zetGetMetricGroupExpProcAddrTable( dditable.pfnCalculateMetricExportDataExp = pDdiTable->pfnCalculateMetricExportDataExp; pDdiTable->pfnCalculateMetricExportDataExp = validation_layer::zetMetricGroupCalculateMetricExportDataExp; + dditable.pfnCreateExp = pDdiTable->pfnCreateExp; + pDdiTable->pfnCreateExp = validation_layer::zetMetricGroupCreateExp; + dditable.pfnAddMetricExp = pDdiTable->pfnAddMetricExp; pDdiTable->pfnAddMetricExp = validation_layer::zetMetricGroupAddMetricExp; diff --git a/source/lib/ze_libapi.cpp b/source/lib/ze_libapi.cpp index 30e2e2d0..cdeea8db 100644 --- a/source/lib/ze_libapi.cpp +++ b/source/lib/ze_libapi.cpp @@ -7042,305 +7042,6 @@ zeKernelSetGlobalOffsetExp( return pfnSetGlobalOffsetExp( hKernel, offsetX, offsetY, offsetZ ); } -/////////////////////////////////////////////////////////////////////////////// -/// @brief Returns a unique command identifier for the next command to be -/// appended to a command list. -/// -/// @details -/// - This function may only be called for a mutable command list. -/// - This function may not be called on a closed command list. -/// - This function may be called from simultaneous threads with the same -/// command list handle. -/// - The implementation of this function should be lock-free. -/// -/// @returns -/// - ::ZE_RESULT_SUCCESS -/// - ::ZE_RESULT_ERROR_UNINITIALIZED -/// - ::ZE_RESULT_ERROR_DEVICE_LOST -/// - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY -/// - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY -/// - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE -/// + `nullptr == hCommandList` -/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER -/// + `nullptr == desc` -/// + `nullptr == pCommandId` -/// - ::ZE_RESULT_ERROR_INVALID_ENUMERATION -/// + `0xff < desc->flags` -ze_result_t ZE_APICALL -zeCommandListGetNextCommandIdExp( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - const ze_mutable_command_id_exp_desc_t* desc, ///< [in] pointer to mutable command identifier descriptor - uint64_t* pCommandId ///< [out] pointer to mutable command identifier to be written - ) -{ - if(ze_lib::context->inTeardown) { - return ZE_RESULT_ERROR_UNINITIALIZED; - } - - auto pfnGetNextCommandIdExp = ze_lib::context->zeDdiTable.load()->CommandListExp.pfnGetNextCommandIdExp; - if( nullptr == pfnGetNextCommandIdExp ) { - if(!ze_lib::context->isInitialized) - return ZE_RESULT_ERROR_UNINITIALIZED; - else - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; - } - - return pfnGetNextCommandIdExp( hCommandList, desc, pCommandId ); -} - -/////////////////////////////////////////////////////////////////////////////// -/// @brief Returns a unique command identifier for the next command to be -/// appended to a command list. Provides possible kernel handles for -/// kernel mutation when ::ZE_MUTABLE_COMMAND_EXP_FLAG_KERNEL_INSTRUCTION -/// flag is present. -/// -/// @details -/// - This function may only be called for a mutable command list. -/// - This function may not be called on a closed command list. -/// - This function may be called from simultaneous threads with the same -/// command list handle. -/// - The implementation of this function should be lock-free. -/// -/// @returns -/// - ::ZE_RESULT_SUCCESS -/// - ::ZE_RESULT_ERROR_UNINITIALIZED -/// - ::ZE_RESULT_ERROR_DEVICE_LOST -/// - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY -/// - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY -/// - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE -/// + `nullptr == hCommandList` -/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER -/// + `nullptr == desc` -/// + `nullptr == pCommandId` -/// - ::ZE_RESULT_ERROR_INVALID_ENUMERATION -/// + `0xff < desc->flags` -ze_result_t ZE_APICALL -zeCommandListGetNextCommandIdWithKernelsExp( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - const ze_mutable_command_id_exp_desc_t* desc, ///< [in][out] pointer to mutable command identifier descriptor - uint32_t numKernels, ///< [in][optional] number of entries on phKernels list - ze_kernel_handle_t* phKernels, ///< [in][optional][range(0, numKernels)] list of kernels that user can - ///< switch between using ::zeCommandListUpdateMutableCommandKernelsExp - ///< call - uint64_t* pCommandId ///< [out] pointer to mutable command identifier to be written - ) -{ - if(ze_lib::context->inTeardown) { - return ZE_RESULT_ERROR_UNINITIALIZED; - } - - auto pfnGetNextCommandIdWithKernelsExp = ze_lib::context->zeDdiTable.load()->CommandListExp.pfnGetNextCommandIdWithKernelsExp; - if( nullptr == pfnGetNextCommandIdWithKernelsExp ) { - if(!ze_lib::context->isInitialized) - return ZE_RESULT_ERROR_UNINITIALIZED; - else - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; - } - - return pfnGetNextCommandIdWithKernelsExp( hCommandList, desc, numKernels, phKernels, pCommandId ); -} - -/////////////////////////////////////////////////////////////////////////////// -/// @brief Updates mutable commands. -/// -/// @details -/// - This function may only be called for a mutable command list. -/// - The application must synchronize mutable command list execution before -/// calling this function. -/// - The application must close a mutable command list after completing all -/// updates. -/// - This function must not be called from simultaneous threads with the -/// same command list handle. -/// - The implementation of this function should be lock-free. -/// -/// @returns -/// - ::ZE_RESULT_SUCCESS -/// - ::ZE_RESULT_ERROR_UNINITIALIZED -/// - ::ZE_RESULT_ERROR_DEVICE_LOST -/// - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY -/// - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY -/// - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE -/// + `nullptr == hCommandList` -/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER -/// + `nullptr == desc` -/// - ::ZE_RESULT_ERROR_INVALID_ARGUMENT -/// + Invalid kernel argument or not matching update descriptor provided -ze_result_t ZE_APICALL -zeCommandListUpdateMutableCommandsExp( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - const ze_mutable_commands_exp_desc_t* desc ///< [in] pointer to mutable commands descriptor; multiple descriptors may - ///< be chained via `pNext` member - ) -{ - if(ze_lib::context->inTeardown) { - return ZE_RESULT_ERROR_UNINITIALIZED; - } - - auto pfnUpdateMutableCommandsExp = ze_lib::context->zeDdiTable.load()->CommandListExp.pfnUpdateMutableCommandsExp; - if( nullptr == pfnUpdateMutableCommandsExp ) { - if(!ze_lib::context->isInitialized) - return ZE_RESULT_ERROR_UNINITIALIZED; - else - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; - } - - return pfnUpdateMutableCommandsExp( hCommandList, desc ); -} - -/////////////////////////////////////////////////////////////////////////////// -/// @brief Updates the signal event for a mutable command in a mutable command -/// list. -/// -/// @details -/// - This function may only be called for a mutable command list. -/// - The type, scope and flags of the signal event must match those of the -/// source command. -/// - The application must synchronize mutable command list execution before -/// calling this function. -/// - The application must close a mutable command list after completing all -/// updates. -/// - This function must not be called from simultaneous threads with the -/// same command list handle. -/// - The implementation of this function should be lock-free. -/// -/// @returns -/// - ::ZE_RESULT_SUCCESS -/// - ::ZE_RESULT_ERROR_UNINITIALIZED -/// - ::ZE_RESULT_ERROR_DEVICE_LOST -/// - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY -/// - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY -/// - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE -/// + `nullptr == hCommandList` -ze_result_t ZE_APICALL -zeCommandListUpdateMutableCommandSignalEventExp( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - uint64_t commandId, ///< [in] command identifier - ze_event_handle_t hSignalEvent ///< [in][optional] handle of the event to signal on completion - ) -{ - if(ze_lib::context->inTeardown) { - return ZE_RESULT_ERROR_UNINITIALIZED; - } - - auto pfnUpdateMutableCommandSignalEventExp = ze_lib::context->zeDdiTable.load()->CommandListExp.pfnUpdateMutableCommandSignalEventExp; - if( nullptr == pfnUpdateMutableCommandSignalEventExp ) { - if(!ze_lib::context->isInitialized) - return ZE_RESULT_ERROR_UNINITIALIZED; - else - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; - } - - return pfnUpdateMutableCommandSignalEventExp( hCommandList, commandId, hSignalEvent ); -} - -/////////////////////////////////////////////////////////////////////////////// -/// @brief Updates the wait events for a mutable command in a mutable command -/// list. -/// -/// @details -/// - This function may only be called for a mutable command list. -/// - The number of wait events must match that of the source command. -/// - The type, scope and flags of the wait events must match those of the -/// source command. -/// - Passing `nullptr` as the wait events will update the command to not -/// wait on any events prior to dispatch. -/// - Passing `nullptr` as an event on event wait list will remove event -/// dependency from this wait list slot. -/// - The application must synchronize mutable command list execution before -/// calling this function. -/// - The application must close a mutable command list after completing all -/// updates. -/// - This function must not be called from simultaneous threads with the -/// same command list handle. -/// - The implementation of this function should be lock-free. -/// -/// @returns -/// - ::ZE_RESULT_SUCCESS -/// - ::ZE_RESULT_ERROR_UNINITIALIZED -/// - ::ZE_RESULT_ERROR_DEVICE_LOST -/// - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY -/// - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY -/// - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE -/// + `nullptr == hCommandList` -/// - ::ZE_RESULT_ERROR_INVALID_SIZE -/// + The `numWaitEvents` parameter does not match that of the original command. -ze_result_t ZE_APICALL -zeCommandListUpdateMutableCommandWaitEventsExp( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - uint64_t commandId, ///< [in] command identifier - uint32_t numWaitEvents, ///< [in][optional] the number of wait events - ze_event_handle_t* phWaitEvents ///< [in][optional][range(0, numWaitEvents)] handle of the events to wait - ///< on before launching - ) -{ - if(ze_lib::context->inTeardown) { - return ZE_RESULT_ERROR_UNINITIALIZED; - } - - auto pfnUpdateMutableCommandWaitEventsExp = ze_lib::context->zeDdiTable.load()->CommandListExp.pfnUpdateMutableCommandWaitEventsExp; - if( nullptr == pfnUpdateMutableCommandWaitEventsExp ) { - if(!ze_lib::context->isInitialized) - return ZE_RESULT_ERROR_UNINITIALIZED; - else - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; - } - - return pfnUpdateMutableCommandWaitEventsExp( hCommandList, commandId, numWaitEvents, phWaitEvents ); -} - -/////////////////////////////////////////////////////////////////////////////// -/// @brief Updates the kernel for a mutable command in a mutable command list. -/// -/// @details -/// - This function may only be called for a mutable command list. -/// - The kernel handle must be from the provided list for given command id. -/// - The application must synchronize mutable command list execution before -/// calling this function. -/// - The application must close a mutable command list after completing all -/// updates. -/// - This function must not be called from simultaneous threads with the -/// same command list handle. -/// - This function must be called before updating kernel arguments and -/// dispatch parameters, when kernel is mutated. -/// - The implementation of this function should be lock-free. -/// -/// @returns -/// - ::ZE_RESULT_SUCCESS -/// - ::ZE_RESULT_ERROR_UNINITIALIZED -/// - ::ZE_RESULT_ERROR_DEVICE_LOST -/// - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY -/// - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY -/// - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE -/// + `nullptr == hCommandList` -/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER -/// + `nullptr == pCommandId` -/// + `nullptr == phKernels` -/// - ::ZE_RESULT_ERROR_INVALID_KERNEL_HANDLE -/// + Invalid kernel handle provided for the mutation kernel instruction operation. -ze_result_t ZE_APICALL -zeCommandListUpdateMutableCommandKernelsExp( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - uint32_t numKernels, ///< [in] the number of kernels to update - uint64_t* pCommandId, ///< [in][range(0, numKernels)] command identifier - ze_kernel_handle_t* phKernels ///< [in][range(0, numKernels)] handle of the kernel for a command - ///< identifier to switch to - ) -{ - if(ze_lib::context->inTeardown) { - return ZE_RESULT_ERROR_UNINITIALIZED; - } - - auto pfnUpdateMutableCommandKernelsExp = ze_lib::context->zeDdiTable.load()->CommandListExp.pfnUpdateMutableCommandKernelsExp; - if( nullptr == pfnUpdateMutableCommandKernelsExp ) { - if(!ze_lib::context->isInitialized) - return ZE_RESULT_ERROR_UNINITIALIZED; - else - return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; - } - - return pfnUpdateMutableCommandKernelsExp( hCommandList, numKernels, pCommandId, phKernels ); -} - /////////////////////////////////////////////////////////////////////////////// /// @brief Reserve Cache on Device /// @@ -8803,23 +8504,291 @@ zeRTASParallelOperationGetPropertiesExp( return ZE_RESULT_ERROR_UNINITIALIZED; } - auto pfnGetPropertiesExp = ze_lib::context->zeDdiTable.load()->RTASParallelOperationExp.pfnGetPropertiesExp; - if( nullptr == pfnGetPropertiesExp ) { + auto pfnGetPropertiesExp = ze_lib::context->zeDdiTable.load()->RTASParallelOperationExp.pfnGetPropertiesExp; + if( nullptr == pfnGetPropertiesExp ) { + if(!ze_lib::context->isInitialized) + return ZE_RESULT_ERROR_UNINITIALIZED; + else + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + } + + return pfnGetPropertiesExp( hParallelOperation, pProperties ); +} + +/////////////////////////////////////////////////////////////////////////////// +/// @brief Joins a parallel build operation +/// +/// @details +/// - All worker threads return the same error code for the parallel build +/// operation upon build completion +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_DEVICE_LOST +/// - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY +/// - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY +/// - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE +/// + `nullptr == hParallelOperation` +ze_result_t ZE_APICALL +zeRTASParallelOperationJoinExp( + ze_rtas_parallel_operation_exp_handle_t hParallelOperation ///< [in] handle of parallel operation object + ) +{ + if(ze_lib::context->inTeardown) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } + + auto pfnJoinExp = ze_lib::context->zeDdiTable.load()->RTASParallelOperationExp.pfnJoinExp; + if( nullptr == pfnJoinExp ) { + if(!ze_lib::context->isInitialized) + return ZE_RESULT_ERROR_UNINITIALIZED; + else + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + } + + return pfnJoinExp( hParallelOperation ); +} + +/////////////////////////////////////////////////////////////////////////////// +/// @brief Destroys a ray tracing acceleration structure builder parallel +/// operation object +/// +/// @details +/// - The implementation of this function may immediately release any +/// internal Host and Device resources associated with this parallel +/// operation. +/// - The application must **not** call this function from simultaneous +/// threads with the same parallel operation handle. +/// - The implementation of this function must be thread-safe. +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_DEVICE_LOST +/// - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY +/// - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY +/// - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE +/// + `nullptr == hParallelOperation` +ze_result_t ZE_APICALL +zeRTASParallelOperationDestroyExp( + ze_rtas_parallel_operation_exp_handle_t hParallelOperation ///< [in][release] handle of parallel operation object to destroy + ) +{ + if(ze_lib::context->inTeardown) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } + + auto pfnDestroyExp = ze_lib::context->zeDdiTable.load()->RTASParallelOperationExp.pfnDestroyExp; + if( nullptr == pfnDestroyExp ) { + if(!ze_lib::context->isInitialized) + return ZE_RESULT_ERROR_UNINITIALIZED; + else + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + } + + return pfnDestroyExp( hParallelOperation ); +} + +/////////////////////////////////////////////////////////////////////////////// +/// @brief Allocate pitched USM memory for images +/// +/// @details +/// - Retrieves pitch for 2D image given the width, height and size in bytes +/// - The memory is then allocated using ::zeMemAllocDevice by providing +/// input size calculated as the returned pitch value multiplied by image height +/// - The application may call this function from simultaneous threads +/// - The implementation of this function must be thread-safe. +/// - The implementation of this function should be lock-free. +/// - The implementation must support ::ZE_experimental_bindless_image extension. +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_DEVICE_LOST +/// - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY +/// - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY +/// - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE +/// + `nullptr == hContext` +/// + `nullptr == hDevice` +ze_result_t ZE_APICALL +zeMemGetPitchFor2dImage( + ze_context_handle_t hContext, ///< [in] handle of the context object + ze_device_handle_t hDevice, ///< [in] handle of the device + size_t imageWidth, ///< [in] imageWidth + size_t imageHeight, ///< [in] imageHeight + unsigned int elementSizeInBytes, ///< [in] Element size in bytes + size_t * rowPitch ///< [out] rowPitch + ) +{ + if(ze_lib::context->inTeardown) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } + + auto pfnGetPitchFor2dImage = ze_lib::context->zeDdiTable.load()->Mem.pfnGetPitchFor2dImage; + if( nullptr == pfnGetPitchFor2dImage ) { + if(!ze_lib::context->isInitialized) + return ZE_RESULT_ERROR_UNINITIALIZED; + else + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + } + + return pfnGetPitchFor2dImage( hContext, hDevice, imageWidth, imageHeight, elementSizeInBytes, rowPitch ); +} + +/////////////////////////////////////////////////////////////////////////////// +/// @brief Get bindless device offset for image +/// +/// @details +/// - The application may call this function from simultaneous threads +/// - The implementation of this function must be thread-safe. +/// - The implementation of this function should be lock-free. +/// - The implementation must support ::ZE_experimental_bindless_image +/// extension. +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_DEVICE_LOST +/// - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY +/// - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY +/// - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE +/// + `nullptr == hImage` +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// + `nullptr == pDeviceOffset` +ze_result_t ZE_APICALL +zeImageGetDeviceOffsetExp( + ze_image_handle_t hImage, ///< [in] handle of the image + uint64_t* pDeviceOffset ///< [out] bindless device offset for image + ) +{ + if(ze_lib::context->inTeardown) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } + + auto pfnGetDeviceOffsetExp = ze_lib::context->zeDdiTable.load()->ImageExp.pfnGetDeviceOffsetExp; + if( nullptr == pfnGetDeviceOffsetExp ) { + if(!ze_lib::context->isInitialized) + return ZE_RESULT_ERROR_UNINITIALIZED; + else + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + } + + return pfnGetDeviceOffsetExp( hImage, pDeviceOffset ); +} + +/////////////////////////////////////////////////////////////////////////////// +/// @brief Creates a command list as the clone of another command list. +/// +/// @details +/// - The source command list must be created with the +/// ::ZE_COMMAND_LIST_FLAG_EXP_CLONEABLE flag. +/// - The source command list must be closed prior to cloning. +/// - The source command list may be cloned while it is running on the +/// device. +/// - The cloned command list inherits all properties of the source command +/// list. +/// - The cloned command list must be destroyed prior to the source command +/// list. +/// - The application must only use the command list for the device, or its +/// sub-devices, which was provided during creation. +/// - The application may call this function from simultaneous threads. +/// - The implementation of this function must be thread-safe. +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_DEVICE_LOST +/// - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY +/// - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY +/// - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE +/// + `nullptr == hCommandList` +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// + `nullptr == phClonedCommandList` +ze_result_t ZE_APICALL +zeCommandListCreateCloneExp( + ze_command_list_handle_t hCommandList, ///< [in] handle to source command list (the command list to clone) + ze_command_list_handle_t* phClonedCommandList ///< [out] pointer to handle of the cloned command list + ) +{ + if(ze_lib::context->inTeardown) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } + + auto pfnCreateCloneExp = ze_lib::context->zeDdiTable.load()->CommandListExp.pfnCreateCloneExp; + if( nullptr == pfnCreateCloneExp ) { + if(!ze_lib::context->isInitialized) + return ZE_RESULT_ERROR_UNINITIALIZED; + else + return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; + } + + return pfnCreateCloneExp( hCommandList, phClonedCommandList ); +} + +/////////////////////////////////////////////////////////////////////////////// +/// @brief Appends command lists to dispatch from an immediate command list. +/// +/// @details +/// - The application must call this function only with command lists +/// created with ::zeCommandListCreateImmediate. +/// - The command lists passed to this function in the `phCommandLists` +/// argument must be regular command lists (i.e. not immediate command +/// lists). +/// - The application may call this function from simultaneous threads. +/// - The implementation of this function should be lock-free. +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_DEVICE_LOST +/// - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY +/// - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY +/// - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE +/// + `nullptr == hCommandListImmediate` +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// + `nullptr == phCommandLists` +ze_result_t ZE_APICALL +zeCommandListImmediateAppendCommandListsExp( + ze_command_list_handle_t hCommandListImmediate, ///< [in] handle of the immediate command list + uint32_t numCommandLists, ///< [in] number of command lists + ze_command_list_handle_t* phCommandLists, ///< [in][range(0, numCommandLists)] handles of command lists + ze_event_handle_t hSignalEvent, ///< [in][optional] handle of the event to signal on completion + ///< - if not null, this event is signaled after the completion of all + ///< appended command lists + uint32_t numWaitEvents, ///< [in][optional] number of events to wait on before executing appended + ///< command lists; must be 0 if nullptr == phWaitEvents + ze_event_handle_t* phWaitEvents ///< [in][optional][range(0, numWaitEvents)] handle of the events to wait + ///< on before executing appended command lists. + ///< - if not null, all wait events must be satisfied prior to the start + ///< of any appended command list(s) + ) +{ + if(ze_lib::context->inTeardown) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } + + auto pfnImmediateAppendCommandListsExp = ze_lib::context->zeDdiTable.load()->CommandListExp.pfnImmediateAppendCommandListsExp; + if( nullptr == pfnImmediateAppendCommandListsExp ) { if(!ze_lib::context->isInitialized) return ZE_RESULT_ERROR_UNINITIALIZED; else return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; } - return pfnGetPropertiesExp( hParallelOperation, pProperties ); + return pfnImmediateAppendCommandListsExp( hCommandListImmediate, numCommandLists, phCommandLists, hSignalEvent, numWaitEvents, phWaitEvents ); } /////////////////////////////////////////////////////////////////////////////// -/// @brief Joins a parallel build operation +/// @brief Returns a unique command identifier for the next command to be +/// appended to a command list. /// /// @details -/// - All worker threads return the same error code for the parallel build -/// operation upon build completion +/// - This function may only be called for a mutable command list. +/// - This function may not be called on a closed command list. +/// - This function may be called from simultaneous threads with the same +/// command list handle. +/// - The implementation of this function should be lock-free. /// /// @returns /// - ::ZE_RESULT_SUCCESS @@ -8828,38 +8797,46 @@ zeRTASParallelOperationGetPropertiesExp( /// - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY /// - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY /// - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE -/// + `nullptr == hParallelOperation` +/// + `nullptr == hCommandList` +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// + `nullptr == desc` +/// + `nullptr == pCommandId` +/// - ::ZE_RESULT_ERROR_INVALID_ENUMERATION +/// + `0xff < desc->flags` ze_result_t ZE_APICALL -zeRTASParallelOperationJoinExp( - ze_rtas_parallel_operation_exp_handle_t hParallelOperation ///< [in] handle of parallel operation object +zeCommandListGetNextCommandIdExp( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + const ze_mutable_command_id_exp_desc_t* desc, ///< [in] pointer to mutable command identifier descriptor + uint64_t* pCommandId ///< [out] pointer to mutable command identifier to be written ) { if(ze_lib::context->inTeardown) { return ZE_RESULT_ERROR_UNINITIALIZED; } - auto pfnJoinExp = ze_lib::context->zeDdiTable.load()->RTASParallelOperationExp.pfnJoinExp; - if( nullptr == pfnJoinExp ) { + auto pfnGetNextCommandIdExp = ze_lib::context->zeDdiTable.load()->CommandListExp.pfnGetNextCommandIdExp; + if( nullptr == pfnGetNextCommandIdExp ) { if(!ze_lib::context->isInitialized) return ZE_RESULT_ERROR_UNINITIALIZED; else return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; } - return pfnJoinExp( hParallelOperation ); + return pfnGetNextCommandIdExp( hCommandList, desc, pCommandId ); } /////////////////////////////////////////////////////////////////////////////// -/// @brief Destroys a ray tracing acceleration structure builder parallel -/// operation object +/// @brief Returns a unique command identifier for the next command to be +/// appended to a command list. Provides possible kernel handles for +/// kernel mutation when ::ZE_MUTABLE_COMMAND_EXP_FLAG_KERNEL_INSTRUCTION +/// flag is present. /// /// @details -/// - The implementation of this function may immediately release any -/// internal Host and Device resources associated with this parallel -/// operation. -/// - The application must **not** call this function from simultaneous -/// threads with the same parallel operation handle. -/// - The implementation of this function must be thread-safe. +/// - This function may only be called for a mutable command list. +/// - This function may not be called on a closed command list. +/// - This function may be called from simultaneous threads with the same +/// command list handle. +/// - The implementation of this function should be lock-free. /// /// @returns /// - ::ZE_RESULT_SUCCESS @@ -8868,38 +8845,50 @@ zeRTASParallelOperationJoinExp( /// - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY /// - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY /// - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE -/// + `nullptr == hParallelOperation` +/// + `nullptr == hCommandList` +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// + `nullptr == desc` +/// + `nullptr == pCommandId` +/// - ::ZE_RESULT_ERROR_INVALID_ENUMERATION +/// + `0xff < desc->flags` ze_result_t ZE_APICALL -zeRTASParallelOperationDestroyExp( - ze_rtas_parallel_operation_exp_handle_t hParallelOperation ///< [in][release] handle of parallel operation object to destroy +zeCommandListGetNextCommandIdWithKernelsExp( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + const ze_mutable_command_id_exp_desc_t* desc, ///< [in][out] pointer to mutable command identifier descriptor + uint32_t numKernels, ///< [in][optional] number of entries on phKernels list + ze_kernel_handle_t* phKernels, ///< [in][optional][range(0, numKernels)] list of kernels that user can + ///< switch between using ::zeCommandListUpdateMutableCommandKernelsExp + ///< call + uint64_t* pCommandId ///< [out] pointer to mutable command identifier to be written ) { if(ze_lib::context->inTeardown) { return ZE_RESULT_ERROR_UNINITIALIZED; } - auto pfnDestroyExp = ze_lib::context->zeDdiTable.load()->RTASParallelOperationExp.pfnDestroyExp; - if( nullptr == pfnDestroyExp ) { + auto pfnGetNextCommandIdWithKernelsExp = ze_lib::context->zeDdiTable.load()->CommandListExp.pfnGetNextCommandIdWithKernelsExp; + if( nullptr == pfnGetNextCommandIdWithKernelsExp ) { if(!ze_lib::context->isInitialized) return ZE_RESULT_ERROR_UNINITIALIZED; else return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; } - return pfnDestroyExp( hParallelOperation ); + return pfnGetNextCommandIdWithKernelsExp( hCommandList, desc, numKernels, phKernels, pCommandId ); } /////////////////////////////////////////////////////////////////////////////// -/// @brief Allocate pitched USM memory for images +/// @brief Updates mutable commands. /// /// @details -/// - Retrieves pitch for 2D image given the width, height and size in bytes -/// - The memory is then allocated using ::zeMemAllocDevice by providing -/// input size calculated as the returned pitch value multiplied by image height -/// - The application may call this function from simultaneous threads -/// - The implementation of this function must be thread-safe. +/// - This function may only be called for a mutable command list. +/// - The application must synchronize mutable command list execution before +/// calling this function. +/// - The application must close a mutable command list after completing all +/// updates. +/// - This function must not be called from simultaneous threads with the +/// same command list handle. /// - The implementation of this function should be lock-free. -/// - The implementation must support ::ZE_experimental_bindless_image extension. /// /// @returns /// - ::ZE_RESULT_SUCCESS @@ -8908,42 +8897,48 @@ zeRTASParallelOperationDestroyExp( /// - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY /// - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY /// - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE -/// + `nullptr == hContext` -/// + `nullptr == hDevice` +/// + `nullptr == hCommandList` +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// + `nullptr == desc` +/// - ::ZE_RESULT_ERROR_INVALID_ARGUMENT +/// + Invalid kernel argument or not matching update descriptor provided ze_result_t ZE_APICALL -zeMemGetPitchFor2dImage( - ze_context_handle_t hContext, ///< [in] handle of the context object - ze_device_handle_t hDevice, ///< [in] handle of the device - size_t imageWidth, ///< [in] imageWidth - size_t imageHeight, ///< [in] imageHeight - unsigned int elementSizeInBytes, ///< [in] Element size in bytes - size_t * rowPitch ///< [out] rowPitch +zeCommandListUpdateMutableCommandsExp( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + const ze_mutable_commands_exp_desc_t* desc ///< [in] pointer to mutable commands descriptor; multiple descriptors may + ///< be chained via `pNext` member ) { if(ze_lib::context->inTeardown) { return ZE_RESULT_ERROR_UNINITIALIZED; } - auto pfnGetPitchFor2dImage = ze_lib::context->zeDdiTable.load()->Mem.pfnGetPitchFor2dImage; - if( nullptr == pfnGetPitchFor2dImage ) { + auto pfnUpdateMutableCommandsExp = ze_lib::context->zeDdiTable.load()->CommandListExp.pfnUpdateMutableCommandsExp; + if( nullptr == pfnUpdateMutableCommandsExp ) { if(!ze_lib::context->isInitialized) return ZE_RESULT_ERROR_UNINITIALIZED; else return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; } - return pfnGetPitchFor2dImage( hContext, hDevice, imageWidth, imageHeight, elementSizeInBytes, rowPitch ); + return pfnUpdateMutableCommandsExp( hCommandList, desc ); } /////////////////////////////////////////////////////////////////////////////// -/// @brief Get bindless device offset for image +/// @brief Updates the signal event for a mutable command in a mutable command +/// list. /// /// @details -/// - The application may call this function from simultaneous threads -/// - The implementation of this function must be thread-safe. +/// - This function may only be called for a mutable command list. +/// - The type, scope and flags of the signal event must match those of the +/// source command. +/// - The application must synchronize mutable command list execution before +/// calling this function. +/// - The application must close a mutable command list after completing all +/// updates. +/// - This function must not be called from simultaneous threads with the +/// same command list handle. /// - The implementation of this function should be lock-free. -/// - The implementation must support ::ZE_experimental_bindless_image -/// extension. /// /// @returns /// - ::ZE_RESULT_SUCCESS @@ -8952,47 +8947,49 @@ zeMemGetPitchFor2dImage( /// - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY /// - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY /// - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE -/// + `nullptr == hImage` -/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER -/// + `nullptr == pDeviceOffset` +/// + `nullptr == hCommandList` ze_result_t ZE_APICALL -zeImageGetDeviceOffsetExp( - ze_image_handle_t hImage, ///< [in] handle of the image - uint64_t* pDeviceOffset ///< [out] bindless device offset for image +zeCommandListUpdateMutableCommandSignalEventExp( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + uint64_t commandId, ///< [in] command identifier + ze_event_handle_t hSignalEvent ///< [in][optional] handle of the event to signal on completion ) { if(ze_lib::context->inTeardown) { return ZE_RESULT_ERROR_UNINITIALIZED; } - auto pfnGetDeviceOffsetExp = ze_lib::context->zeDdiTable.load()->ImageExp.pfnGetDeviceOffsetExp; - if( nullptr == pfnGetDeviceOffsetExp ) { + auto pfnUpdateMutableCommandSignalEventExp = ze_lib::context->zeDdiTable.load()->CommandListExp.pfnUpdateMutableCommandSignalEventExp; + if( nullptr == pfnUpdateMutableCommandSignalEventExp ) { if(!ze_lib::context->isInitialized) return ZE_RESULT_ERROR_UNINITIALIZED; else return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; } - return pfnGetDeviceOffsetExp( hImage, pDeviceOffset ); + return pfnUpdateMutableCommandSignalEventExp( hCommandList, commandId, hSignalEvent ); } /////////////////////////////////////////////////////////////////////////////// -/// @brief Creates a command list as the clone of another command list. +/// @brief Updates the wait events for a mutable command in a mutable command +/// list. /// /// @details -/// - The source command list must be created with the -/// ::ZE_COMMAND_LIST_FLAG_EXP_CLONEABLE flag. -/// - The source command list must be closed prior to cloning. -/// - The source command list may be cloned while it is running on the -/// device. -/// - The cloned command list inherits all properties of the source command -/// list. -/// - The cloned command list must be destroyed prior to the source command -/// list. -/// - The application must only use the command list for the device, or its -/// sub-devices, which was provided during creation. -/// - The application may call this function from simultaneous threads. -/// - The implementation of this function must be thread-safe. +/// - This function may only be called for a mutable command list. +/// - The number of wait events must match that of the source command. +/// - The type, scope and flags of the wait events must match those of the +/// source command. +/// - Passing `nullptr` as the wait events will update the command to not +/// wait on any events prior to dispatch. +/// - Passing `nullptr` as an event on event wait list will remove event +/// dependency from this wait list slot. +/// - The application must synchronize mutable command list execution before +/// calling this function. +/// - The application must close a mutable command list after completing all +/// updates. +/// - This function must not be called from simultaneous threads with the +/// same command list handle. +/// - The implementation of this function should be lock-free. /// /// @returns /// - ::ZE_RESULT_SUCCESS @@ -9002,39 +8999,46 @@ zeImageGetDeviceOffsetExp( /// - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY /// - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE /// + `nullptr == hCommandList` -/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER -/// + `nullptr == phClonedCommandList` +/// - ::ZE_RESULT_ERROR_INVALID_SIZE +/// + The `numWaitEvents` parameter does not match that of the original command. ze_result_t ZE_APICALL -zeCommandListCreateCloneExp( - ze_command_list_handle_t hCommandList, ///< [in] handle to source command list (the command list to clone) - ze_command_list_handle_t* phClonedCommandList ///< [out] pointer to handle of the cloned command list +zeCommandListUpdateMutableCommandWaitEventsExp( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + uint64_t commandId, ///< [in] command identifier + uint32_t numWaitEvents, ///< [in][optional] the number of wait events + ze_event_handle_t* phWaitEvents ///< [in][optional][range(0, numWaitEvents)] handle of the events to wait + ///< on before launching ) { if(ze_lib::context->inTeardown) { return ZE_RESULT_ERROR_UNINITIALIZED; } - auto pfnCreateCloneExp = ze_lib::context->zeDdiTable.load()->CommandListExp.pfnCreateCloneExp; - if( nullptr == pfnCreateCloneExp ) { + auto pfnUpdateMutableCommandWaitEventsExp = ze_lib::context->zeDdiTable.load()->CommandListExp.pfnUpdateMutableCommandWaitEventsExp; + if( nullptr == pfnUpdateMutableCommandWaitEventsExp ) { if(!ze_lib::context->isInitialized) return ZE_RESULT_ERROR_UNINITIALIZED; else return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; } - return pfnCreateCloneExp( hCommandList, phClonedCommandList ); + return pfnUpdateMutableCommandWaitEventsExp( hCommandList, commandId, numWaitEvents, phWaitEvents ); } /////////////////////////////////////////////////////////////////////////////// -/// @brief Appends command lists to dispatch from an immediate command list. +/// @brief Updates the kernel for a mutable command in a mutable command list. /// /// @details -/// - The application must call this function only with command lists -/// created with ::zeCommandListCreateImmediate. -/// - The command lists passed to this function in the `phCommandLists` -/// argument must be regular command lists (i.e. not immediate command -/// lists). -/// - The application may call this function from simultaneous threads. +/// - This function may only be called for a mutable command list. +/// - The kernel handle must be from the provided list for given command id. +/// - The application must synchronize mutable command list execution before +/// calling this function. +/// - The application must close a mutable command list after completing all +/// updates. +/// - This function must not be called from simultaneous threads with the +/// same command list handle. +/// - This function must be called before updating kernel arguments and +/// dispatch parameters, when kernel is mutated. /// - The implementation of this function should be lock-free. /// /// @returns @@ -9044,38 +9048,34 @@ zeCommandListCreateCloneExp( /// - ::ZE_RESULT_ERROR_OUT_OF_HOST_MEMORY /// - ::ZE_RESULT_ERROR_OUT_OF_DEVICE_MEMORY /// - ::ZE_RESULT_ERROR_INVALID_NULL_HANDLE -/// + `nullptr == hCommandListImmediate` +/// + `nullptr == hCommandList` /// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER -/// + `nullptr == phCommandLists` +/// + `nullptr == pCommandId` +/// + `nullptr == phKernels` +/// - ::ZE_RESULT_ERROR_INVALID_KERNEL_HANDLE +/// + Invalid kernel handle provided for the mutation kernel instruction operation. ze_result_t ZE_APICALL -zeCommandListImmediateAppendCommandListsExp( - ze_command_list_handle_t hCommandListImmediate, ///< [in] handle of the immediate command list - uint32_t numCommandLists, ///< [in] number of command lists - ze_command_list_handle_t* phCommandLists, ///< [in][range(0, numCommandLists)] handles of command lists - ze_event_handle_t hSignalEvent, ///< [in][optional] handle of the event to signal on completion - ///< - if not null, this event is signaled after the completion of all - ///< appended command lists - uint32_t numWaitEvents, ///< [in][optional] number of events to wait on before executing appended - ///< command lists; must be 0 if nullptr == phWaitEvents - ze_event_handle_t* phWaitEvents ///< [in][optional][range(0, numWaitEvents)] handle of the events to wait - ///< on before executing appended command lists. - ///< - if not null, all wait events must be satisfied prior to the start - ///< of any appended command list(s) +zeCommandListUpdateMutableCommandKernelsExp( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + uint32_t numKernels, ///< [in] the number of kernels to update + uint64_t* pCommandId, ///< [in][range(0, numKernels)] command identifier + ze_kernel_handle_t* phKernels ///< [in][range(0, numKernels)] handle of the kernel for a command + ///< identifier to switch to ) { if(ze_lib::context->inTeardown) { return ZE_RESULT_ERROR_UNINITIALIZED; } - auto pfnImmediateAppendCommandListsExp = ze_lib::context->zeDdiTable.load()->CommandListExp.pfnImmediateAppendCommandListsExp; - if( nullptr == pfnImmediateAppendCommandListsExp ) { + auto pfnUpdateMutableCommandKernelsExp = ze_lib::context->zeDdiTable.load()->CommandListExp.pfnUpdateMutableCommandKernelsExp; + if( nullptr == pfnUpdateMutableCommandKernelsExp ) { if(!ze_lib::context->isInitialized) return ZE_RESULT_ERROR_UNINITIALIZED; else return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; } - return pfnImmediateAppendCommandListsExp( hCommandListImmediate, numCommandLists, phCommandLists, hSignalEvent, numWaitEvents, phWaitEvents ); + return pfnUpdateMutableCommandKernelsExp( hCommandList, numKernels, pCommandId, phKernels ); } } // extern "C" diff --git a/source/lib/ze_tracing_register_cb_libapi.cpp b/source/lib/ze_tracing_register_cb_libapi.cpp index 8fafc55b..7f2ea268 100644 --- a/source/lib/ze_tracing_register_cb_libapi.cpp +++ b/source/lib/ze_tracing_register_cb_libapi.cpp @@ -3668,156 +3668,6 @@ zelTracerKernelSetGlobalOffsetExpRegisterCallback( } -ZE_APIEXPORT ze_result_t ZE_APICALL -zelTracerCommandListGetNextCommandIdExpRegisterCallback( - zel_tracer_handle_t hTracer, - zel_tracer_reg_t callback_type, - ze_pfnCommandListGetNextCommandIdExpCb_t pfnGetNextCommandIdExpCb - ) { - - if(!ze_lib::context->tracing_lib) - return ZE_RESULT_ERROR_UNINITIALIZED; - typedef ze_result_t (ZE_APICALL *ze_pfnSetCallback_t)( - zel_tracer_handle_t hTracer, - zel_tracer_reg_t callback_type, - ze_pfnCommandListGetNextCommandIdExpCb_t pfnGetNextCommandIdExpCb - ); - - auto func = reinterpret_cast( - GET_FUNCTION_PTR(ze_lib::context->tracing_lib, "zelTracerCommandListGetNextCommandIdExpRegisterCallback") ); - - if(func) - return func(hTracer, callback_type, pfnGetNextCommandIdExpCb); - - return ZE_RESULT_ERROR_UNINITIALIZED; -} - - -ZE_APIEXPORT ze_result_t ZE_APICALL -zelTracerCommandListGetNextCommandIdWithKernelsExpRegisterCallback( - zel_tracer_handle_t hTracer, - zel_tracer_reg_t callback_type, - ze_pfnCommandListGetNextCommandIdWithKernelsExpCb_t pfnGetNextCommandIdWithKernelsExpCb - ) { - - if(!ze_lib::context->tracing_lib) - return ZE_RESULT_ERROR_UNINITIALIZED; - typedef ze_result_t (ZE_APICALL *ze_pfnSetCallback_t)( - zel_tracer_handle_t hTracer, - zel_tracer_reg_t callback_type, - ze_pfnCommandListGetNextCommandIdWithKernelsExpCb_t pfnGetNextCommandIdWithKernelsExpCb - ); - - auto func = reinterpret_cast( - GET_FUNCTION_PTR(ze_lib::context->tracing_lib, "zelTracerCommandListGetNextCommandIdWithKernelsExpRegisterCallback") ); - - if(func) - return func(hTracer, callback_type, pfnGetNextCommandIdWithKernelsExpCb); - - return ZE_RESULT_ERROR_UNINITIALIZED; -} - - -ZE_APIEXPORT ze_result_t ZE_APICALL -zelTracerCommandListUpdateMutableCommandsExpRegisterCallback( - zel_tracer_handle_t hTracer, - zel_tracer_reg_t callback_type, - ze_pfnCommandListUpdateMutableCommandsExpCb_t pfnUpdateMutableCommandsExpCb - ) { - - if(!ze_lib::context->tracing_lib) - return ZE_RESULT_ERROR_UNINITIALIZED; - typedef ze_result_t (ZE_APICALL *ze_pfnSetCallback_t)( - zel_tracer_handle_t hTracer, - zel_tracer_reg_t callback_type, - ze_pfnCommandListUpdateMutableCommandsExpCb_t pfnUpdateMutableCommandsExpCb - ); - - auto func = reinterpret_cast( - GET_FUNCTION_PTR(ze_lib::context->tracing_lib, "zelTracerCommandListUpdateMutableCommandsExpRegisterCallback") ); - - if(func) - return func(hTracer, callback_type, pfnUpdateMutableCommandsExpCb); - - return ZE_RESULT_ERROR_UNINITIALIZED; -} - - -ZE_APIEXPORT ze_result_t ZE_APICALL -zelTracerCommandListUpdateMutableCommandSignalEventExpRegisterCallback( - zel_tracer_handle_t hTracer, - zel_tracer_reg_t callback_type, - ze_pfnCommandListUpdateMutableCommandSignalEventExpCb_t pfnUpdateMutableCommandSignalEventExpCb - ) { - - if(!ze_lib::context->tracing_lib) - return ZE_RESULT_ERROR_UNINITIALIZED; - typedef ze_result_t (ZE_APICALL *ze_pfnSetCallback_t)( - zel_tracer_handle_t hTracer, - zel_tracer_reg_t callback_type, - ze_pfnCommandListUpdateMutableCommandSignalEventExpCb_t pfnUpdateMutableCommandSignalEventExpCb - ); - - auto func = reinterpret_cast( - GET_FUNCTION_PTR(ze_lib::context->tracing_lib, "zelTracerCommandListUpdateMutableCommandSignalEventExpRegisterCallback") ); - - if(func) - return func(hTracer, callback_type, pfnUpdateMutableCommandSignalEventExpCb); - - return ZE_RESULT_ERROR_UNINITIALIZED; -} - - -ZE_APIEXPORT ze_result_t ZE_APICALL -zelTracerCommandListUpdateMutableCommandWaitEventsExpRegisterCallback( - zel_tracer_handle_t hTracer, - zel_tracer_reg_t callback_type, - ze_pfnCommandListUpdateMutableCommandWaitEventsExpCb_t pfnUpdateMutableCommandWaitEventsExpCb - ) { - - if(!ze_lib::context->tracing_lib) - return ZE_RESULT_ERROR_UNINITIALIZED; - typedef ze_result_t (ZE_APICALL *ze_pfnSetCallback_t)( - zel_tracer_handle_t hTracer, - zel_tracer_reg_t callback_type, - ze_pfnCommandListUpdateMutableCommandWaitEventsExpCb_t pfnUpdateMutableCommandWaitEventsExpCb - ); - - auto func = reinterpret_cast( - GET_FUNCTION_PTR(ze_lib::context->tracing_lib, "zelTracerCommandListUpdateMutableCommandWaitEventsExpRegisterCallback") ); - - if(func) - return func(hTracer, callback_type, pfnUpdateMutableCommandWaitEventsExpCb); - - return ZE_RESULT_ERROR_UNINITIALIZED; -} - - -ZE_APIEXPORT ze_result_t ZE_APICALL -zelTracerCommandListUpdateMutableCommandKernelsExpRegisterCallback( - zel_tracer_handle_t hTracer, - zel_tracer_reg_t callback_type, - ze_pfnCommandListUpdateMutableCommandKernelsExpCb_t pfnUpdateMutableCommandKernelsExpCb - ) { - - if(!ze_lib::context->tracing_lib) - return ZE_RESULT_ERROR_UNINITIALIZED; - typedef ze_result_t (ZE_APICALL *ze_pfnSetCallback_t)( - zel_tracer_handle_t hTracer, - zel_tracer_reg_t callback_type, - ze_pfnCommandListUpdateMutableCommandKernelsExpCb_t pfnUpdateMutableCommandKernelsExpCb - ); - - auto func = reinterpret_cast( - GET_FUNCTION_PTR(ze_lib::context->tracing_lib, "zelTracerCommandListUpdateMutableCommandKernelsExpRegisterCallback") ); - - if(func) - return func(hTracer, callback_type, pfnUpdateMutableCommandKernelsExpCb); - - return ZE_RESULT_ERROR_UNINITIALIZED; -} - - ZE_APIEXPORT ze_result_t ZE_APICALL zelTracerDeviceReserveCacheExtRegisterCallback( zel_tracer_handle_t hTracer, @@ -4693,4 +4543,154 @@ zelTracerCommandListImmediateAppendCommandListsExpRegisterCallback( } +ZE_APIEXPORT ze_result_t ZE_APICALL +zelTracerCommandListGetNextCommandIdExpRegisterCallback( + zel_tracer_handle_t hTracer, + zel_tracer_reg_t callback_type, + ze_pfnCommandListGetNextCommandIdExpCb_t pfnGetNextCommandIdExpCb + ) { + + if(!ze_lib::context->tracing_lib) + return ZE_RESULT_ERROR_UNINITIALIZED; + typedef ze_result_t (ZE_APICALL *ze_pfnSetCallback_t)( + zel_tracer_handle_t hTracer, + zel_tracer_reg_t callback_type, + ze_pfnCommandListGetNextCommandIdExpCb_t pfnGetNextCommandIdExpCb + ); + + auto func = reinterpret_cast( + GET_FUNCTION_PTR(ze_lib::context->tracing_lib, "zelTracerCommandListGetNextCommandIdExpRegisterCallback") ); + + if(func) + return func(hTracer, callback_type, pfnGetNextCommandIdExpCb); + + return ZE_RESULT_ERROR_UNINITIALIZED; +} + + +ZE_APIEXPORT ze_result_t ZE_APICALL +zelTracerCommandListGetNextCommandIdWithKernelsExpRegisterCallback( + zel_tracer_handle_t hTracer, + zel_tracer_reg_t callback_type, + ze_pfnCommandListGetNextCommandIdWithKernelsExpCb_t pfnGetNextCommandIdWithKernelsExpCb + ) { + + if(!ze_lib::context->tracing_lib) + return ZE_RESULT_ERROR_UNINITIALIZED; + typedef ze_result_t (ZE_APICALL *ze_pfnSetCallback_t)( + zel_tracer_handle_t hTracer, + zel_tracer_reg_t callback_type, + ze_pfnCommandListGetNextCommandIdWithKernelsExpCb_t pfnGetNextCommandIdWithKernelsExpCb + ); + + auto func = reinterpret_cast( + GET_FUNCTION_PTR(ze_lib::context->tracing_lib, "zelTracerCommandListGetNextCommandIdWithKernelsExpRegisterCallback") ); + + if(func) + return func(hTracer, callback_type, pfnGetNextCommandIdWithKernelsExpCb); + + return ZE_RESULT_ERROR_UNINITIALIZED; +} + + +ZE_APIEXPORT ze_result_t ZE_APICALL +zelTracerCommandListUpdateMutableCommandsExpRegisterCallback( + zel_tracer_handle_t hTracer, + zel_tracer_reg_t callback_type, + ze_pfnCommandListUpdateMutableCommandsExpCb_t pfnUpdateMutableCommandsExpCb + ) { + + if(!ze_lib::context->tracing_lib) + return ZE_RESULT_ERROR_UNINITIALIZED; + typedef ze_result_t (ZE_APICALL *ze_pfnSetCallback_t)( + zel_tracer_handle_t hTracer, + zel_tracer_reg_t callback_type, + ze_pfnCommandListUpdateMutableCommandsExpCb_t pfnUpdateMutableCommandsExpCb + ); + + auto func = reinterpret_cast( + GET_FUNCTION_PTR(ze_lib::context->tracing_lib, "zelTracerCommandListUpdateMutableCommandsExpRegisterCallback") ); + + if(func) + return func(hTracer, callback_type, pfnUpdateMutableCommandsExpCb); + + return ZE_RESULT_ERROR_UNINITIALIZED; +} + + +ZE_APIEXPORT ze_result_t ZE_APICALL +zelTracerCommandListUpdateMutableCommandSignalEventExpRegisterCallback( + zel_tracer_handle_t hTracer, + zel_tracer_reg_t callback_type, + ze_pfnCommandListUpdateMutableCommandSignalEventExpCb_t pfnUpdateMutableCommandSignalEventExpCb + ) { + + if(!ze_lib::context->tracing_lib) + return ZE_RESULT_ERROR_UNINITIALIZED; + typedef ze_result_t (ZE_APICALL *ze_pfnSetCallback_t)( + zel_tracer_handle_t hTracer, + zel_tracer_reg_t callback_type, + ze_pfnCommandListUpdateMutableCommandSignalEventExpCb_t pfnUpdateMutableCommandSignalEventExpCb + ); + + auto func = reinterpret_cast( + GET_FUNCTION_PTR(ze_lib::context->tracing_lib, "zelTracerCommandListUpdateMutableCommandSignalEventExpRegisterCallback") ); + + if(func) + return func(hTracer, callback_type, pfnUpdateMutableCommandSignalEventExpCb); + + return ZE_RESULT_ERROR_UNINITIALIZED; +} + + +ZE_APIEXPORT ze_result_t ZE_APICALL +zelTracerCommandListUpdateMutableCommandWaitEventsExpRegisterCallback( + zel_tracer_handle_t hTracer, + zel_tracer_reg_t callback_type, + ze_pfnCommandListUpdateMutableCommandWaitEventsExpCb_t pfnUpdateMutableCommandWaitEventsExpCb + ) { + + if(!ze_lib::context->tracing_lib) + return ZE_RESULT_ERROR_UNINITIALIZED; + typedef ze_result_t (ZE_APICALL *ze_pfnSetCallback_t)( + zel_tracer_handle_t hTracer, + zel_tracer_reg_t callback_type, + ze_pfnCommandListUpdateMutableCommandWaitEventsExpCb_t pfnUpdateMutableCommandWaitEventsExpCb + ); + + auto func = reinterpret_cast( + GET_FUNCTION_PTR(ze_lib::context->tracing_lib, "zelTracerCommandListUpdateMutableCommandWaitEventsExpRegisterCallback") ); + + if(func) + return func(hTracer, callback_type, pfnUpdateMutableCommandWaitEventsExpCb); + + return ZE_RESULT_ERROR_UNINITIALIZED; +} + + +ZE_APIEXPORT ze_result_t ZE_APICALL +zelTracerCommandListUpdateMutableCommandKernelsExpRegisterCallback( + zel_tracer_handle_t hTracer, + zel_tracer_reg_t callback_type, + ze_pfnCommandListUpdateMutableCommandKernelsExpCb_t pfnUpdateMutableCommandKernelsExpCb + ) { + + if(!ze_lib::context->tracing_lib) + return ZE_RESULT_ERROR_UNINITIALIZED; + typedef ze_result_t (ZE_APICALL *ze_pfnSetCallback_t)( + zel_tracer_handle_t hTracer, + zel_tracer_reg_t callback_type, + ze_pfnCommandListUpdateMutableCommandKernelsExpCb_t pfnUpdateMutableCommandKernelsExpCb + ); + + auto func = reinterpret_cast( + GET_FUNCTION_PTR(ze_lib::context->tracing_lib, "zelTracerCommandListUpdateMutableCommandKernelsExpRegisterCallback") ); + + if(func) + return func(hTracer, callback_type, pfnUpdateMutableCommandKernelsExpCb); + + return ZE_RESULT_ERROR_UNINITIALIZED; +} + + } //Extern C \ No newline at end of file diff --git a/source/loader/ze_ldrddi.cpp b/source/loader/ze_ldrddi.cpp index c52e5cf9..b0d1dcd8 100644 --- a/source/loader/ze_ldrddi.cpp +++ b/source/loader/ze_ldrddi.cpp @@ -4859,191 +4859,6 @@ namespace loader return result; } - /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeCommandListGetNextCommandIdExp - __zedlllocal ze_result_t ZE_APICALL - zeCommandListGetNextCommandIdExp( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - const ze_mutable_command_id_exp_desc_t* desc, ///< [in] pointer to mutable command identifier descriptor - uint64_t* pCommandId ///< [out] pointer to mutable command identifier to be written - ) - { - ze_result_t result = ZE_RESULT_SUCCESS; - - // extract driver's function pointer table - auto dditable = reinterpret_cast( hCommandList )->dditable; - auto pfnGetNextCommandIdExp = dditable->ze.CommandListExp.pfnGetNextCommandIdExp; - if( nullptr == pfnGetNextCommandIdExp ) - return ZE_RESULT_ERROR_UNINITIALIZED; - - // convert loader handle to driver handle - hCommandList = reinterpret_cast( hCommandList )->handle; - - // forward to device-driver - result = pfnGetNextCommandIdExp( hCommandList, desc, pCommandId ); - - return result; - } - - /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeCommandListGetNextCommandIdWithKernelsExp - __zedlllocal ze_result_t ZE_APICALL - zeCommandListGetNextCommandIdWithKernelsExp( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - const ze_mutable_command_id_exp_desc_t* desc, ///< [in][out] pointer to mutable command identifier descriptor - uint32_t numKernels, ///< [in][optional] number of entries on phKernels list - ze_kernel_handle_t* phKernels, ///< [in][optional][range(0, numKernels)] list of kernels that user can - ///< switch between using ::zeCommandListUpdateMutableCommandKernelsExp - ///< call - uint64_t* pCommandId ///< [out] pointer to mutable command identifier to be written - ) - { - ze_result_t result = ZE_RESULT_SUCCESS; - - // extract driver's function pointer table - auto dditable = reinterpret_cast( hCommandList )->dditable; - auto pfnGetNextCommandIdWithKernelsExp = dditable->ze.CommandListExp.pfnGetNextCommandIdWithKernelsExp; - if( nullptr == pfnGetNextCommandIdWithKernelsExp ) - return ZE_RESULT_ERROR_UNINITIALIZED; - - // convert loader handle to driver handle - hCommandList = reinterpret_cast( hCommandList )->handle; - - // convert loader handles to driver handles - auto phKernelsLocal = new ze_kernel_handle_t [numKernels]; - for( size_t i = 0; ( nullptr != phKernels ) && ( i < numKernels ); ++i ) - phKernelsLocal[ i ] = reinterpret_cast( phKernels[ i ] )->handle; - - // forward to device-driver - result = pfnGetNextCommandIdWithKernelsExp( hCommandList, desc, numKernels, phKernelsLocal, pCommandId ); - delete []phKernelsLocal; - - return result; - } - - /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeCommandListUpdateMutableCommandsExp - __zedlllocal ze_result_t ZE_APICALL - zeCommandListUpdateMutableCommandsExp( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - const ze_mutable_commands_exp_desc_t* desc ///< [in] pointer to mutable commands descriptor; multiple descriptors may - ///< be chained via `pNext` member - ) - { - ze_result_t result = ZE_RESULT_SUCCESS; - - // extract driver's function pointer table - auto dditable = reinterpret_cast( hCommandList )->dditable; - auto pfnUpdateMutableCommandsExp = dditable->ze.CommandListExp.pfnUpdateMutableCommandsExp; - if( nullptr == pfnUpdateMutableCommandsExp ) - return ZE_RESULT_ERROR_UNINITIALIZED; - - // convert loader handle to driver handle - hCommandList = reinterpret_cast( hCommandList )->handle; - - // forward to device-driver - result = pfnUpdateMutableCommandsExp( hCommandList, desc ); - - return result; - } - - /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeCommandListUpdateMutableCommandSignalEventExp - __zedlllocal ze_result_t ZE_APICALL - zeCommandListUpdateMutableCommandSignalEventExp( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - uint64_t commandId, ///< [in] command identifier - ze_event_handle_t hSignalEvent ///< [in][optional] handle of the event to signal on completion - ) - { - ze_result_t result = ZE_RESULT_SUCCESS; - - // extract driver's function pointer table - auto dditable = reinterpret_cast( hCommandList )->dditable; - auto pfnUpdateMutableCommandSignalEventExp = dditable->ze.CommandListExp.pfnUpdateMutableCommandSignalEventExp; - if( nullptr == pfnUpdateMutableCommandSignalEventExp ) - return ZE_RESULT_ERROR_UNINITIALIZED; - - // convert loader handle to driver handle - hCommandList = reinterpret_cast( hCommandList )->handle; - - // convert loader handle to driver handle - hSignalEvent = ( hSignalEvent ) ? reinterpret_cast( hSignalEvent )->handle : nullptr; - - // forward to device-driver - result = pfnUpdateMutableCommandSignalEventExp( hCommandList, commandId, hSignalEvent ); - - return result; - } - - /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeCommandListUpdateMutableCommandWaitEventsExp - __zedlllocal ze_result_t ZE_APICALL - zeCommandListUpdateMutableCommandWaitEventsExp( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - uint64_t commandId, ///< [in] command identifier - uint32_t numWaitEvents, ///< [in][optional] the number of wait events - ze_event_handle_t* phWaitEvents ///< [in][optional][range(0, numWaitEvents)] handle of the events to wait - ///< on before launching - ) - { - ze_result_t result = ZE_RESULT_SUCCESS; - - // extract driver's function pointer table - auto dditable = reinterpret_cast( hCommandList )->dditable; - auto pfnUpdateMutableCommandWaitEventsExp = dditable->ze.CommandListExp.pfnUpdateMutableCommandWaitEventsExp; - if( nullptr == pfnUpdateMutableCommandWaitEventsExp ) - return ZE_RESULT_ERROR_UNINITIALIZED; - - // convert loader handle to driver handle - hCommandList = reinterpret_cast( hCommandList )->handle; - - // convert loader handles to driver handles - auto phWaitEventsLocal = new ze_event_handle_t [numWaitEvents]; - for( size_t i = 0; ( nullptr != phWaitEvents ) && ( i < numWaitEvents ); ++i ) - phWaitEventsLocal[ i ] = reinterpret_cast( phWaitEvents[ i ] )->handle; - - // forward to device-driver - result = pfnUpdateMutableCommandWaitEventsExp( hCommandList, commandId, numWaitEvents, phWaitEventsLocal ); - delete []phWaitEventsLocal; - - return result; - } - - /////////////////////////////////////////////////////////////////////////////// - /// @brief Intercept function for zeCommandListUpdateMutableCommandKernelsExp - __zedlllocal ze_result_t ZE_APICALL - zeCommandListUpdateMutableCommandKernelsExp( - ze_command_list_handle_t hCommandList, ///< [in] handle of the command list - uint32_t numKernels, ///< [in] the number of kernels to update - uint64_t* pCommandId, ///< [in][range(0, numKernels)] command identifier - ze_kernel_handle_t* phKernels ///< [in][range(0, numKernels)] handle of the kernel for a command - ///< identifier to switch to - ) - { - ze_result_t result = ZE_RESULT_SUCCESS; - - // extract driver's function pointer table - auto dditable = reinterpret_cast( hCommandList )->dditable; - auto pfnUpdateMutableCommandKernelsExp = dditable->ze.CommandListExp.pfnUpdateMutableCommandKernelsExp; - if( nullptr == pfnUpdateMutableCommandKernelsExp ) - return ZE_RESULT_ERROR_UNINITIALIZED; - - // convert loader handle to driver handle - hCommandList = reinterpret_cast( hCommandList )->handle; - - // convert loader handles to driver handles - auto phKernelsLocal = new ze_kernel_handle_t [numKernels]; - for( size_t i = 0; ( nullptr != phKernels ) && ( i < numKernels ); ++i ) - phKernelsLocal[ i ] = reinterpret_cast( phKernels[ i ] )->handle; - - // forward to device-driver - result = pfnUpdateMutableCommandKernelsExp( hCommandList, numKernels, pCommandId, phKernelsLocal ); - delete []phKernelsLocal; - - return result; - } - /////////////////////////////////////////////////////////////////////////////// /// @brief Intercept function for zeDeviceReserveCacheExt __zedlllocal ze_result_t ZE_APICALL @@ -6305,6 +6120,191 @@ namespace loader return result; } + /////////////////////////////////////////////////////////////////////////////// + /// @brief Intercept function for zeCommandListGetNextCommandIdExp + __zedlllocal ze_result_t ZE_APICALL + zeCommandListGetNextCommandIdExp( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + const ze_mutable_command_id_exp_desc_t* desc, ///< [in] pointer to mutable command identifier descriptor + uint64_t* pCommandId ///< [out] pointer to mutable command identifier to be written + ) + { + ze_result_t result = ZE_RESULT_SUCCESS; + + // extract driver's function pointer table + auto dditable = reinterpret_cast( hCommandList )->dditable; + auto pfnGetNextCommandIdExp = dditable->ze.CommandListExp.pfnGetNextCommandIdExp; + if( nullptr == pfnGetNextCommandIdExp ) + return ZE_RESULT_ERROR_UNINITIALIZED; + + // convert loader handle to driver handle + hCommandList = reinterpret_cast( hCommandList )->handle; + + // forward to device-driver + result = pfnGetNextCommandIdExp( hCommandList, desc, pCommandId ); + + return result; + } + + /////////////////////////////////////////////////////////////////////////////// + /// @brief Intercept function for zeCommandListGetNextCommandIdWithKernelsExp + __zedlllocal ze_result_t ZE_APICALL + zeCommandListGetNextCommandIdWithKernelsExp( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + const ze_mutable_command_id_exp_desc_t* desc, ///< [in][out] pointer to mutable command identifier descriptor + uint32_t numKernels, ///< [in][optional] number of entries on phKernels list + ze_kernel_handle_t* phKernels, ///< [in][optional][range(0, numKernels)] list of kernels that user can + ///< switch between using ::zeCommandListUpdateMutableCommandKernelsExp + ///< call + uint64_t* pCommandId ///< [out] pointer to mutable command identifier to be written + ) + { + ze_result_t result = ZE_RESULT_SUCCESS; + + // extract driver's function pointer table + auto dditable = reinterpret_cast( hCommandList )->dditable; + auto pfnGetNextCommandIdWithKernelsExp = dditable->ze.CommandListExp.pfnGetNextCommandIdWithKernelsExp; + if( nullptr == pfnGetNextCommandIdWithKernelsExp ) + return ZE_RESULT_ERROR_UNINITIALIZED; + + // convert loader handle to driver handle + hCommandList = reinterpret_cast( hCommandList )->handle; + + // convert loader handles to driver handles + auto phKernelsLocal = new ze_kernel_handle_t [numKernels]; + for( size_t i = 0; ( nullptr != phKernels ) && ( i < numKernels ); ++i ) + phKernelsLocal[ i ] = reinterpret_cast( phKernels[ i ] )->handle; + + // forward to device-driver + result = pfnGetNextCommandIdWithKernelsExp( hCommandList, desc, numKernels, phKernelsLocal, pCommandId ); + delete []phKernelsLocal; + + return result; + } + + /////////////////////////////////////////////////////////////////////////////// + /// @brief Intercept function for zeCommandListUpdateMutableCommandsExp + __zedlllocal ze_result_t ZE_APICALL + zeCommandListUpdateMutableCommandsExp( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + const ze_mutable_commands_exp_desc_t* desc ///< [in] pointer to mutable commands descriptor; multiple descriptors may + ///< be chained via `pNext` member + ) + { + ze_result_t result = ZE_RESULT_SUCCESS; + + // extract driver's function pointer table + auto dditable = reinterpret_cast( hCommandList )->dditable; + auto pfnUpdateMutableCommandsExp = dditable->ze.CommandListExp.pfnUpdateMutableCommandsExp; + if( nullptr == pfnUpdateMutableCommandsExp ) + return ZE_RESULT_ERROR_UNINITIALIZED; + + // convert loader handle to driver handle + hCommandList = reinterpret_cast( hCommandList )->handle; + + // forward to device-driver + result = pfnUpdateMutableCommandsExp( hCommandList, desc ); + + return result; + } + + /////////////////////////////////////////////////////////////////////////////// + /// @brief Intercept function for zeCommandListUpdateMutableCommandSignalEventExp + __zedlllocal ze_result_t ZE_APICALL + zeCommandListUpdateMutableCommandSignalEventExp( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + uint64_t commandId, ///< [in] command identifier + ze_event_handle_t hSignalEvent ///< [in][optional] handle of the event to signal on completion + ) + { + ze_result_t result = ZE_RESULT_SUCCESS; + + // extract driver's function pointer table + auto dditable = reinterpret_cast( hCommandList )->dditable; + auto pfnUpdateMutableCommandSignalEventExp = dditable->ze.CommandListExp.pfnUpdateMutableCommandSignalEventExp; + if( nullptr == pfnUpdateMutableCommandSignalEventExp ) + return ZE_RESULT_ERROR_UNINITIALIZED; + + // convert loader handle to driver handle + hCommandList = reinterpret_cast( hCommandList )->handle; + + // convert loader handle to driver handle + hSignalEvent = ( hSignalEvent ) ? reinterpret_cast( hSignalEvent )->handle : nullptr; + + // forward to device-driver + result = pfnUpdateMutableCommandSignalEventExp( hCommandList, commandId, hSignalEvent ); + + return result; + } + + /////////////////////////////////////////////////////////////////////////////// + /// @brief Intercept function for zeCommandListUpdateMutableCommandWaitEventsExp + __zedlllocal ze_result_t ZE_APICALL + zeCommandListUpdateMutableCommandWaitEventsExp( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + uint64_t commandId, ///< [in] command identifier + uint32_t numWaitEvents, ///< [in][optional] the number of wait events + ze_event_handle_t* phWaitEvents ///< [in][optional][range(0, numWaitEvents)] handle of the events to wait + ///< on before launching + ) + { + ze_result_t result = ZE_RESULT_SUCCESS; + + // extract driver's function pointer table + auto dditable = reinterpret_cast( hCommandList )->dditable; + auto pfnUpdateMutableCommandWaitEventsExp = dditable->ze.CommandListExp.pfnUpdateMutableCommandWaitEventsExp; + if( nullptr == pfnUpdateMutableCommandWaitEventsExp ) + return ZE_RESULT_ERROR_UNINITIALIZED; + + // convert loader handle to driver handle + hCommandList = reinterpret_cast( hCommandList )->handle; + + // convert loader handles to driver handles + auto phWaitEventsLocal = new ze_event_handle_t [numWaitEvents]; + for( size_t i = 0; ( nullptr != phWaitEvents ) && ( i < numWaitEvents ); ++i ) + phWaitEventsLocal[ i ] = reinterpret_cast( phWaitEvents[ i ] )->handle; + + // forward to device-driver + result = pfnUpdateMutableCommandWaitEventsExp( hCommandList, commandId, numWaitEvents, phWaitEventsLocal ); + delete []phWaitEventsLocal; + + return result; + } + + /////////////////////////////////////////////////////////////////////////////// + /// @brief Intercept function for zeCommandListUpdateMutableCommandKernelsExp + __zedlllocal ze_result_t ZE_APICALL + zeCommandListUpdateMutableCommandKernelsExp( + ze_command_list_handle_t hCommandList, ///< [in] handle of the command list + uint32_t numKernels, ///< [in] the number of kernels to update + uint64_t* pCommandId, ///< [in][range(0, numKernels)] command identifier + ze_kernel_handle_t* phKernels ///< [in][range(0, numKernels)] handle of the kernel for a command + ///< identifier to switch to + ) + { + ze_result_t result = ZE_RESULT_SUCCESS; + + // extract driver's function pointer table + auto dditable = reinterpret_cast( hCommandList )->dditable; + auto pfnUpdateMutableCommandKernelsExp = dditable->ze.CommandListExp.pfnUpdateMutableCommandKernelsExp; + if( nullptr == pfnUpdateMutableCommandKernelsExp ) + return ZE_RESULT_ERROR_UNINITIALIZED; + + // convert loader handle to driver handle + hCommandList = reinterpret_cast( hCommandList )->handle; + + // convert loader handles to driver handles + auto phKernelsLocal = new ze_kernel_handle_t [numKernels]; + for( size_t i = 0; ( nullptr != phKernels ) && ( i < numKernels ); ++i ) + phKernelsLocal[ i ] = reinterpret_cast( phKernels[ i ] )->handle; + + // forward to device-driver + result = pfnUpdateMutableCommandKernelsExp( hCommandList, numKernels, pCommandId, phKernelsLocal ); + delete []phKernelsLocal; + + return result; + } + } // namespace loader #if defined(__cplusplus) @@ -7321,13 +7321,13 @@ zeGetCommandListExpProcAddrTable( { // return pointers to loader's DDIs pDdiTable->pfnGetNextCommandIdWithKernelsExp = loader::zeCommandListGetNextCommandIdWithKernelsExp; - pDdiTable->pfnUpdateMutableCommandsExp = loader::zeCommandListUpdateMutableCommandsExp; - pDdiTable->pfnUpdateMutableCommandSignalEventExp = loader::zeCommandListUpdateMutableCommandSignalEventExp; pDdiTable->pfnUpdateMutableCommandKernelsExp = loader::zeCommandListUpdateMutableCommandKernelsExp; pDdiTable->pfnCreateCloneExp = loader::zeCommandListCreateCloneExp; + pDdiTable->pfnImmediateAppendCommandListsExp = loader::zeCommandListImmediateAppendCommandListsExp; pDdiTable->pfnGetNextCommandIdExp = loader::zeCommandListGetNextCommandIdExp; + pDdiTable->pfnUpdateMutableCommandsExp = loader::zeCommandListUpdateMutableCommandsExp; + pDdiTable->pfnUpdateMutableCommandSignalEventExp = loader::zeCommandListUpdateMutableCommandSignalEventExp; pDdiTable->pfnUpdateMutableCommandWaitEventsExp = loader::zeCommandListUpdateMutableCommandWaitEventsExp; - pDdiTable->pfnImmediateAppendCommandListsExp = loader::zeCommandListImmediateAppendCommandListsExp; } else { diff --git a/source/loader/zet_ldrddi.cpp b/source/loader/zet_ldrddi.cpp index 1b6f2f66..1bf7ea2c 100644 --- a/source/loader/zet_ldrddi.cpp +++ b/source/loader/zet_ldrddi.cpp @@ -3316,11 +3316,11 @@ zetGetMetricGroupExpProcAddrTable( if( ( loader::context->zeDrivers.size() > 1 ) || loader::context->forceIntercept ) { // return pointers to loader's DDIs - pDdiTable->pfnCreateExp = loader::zetMetricGroupCreateExp; pDdiTable->pfnCalculateMultipleMetricValuesExp = loader::zetMetricGroupCalculateMultipleMetricValuesExp; pDdiTable->pfnGetGlobalTimestampsExp = loader::zetMetricGroupGetGlobalTimestampsExp; pDdiTable->pfnGetExportDataExp = loader::zetMetricGroupGetExportDataExp; pDdiTable->pfnCalculateMetricExportDataExp = loader::zetMetricGroupCalculateMetricExportDataExp; + pDdiTable->pfnCreateExp = loader::zetMetricGroupCreateExp; pDdiTable->pfnAddMetricExp = loader::zetMetricGroupAddMetricExp; pDdiTable->pfnRemoveMetricExp = loader::zetMetricGroupRemoveMetricExp; pDdiTable->pfnCloseExp = loader::zetMetricGroupCloseExp;