Ctrl+K

Tools API

Contents

Tools API#

oneAPI Level Zero Specification - Version 1.11

Common#

Common Enums#

zet_structure_type_t#

enum zet_structure_type_t#

Defines structure types.

Values:

enumerator ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES#

zet_metric_group_properties_t

enumerator ZET_STRUCTURE_TYPE_METRIC_PROPERTIES#

zet_metric_properties_t

enumerator ZET_STRUCTURE_TYPE_METRIC_STREAMER_DESC#

zet_metric_streamer_desc_t

enumerator ZET_STRUCTURE_TYPE_METRIC_QUERY_POOL_DESC#

zet_metric_query_pool_desc_t

enumerator ZET_STRUCTURE_TYPE_PROFILE_PROPERTIES#

zet_profile_properties_t

enumerator ZET_STRUCTURE_TYPE_DEVICE_DEBUG_PROPERTIES#

zet_device_debug_properties_t

enumerator ZET_STRUCTURE_TYPE_DEBUG_MEMORY_SPACE_DESC#

zet_debug_memory_space_desc_t

enumerator ZET_STRUCTURE_TYPE_DEBUG_REGSET_PROPERTIES#

zet_debug_regset_properties_t

enumerator ZET_STRUCTURE_TYPE_GLOBAL_METRICS_TIMESTAMPS_EXP_PROPERTIES#

zet_metric_global_timestamps_resolution_exp_t. Deprecated, use ZET_STRUCTURE_TYPE_METRIC_GLOBAL_TIMESTAMPS_RESOLUTION_EXP.

enumerator ZET_STRUCTURE_TYPE_METRIC_GLOBAL_TIMESTAMPS_RESOLUTION_EXP#

zet_metric_global_timestamps_resolution_exp_t

enumerator ZET_STRUCTURE_TYPE_TRACER_EXP_DESC#

zet_tracer_exp_desc_t

enumerator ZET_STRUCTURE_TYPE_METRICS_CALCULATE_EXP_DESC#

zet_metric_calculate_exp_desc_t. Deprecated, use ZET_STRUCTURE_TYPE_METRIC_CALCULATE_EXP_DESC.

enumerator ZET_STRUCTURE_TYPE_METRIC_CALCULATE_EXP_DESC#

zet_metric_calculate_exp_desc_t

enumerator ZET_STRUCTURE_TYPE_METRIC_PROGRAMMABLE_EXP_PROPERTIES#

zet_metric_programmable_exp_properties_t

enumerator ZET_STRUCTURE_TYPE_METRIC_PROGRAMMABLE_PARAM_INFO_EXP#

zet_metric_programmable_param_info_exp_t

enumerator ZET_STRUCTURE_TYPE_METRIC_PROGRAMMABLE_PARAM_VALUE_INFO_EXP#

zet_metric_programmable_param_value_info_exp_t

enumerator ZET_STRUCTURE_TYPE_METRIC_GROUP_TYPE_EXP#

zet_metric_group_type_exp_t

enumerator ZET_STRUCTURE_TYPE_EXPORT_DMA_EXP_PROPERTIES#

zet_export_dma_buf_exp_properties_t

enumerator ZET_STRUCTURE_TYPE_METRIC_TRACER_EXP_DESC#

zet_metric_tracer_exp_desc_t

enumerator ZET_STRUCTURE_TYPE_FORCE_UINT32#

zet_value_type_t#

enum zet_value_type_t#

Supported value types.

Values:

enumerator ZET_VALUE_TYPE_UINT32#

32-bit unsigned-integer

enumerator ZET_VALUE_TYPE_UINT64#

64-bit unsigned-integer

enumerator ZET_VALUE_TYPE_FLOAT32#

32-bit floating-point

enumerator ZET_VALUE_TYPE_FLOAT64#

64-bit floating-point

enumerator ZET_VALUE_TYPE_BOOL8#

8-bit boolean

enumerator ZET_VALUE_TYPE_STRING#

C string.

enumerator ZET_VALUE_TYPE_UINT8#

8-bit unsigned-integer

enumerator ZET_VALUE_TYPE_UINT16#

16-bit unsigned-integer

enumerator ZET_VALUE_TYPE_FORCE_UINT32#

Common Structures#

zet_base_properties_t#

struct zet_base_properties_t#

Base for all properties types.

Public Members

zet_structure_type_t stype#

[in] type of this structure

void *pNext#

[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).

zet_base_desc_t#

struct zet_base_desc_t#

Base for all descriptor types.

Public Members

zet_structure_type_t stype#

[in] type of this structure

const void *pNext#

[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).

zet_value_t#

union zet_value_t#
#include <zet_api.h>

Union of values.

Public Members

uint32_t ui32#

[out] 32-bit unsigned-integer

uint64_t ui64#

[out] 64-bit unsigned-integer

float fp32#

[out] 32-bit floating-point

double fp64#

[out] 64-bit floating-point

ze_bool_t b8#

[out] 8-bit boolean

zet_typed_value_t#

struct zet_typed_value_t#

Typed value.

Public Members

zet_value_type_t type#

[out] type of value

zet_value_t value#

[out] value

Module#

Module Functions#

zetModuleGetDebugInfo#

ZE_APIEXPORT ze_result_t ZE_APICALL zetModuleGetDebugInfo(zet_module_handle_t hModule, zet_module_debug_info_format_t format, size_t *pSize, uint8_t *pDebugInfo)#

Retrieve debug info from module.

  • 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.

Parameters:

  • hModule – [in] handle of the module

  • format – [in] debug info format requested

  • pSize – [in,out] size of debug info in bytes

  • pDebugInfo – [in,out][optional] byte pointer to debug info

Returns:

Module Enums#

zet_module_debug_info_format_t#

enum zet_module_debug_info_format_t#

Supported module debug info formats.

Values:

enumerator ZET_MODULE_DEBUG_INFO_FORMAT_ELF_DWARF#

Format is ELF/DWARF.

enumerator ZET_MODULE_DEBUG_INFO_FORMAT_FORCE_UINT32#

Debug#

Debug Functions#

zetDeviceGetDebugProperties#

ZE_APIEXPORT ze_result_t ZE_APICALL zetDeviceGetDebugProperties(zet_device_handle_t hDevice, zet_device_debug_properties_t *pDebugProperties)#

Retrieves debug properties of the device.

Parameters:

  • hDevice – [in] device handle

  • pDebugProperties – [in,out] query result for debug properties

Returns:

zetDebugAttach#

ZE_APIEXPORT ze_result_t ZE_APICALL zetDebugAttach(zet_device_handle_t hDevice, const zet_debug_config_t *config, zet_debug_session_handle_t *phDebug)#

Attach to a device.

Parameters:

  • hDevice – [in] device handle

  • config – [in] the debug configuration

  • phDebug – [out] debug session handle

Returns:

zetDebugDetach#

ZE_APIEXPORT ze_result_t ZE_APICALL zetDebugDetach(zet_debug_session_handle_t hDebug)#

Close a debug session.

Parameters:

hDebug – [in][release] debug session handle

Returns:

zetDebugReadEvent#

ZE_APIEXPORT ze_result_t ZE_APICALL zetDebugReadEvent(zet_debug_session_handle_t hDebug, uint64_t timeout, zet_debug_event_t *event)#

Read the topmost debug event.

Parameters:

  • hDebug – [in] debug session handle

  • timeout – [in] if non-zero, then indicates the maximum time (in milliseconds) to yield before returning ZE_RESULT_SUCCESS or ZE_RESULT_NOT_READY; if zero, then immediately returns the status of the event; if UINT64_MAX, then function will not return until complete or device is lost. Due to external dependencies, timeout may be rounded to the closest value allowed by the accuracy of those dependencies.

  • event – [in,out] a pointer to a zet_debug_event_t.

Returns:

zetDebugAcknowledgeEvent#

ZE_APIEXPORT ze_result_t ZE_APICALL zetDebugAcknowledgeEvent(zet_debug_session_handle_t hDebug, const zet_debug_event_t *event)#

Acknowledge a debug event.

Parameters:

  • hDebug – [in] debug session handle

  • event – [in] a pointer to a zet_debug_event_t.

Returns:

zetDebugInterrupt#

ZE_APIEXPORT ze_result_t ZE_APICALL zetDebugInterrupt(zet_debug_session_handle_t hDebug, ze_device_thread_t thread)#

Interrupt device threads.

Parameters:

  • hDebug – [in] debug session handle

  • thread – [in] the thread to interrupt

Returns:

zetDebugResume#

ZE_APIEXPORT ze_result_t ZE_APICALL zetDebugResume(zet_debug_session_handle_t hDebug, ze_device_thread_t thread)#

Resume device threads.

Parameters:

  • hDebug – [in] debug session handle

  • thread – [in] the thread to resume

Returns:

zetDebugReadMemory#

ZE_APIEXPORT ze_result_t ZE_APICALL zetDebugReadMemory(zet_debug_session_handle_t hDebug, ze_device_thread_t thread, const zet_debug_memory_space_desc_t *desc, size_t size, void *buffer)#

Read memory.

  • The thread identifier ‘all’ can be used for accessing the default memory space, e.g. for setting breakpoints.

Parameters:

  • hDebug – [in] debug session handle

  • thread – [in] the thread identifier.

  • desc – [in] memory space descriptor

  • size – [in] the number of bytes to read

  • buffer – [in,out] a buffer to hold a copy of the memory

Returns:

zetDebugWriteMemory#

ZE_APIEXPORT ze_result_t ZE_APICALL zetDebugWriteMemory(zet_debug_session_handle_t hDebug, ze_device_thread_t thread, const zet_debug_memory_space_desc_t *desc, size_t size, const void *buffer)#

Write memory.

  • The thread identifier ‘all’ can be used for accessing the default memory space, e.g. for setting breakpoints.

Parameters:

  • hDebug – [in] debug session handle

  • thread – [in] the thread identifier.

  • desc – [in] memory space descriptor

  • size – [in] the number of bytes to write

  • buffer – [in] a buffer holding the pattern to write

Returns:

zetDebugGetRegisterSetProperties#

ZE_APIEXPORT ze_result_t ZE_APICALL zetDebugGetRegisterSetProperties(zet_device_handle_t hDevice, uint32_t *pCount, zet_debug_regset_properties_t *pRegisterSetProperties)#

Retrieves debug register set properties.

Parameters:

  • hDevice – [in] device handle

  • pCount – [in,out] pointer to the number of register set properties. if count is zero, then the driver shall update the value with the total number of register set properties available. if 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.

  • pRegisterSetProperties – [in,out][optional][range(0, *pCount)] array of query results for register set properties. if count is less than the number of register set properties available, then driver shall only retrieve that number of register set properties.

Returns:

zetDebugGetThreadRegisterSetProperties#

ZE_APIEXPORT ze_result_t ZE_APICALL zetDebugGetThreadRegisterSetProperties(zet_debug_session_handle_t hDebug, ze_device_thread_t thread, uint32_t *pCount, zet_debug_regset_properties_t *pRegisterSetProperties)#

Retrieves debug register set properties for a given thread.

Parameters:

  • hDebug – [in] debug session handle

  • thread – [in] the thread identifier specifying a single stopped thread

  • pCount – [in,out] pointer to the number of register set properties. if count is zero, then the driver shall update the value with the total number of register set properties available. if 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.

  • pRegisterSetProperties – [in,out][optional][range(0, *pCount)] array of query results for register set properties. if count is less than the number of register set properties available, then driver shall only retrieve that number of register set properties.

Returns:

zetDebugReadRegisters#

ZE_APIEXPORT ze_result_t ZE_APICALL zetDebugReadRegisters(zet_debug_session_handle_t hDebug, ze_device_thread_t thread, uint32_t type, uint32_t start, uint32_t count, void *pRegisterValues)#

Read register state.

Parameters:

  • hDebug – [in] debug session handle

  • thread – [in] the thread identifier

  • type – [in] register set type

  • start – [in] the starting offset into the register state area; must be less than the count member of zet_debug_regset_properties_t for the type

  • count – [in] the number of registers to read; start+count must be less than or equal to the count member of ::zet_debug_register_group_properties_t for the type

  • pRegisterValues – [in,out][optional][range(0, count)] buffer of register values

Returns:

zetDebugWriteRegisters#

ZE_APIEXPORT ze_result_t ZE_APICALL zetDebugWriteRegisters(zet_debug_session_handle_t hDebug, ze_device_thread_t thread, uint32_t type, uint32_t start, uint32_t count, void *pRegisterValues)#

Write register state.

Parameters:

  • hDebug – [in] debug session handle

  • thread – [in] the thread identifier

  • type – [in] register set type

  • start – [in] the starting offset into the register state area; must be less than the count member of zet_debug_regset_properties_t for the type

  • count – [in] the number of registers to write; start+count must be less than or equal to the count member of ::zet_debug_register_group_properties_t for the type

  • pRegisterValues – [in,out][optional][range(0, count)] buffer of register values

Returns:

Debug Enums#

zet_device_debug_property_flags_t#

enum zet_device_debug_property_flag_t#

Values:

enumerator ZET_DEVICE_DEBUG_PROPERTY_FLAG_ATTACH#

the device supports attaching for debug

enumerator ZET_DEVICE_DEBUG_PROPERTY_FLAG_FORCE_UINT32#

zet_debug_event_flags_t#

enum zet_debug_event_flag_t#

Values:

enumerator ZET_DEBUG_EVENT_FLAG_NEED_ACK#

The event needs to be acknowledged by calling zetDebugAcknowledgeEvent.

enumerator ZET_DEBUG_EVENT_FLAG_FORCE_UINT32#

zet_debug_event_type_t#

enum zet_debug_event_type_t#

Supported debug event types.

Values:

enumerator ZET_DEBUG_EVENT_TYPE_INVALID#

The event is invalid.

enumerator ZET_DEBUG_EVENT_TYPE_DETACHED#

The tool was detached.

enumerator ZET_DEBUG_EVENT_TYPE_PROCESS_ENTRY#

The debuggee process created command queues on the device.

enumerator ZET_DEBUG_EVENT_TYPE_PROCESS_EXIT#

The debuggee process destroyed all command queues on the device.

enumerator ZET_DEBUG_EVENT_TYPE_MODULE_LOAD#

An in-memory module was loaded onto the device.

enumerator ZET_DEBUG_EVENT_TYPE_MODULE_UNLOAD#

An in-memory module is about to get unloaded from the device.

enumerator ZET_DEBUG_EVENT_TYPE_THREAD_STOPPED#

The thread stopped due to a device exception.

enumerator ZET_DEBUG_EVENT_TYPE_THREAD_UNAVAILABLE#

The thread is not available to be stopped.

enumerator ZET_DEBUG_EVENT_TYPE_PAGE_FAULT#

A page request could not be completed on the device.

enumerator ZET_DEBUG_EVENT_TYPE_FORCE_UINT32#

zet_debug_detach_reason_t#

enum zet_debug_detach_reason_t#

Supported debug detach reasons.

Values:

enumerator ZET_DEBUG_DETACH_REASON_INVALID#

The detach reason is not valid.

enumerator ZET_DEBUG_DETACH_REASON_HOST_EXIT#

The host process exited.

enumerator ZET_DEBUG_DETACH_REASON_FORCE_UINT32#

zet_debug_page_fault_reason_t#

enum zet_debug_page_fault_reason_t#

Page fault reasons.

Values:

enumerator ZET_DEBUG_PAGE_FAULT_REASON_INVALID#

The page fault reason is not valid.

enumerator ZET_DEBUG_PAGE_FAULT_REASON_MAPPING_ERROR#

The address is not mapped.

enumerator ZET_DEBUG_PAGE_FAULT_REASON_PERMISSION_ERROR#

Invalid access permissions.

enumerator ZET_DEBUG_PAGE_FAULT_REASON_FORCE_UINT32#

zet_debug_memory_space_type_t#

enum zet_debug_memory_space_type_t#

Supported device memory space types.

Values:

enumerator ZET_DEBUG_MEMORY_SPACE_TYPE_DEFAULT#

default memory space (attribute may be omitted)

enumerator ZET_DEBUG_MEMORY_SPACE_TYPE_SLM#

shared local memory space (GPU-only)

enumerator ZET_DEBUG_MEMORY_SPACE_TYPE_ELF#

ELF file memory space.

enumerator ZET_DEBUG_MEMORY_SPACE_TYPE_FORCE_UINT32#

zet_debug_regset_flags_t#

enum zet_debug_regset_flag_t#

Values:

enumerator ZET_DEBUG_REGSET_FLAG_READABLE#

register set is readable

enumerator ZET_DEBUG_REGSET_FLAG_WRITEABLE#

register set is writeable

enumerator ZET_DEBUG_REGSET_FLAG_FORCE_UINT32#

Debug Structures#

zet_device_debug_properties_t#

struct zet_device_debug_properties_t#

Device debug properties queried using zetDeviceGetDebugProperties.

Public Members

zet_structure_type_t stype#

[in] type of this structure

void *pNext#

[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).

zet_device_debug_property_flags_t flags#

[out] returns 0 (none) or a valid combination of zet_device_debug_property_flag_t

zet_debug_config_t#

struct zet_debug_config_t#

Debug configuration provided to zetDebugAttach.

Public Members

uint32_t pid#

[in] the host process identifier

zet_debug_event_info_detached_t#

struct zet_debug_event_info_detached_t#

Event information for ZET_DEBUG_EVENT_TYPE_DETACHED.

Public Members

zet_debug_detach_reason_t reason#

[out] the detach reason

zet_debug_event_info_module_t#

struct zet_debug_event_info_module_t#

Event information for ZET_DEBUG_EVENT_TYPE_MODULE_LOAD and ZET_DEBUG_EVENT_TYPE_MODULE_UNLOAD.

Public Members

zet_module_debug_info_format_t format#

[out] the module format

uint64_t moduleBegin#

[out] the begin address of the in-memory module (inclusive)

uint64_t moduleEnd#

[out] the end address of the in-memory module (exclusive)

uint64_t load#

[out] the load address of the module on the device

zet_debug_event_info_thread_stopped_t#

struct zet_debug_event_info_thread_stopped_t#

Event information for ZET_DEBUG_EVENT_TYPE_THREAD_STOPPED and ZET_DEBUG_EVENT_TYPE_THREAD_UNAVAILABLE.

Public Members

ze_device_thread_t thread#

[out] the stopped/unavailable thread

zet_debug_event_info_page_fault_t#

struct zet_debug_event_info_page_fault_t#

Event information for ZET_DEBUG_EVENT_TYPE_PAGE_FAULT.

Public Members

uint64_t address#

[out] the faulting address

uint64_t mask#

[out] the alignment mask

zet_debug_page_fault_reason_t reason#

[out] the page fault reason

zet_debug_event_info_t#

union zet_debug_event_info_t#
#include <zet_api.h>

Event type-specific information.

Public Members

zet_debug_event_info_detached_t detached#

[out] type == ZET_DEBUG_EVENT_TYPE_DETACHED

zet_debug_event_info_module_t module#

[out] type == ZET_DEBUG_EVENT_TYPE_MODULE_LOAD or ZET_DEBUG_EVENT_TYPE_MODULE_UNLOAD

zet_debug_event_info_thread_stopped_t thread#

[out] type == ZET_DEBUG_EVENT_TYPE_THREAD_STOPPED or ZET_DEBUG_EVENT_TYPE_THREAD_UNAVAILABLE

zet_debug_event_info_page_fault_t page_fault#

[out] type == ZET_DEBUG_EVENT_TYPE_PAGE_FAULT

zet_debug_event_t#

struct zet_debug_event_t#

A debug event on the device.

Public Members

zet_debug_event_type_t type#

[out] the event type

zet_debug_event_flags_t flags#

[out] returns 0 (none) or a combination of zet_debug_event_flag_t

zet_debug_event_info_t info#

[out] event type specific information

zet_debug_memory_space_desc_t#

struct zet_debug_memory_space_desc_t#

Device memory space descriptor.

Public Members

zet_structure_type_t stype#

[in] type of this structure

const void *pNext#

[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).

zet_debug_memory_space_type_t type#

[in] type of memory space

uint64_t address#

[in] the virtual address within the memory space

zet_debug_regset_properties_t#

struct zet_debug_regset_properties_t#

Device register set properties queried using zetDebugGetRegisterSetProperties.

Public Members

zet_structure_type_t stype#

[in] type of this structure

void *pNext#

[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).

uint32_t type#

[out] device-specific register set type

uint32_t version#

[out] device-specific version of this register set

zet_debug_regset_flags_t generalFlags#

[out] general register set flags

uint32_t deviceFlags#

[out] device-specific register set flags

uint32_t count#

[out] number of registers in the set

uint32_t bitSize#

[out] the size of a register in bits

uint32_t byteSize#

[out] the size required for reading or writing a register in bytes

Metric#

Metric Functions#

zetMetricGroupGet#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricGroupGet(zet_device_handle_t hDevice, uint32_t *pCount, zet_metric_group_handle_t *phMetricGroups)#

Retrieves metric group for a device.

  • The application may call this function from simultaneous threads.

Parameters:

  • hDevice – [in] handle of the device

  • pCount – [in,out] pointer to the number of metric groups. if count is zero, then the driver shall update the value with the total number of metric groups available. if 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.

  • phMetricGroups – [in,out][optional][range(0, *pCount)] array of handle of metric groups. if count is less than the number of metric groups available, then driver shall only retrieve that number of metric groups.

Returns:

zetMetricGroupGetProperties#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricGroupGetProperties(zet_metric_group_handle_t hMetricGroup, zet_metric_group_properties_t *pProperties)#

Retrieves attributes of a metric group.

  • The application may call this function from simultaneous threads.

Parameters:

  • hMetricGroup – [in] handle of the metric group

  • pProperties – [in,out] metric group properties

Returns:

zetMetricGroupCalculateMetricValues#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricGroupCalculateMetricValues(zet_metric_group_handle_t hMetricGroup, zet_metric_group_calculation_type_t type, size_t rawDataSize, const uint8_t *pRawData, uint32_t *pMetricValueCount, zet_typed_value_t *pMetricValues)#

Calculates metric values from raw data.

  • The application may call this function from simultaneous threads.

Parameters:

  • hMetricGroup – [in] handle of the metric group

  • type – [in] calculation type to be applied on raw data

  • rawDataSize – [in] size in bytes of raw data buffer

  • pRawData – [in][range(0, rawDataSize)] buffer of raw data to calculate

  • pMetricValueCount – [in,out] pointer to number of metric values calculated. if count is zero, then the driver shall update the value with the total number of metric values to be calculated. if 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.

  • pMetricValues – [in,out][optional][range(0, *pMetricValueCount)] buffer of calculated metrics. if count is less than the number available in the raw data buffer, then driver shall only calculate that number of metric values.

Returns:

zetMetricGet#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricGet(zet_metric_group_handle_t hMetricGroup, uint32_t *pCount, zet_metric_handle_t *phMetrics)#

Retrieves metric from a metric group.

  • The application may call this function from simultaneous threads.

Parameters:

  • hMetricGroup – [in] handle of the metric group

  • pCount – [in,out] pointer to the number of metrics. if count is zero, then the driver shall update the value with the total number of metrics available. if count is greater than the number of metrics available, then the driver shall update the value with the correct number of metrics available.

  • phMetrics – [in,out][optional][range(0, *pCount)] array of handle of metrics. if count is less than the number of metrics available, then driver shall only retrieve that number of metrics.

Returns:

zetMetricGetProperties#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricGetProperties(zet_metric_handle_t hMetric, zet_metric_properties_t *pProperties)#

Retrieves attributes of a metric.

  • The application may call this function from simultaneous threads.

Parameters:

  • hMetric – [in] handle of the metric

  • pProperties – [in,out] metric properties

Returns:

zetContextActivateMetricGroups#

ZE_APIEXPORT ze_result_t ZE_APICALL zetContextActivateMetricGroups(zet_context_handle_t hContext, zet_device_handle_t hDevice, uint32_t count, zet_metric_group_handle_t *phMetricGroups)#

Activates metric groups.

  • 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 zet_metric_group_properties_t.

  • The application must not call this function from simultaneous threads with the same device handle.

Parameters:

  • hContext – [in] handle of the context object

  • hDevice – [in] handle of the device

  • count – [in] metric group count to activate; must be 0 if nullptr == phMetricGroups

  • phMetricGroups – [in][optional][range(0, count)] handles of the metric groups to activate. nullptr deactivates all previously used metric groups. all metrics groups must come from a different domains. metric query and metric stream must use activated metric groups.

Returns:

zetMetricStreamerOpen#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricStreamerOpen(zet_context_handle_t hContext, zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup, zet_metric_streamer_desc_t *desc, ze_event_handle_t hNotificationEvent, zet_metric_streamer_handle_t *phMetricStreamer)#

Opens metric streamer for a device.

  • The notification event must have been created from an event pool that was created using ZE_EVENT_POOL_FLAG_HOST_VISIBLE flag.

  • The duration of the signal event created from an event pool that was created using ZE_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.

Parameters:

  • hContext – [in] handle of the context object

  • hDevice – [in] handle of the device

  • hMetricGroup – [in] handle of the metric group

  • desc – [in,out] metric streamer descriptor

  • hNotificationEvent – [in][optional] event used for report availability notification

  • phMetricStreamer – [out] handle of metric streamer

Returns:

zetCommandListAppendMetricStreamerMarker#

ZE_APIEXPORT ze_result_t ZE_APICALL zetCommandListAppendMetricStreamerMarker(zet_command_list_handle_t hCommandList, zet_metric_streamer_handle_t hMetricStreamer, uint32_t value)#

Append metric streamer marker into a command list.

  • 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.

Parameters:

  • hCommandList – [in] handle of the command list

  • hMetricStreamer – [in] handle of the metric streamer

  • value – [in] streamer marker value

Returns:

zetMetricStreamerClose#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricStreamerClose(zet_metric_streamer_handle_t hMetricStreamer)#

Closes metric streamer.

  • The application must not call this function from simultaneous threads with the same metric streamer handle.

Parameters:

hMetricStreamer – [in][release] handle of the metric streamer

Returns:

zetMetricStreamerReadData#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricStreamerReadData(zet_metric_streamer_handle_t hMetricStreamer, uint32_t maxReportCount, size_t *pRawDataSize, uint8_t *pRawData)#

Reads data from metric streamer.

  • The application may call this function from simultaneous threads.

Parameters:

  • hMetricStreamer – [in] handle of the metric streamer

  • maxReportCount – [in] the maximum number of reports the application wants to receive. if UINT32_MAX, then function will retrieve all reports available

  • pRawDataSize – [in,out] pointer to size in bytes of raw data requested to read. if size is zero, then the driver will update the value with the total size in bytes needed for all reports available. if size is non-zero, then driver will only retrieve the number of reports that fit into the buffer. if size is larger than size needed for all reports, then driver will update the value with the actual size needed.

  • pRawData – [in,out][optional][range(0, *pRawDataSize)] buffer containing streamer reports in raw format

Returns:

zetMetricQueryPoolCreate#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricQueryPoolCreate(zet_context_handle_t hContext, zet_device_handle_t hDevice, zet_metric_group_handle_t hMetricGroup, const zet_metric_query_pool_desc_t *desc, zet_metric_query_pool_handle_t *phMetricQueryPool)#

Creates a pool of metric queries on the context.

  • The application may call this function from simultaneous threads.

  • The implementation of this function must be thread-safe.

Parameters:

  • hContext – [in] handle of the context object

  • hDevice – [in] handle of the device

  • hMetricGroup – [in] metric group associated with the query object.

  • desc – [in] metric query pool descriptor

  • phMetricQueryPool – [out] handle of metric query pool

Returns:

zetMetricQueryPoolDestroy#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricQueryPoolDestroy(zet_metric_query_pool_handle_t hMetricQueryPool)#

Deletes a query pool object.

  • 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.

Parameters:

hMetricQueryPool – [in][release] handle of the metric query pool

Returns:

zetMetricQueryCreate#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricQueryCreate(zet_metric_query_pool_handle_t hMetricQueryPool, uint32_t index, zet_metric_query_handle_t *phMetricQuery)#

Creates metric query from the pool.

  • The application may call this function from simultaneous threads.

  • The implementation of this function must be thread-safe.

Parameters:

  • hMetricQueryPool – [in] handle of the metric query pool

  • index – [in] index of the query within the pool

  • phMetricQuery – [out] handle of metric query

Returns:

zetMetricQueryDestroy#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricQueryDestroy(zet_metric_query_handle_t hMetricQuery)#

Deletes a metric query object.

  • 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.

Parameters:

hMetricQuery – [in][release] handle of metric query

Returns:

zetMetricQueryReset#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricQueryReset(zet_metric_query_handle_t hMetricQuery)#

Resets a metric query object back to initial state.

  • 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.

Parameters:

hMetricQuery – [in] handle of metric query

Returns:

zetCommandListAppendMetricQueryBegin#

ZE_APIEXPORT ze_result_t ZE_APICALL zetCommandListAppendMetricQueryBegin(zet_command_list_handle_t hCommandList, zet_metric_query_handle_t hMetricQuery)#

Appends metric query begin into a command list.

  • 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.

Parameters:

  • hCommandList – [in] handle of the command list

  • hMetricQuery – [in] handle of the metric query

Returns:

zetCommandListAppendMetricQueryEnd#

ZE_APIEXPORT ze_result_t ZE_APICALL zetCommandListAppendMetricQueryEnd(zet_command_list_handle_t hCommandList, zet_metric_query_handle_t hMetricQuery, ze_event_handle_t hSignalEvent, uint32_t numWaitEvents, ze_event_handle_t *phWaitEvents)#

Appends metric query end into a command list.

  • 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 ZE_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.

Parameters:

  • hCommandList – [in] handle of the command list

  • hMetricQuery – [in] handle of the metric query

  • hSignalEvent – [in][optional] handle of the event to signal on completion

  • numWaitEvents – [in] must be zero

  • phWaitEvents – [in][mbz] must be nullptr

Returns:

zetCommandListAppendMetricMemoryBarrier#

ZE_APIEXPORT ze_result_t ZE_APICALL zetCommandListAppendMetricMemoryBarrier(zet_command_list_handle_t hCommandList)#

Appends metric query commands to flush all caches.

  • The application must not call this function from simultaneous threads with the same command list handle.

Parameters:

hCommandList – [in] handle of the command list

Returns:

zetMetricQueryGetData#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricQueryGetData(zet_metric_query_handle_t hMetricQuery, size_t *pRawDataSize, uint8_t *pRawData)#

Retrieves raw data for a given metric query.

  • The application may call this function from simultaneous threads.

Parameters:

  • hMetricQuery – [in] handle of the metric query

  • pRawDataSize – [in,out] pointer to size in bytes of raw data requested to read. if size is zero, then the driver will update the value with the total size in bytes needed for all reports available. if size is non-zero, then driver will only retrieve the number of reports that fit into the buffer. if size is larger than size needed for all reports, then driver will update the value with the actual size needed.

  • pRawData – [in,out][optional][range(0, *pRawDataSize)] buffer containing query reports in raw format

Returns:

Metric Enums#

zet_metric_group_sampling_type_flags_t#

enum zet_metric_group_sampling_type_flag_t#

Values:

enumerator ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EVENT_BASED#

Event based sampling.

enumerator ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED#

Time based sampling.

enumerator ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_EXP_TRACER_BASED#

Experimental Tracer based sampling.

enumerator ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_FORCE_UINT32#

zet_metric_type_t#

enum zet_metric_type_t#

Metric types.

Values:

enumerator ZET_METRIC_TYPE_DURATION#

Metric type: duration.

enumerator ZET_METRIC_TYPE_EVENT#

Metric type: event.

enumerator ZET_METRIC_TYPE_EVENT_WITH_RANGE#

Metric type: event with range.

enumerator ZET_METRIC_TYPE_THROUGHPUT#

Metric type: throughput.

enumerator ZET_METRIC_TYPE_TIMESTAMP#

Metric type: timestamp.

enumerator ZET_METRIC_TYPE_FLAG#

Metric type: flag.

enumerator ZET_METRIC_TYPE_RATIO#

Metric type: ratio.

enumerator ZET_METRIC_TYPE_RAW#

Metric type: raw.

enumerator ZET_METRIC_TYPE_IP_EXP#

Metric type: instruction pointer. Deprecated, use ZET_METRIC_TYPE_IP.

enumerator ZET_METRIC_TYPE_IP#

Metric type: instruction pointer.

enumerator ZET_METRIC_TYPE_EVENT_EXP_TIMESTAMP#

Metric type: event with only timestamp and value has no meaning.

enumerator ZET_METRIC_TYPE_EVENT_EXP_START#

Metric type: the first event of a start/end event pair.

enumerator ZET_METRIC_TYPE_EVENT_EXP_END#

Metric type: the second event of a start/end event pair.

enumerator ZET_METRIC_TYPE_EXPORT_DMA_BUF#

Metric which exports linux dma_buf, which could be imported/mapped to the host process

enumerator ZET_METRIC_TYPE_EVENT_EXP_MONOTONIC_WRAPS_VALUE#

Metric type: value of the event is a monotonically increasing value that can wrap around

enumerator ZET_METRIC_TYPE_FORCE_UINT32#

zet_metric_group_calculation_type_t#

enum zet_metric_group_calculation_type_t#

Metric group calculation type.

Values:

enumerator ZET_METRIC_GROUP_CALCULATION_TYPE_METRIC_VALUES#

Calculated metric values from raw data.

enumerator ZET_METRIC_GROUP_CALCULATION_TYPE_MAX_METRIC_VALUES#

Maximum metric values.

enumerator ZET_METRIC_GROUP_CALCULATION_TYPE_FORCE_UINT32#

zet_metric_query_pool_type_t#

enum zet_metric_query_pool_type_t#

Metric query pool types.

Values:

enumerator ZET_METRIC_QUERY_POOL_TYPE_PERFORMANCE#

Performance metric query pool.

enumerator ZET_METRIC_QUERY_POOL_TYPE_EXECUTION#

Skips workload execution between begin/end calls.

enumerator ZET_METRIC_QUERY_POOL_TYPE_FORCE_UINT32#

Metric Structures#

zet_metric_group_properties_t#

struct zet_metric_group_properties_t#

Metric group properties queried using zetMetricGroupGetProperties.

Public Members

zet_structure_type_t stype#

[in] type of this structure

void *pNext#

[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).

char name[ZET_MAX_METRIC_GROUP_NAME]#

[out] metric group name

char description[ZET_MAX_METRIC_GROUP_DESCRIPTION]#

[out] metric group description

zet_metric_group_sampling_type_flags_t samplingType#

[out] metric group sampling type. returns a combination of zet_metric_group_sampling_type_flag_t.

uint32_t domain#

[out] metric group domain number. Cannot use multiple, simultaneous metric groups from the same domain.

uint32_t metricCount#

[out] metric count belonging to this group

zet_metric_properties_t#

struct zet_metric_properties_t#

Metric properties queried using zetMetricGetProperties.

Public Members

zet_structure_type_t stype#

[in] type of this structure

void *pNext#

[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).

char name[ZET_MAX_METRIC_NAME]#

[out] metric name

char description[ZET_MAX_METRIC_DESCRIPTION]#

[out] metric description

char component[ZET_MAX_METRIC_COMPONENT]#

[out] metric component

uint32_t tierNumber#

[out] number of tier

zet_metric_type_t metricType#

[out] metric type

zet_value_type_t resultType#

[out] metric result type

char resultUnits[ZET_MAX_METRIC_RESULT_UNITS]#

[out] metric result units

zet_metric_streamer_desc_t#

struct zet_metric_streamer_desc_t#

Metric streamer descriptor.

Public Members

zet_structure_type_t stype#

[in] type of this structure

const void *pNext#

[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).

uint32_t notifyEveryNReports#

[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 zetMetricStreamerOpen.

uint32_t samplingPeriod#

[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 zetMetricStreamerOpen.

zet_metric_query_pool_desc_t#

struct zet_metric_query_pool_desc_t#

Metric query pool description.

Public Members

zet_structure_type_t stype#

[in] type of this structure

const void *pNext#

[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).

zet_metric_query_pool_type_t type#

[in] Query pool type.

uint32_t count#

[in] Internal slots count within query pool object.

Pin#

Pin Functions#

zetKernelGetProfileInfo#

ZE_APIEXPORT ze_result_t ZE_APICALL zetKernelGetProfileInfo(zet_kernel_handle_t hKernel, zet_profile_properties_t *pProfileProperties)#

Retrieve profiling information generated for the kernel.

  • Module must be created using the following build option:

    • ”-zet-profile-flags <n>” - enable generation of profile information

    • ”<n>” must be a combination of zet_profile_flag_t, in hex

  • The application may call this function from simultaneous threads.

  • The implementation of this function should be lock-free.

Parameters:

  • hKernel – [in] handle to kernel

  • pProfileProperties – [out] pointer to profile properties

Returns:

Pin Enums#

zet_profile_flags_t#

enum zet_profile_flag_t#

Values:

enumerator ZET_PROFILE_FLAG_REGISTER_REALLOCATION#

request the compiler attempt to minimize register usage as much as possible to allow for instrumentation

enumerator ZET_PROFILE_FLAG_FREE_REGISTER_INFO#

request the compiler generate free register info

enumerator ZET_PROFILE_FLAG_FORCE_UINT32#

zet_profile_token_type_t#

enum zet_profile_token_type_t#

Supported profile token types.

Values:

enumerator ZET_PROFILE_TOKEN_TYPE_FREE_REGISTER#

GRF info.

enumerator ZET_PROFILE_TOKEN_TYPE_FORCE_UINT32#

Pin Structures#

zet_profile_properties_t#

struct zet_profile_properties_t#

Profiling meta-data for instrumentation.

Public Members

zet_structure_type_t stype#

[in] type of this structure

void *pNext#

[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).

zet_profile_flags_t flags#

[out] indicates which flags were enabled during compilation. returns 0 (none) or a combination of zet_profile_flag_t

uint32_t numTokens#

[out] number of tokens immediately following this structure

zet_profile_free_register_token_t#

struct zet_profile_free_register_token_t#

Profile free register token detailing unused registers in the current function.

Public Members

zet_profile_token_type_t type#

[out] type of token

uint32_t size#

[out] total size of the token, in bytes

uint32_t count#

[out] number of register sequences immediately following this structure

zet_profile_register_sequence_t#

struct zet_profile_register_sequence_t#

Profile register sequence detailing consecutive bytes, all of which are unused.

Public Members

uint32_t start#

[out] starting byte in the register table, representing the start of unused bytes in the current function

uint32_t count#

[out] number of consecutive bytes in the sequence, starting from start

Tracing#

Tracing Functions#

zetTracerExpCreate#

ZE_APIEXPORT ze_result_t ZE_APICALL zetTracerExpCreate(zet_context_handle_t hContext, const zet_tracer_exp_desc_t *desc, zet_tracer_exp_handle_t *phTracer)#

Creates a tracer on the context.

  • 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.

Parameters:

  • hContext – [in] handle of the context object

  • desc – [in] pointer to tracer descriptor

  • phTracer – [out] pointer to handle of tracer object created

Returns:

zetTracerExpDestroy#

ZE_APIEXPORT ze_result_t ZE_APICALL zetTracerExpDestroy(zet_tracer_exp_handle_t hTracer)#

Destroys a tracer.

  • 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.

Parameters:

hTracer – [in][release] handle of tracer object to destroy

Returns:

zetTracerExpSetPrologues#

ZE_APIEXPORT ze_result_t ZE_APICALL zetTracerExpSetPrologues(zet_tracer_exp_handle_t hTracer, zet_core_callbacks_t *pCoreCbs)#

Sets the collection of callbacks to be executed before driver execution.

  • 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.

Parameters:

  • hTracer – [in] handle of the tracer

  • pCoreCbs – [in] pointer to table of ‘core’ callback function pointers

Returns:

zetTracerExpSetEpilogues#

ZE_APIEXPORT ze_result_t ZE_APICALL zetTracerExpSetEpilogues(zet_tracer_exp_handle_t hTracer, zet_core_callbacks_t *pCoreCbs)#

Sets the collection of callbacks to be executed after driver execution.

  • 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.

Parameters:

  • hTracer – [in] handle of the tracer

  • pCoreCbs – [in] pointer to table of ‘core’ callback function pointers

Returns:

zetTracerExpSetEnabled#

ZE_APIEXPORT ze_result_t ZE_APICALL zetTracerExpSetEnabled(zet_tracer_exp_handle_t hTracer, ze_bool_t enable)#

Enables (or disables) the tracer.

  • The application must not call this function from simultaneous threads with the same tracer handle.

Parameters:

  • hTracer – [in] handle of the tracer

  • enable – [in] enable the tracer if true; disable if false

Returns:

Tracing Enums#

zet_api_tracing_exp_version_t#

enum zet_api_tracing_exp_version_t#

API Tracing Experimental Extension Version(s)

Values:

enumerator ZET_API_TRACING_EXP_VERSION_1_0#

version 1.0

enumerator ZET_API_TRACING_EXP_VERSION_CURRENT#

latest known version

enumerator ZET_API_TRACING_EXP_VERSION_FORCE_UINT32#

Tracing Structures#

zet_tracer_exp_desc_t#

struct zet_tracer_exp_desc_t#

Tracer descriptor.

Public Members

zet_structure_type_t stype#

[in] type of this structure

const void *pNext#

[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).

void *pUserData#

[in] pointer passed to every tracer’s callbacks

Concurrentmetricgroup#

Concurrentmetricgroup Functions#

zetDeviceGetConcurrentMetricGroupsExp#

ZE_APIEXPORT ze_result_t ZE_APICALL zetDeviceGetConcurrentMetricGroupsExp(zet_device_handle_t hDevice, uint32_t metricGroupCount, zet_metric_group_handle_t *phMetricGroups, uint32_t *pMetricGroupsCountPerConcurrentGroup, uint32_t *pConcurrentGroupCount)#

Get sets of metric groups which could be collected concurrently.

  • Re-arrange the input metric groups to provide sets of concurrent metric groups.

Parameters:

  • hDevice – [in] handle of the device

  • metricGroupCount – [in] metric group count

  • phMetricGroups – [in,out] metrics groups to be re-arranged to be sets of concurrent groups

  • pMetricGroupsCountPerConcurrentGroup – [in,out][optional][*pConcurrentGroupCount] count of metric groups per concurrent group.

  • pConcurrentGroupCount – [out] number of concurrent groups. The value of this parameter could be used to determine the number of replays necessary.

Returns:

Concurrentmetricgroup Enums#

zet_concurrent_metric_groups_exp_version_t#

enum zet_concurrent_metric_groups_exp_version_t#

Concurrent Metric Groups Experimental Extension Version(s)

Values:

enumerator ZET_CONCURRENT_METRIC_GROUPS_EXP_VERSION_1_0#

version 1.0

enumerator ZET_CONCURRENT_METRIC_GROUPS_EXP_VERSION_CURRENT#

latest known version

enumerator ZET_CONCURRENT_METRIC_GROUPS_EXP_VERSION_FORCE_UINT32#

Metrictracer#

Metrictracer Functions#

zetMetricTracerCreateExp#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricTracerCreateExp(zet_context_handle_t hContext, zet_device_handle_t hDevice, uint32_t metricGroupCount, zet_metric_group_handle_t *phMetricGroups, zet_metric_tracer_exp_desc_t *desc, ze_event_handle_t hNotificationEvent, zet_metric_tracer_exp_handle_t *phMetricTracer)#

Create a metric tracer for a device.

  • The notification event must have been created from an event pool that was created using ZE_EVENT_POOL_FLAG_HOST_VISIBLE flag.

  • The duration of the signal event created from an event pool that was created using ZE_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

Parameters:

  • hContext – [in] handle of the context object

  • hDevice – [in] handle of the device

  • metricGroupCount – [in] metric group count

  • phMetricGroups – [in][range(0, metricGroupCount )] handles of the metric groups to trace

  • desc – [in,out] metric tracer descriptor

  • hNotificationEvent – [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

  • phMetricTracer – [out] handle of the metric tracer

Returns:

zetMetricTracerDestroyExp#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricTracerDestroyExp(zet_metric_tracer_exp_handle_t hMetricTracer)#

Destroy a metric tracer.

  • The application must not call this function from simultaneous threads with the same metric tracer handle.

Parameters:

hMetricTracer – [in] handle of the metric tracer

Returns:

zetMetricTracerEnableExp#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricTracerEnableExp(zet_metric_tracer_exp_handle_t hMetricTracer, ze_bool_t synchronous)#

Start events collection.

  • 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.

Parameters:

  • hMetricTracer – [in] handle of the metric tracer

  • synchronous – [in] request synchronous behavior. Confirmation of successful asynchronous operation is done by calling zetMetricTracerReadDataExp() and checking the return status: ZE_RESULT_NOT_READY will be returned when the tracer is inactive. ZE_RESULT_SUCCESS will be returned when the tracer is active.

Returns:

zetMetricTracerDisableExp#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricTracerDisableExp(zet_metric_tracer_exp_handle_t hMetricTracer, ze_bool_t synchronous)#

Stop events collection.

  • 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.

Parameters:

  • hMetricTracer – [in] handle of the metric tracer

  • synchronous – [in] request synchronous behavior. Confirmation of successful asynchronous operation is done by calling zetMetricTracerReadDataExp() and checking the return status: ZE_RESULT_SUCCESS will be returned when the tracer is active or when it is inactive but still has data. ZE_RESULT_NOT_READY will be returned when the tracer is inactive and has no more data to be retrieved.

Returns:

zetMetricTracerReadDataExp#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricTracerReadDataExp(zet_metric_tracer_exp_handle_t hMetricTracer, size_t *pRawDataSize, uint8_t *pRawData)#

Read data from the metric tracer.

  • 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

Parameters:

  • hMetricTracer – [in] handle of the metric tracer

  • pRawDataSize – [in,out] pointer to size in bytes of raw data requested to read. if size is zero, then the driver will update the value with the total size in bytes needed for all data available. if size is non-zero, then driver will only retrieve that amount of data. if size is larger than size needed for all data, then driver will update the value with the actual size needed.

  • pRawData – [in,out][optional][range(0, *pRawDataSize)] buffer containing tracer data in raw format

Returns:

zetMetricDecoderCreateExp#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricDecoderCreateExp(zet_metric_tracer_exp_handle_t hMetricTracer, zet_metric_decoder_exp_handle_t *phMetricDecoder)#

Create a metric decoder for a given metric tracer.

Parameters:

  • hMetricTracer – [in] handle of the metric tracer

  • phMetricDecoder – [out] handle of the metric decoder object

Returns:

zetMetricDecoderDestroyExp#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricDecoderDestroyExp(zet_metric_decoder_exp_handle_t phMetricDecoder)#

Destroy a metric decoder.

Parameters:

phMetricDecoder – [in] handle of the metric decoder object

Returns:

zetMetricDecoderGetDecodableMetricsExp#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricDecoderGetDecodableMetricsExp(zet_metric_decoder_exp_handle_t hMetricDecoder, uint32_t *pCount, zet_metric_handle_t *phMetrics)#

Return the list of the decodable metrics from the decoder.

  • 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.

Parameters:

  • hMetricDecoder – [in] handle of the metric decoder object

  • pCount – [in,out] pointer to number of decodable metric in the hMetricDecoder handle. If count is zero, then the driver shall update the value with the total number of decodable metrics available in the decoder. if count is greater than zero but less than the total number of decodable metrics available in the decoder, then only that number will be returned. if count is greater than the number of decodable metrics available in the decoder, then the driver shall update the value with the actual number of decodable metrics available.

  • phMetrics – [in,out] [range(0, *pCount)] array of handles of decodable metrics in the hMetricDecoder handle provided.

Returns:

zetMetricTracerDecodeExp#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricTracerDecodeExp(zet_metric_decoder_exp_handle_t phMetricDecoder, size_t *pRawDataSize, uint8_t *pRawData, uint32_t metricsCount, zet_metric_handle_t *phMetrics, uint32_t *pSetCount, uint32_t *pMetricEntriesCountPerSet, uint32_t *pMetricEntriesCount, zet_metric_entry_exp_t *pMetricEntries)#

Decode raw events collected from a tracer.

Parameters:

  • phMetricDecoder – [in] handle of the metric decoder object

  • pRawDataSize – [in,out] size in bytes of raw data buffer. If pMetricEntriesCount is greater than zero but less than total number of decodable metrics available in the raw data buffer, then driver shall update this value with actual number of raw data bytes processed.

  • pRawData – [in,out][optional][range(0, *pRawDataSize)] buffer containing tracer data in raw format

  • metricsCount – [in] number of decodable metrics in the tracer for which the hMetricDecoder handle was provided. See zetMetricDecoderGetDecodableMetricsExp(). If metricCount is greater than zero but less than the number decodable metrics available in the raw data buffer, then driver shall only decode those.

  • phMetrics – [in] [range(0, metricsCount)] array of handles of decodable metrics in the decoder for which the hMetricDecoder handle was provided. Metrics handles are expected to be for decodable metrics, see ::zetMetricDecoderGetDecodableMetrics()

  • pSetCount – [in,out] pointer to number of metric sets. If count is zero, then the driver shall update the value with the total number of metric sets to be decoded. If 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 decoded. There is a 1:1 relation between the number of sets and sub-devices returned in the decoded entries.

  • pMetricEntriesCountPerSet – [in,out][optional][range(0, *pSetCount)] buffer of metric entries counts per metric set, one value per set.

  • pMetricEntriesCount – [in,out] pointer to the total number of metric entries decoded, for all metric sets. If count is zero, then the driver shall update the value with the total number of metric entries to be decoded. If count is greater than zero but less than the total number of metric entries available in the raw data, then user provided number will be decoded. If count is greater than the number available in the raw data buffer, then the driver shall update the value with the actual number of decodable metric entries decoded. If set to null, then driver will only update the value of pSetCount.

  • pMetricEntries – [in,out][optional][range(0, *pMetricEntriesCount)] buffer containing decoded metric entries

Returns:

Metrictracer Enums#

zet_metric_tracer_exp_version_t#

enum zet_metric_tracer_exp_version_t#

Metric Tracer Experimental Extension Version(s)

Values:

enumerator ZET_METRIC_TRACER_EXP_VERSION_1_0#

version 1.0

enumerator ZET_METRIC_TRACER_EXP_VERSION_CURRENT#

latest known version

enumerator ZET_METRIC_TRACER_EXP_VERSION_FORCE_UINT32#

Metrictracer Structures#

zet_metric_tracer_exp_desc_t#

struct zet_metric_tracer_exp_desc_t#

Metric tracer descriptor.

Public Members

zet_structure_type_t stype#

[in] type of this structure

const void *pNext#

[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).

uint32_t notifyEveryNBytes#

[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.

zet_metric_entry_exp_t#

struct zet_metric_entry_exp_t#

Decoded metric entry.

Public Members

zet_value_t value#

[out] value of the decodable metric entry or event. Number is meaningful based on the metric type.

uint64_t timeStamp#

[out] timestamp at which the event happened.

uint32_t metricIndex#

[out] index to the decodable metric handle in the input array (phMetric) in zetMetricTracerDecodeExp().

ze_bool_t onSubdevice#

[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.

uint32_t subdeviceId#

[out] If onSubdevice is true, this gives the ID of the sub-device.

Metricexportmemory#

Metricexportmemory Enums#

zet_metric_group_type_exp_flags_t#

enum zet_metric_group_type_exp_flag_t#

Values:

enumerator ZET_METRIC_GROUP_TYPE_EXP_FLAG_EXPORT_DMA_BUF#

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.

enumerator ZET_METRIC_GROUP_TYPE_EXP_FLAG_USER_CREATED#

Metric group created using zetMetricGroupCreateExp.

enumerator ZET_METRIC_GROUP_TYPE_EXP_FLAG_OTHER#

Metric group which has a collection of metrics.

enumerator ZET_METRIC_GROUP_TYPE_EXP_FLAG_FORCE_UINT32#

Metricexportmemory Structures#

zet_metric_group_type_exp_t#

struct zet_metric_group_type_exp_t#

Query the metric group type using pNext of zet_metric_group_properties_t.

Public Members

zet_structure_type_t stype#

[in] type of this structure

void *pNext#

[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).

zet_metric_group_type_exp_flags_t type#

[out] metric group type. returns a combination of zet_metric_group_type_exp_flags_t.

zet_export_dma_buf_exp_properties_t#

struct zet_export_dma_buf_exp_properties_t#

Exported dma_buf properties queried using pNext of zet_metric_group_properties_t or zet_metric_properties_t.

Public Members

zet_structure_type_t stype#

[in] type of this structure

void *pNext#

[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).

int fd#

[out] the file descriptor handle that could be used to import the memory by the host process.

size_t size#

[out] size in bytes of the dma_buf

Multimetricvalues#

Multimetricvalues Functions#

zetMetricGroupCalculateMultipleMetricValuesExp#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricGroupCalculateMultipleMetricValuesExp(zet_metric_group_handle_t hMetricGroup, zet_metric_group_calculation_type_t type, size_t rawDataSize, const uint8_t *pRawData, uint32_t *pSetCount, uint32_t *pTotalMetricValueCount, uint32_t *pMetricCounts, zet_typed_value_t *pMetricValues)#

Calculate one or more sets of metric values from raw data.

  • This function is similar to zetMetricGroupCalculateMetricValues 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.

Parameters:

  • hMetricGroup – [in] handle of the metric group

  • type – [in] calculation type to be applied on raw data

  • rawDataSize – [in] size in bytes of raw data buffer

  • pRawData – [in][range(0, rawDataSize)] buffer of raw data to calculate

  • pSetCount – [in,out] pointer to number of metric sets. if count is zero, then the driver shall update the value with the total number of metric sets to be calculated. if 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.

  • pTotalMetricValueCount – [in,out] pointer to number of the total number of metric values calculated, for all metric sets. if count is zero, then the driver shall update the value with the total number of metric values to be calculated. if 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.

  • pMetricCounts – [in,out][optional][range(0, *pSetCount)] buffer of metric counts per metric set.

  • pMetricValues – [in,out][optional][range(0, *pTotalMetricValueCount)] buffer of calculated metrics. if count is less than the number available in the raw data buffer, then driver shall only calculate that number of metric values.

Returns:

Multimetricvalues Enums#

ze_calculate_multiple_metrics_exp_version_t#

enum ze_calculate_multiple_metrics_exp_version_t#

Calculating Multiple Metrics Experimental Extension Version(s)

Values:

enumerator ZE_CALCULATE_MULTIPLE_METRICS_EXP_VERSION_1_0#

version 1.0

enumerator ZE_CALCULATE_MULTIPLE_METRICS_EXP_VERSION_CURRENT#

latest known version

enumerator ZE_CALCULATE_MULTIPLE_METRICS_EXP_VERSION_FORCE_UINT32#

Globaltimestamps#

Globaltimestamps Functions#

zetMetricGroupGetGlobalTimestampsExp#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricGroupGetGlobalTimestampsExp(zet_metric_group_handle_t hMetricGroup, ze_bool_t synchronizedWithHost, uint64_t *globalTimestamp, uint64_t *metricTimestamp)#

Returns metric timestamps synchronized with global device timestamps, optionally synchronized with host.

  • The application may call this function from simultaneous threads.

  • By default, the global and metrics timestamps are synchronized to the device.

Parameters:

  • hMetricGroup – [in] handle of the metric group

  • synchronizedWithHost – [in] Returns the timestamps synchronized to the host or the device.

  • globalTimestamp – [out] Device timestamp.

  • metricTimestamp – [out] Metric timestamp.

Returns:

Globaltimestamps Enums#

ze_metric_global_timestamps_exp_version_t#

enum ze_metric_global_timestamps_exp_version_t#

Global Metric Timestamps Experimental Extension Version(s)

Values:

enumerator ZE_METRIC_GLOBAL_TIMESTAMPS_EXP_VERSION_1_0#

version 1.0

enumerator ZE_METRIC_GLOBAL_TIMESTAMPS_EXP_VERSION_CURRENT#

latest known version

enumerator ZE_METRIC_GLOBAL_TIMESTAMPS_EXP_VERSION_FORCE_UINT32#

Globaltimestamps Structures#

zet_metric_global_timestamps_resolution_exp_t#

struct zet_metric_global_timestamps_resolution_exp_t#

Metric timestamps resolution.

Public Members

zet_structure_type_t stype#

[in] type of this structure

const void *pNext#

[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).

uint64_t timerResolution#

[out] Returns the resolution of metrics timer (used for timestamps) in cycles/sec.

uint64_t timestampValidBits#

[out] Returns the number of valid bits in the timestamp value.

Metricexportdata#

Metricexportdata Functions#

zetMetricGroupGetExportDataExp#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricGroupGetExportDataExp(zet_metric_group_handle_t hMetricGroup, const uint8_t *pRawData, size_t rawDataSize, size_t *pExportDataSize, uint8_t *pExportData)#

Export Metrics Data for system independent calculation.

  • 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.

Parameters:

  • hMetricGroup – [in] handle of the metric group

  • pRawData – [in] buffer of raw data

  • rawDataSize – [in] size in bytes of raw data buffer

  • pExportDataSize – [in,out] size in bytes of export data buffer if size is zero, then the driver shall update the value with the number of bytes necessary to store the exported data. if size is greater than required, then the driver shall update the value with the actual number of bytes necessary to store the exported data.

  • pExportData – [in,out][optional][range(0, *pExportDataSize)] buffer of exported data.

Returns:

zetMetricGroupCalculateMetricExportDataExp#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricGroupCalculateMetricExportDataExp(ze_driver_handle_t hDriver, zet_metric_group_calculation_type_t type, size_t exportDataSize, const uint8_t *pExportData, zet_metric_calculate_exp_desc_t *pCalculateDescriptor, uint32_t *pSetCount, uint32_t *pTotalMetricValueCount, uint32_t *pMetricCounts, zet_typed_value_t *pMetricValues)#

Calculate one or more sets of metric values from exported raw data.

  • Calculate metrics values using exported data returned by zetMetricGroupGetExportDataExp.

  • This function is similar to zetMetricGroupCalculateMultipleMetricValuesExp 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.

Parameters:

  • hDriver – [in] handle of the driver instance

  • type – [in] calculation type to be applied on raw data

  • exportDataSize – [in] size in bytes of exported data buffer

  • pExportData – [in][range(0, exportDataSize)] buffer of exported data to calculate

  • pCalculateDescriptor – [in] descriptor specifying calculation specific parameters

  • pSetCount – [in,out] pointer to number of metric sets. if count is zero, then the driver shall update the value with the total number of metric sets to be calculated. if 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.

  • pTotalMetricValueCount – [in,out] pointer to number of the total number of metric values calculated, for all metric sets. if count is zero, then the driver shall update the value with the total number of metric values to be calculated. if 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.

  • pMetricCounts – [in,out][optional][range(0, *pSetCount)] buffer of metric counts per metric set.

  • pMetricValues – [in,out][optional][range(0, *pTotalMetricValueCount)] buffer of calculated metrics. if count is less than the number available in the raw data buffer, then driver shall only calculate that number of metric values.

Returns:

Metricexportdata Enums#

zet_export_metric_data_exp_version_t#

enum zet_export_metric_data_exp_version_t#

Exporting Metrics Data Experimental Extension Version(s)

Values:

enumerator ZET_EXPORT_METRIC_DATA_EXP_VERSION_1_0#

version 1.0

enumerator ZET_EXPORT_METRIC_DATA_EXP_VERSION_CURRENT#

latest known version

enumerator ZET_EXPORT_METRIC_DATA_EXP_VERSION_FORCE_UINT32#

Metricexportdata Structures#

zet_metric_calculate_exp_desc_t#

struct zet_metric_calculate_exp_desc_t#

Metrics calculation descriptor.

Public Members

zet_structure_type_t stype#

[in] type of this structure

const void *pNext#

[in][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).

uint32_t rawReportSkipCount#

[in] number of reports to skip during calculation

Metricprogrammable#

Metricprogrammable Functions#

zetMetricProgrammableGetExp#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricProgrammableGetExp(zet_device_handle_t hDevice, uint32_t *pCount, zet_metric_programmable_exp_handle_t *phMetricProgrammables)#

Query and get the available metric programmable handles.

  • 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.

Parameters:

  • hDevice – [in] handle of the device

  • pCount – [in,out] pointer to the number of metric programmable handles. if count is zero, then the driver shall update the value with the total number of metric programmable handles available. if 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.

  • phMetricProgrammables – [in,out][optional][range(0, *pCount)] array of handle of metric programmables. if count is less than the number of metric programmables available, then driver shall only retrieve that number of metric programmables.

Returns:

zetMetricProgrammableGetPropertiesExp#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricProgrammableGetPropertiesExp(zet_metric_programmable_exp_handle_t hMetricProgrammable, zet_metric_programmable_exp_properties_t *pProperties)#

Get the properties of the metric programmable.

  • Returns the properties of the metric programmable.

Parameters:

  • hMetricProgrammable – [in] handle of the metric programmable

  • pProperties – [in,out] properties of the metric programmable

Returns:

zetMetricProgrammableGetParamInfoExp#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricProgrammableGetParamInfoExp(zet_metric_programmable_exp_handle_t hMetricProgrammable, uint32_t *pParameterCount, zet_metric_programmable_param_info_exp_t *pParameterInfo)#

Get the information about the parameters of the metric programmable.

  • Returns information about the parameters of the metric programmable handle.

Parameters:

  • hMetricProgrammable – [in] handle of the metric programmable

  • pParameterCount – [in,out] count of the parameters to retrieve parameter info. if value pParameterCount is greater than count of parameters available, then pParameterCount will be updated with count of parameters available. The count of parameters available can be queried using zetMetricProgrammableGetPropertiesExp.

  • pParameterInfo – [in,out][range(1, *pParameterCount)] array of parameter info. if parameterCount is less than the number of parameters available, then driver shall only retrieve that number of parameter info.

Returns:

zetMetricProgrammableGetParamValueInfoExp#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricProgrammableGetParamValueInfoExp(zet_metric_programmable_exp_handle_t hMetricProgrammable, uint32_t parameterOrdinal, uint32_t *pValueInfoCount, zet_metric_programmable_param_value_info_exp_t *pValueInfo)#

Get the information about the parameter value of the metric programmable.

  • Returns the value-information about the parameter at the specific ordinal of the metric programmable handle.

Parameters:

  • hMetricProgrammable – [in] handle of the metric programmable

  • parameterOrdinal – [in] ordinal of the parameter in the metric programmable

  • pValueInfoCount – [in,out] count of parameter value information to retrieve. if value at pValueInfoCount is greater than count of value info available, then pValueInfoCount will be updated with count of value info available. The count of parameter value info available can be queried using zetMetricProgrammableGetParamInfoExp.

  • pValueInfo – [in,out][range(1, *pValueInfoCount)] array of parameter value info. if pValueInfoCount is less than the number of value info available, then driver shall only retrieve that number of value info.

Returns:

zetMetricCreateFromProgrammableExp2#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricCreateFromProgrammableExp2(zet_metric_programmable_exp_handle_t hMetricProgrammable, uint32_t parameterCount, zet_metric_programmable_param_value_exp_t *pParameterValues, const char *pName, const char *pDescription, uint32_t *pMetricHandleCount, zet_metric_handle_t *phMetricHandles)#

Create metric handles by applying parameter values on the metric programmable handle.

  • 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

Parameters:

  • hMetricProgrammable – [in] handle of the metric programmable

  • parameterCount – [in] Count of parameters to set.

  • pParameterValues – [in] list of parameter values to be set.

  • pName – [in] pointer to metric name to be used. Must point to a null-terminated character array no longer than ZET_MAX_METRIC_NAME.

  • pDescription – [in] pointer to metric description to be used. Must point to a null-terminated character array no longer than ZET_MAX_METRIC_DESCRIPTION.

  • pMetricHandleCount – [in,out] Pointer to the number of metric handles. if count is zero, then the driver shall update the value with the number of metric handles available for this programmable. if 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.

  • phMetricHandles – [in,out][optional][range(0,*pMetricHandleCount)] array of handle of metrics. if count is less than the number of metrics available, then driver shall only retrieve that number of metric handles.

Returns:

zetMetricCreateFromProgrammableExp#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricCreateFromProgrammableExp(zet_metric_programmable_exp_handle_t hMetricProgrammable, zet_metric_programmable_param_value_exp_t *pParameterValues, uint32_t parameterCount, const char *pName, const char *pDescription, uint32_t *pMetricHandleCount, zet_metric_handle_t *phMetricHandles)#

Create metric handles by applying parameter values on the metric programmable handle.

Parameters:

  • hMetricProgrammable – [in] handle of the metric programmable

  • pParameterValues – [in] list of parameter values to be set.

  • parameterCount – [in] Count of parameters to set.

  • pName – [in] pointer to metric name to be used. Must point to a null-terminated character array no longer than ZET_MAX_METRIC_NAME.

  • pDescription – [in] pointer to metric description to be used. Must point to a null-terminated character array no longer than ZET_MAX_METRIC_DESCRIPTION.

  • pMetricHandleCount – [in,out] Pointer to the number of metric handles. if count is zero, then the driver shall update the value with the number of metric handles available for this programmable. if 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.

  • phMetricHandles – [in,out][optional][range(0,*pMetricHandleCount)] array of handle of metrics. if count is less than the number of metrics available, then driver shall only retrieve that number of metric handles.

Returns:

zetDeviceCreateMetricGroupsFromMetricsExp#

ZE_APIEXPORT ze_result_t ZE_APICALL zetDeviceCreateMetricGroupsFromMetricsExp(zet_device_handle_t hDevice, uint32_t metricCount, zet_metric_handle_t *phMetrics, const char *pMetricGroupNamePrefix, const char *pDescription, uint32_t *pMetricGroupCount, zet_metric_group_handle_t *phMetricGroup)#

Create multiple metric group handles from metric handles.

  • 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.

Parameters:

  • hDevice – [in] handle of the device.

  • metricCount – [in] number of metric handles.

  • phMetrics – [in] metric handles to be added to the metric groups.

  • pMetricGroupNamePrefix – [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.

  • pDescription – [in] pointer to description of the metric groups. Must point to a null-terminated character array no longer than ZET_MAX_METRIC_GROUP_DESCRIPTION.

  • pMetricGroupCount – [in,out] pointer to the number of metric group handles to be created. if pMetricGroupCount is zero, then the driver shall update the value with the maximum possible number of metric group handles that could be created. if 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. if pMetricGroupCount is lesser than the number of metric group handles that could be created, then ZE_RESULT_ERROR_INVALID_ARGUMENT is returned.

  • phMetricGroup – [in,out][optional][range(0, *pMetricGroupCount)] array of handle of metric group handles. Created Metric group handles.

Returns:

zetMetricGroupCreateExp#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricGroupCreateExp(zet_device_handle_t hDevice, const char *pName, const char *pDescription, zet_metric_group_sampling_type_flags_t samplingType, zet_metric_group_handle_t *phMetricGroup)#

Create metric group handle.

  • This API is deprecated. Please use ::zetCreateMetricGroupsFromMetricsExp()

Parameters:

  • hDevice – [in] handle of the device

  • pName – [in] pointer to metric group name. Must point to a null-terminated character array no longer than ZET_MAX_METRIC_GROUP_NAME.

  • pDescription – [in] pointer to metric group description. Must point to a null-terminated character array no longer than ZET_MAX_METRIC_GROUP_DESCRIPTION.

  • samplingType – [in] Sampling type for the metric group.

  • phMetricGroup – [in,out] Created Metric group handle

Returns:

zetMetricGroupAddMetricExp#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricGroupAddMetricExp(zet_metric_group_handle_t hMetricGroup, zet_metric_handle_t hMetric, size_t *pErrorStringSize, char *pErrorString)#

Add a metric handle to the metric group handle created using zetMetricGroupCreateExp.

  • 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.

Parameters:

  • hMetricGroup – [in] Handle of the metric group

  • hMetric – [in] Metric to be added to the group.

  • pErrorStringSize – [in,out][optional] Size of the error string to query, if an error was reported during adding the metric handle. if *pErrorStringSize is zero, then the driver shall update the value with the size of the error string in bytes.

  • pErrorString – [in,out][optional][range(0, *pErrorStringSize)] Error string. if *pErrorStringSize is less than the length of the error string available, then driver shall only retrieve that length of error string.

Returns:

zetMetricGroupRemoveMetricExp#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricGroupRemoveMetricExp(zet_metric_group_handle_t hMetricGroup, zet_metric_handle_t hMetric)#

Remove a metric from the metric group handle created using zetMetricGroupCreateExp.

  • Remove an already added metric handle from the metric group.

Parameters:

  • hMetricGroup – [in] Handle of the metric group

  • hMetric – [in] Metric handle to be removed from the metric group.

Returns:

zetMetricGroupCloseExp#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricGroupCloseExp(zet_metric_group_handle_t hMetricGroup)#

Closes a created metric group using zetMetricGroupCreateExp, so that it can be activated.

Parameters:

hMetricGroup – [in] Handle of the metric group

Returns:

zetMetricGroupDestroyExp#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricGroupDestroyExp(zet_metric_group_handle_t hMetricGroup)#

Destroy a metric group created using zetMetricGroupCreateExp.

Parameters:

hMetricGroup – [in] Handle of the metric group to destroy

Returns:

zetMetricDestroyExp#

ZE_APIEXPORT ze_result_t ZE_APICALL zetMetricDestroyExp(zet_metric_handle_t hMetric)#

Destroy a metric created using zetMetricCreateFromProgrammableExp2.

Parameters:

hMetric – [in] Handle of the metric to destroy

Returns:

Metricprogrammable Enums#

zet_metric_programmable_exp_version_t#

enum zet_metric_programmable_exp_version_t#

Programmable Metrics Experimental Extension Version(s)

Values:

enumerator ZET_METRIC_PROGRAMMABLE_EXP_VERSION_1_1#

version 1.1

enumerator ZET_METRIC_PROGRAMMABLE_EXP_VERSION_CURRENT#

latest known version

enumerator ZET_METRIC_PROGRAMMABLE_EXP_VERSION_FORCE_UINT32#

zet_metric_programmable_param_type_exp_t#

enum zet_metric_programmable_param_type_exp_t#

Metric Programmable Parameter types.

Values:

enumerator ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_DISAGGREGATION#

Metric is disaggregated.

enumerator ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_LATENCY#

Metric for latency measurement.

enumerator ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_NORMALIZATION_UTILIZATION#

Produces normalization in percent using raw_metric * 100 / cycles / HW instance_count.

enumerator ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_NORMALIZATION_AVERAGE#

Produces normalization using raw_metric / HW instance_count.

enumerator ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_NORMALIZATION_RATE#

Produces normalization average using raw_metric / timestamp.

enumerator ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_NORMALIZATION_BYTES#

Produces normalization average using raw_metric * n bytes.

enumerator ZET_METRIC_PROGRAMMABLE_PARAM_TYPE_EXP_FORCE_UINT32#

zet_value_info_type_exp_t#

enum zet_value_info_type_exp_t#

Supported value info types.

Values:

enumerator ZET_VALUE_INFO_TYPE_EXP_UINT32#

32-bit unsigned-integer

enumerator ZET_VALUE_INFO_TYPE_EXP_UINT64#

64-bit unsigned-integer

enumerator ZET_VALUE_INFO_TYPE_EXP_FLOAT32#

32-bit floating-point

enumerator ZET_VALUE_INFO_TYPE_EXP_FLOAT64#

64-bit floating-point

enumerator ZET_VALUE_INFO_TYPE_EXP_BOOL8#

8-bit boolean

enumerator ZET_VALUE_INFO_TYPE_EXP_UINT8#

8-bit unsigned-integer

enumerator ZET_VALUE_INFO_TYPE_EXP_UINT16#

16-bit unsigned-integer

enumerator ZET_VALUE_INFO_TYPE_EXP_UINT64_RANGE#

64-bit unsigned-integer range (minimum and maximum)

enumerator ZET_VALUE_INFO_TYPE_EXP_FLOAT64_RANGE#

64-bit floating point range (minimum and maximum)

enumerator ZET_VALUE_INFO_TYPE_EXP_FORCE_UINT32#

Metricprogrammable Structures#

zet_metric_programmable_exp_properties_t#

struct zet_metric_programmable_exp_properties_t#

Metric Programmable properties queried using zetMetricProgrammableGetPropertiesExp.

Public Members

zet_structure_type_t stype#

[in] type of this structure

void *pNext#

[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).

char name[ZET_MAX_METRIC_PROGRAMMABLE_NAME_EXP]#

[out] metric programmable name

char description[ZET_MAX_METRIC_PROGRAMMABLE_DESCRIPTION_EXP]#

[out] metric programmable description

char component[ZET_MAX_METRIC_PROGRAMMABLE_COMPONENT_EXP]#

[out] metric programmable component

uint32_t tierNumber#

[out] tier number

uint32_t domain#

[out] metric domain number.

uint32_t parameterCount#

[out] number of parameters in the programmable

zet_metric_group_sampling_type_flags_t samplingType#

[out] metric sampling type. returns a combination of zet_metric_group_sampling_type_flag_t.

uint32_t sourceId#

[out] unique metric source identifier(within platform)to identify the HW block where the metric is collected.

zet_value_uint64_range_exp_t#

struct zet_value_uint64_range_exp_t#

Value info of type uint64_t range.

Public Members

uint64_t ui64Min#

[out] minimum value of the range

uint64_t ui64Max#

[out] maximum value of the range

zet_value_fp64_range_exp_t#

struct zet_value_fp64_range_exp_t#

Value info of type float64 range.

Public Members

double fp64Min#

[out] minimum value of the range

double fp64Max#

[out] maximum value of the range

zet_value_info_exp_t#

union zet_value_info_exp_t#
#include <zet_api.h>

Union of value information.

Public Members

uint32_t ui32#

[out] 32-bit unsigned-integer

uint64_t ui64#

[out] 64-bit unsigned-integer

float fp32#

[out] 32-bit floating-point

double fp64#

[out] 64-bit floating-point

ze_bool_t b8#

[out] 8-bit boolean

uint8_t ui8#

[out] 8-bit unsigned integer

uint16_t ui16#

[out] 16-bit unsigned integer

zet_value_uint64_range_exp_t ui64Range#

[out] minimum and maximum value of the range

zet_value_fp64_range_exp_t fp64Range#

[out] minimum and maximum value of the range

zet_metric_programmable_param_info_exp_t#

struct zet_metric_programmable_param_info_exp_t#

Metric Programmable parameter information.

Public Members

zet_structure_type_t stype#

[in] type of this structure

void *pNext#

[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).

zet_metric_programmable_param_type_exp_t type#

[out] programmable parameter type

char name[ZET_MAX_METRIC_PROGRAMMABLE_PARAMETER_NAME_EXP]#

[out] metric programmable parameter name

zet_value_info_type_exp_t valueInfoType#

[out] value info type

zet_value_t defaultValue#

[out] default value for the parameter

uint32_t valueInfoCount#

[out] count of zet_metric_programmable_param_value_info_exp_t

zet_metric_programmable_param_value_info_exp_t#

struct zet_metric_programmable_param_value_info_exp_t#

Metric Programmable parameter value information.

Public Members

zet_structure_type_t stype#

[in] type of this structure

void *pNext#

[in,out][optional] must be null or a pointer to an extension-specific structure (i.e. contains stype and pNext).

zet_value_info_exp_t valueInfo#

[out] information about the parameter value

char description[ZET_MAX_METRIC_PROGRAMMABLE_VALUE_DESCRIPTION_EXP]#

[out] description about the value

zet_metric_programmable_param_value_exp_t#

struct zet_metric_programmable_param_value_exp_t#

Metric Programmable parameter value.

Public Members

zet_value_t value#

[in] parameter value

Contents