Sysman API

oneAPI Level Zero Specification - Version 0.95.0

Device

Device Functions

zesDeviceGetProperties

ZE_APIEXPORT ze_result_t ZE_APICALL zesDeviceGetProperties(zes_device_handle_t hDevice, zes_device_properties_t *pProperties)

Get properties about the device.

Parameters

  • hDevice: Sysman handle of the device.

  • pProperties: Structure that will contain information about the device.

  • The application may call this function from simultaneous threads.

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

Return

zesDeviceGetState

ZE_APIEXPORT ze_result_t ZE_APICALL zesDeviceGetState(zes_device_handle_t hDevice, zes_device_state_t *pState)

Get information about the state of the device - if a reset is required, reasons for the reset and if the device has been repaired.

Parameters

  • hDevice: Sysman handle of the device.

  • pState: Structure that will contain information about the device.

  • The application may call this function from simultaneous threads.

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

Return

zesDeviceReset

ZE_APIEXPORT ze_result_t ZE_APICALL zesDeviceReset(zes_device_handle_t hDevice, ze_bool_t force)

Reset device.

Parameters

  • hDevice: Sysman handle for the device

  • force: If set to true, all applications that are currently using the device will be forcibly killed.

  • 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 a timeout occurred waiting for the reset to complete.

Return

zesDeviceProcessesGetState

ZE_APIEXPORT ze_result_t ZE_APICALL zesDeviceProcessesGetState(zes_device_handle_t hDevice, uint32_t *pCount, zes_process_state_t *pProcesses)

Get information about host processes using the device.

Parameters

  • hDevice: Sysman handle for the device

  • pCount: pointer to the number of processes. if count is zero, then the driver will update the value with the total number of processes currently using the device. if count is non-zero but less than the number of processes, the driver will set to the number of processes currently using the device and return the error ZE_RESULT_ERROR_INVALID_SIZE. if count is larger than the number of processes, then the driver will update the value with the correct number of processes that are returned.

  • pProcesses: [optional][range(0, *pCount)] array of process information, one for each process currently using the device

  • The number of processes connected to the device is dynamic. This means that between a call to determine the correct value of pCount and the subsequent call, the number of processes may have increased. It is recommended that a large array be passed in so as to avoid receiving the error ZE_RESULT_ERROR_INVALID_SIZE.

  • The application may call this function from simultaneous threads.

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

Return

zesDevicePciGetProperties

ZE_APIEXPORT ze_result_t ZE_APICALL zesDevicePciGetProperties(zes_device_handle_t hDevice, zes_pci_properties_t *pProperties)

Get PCI properties - address, max speed.

Parameters

  • hDevice: Sysman handle of the device.

  • pProperties: Will contain the PCI properties.

  • The application may call this function from simultaneous threads.

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

Return

zesDevicePciGetState

ZE_APIEXPORT ze_result_t ZE_APICALL zesDevicePciGetState(zes_device_handle_t hDevice, zes_pci_state_t *pState)

Get current PCI state - current speed.

Parameters

  • hDevice: Sysman handle of the device.

  • pState: Will contain the PCI properties.

  • The application may call this function from simultaneous threads.

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

Return

zesDevicePciGetBars

ZE_APIEXPORT ze_result_t ZE_APICALL zesDevicePciGetBars(zes_device_handle_t hDevice, uint32_t *pCount, zes_pci_bar_properties_t *pProperties)

Get information about each configured bar.

Parameters

  • hDevice: Sysman handle of the device.

  • pCount: pointer to the number of PCI bars. if count is zero, then the driver will update the value with the total number of bars. if count is non-zero, then driver will only retrieve that number of bars. if count is larger than the number of bar, then the driver will update the value with the correct number of bars that are returned.

  • pProperties: [optional][range(0, *pCount)] array of bar properties

  • The application may call this function from simultaneous threads.

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

Return

zesDevicePciGetStats

ZE_APIEXPORT ze_result_t ZE_APICALL zesDevicePciGetStats(zes_device_handle_t hDevice, zes_pci_stats_t *pStats)

Get PCI stats - bandwidth, number of packets, number of replays.

Parameters

  • hDevice: Sysman handle of the device.

  • pStats: Will contain a snapshot of the latest stats.

  • The application may call this function from simultaneous threads.

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

Return

Device Enums

zes_version_t

enum zes_version_t

API version of Sysman.

Values:

ZES_VERSION_1_0 = ZE_MAKE_VERSION(1, )

version 1.0

ZES_VERSION_CURRENT = ZE_MAKE_VERSION(1, )

latest known version

zes_engine_type_t

enum zes_engine_type_t

Types of accelerator engines.

Values:

ZES_ENGINE_TYPE_OTHER = 0

Undefined types of accelerators.

ZES_ENGINE_TYPE_COMPUTE

Engines that process compute kernels.

ZES_ENGINE_TYPE_3D

Engines that process 3D content.

ZES_ENGINE_TYPE_MEDIA

Engines that process media workloads.

ZES_ENGINE_TYPE_DMA

Engines that copy blocks of data.

zes_repair_status_t

enum zes_repair_status_t

Device repair status.

Values:

ZES_REPAIR_STATUS_UNSUPPORTED = 0

The device does not support in-field repairs.

ZES_REPAIR_STATUS_NOT_PERFORMED

The device has never been repaired.

ZES_REPAIR_STATUS_PERFORMED

The device has been repaired.

zes_reset_reasons_t

enum zes_reset_reasons_t

Device reset reasons.

Values:

ZES_RESET_REASONS_NONE = 0

The device does not need to be reset.

ZES_RESET_REASONS_WEDGED = ZE_BIT(0)

The device needs to be reset because one or more parts of the hardware is wedged

ZES_RESET_REASONS_REPAIR = ZE_BIT(1)

The device needs to be reset in order to complete in-field repairs.

zes_pci_bar_type_t

enum zes_pci_bar_type_t

PCI bar types.

Values:

ZES_PCI_BAR_TYPE_MMIO = 0

MMIO registers.

ZES_PCI_BAR_TYPE_ROM

ROM aperture.

ZES_PCI_BAR_TYPE_MEM

Device memory.

Device Structures

zes_device_state_t

struct zes_device_state_t

Device state.

Public Members

uint32_t reset

[out] Indicates if the device needs to be reset and for what reasons (bitfield of zes_reset_reasons_t)

zes_repair_status_t repaired

[out] Indicates if the device has been repaired

zes_device_properties_t

struct zes_device_properties_t

Device properties.

Public Members

ze_device_properties_t core

[out] Core device properties

uint32_t numSubdevices

[out] Number of sub-devices

char serialNumber[ZES_STRING_PROPERTY_SIZE]

[out] Manufacturing serial number (NULL terminated string value)

char boardNumber[ZES_STRING_PROPERTY_SIZE]

[out] Manufacturing board number (NULL terminated string value)

char brandName[ZES_STRING_PROPERTY_SIZE]

[out] Brand name of the device (NULL terminated string value)

char modelName[ZES_STRING_PROPERTY_SIZE]

[out] Model name of the device (NULL terminated string value)

char vendorName[ZES_STRING_PROPERTY_SIZE]

[out] Vendor name of the device (NULL terminated string value)

char driverVersion[ZES_STRING_PROPERTY_SIZE]

[out] Installed driver version (NULL terminated string value)

zes_process_state_t

struct zes_process_state_t

Contains information about a process that has an open connection with this device.

  • The application can use the process ID to query the OS for the owner and the path to the executable.

Public Members

uint32_t processId

[out] Host OS process ID.

uint64_t memSize

[out] Device memory size in bytes allocated by this process (may not necessarily be resident on the device at the time of reading).

uint64_t engines

[out] Bitfield of accelerator engines being used by this process (or 1<<zes_engine_type_t together).

zes_pci_address_t

struct zes_pci_address_t

PCI address.

Public Members

uint32_t domain

[out] BDF domain

uint32_t bus

[out] BDF bus

uint32_t device

[out] BDF device

uint32_t function

[out] BDF function

zes_pci_speed_t

struct zes_pci_speed_t

PCI speed.

Public Members

uint32_t gen

[out] The link generation

uint32_t width

[out] The number of lanes

uint64_t maxBandwidth

[out] The maximum bandwidth in bytes/sec

zes_pci_properties_t

struct zes_pci_properties_t

Static PCI properties.

Public Members

zes_pci_address_t address

[out] The BDF address

zes_pci_speed_t maxSpeed

[out] Fastest port configuration supported by the device.

zes_pci_state_t

struct zes_pci_state_t

Dynamic PCI state.

Public Members

zes_pci_link_status_t status

[out] The current status of the port

zes_pci_link_qual_issues_t qualityIssues

[out] If status is ZES_PCI_LINK_STATUS_YELLOW, this gives a bitfield of quality issues that have been detected

zes_pci_link_stab_issues_t stabilityIssues

[out] If status is ZES_PCI_LINK_STATUS_RED, this gives a bitfield of reasons for the connection instability

zes_pci_speed_t speed

[out] The current port configure speed

zes_pci_bar_properties_t

struct zes_pci_bar_properties_t

Properties of a pci bar.

Public Members

zes_pci_bar_type_t type

[out] The type of bar

uint32_t index

[out] The index of the bar

uint64_t base

[out] Base address of the bar.

uint64_t size

[out] Size of the bar.

zes_pci_stats_t

struct zes_pci_stats_t

PCI stats counters.

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

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

Public Members

uint64_t timestamp

[out] Monotonic timestamp counter in microseconds when the measurement was made. No assumption should be made about the absolute value of the timestamp. It should only be used to calculate delta time between two snapshots of the same structure. Never take the delta of this timestamp with the timestamp from a different structure.

uint64_t replayCounter

[out] Monotonic counter for the number of replay packets

uint64_t packetCounter

[out] Monotonic counter for the number of packets

uint64_t rxCounter

[out] Monotonic counter for the number of bytes received

uint64_t txCounter

[out] Monotonic counter for the number of bytes transmitted (including replays)

zes_pci_speed_t speed

[out] The current speed of the link

Diagnostics

Diagnostics Functions

zesDeviceEnumDiagnosticTestSuites

ZE_APIEXPORT ze_result_t ZE_APICALL zesDeviceEnumDiagnosticTestSuites(zes_device_handle_t hDevice, uint32_t *pCount, zes_diag_handle_t *phDiagnostics)

Get handle of diagnostics test suites.

Parameters

  • hDevice: Sysman handle of the device.

  • pCount: pointer to the number of components of this type. if count is zero, then the driver will update the value with the total number of components of this type. if count is non-zero, then driver will only retrieve that number of components. if count is larger than the number of components available, then the driver will update the value with the correct number of components that are returned.

  • phDiagnostics: [optional][range(0, *pCount)] array of handle of components of this type

  • The application may call this function from simultaneous threads.

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

Return

zesDiagnosticsGetProperties

ZE_APIEXPORT ze_result_t ZE_APICALL zesDiagnosticsGetProperties(zes_diag_handle_t hDiagnostics, zes_diag_properties_t *pProperties)

Get properties of a diagnostics test suite.

Parameters

  • hDiagnostics: Handle for the component.

  • pProperties: Structure describing the properties of a diagnostics test suite

  • The application may call this function from simultaneous threads.

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

Return

zesDiagnosticsGetTests

ZE_APIEXPORT ze_result_t ZE_APICALL zesDiagnosticsGetTests(zes_diag_handle_t hDiagnostics, uint32_t *pCount, zes_diag_test_t *pTests)

Get individual tests that can be run separately. Not all test suites permit running individual tests - check zes_diag_properties_t.haveTests.

Parameters

  • hDiagnostics: Handle for the component.

  • pCount: pointer to the number of tests. If count is zero, then the driver will update the value with the total number of tests available. If count is non-zero, then driver will only retrieve that number of tests. If count is larger than the number of tests available, then the driver will update the value with the correct number of tests available.

  • pTests: [optional][range(0, *pCount)] Array of tests sorted by increasing value of zes_diag_test_t.index

  • The list of available tests is returned in order of increasing test index zes_diag_test_t.index.

  • The application may call this function from simultaneous threads.

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

Return

zesDiagnosticsRunTests

ZE_APIEXPORT ze_result_t ZE_APICALL zesDiagnosticsRunTests(zes_diag_handle_t hDiagnostics, uint32_t start, uint32_t end, zes_diag_result_t *pResult)

Run a diagnostics test suite, either all tests or a subset of tests.

Parameters

  • hDiagnostics: Handle for the component.

  • start: The index of the first test to run. Set to ZES_DIAG_FIRST_TEST_INDEX to start from the beginning.

  • end: The index of the last test to run. Set to ZES_DIAG_LAST_TEST_INDEX to complete all tests after the start test.

  • pResult: The result of the diagnostics

  • WARNING: Performancing diagnostics may destroy current device state information. Gracefully close any running workloads before initiating.

  • To run all tests in a test suite, set start = ZES_DIAG_FIRST_TEST_INDEX and end = ZES_DIAG_LAST_TEST_INDEX.

  • If the test suite permits running individual tests, zes_diag_properties_t.haveTests will be true. In this case, the function zesDiagnosticsGetTests() 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.

Return

Diagnostics Enums

zes_diag_type_t

enum zes_diag_type_t

Diagnostic test suite type.

Values:

ZES_DIAG_TYPE_SCAN = 0

Run SCAN diagnostics.

ZES_DIAG_TYPE_ARRAY

Run Array diagnostics.

zes_diag_result_t

enum zes_diag_result_t

Diagnostic results.

Values:

ZES_DIAG_RESULT_NO_ERRORS = 0

Diagnostic completed without finding errors to repair.

ZES_DIAG_RESULT_ABORT

Diagnostic had problems running tests.

ZES_DIAG_RESULT_FAIL_CANT_REPAIR

Diagnostic had problems setting up repairs.

ZES_DIAG_RESULT_REBOOT_FOR_REPAIR

Diagnostics found errors, setup for repair and reboot is required to complete the process

Diagnostics Structures

zes_diag_test_t

struct zes_diag_test_t

Diagnostic test.

Public Members

uint32_t index

[out] Index of the test

char name[ZES_STRING_PROPERTY_SIZE]

[out] Name of the test

zes_diag_properties_t

struct zes_diag_properties_t

Diagnostics test suite properties.

Public Members

zes_diag_type_t type

[out] The type of diagnostics test suite

ze_bool_t onSubdevice

[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

uint32_t subdeviceId

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

char name[ZES_STRING_PROPERTY_SIZE]

[out] Name of the diagnostics test suite

ze_bool_t haveTests

[out] Indicates if this test suite has individual tests which can be run separately (use the function zesDiagnosticsGetTests() to get the list of these tests)

Engine

Engine Functions

zesDeviceEnumEngineGroups

ZE_APIEXPORT ze_result_t ZE_APICALL zesDeviceEnumEngineGroups(zes_device_handle_t hDevice, uint32_t *pCount, zes_engine_handle_t *phEngine)

Get handle of engine groups.

Parameters

  • hDevice: Sysman handle of the device.

  • pCount: pointer to the number of components of this type. if count is zero, then the driver will update the value with the total number of components of this type. if count is non-zero, then driver will only retrieve that number of components. if count is larger than the number of components available, then the driver will update the value with the correct number of components that are returned.

  • phEngine: [optional][range(0, *pCount)] array of handle of components of this type

  • The application may call this function from simultaneous threads.

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

Return

zesEngineGetProperties

ZE_APIEXPORT ze_result_t ZE_APICALL zesEngineGetProperties(zes_engine_handle_t hEngine, zes_engine_properties_t *pProperties)

Get engine group properties.

Parameters

  • hEngine: Handle for the component.

  • pProperties: The properties for the specified engine group.

  • The application may call this function from simultaneous threads.

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

Return

zesEngineGetActivity

ZE_APIEXPORT ze_result_t ZE_APICALL zesEngineGetActivity(zes_engine_handle_t hEngine, zes_engine_stats_t *pStats)

Get the activity stats for an engine group.

Parameters

  • hEngine: Handle for the component.

  • pStats: Will contain a snapshot of the engine group activity counters.

  • The application may call this function from simultaneous threads.

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

Return

Engine Enums

zes_engine_group_t

enum zes_engine_group_t

Accelerator engine groups.

Values:

ZES_ENGINE_GROUP_ALL = 0

Access information about all engines combined.

ZES_ENGINE_GROUP_COMPUTE_ALL

Access information about all compute engines combined.

ZES_ENGINE_GROUP_MEDIA_ALL

Access information about all media engines combined.

ZES_ENGINE_GROUP_COPY_ALL

Access information about all copy (blitter) engines combined.

Engine Structures

zes_engine_properties_t

struct zes_engine_properties_t

Engine group properties.

Public Members

zes_engine_group_t type

[out] The engine group

ze_bool_t onSubdevice

[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

uint32_t subdeviceId

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

zes_engine_stats_t

struct zes_engine_stats_t

Engine activity counters.

  • Percent utilization is calculated by taking two snapshots (s1, s2) and using the equation: util = (s2.activeTime - s1.activeTime) / (s2.timestamp - s1.timestamp)

Public Members

uint64_t activeTime

[out] Monotonic counter for time in microseconds that this resource is actively running workloads.

uint64_t timestamp

[out] Monotonic timestamp counter in microseconds when activeTime counter was sampled. No assumption should be made about the absolute value of the timestamp. It should only be used to calculate delta time between two snapshots of the same structure. Never take the delta of this timestamp with the timestamp from a different structure.

Events

Events Functions

zesDeviceCreateEvents

ZE_APIEXPORT ze_result_t ZE_APICALL zesDeviceCreateEvents(zes_device_handle_t hDevice, zes_event_handle_t *phEvent)

Get the event handle for the specified device.

Parameters

  • hDevice: Sysman handle for the device

  • phEvent: The event handle for the specified device.

  • The application may call this function from simultaneous threads.

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

Return

zesEventGetConfig

ZE_APIEXPORT ze_result_t ZE_APICALL zesEventGetConfig(zes_event_handle_t hEvent, zes_event_config_t *pConfig)

Find out which events are currently registered on the specified device event handler.

Parameters

  • hEvent: The event handle for the device

  • pConfig: Will contain the current event configuration (list of registered events).

  • The application may call this function from simultaneous threads.

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

Return

zesEventSetConfig

ZE_APIEXPORT ze_result_t ZE_APICALL zesEventSetConfig(zes_event_handle_t hEvent, const zes_event_config_t *pConfig)

Set a new event configuration (list of registered events) on the specified device event handler.

Parameters

  • hEvent: The event handle for the device

  • pConfig: New event configuration (list of registered events).

  • The application may call this function from simultaneous threads.

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

Return

zesEventGetState

ZE_APIEXPORT ze_result_t ZE_APICALL zesEventGetState(zes_event_handle_t hEvent, ze_bool_t clear, uint32_t *pEvents)

Get events that have been triggered for a specific device.

Parameters

  • hEvent: The event handle for the device.

  • clear: Indicates if the event list for this device should be cleared.

  • pEvents: Bitfield of events zes_event_type_t that have been triggered by this device.

  • If events have occurred on the specified device event handle, they are returned and the corresponding event status is cleared if the argument clear = true.

  • The application may call this function from simultaneous threads.

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

Return

zesEventListen

ZE_APIEXPORT ze_result_t ZE_APICALL zesEventListen(ze_driver_handle_t hDriver, uint32_t timeout, uint32_t count, zes_event_handle_t *phEvents, uint32_t *pEvents)

Wait for the specified list of event handles to receive any registered events.

Parameters

  • hDriver: handle of the driver instance

  • timeout: How long to wait in milliseconds for events to arrive. Set to ZES_EVENT_WAIT_NONE will check status and return immediately. Set to ZES_EVENT_WAIT_INFINITE to block until events arrive.

  • count: Number of handles in phEvents

  • phEvents: [range(0, count)] Handle of events that should be listened to

  • pEvents: Bitfield of events zes_event_type_t that have been triggered by any of the supplied event handles. If timeout is not ZES_EVENT_WAIT_INFINITE and this value is ZES_EVENT_TYPE_NONE, then a timeout has occurred.

  • If previous events arrived and were not cleared using zesEventGetState(), this call will return immediately.

  • The application may call this function from simultaneous threads.

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

Return

Events Enums

zes_event_type_t

enum zes_event_type_t

Event types.

Values:

ZES_EVENT_TYPE_NONE = 0

Specifies no events.

ZES_EVENT_TYPE_DEVICE_RESET = ZE_BIT(0)

Event is triggered when the driver is going to reset the device.

ZES_EVENT_TYPE_DEVICE_SLEEP_STATE_ENTER = ZE_BIT(1)

deep sleep state

Event is triggered when the driver is about to put the device into a

ZES_EVENT_TYPE_DEVICE_SLEEP_STATE_EXIT = ZE_BIT(2)

sleep state

Event is triggered when the driver is waking the device up from a deep

ZES_EVENT_TYPE_FREQ_THROTTLED = ZE_BIT(3)

Event is triggered when the frequency starts being throttled.

ZES_EVENT_TYPE_ENERGY_THRESHOLD_CROSSED = ZE_BIT(4)

(use zesPowerSetEnergyThreshold() to configure).

Event is triggered when the energy consumption threshold is reached

ZES_EVENT_TYPE_TEMP_CRITICAL = ZE_BIT(5)

Event is triggered when the critical temperature is reached (use zesTemperatureSetConfig() to configure - disabled by default).

ZES_EVENT_TYPE_TEMP_THRESHOLD1 = ZE_BIT(6)

Event is triggered when the temperature crosses threshold 1 (use zesTemperatureSetConfig() to configure - disabled by default).

ZES_EVENT_TYPE_TEMP_THRESHOLD2 = ZE_BIT(7)

Event is triggered when the temperature crosses threshold 2 (use zesTemperatureSetConfig() to configure - disabled by default).

ZES_EVENT_TYPE_MEM_HEALTH = ZE_BIT(8)

Event is triggered when the health of device memory changes.

ZES_EVENT_TYPE_FABRIC_PORT_HEALTH = ZE_BIT(9)

Event is triggered when the health of fabric ports change.

ZES_EVENT_TYPE_PCI_LINK_HEALTH = ZE_BIT(10)

Event is triggered when the health of the PCI link changes.

ZES_EVENT_TYPE_RAS_CORRECTABLE_ERRORS = ZE_BIT(11)

Event is triggered when accelerator RAS correctable errors cross thresholds (use zesRasSetConfig() to configure - disabled by default).

ZES_EVENT_TYPE_RAS_UNCORRECTABLE_ERRORS = ZE_BIT(12)

Event is triggered when accelerator RAS uncorrectable errors cross thresholds (use zesRasSetConfig() to configure - disabled by default).

ZES_EVENT_TYPE_DEVICE_RESET_REQUIRED = ZE_BIT(14)

zesDeviceGetState() to determine the reasons for the reset).

Event is triggered when the device needs to be reset (use

ZES_EVENT_TYPE_ALL = 0x0FFF

Specifies all events.

Events Structures

zes_event_config_t

struct zes_event_config_t

Event configuration for a device.

Public Members

uint32_t registered

[in,out] List of registered events (Bitfield of events zes_event_type_t). ZES_EVENT_TYPE_NONE indicates there are no registered events. ZES_EVENT_TYPE_ALL indicates that all events are registered.

Fabric

Fabric Functions

zesDeviceEnumFabricPorts

ZE_APIEXPORT ze_result_t ZE_APICALL zesDeviceEnumFabricPorts(zes_device_handle_t hDevice, uint32_t *pCount, zes_fabric_port_handle_t *phPort)

Get handle of Fabric ports in a device.

Parameters

  • hDevice: Sysman handle of the device.

  • pCount: pointer to the number of components of this type. if count is zero, then the driver will update the value with the total number of components of this type. if count is non-zero, then driver will only retrieve that number of components. if count is larger than the number of components available, then the driver will update the value with the correct number of components that are returned.

  • phPort: [optional][range(0, *pCount)] array of handle of components of this type

  • The application may call this function from simultaneous threads.

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

Return

zesFabricPortGetProperties

ZE_APIEXPORT ze_result_t ZE_APICALL zesFabricPortGetProperties(zes_fabric_port_handle_t hPort, zes_fabric_port_properties_t *pProperties)

Get Fabric port properties.

Parameters

  • hPort: Handle for the component.

  • pProperties: Will contain properties of the Fabric Port.

  • The application may call this function from simultaneous threads.

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

Return

zesFabricPortGetLinkType

ZE_APIEXPORT ze_result_t ZE_APICALL zesFabricPortGetLinkType(zes_fabric_port_handle_t hPort, zes_fabric_link_type_t *pLinkType)

Get Fabric port link type.

Parameters

  • hPort: Handle for the component.

  • pLinkType: Will contain details about the link attached to the Fabric port.

  • The application may call this function from simultaneous threads.

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

Return

zesFabricPortGetConfig

ZE_APIEXPORT ze_result_t ZE_APICALL zesFabricPortGetConfig(zes_fabric_port_handle_t hPort, zes_fabric_port_config_t *pConfig)

Get Fabric port configuration.

Parameters

  • hPort: Handle for the component.

  • pConfig: Will contain configuration of the Fabric Port.

  • The application may call this function from simultaneous threads.

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

Return

zesFabricPortSetConfig

ZE_APIEXPORT ze_result_t ZE_APICALL zesFabricPortSetConfig(zes_fabric_port_handle_t hPort, const zes_fabric_port_config_t *pConfig)

Set Fabric port configuration.

Parameters

  • hPort: Handle for the component.

  • pConfig: Contains new configuration of the Fabric Port.

  • The application may call this function from simultaneous threads.

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

Return

zesFabricPortGetState

ZE_APIEXPORT ze_result_t ZE_APICALL zesFabricPortGetState(zes_fabric_port_handle_t hPort, zes_fabric_port_state_t *pState)

Get Fabric port state - status (green/yellow/red/black), reasons for link degradation or instability, current rx/tx speed.

Parameters

  • hPort: Handle for the component.

  • pState: Will contain the current state of the Fabric Port

  • The application may call this function from simultaneous threads.

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

Return

zesFabricPortGetThroughput

ZE_APIEXPORT ze_result_t ZE_APICALL zesFabricPortGetThroughput(zes_fabric_port_handle_t hPort, zes_fabric_port_throughput_t *pThroughput)

Get Fabric port throughput.

Parameters

  • hPort: Handle for the component.

  • pThroughput: Will contain the Fabric port throughput counters.

  • The application may call this function from simultaneous threads.

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

Return

Fabric Enums

zes_fabric_port_status_t

enum zes_fabric_port_status_t

Fabric port status.

Values:

ZES_FABRIC_PORT_STATUS_GREEN = 0

The port is up and operating as expected.

ZES_FABRIC_PORT_STATUS_YELLOW

The port is up but has quality and/or speed degradation.

ZES_FABRIC_PORT_STATUS_RED

Port connection instabilities are preventing workloads making forward progress

ZES_FABRIC_PORT_STATUS_BLACK

The port is configured down.

zes_fabric_port_qual_issues_t

enum zes_fabric_port_qual_issues_t

Fabric port quality degradation reasons.

Values:

ZES_FABRIC_PORT_QUAL_ISSUES_NONE = 0

There are no quality issues with the link at this time.

ZES_FABRIC_PORT_QUAL_ISSUES_LINK_ERRORS = ZE_BIT(0)

Excessive link errors are occurring.

ZES_FABRIC_PORT_QUAL_ISSUES_SPEED = ZE_BIT(1)

There is a degradation in the bitrate and/or width of the link.

zes_fabric_port_stab_issues_t

enum zes_fabric_port_stab_issues_t

Fabric port stability issues.

Values:

ZES_FABRIC_PORT_STAB_ISSUES_NONE = 0

There are no connection stability issues at this time.

ZES_FABRIC_PORT_STAB_ISSUES_FAILED = ZE_BIT(0)

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.

ZES_FABRIC_PORT_STAB_ISSUES_TRAINING_TIMEOUT = ZE_BIT(1)

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.

ZES_FABRIC_PORT_STAB_ISSUES_FLAPPING = ZE_BIT(2)

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 zesFabricPortSetConfig().

Fabric Structures

zes_fabric_port_id_t

struct zes_fabric_port_id_t

Unique identifier for a fabric port.

  • 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 zes_fabric_port_state_t.remotePortId to zes_fabric_port_properties_t.portId.

Public Members

uint32_t fabricId

[out] Unique identifier for the fabric end-point

uint32_t attachId

[out] Unique identifier for the device attachment point

uint8_t portNumber

[out] The logical port number (this is typically marked somewhere on the physical device)

zes_fabric_port_speed_t

struct zes_fabric_port_speed_t

Fabric port speed in one direction.

Public Members

uint64_t bitRate

[out] Bits/sec that the link is operating at

uint32_t width

[out] The number of lanes

zes_fabric_port_properties_t

struct zes_fabric_port_properties_t

Fabric port properties.

Public Members

char model[ZES_MAX_FABRIC_PORT_MODEL_SIZE]

[out] Description of port technology

ze_bool_t onSubdevice

[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

uint32_t subdeviceId

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

zes_fabric_port_id_t portId

[out] The unique port identifier

zes_fabric_port_speed_t maxRxSpeed

[out] Maximum speed supported by the receive side of the port

zes_fabric_port_speed_t maxTxSpeed

[out] Maximum speed supported by the transmit side of the port

zes_fabric_port_config_t

struct zes_fabric_port_config_t

Fabric port configuration.

Public Members

ze_bool_t enabled

[in,out] Port is configured up/down

ze_bool_t beaconing

[in,out] Beaconing is configured on/off

zes_fabric_port_state_t

struct zes_fabric_port_state_t

Fabric port state.

Public Members

zes_fabric_port_status_t status

[out] The current status of the port

zes_fabric_port_qual_issues_t qualityIssues

[out] If status is ZES_FABRIC_PORT_STATUS_YELLOW, this gives a bitfield of quality issues that have been detected

zes_fabric_port_stab_issues_t stabilityIssues

[out] If status is ZES_FABRIC_PORT_STATUS_RED, this gives a bitfield of reasons for the connection instability

zes_fabric_port_id_t remotePortId

[out] The unique port identifier for the remote connection point

zes_fabric_port_speed_t rxSpeed

[out] Current maximum receive speed

zes_fabric_port_speed_t txSpeed

[out] Current maximum transmit speed

zes_fabric_port_throughput_t

struct zes_fabric_port_throughput_t

Fabric port throughput.

Public Members

uint64_t timestamp

[out] Monotonic timestamp counter in microseconds when the measurement was made. No assumption should be made about the absolute value of the timestamp. It should only be used to calculate delta time between two snapshots of the same structure. Never take the delta of this timestamp with the timestamp from a different structure.

uint64_t rxCounter

[out] Monotonic counter for the number of bytes received. This includes all protocol overhead, not only the GPU traffic.

uint64_t txCounter

[out] Monotonic counter for the number of bytes transmitted. This includes all protocol overhead, not only the GPU traffic.

Fan

Fan Functions

zesDeviceEnumFans

ZE_APIEXPORT ze_result_t ZE_APICALL zesDeviceEnumFans(zes_device_handle_t hDevice, uint32_t *pCount, zes_fan_handle_t *phFan)

Get handle of fans.

Parameters

  • hDevice: Sysman handle of the device.

  • pCount: pointer to the number of components of this type. if count is zero, then the driver will update the value with the total number of components of this type. if count is non-zero, then driver will only retrieve that number of components. if count is larger than the number of components available, then the driver will update the value with the correct number of components that are returned.

  • phFan: [optional][range(0, *pCount)] array of handle of components of this type

  • The application may call this function from simultaneous threads.

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

Return

zesFanGetProperties

ZE_APIEXPORT ze_result_t ZE_APICALL zesFanGetProperties(zes_fan_handle_t hFan, zes_fan_properties_t *pProperties)

Get fan properties.

Parameters

  • hFan: Handle for the component.

  • pProperties: Will contain the properties of the fan.

  • The application may call this function from simultaneous threads.

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

Return

zesFanGetConfig

ZE_APIEXPORT ze_result_t ZE_APICALL zesFanGetConfig(zes_fan_handle_t hFan, zes_fan_config_t *pConfig)

Get current fan configuration.

Parameters

  • hFan: Handle for the component.

  • pConfig: Will contain the current configuration of the fan.

  • The application may call this function from simultaneous threads.

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

Return

zesFanSetConfig

ZE_APIEXPORT ze_result_t ZE_APICALL zesFanSetConfig(zes_fan_handle_t hFan, const zes_fan_config_t *pConfig)

Set fan configuration.

Parameters

  • hFan: Handle for the component.

  • pConfig: New fan configuration.

  • The application may call this function from simultaneous threads.

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

Return

zesFanGetState

ZE_APIEXPORT ze_result_t ZE_APICALL zesFanGetState(zes_fan_handle_t hFan, zes_fan_speed_units_t units, uint32_t *pSpeed)

Get current state of a fan - current mode and speed.

Parameters

  • hFan: Handle for the component.

  • units: The units in which the fan speed should be returned.

  • pSpeed: Will contain the current speed of the fan in the units requested.

  • The application may call this function from simultaneous threads.

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

Return

Fan Enums

zes_fan_speed_mode_t

enum zes_fan_speed_mode_t

Fan resource speed mode.

Values:

ZES_FAN_SPEED_MODE_DEFAULT = 0

The fan speed is operating using the hardware default settings.

ZES_FAN_SPEED_MODE_FIXED

The fan speed is currently set to a fixed value.

ZES_FAN_SPEED_MODE_TABLE

The fan speed is currently controlled dynamically by hardware based on a temp/speed table

zes_fan_speed_units_t

enum zes_fan_speed_units_t

Fan speed units.

Values:

ZES_FAN_SPEED_UNITS_RPM = 0

The fan speed is in units of revolutions per minute (rpm)

ZES_FAN_SPEED_UNITS_PERCENT

The fan speed is a percentage of the maximum speed of the fan.

Fan Structures

zes_fan_temp_speed_t

struct zes_fan_temp_speed_t

Fan temperature/speed pair.

Public Members

uint32_t temperature

[in,out] Temperature in degrees Celsius.

uint32_t speed

[in,out] The speed of the fan

zes_fan_speed_units_t units

[in,out] The units of the member speed

zes_fan_properties_t

struct zes_fan_properties_t

Fan properties.

Public Members

ze_bool_t onSubdevice

[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

uint32_t subdeviceId

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

ze_bool_t canControl

[out] Indicates if software can control the fan speed assuming the user has permissions

uint32_t maxSpeed

[out] The maximum RPM of the fan

uint32_t maxPoints

[out] The maximum number of points in the fan temp/speed table

zes_fan_config_t

struct zes_fan_config_t

Fan configuration.

Public Members

zes_fan_speed_mode_t mode

[in,out] The fan speed mode (fixed, temp-speed table)

uint32_t speed

[in,out] The fixed fan speed setting

zes_fan_speed_units_t speedUnits

[in,out] The units of the fixed fan speed setting

uint32_t numPoints

[in,out] The number of valid points in the fan speed table

zes_fan_temp_speed_t table[ZES_FAN_TEMP_SPEED_PAIR_COUNT]

[in,out] Array of temperature/fan speed pairs

Firmware

Firmware Functions

zesDeviceEnumFirmwares

ZE_APIEXPORT ze_result_t ZE_APICALL zesDeviceEnumFirmwares(zes_device_handle_t hDevice, uint32_t *pCount, zes_firmware_handle_t *phFirmware)

Get handle of firmwares.

Parameters

  • hDevice: Sysman handle of the device.

  • pCount: pointer to the number of components of this type. if count is zero, then the driver will update the value with the total number of components of this type. if count is non-zero, then driver will only retrieve that number of components. if count is larger than the number of components available, then the driver will update the value with the correct number of components that are returned.

  • phFirmware: [optional][range(0, *pCount)] array of handle of components of this type

  • The application may call this function from simultaneous threads.

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

Return

zesFirmwareGetProperties

ZE_APIEXPORT ze_result_t ZE_APICALL zesFirmwareGetProperties(zes_firmware_handle_t hFirmware, zes_firmware_properties_t *pProperties)

Get firmware properties.

Parameters

  • hFirmware: Handle for the component.

  • pProperties: Pointer to an array that will hold the properties of the firmware

  • The application may call this function from simultaneous threads.

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

Return

zesFirmwareGetChecksum

ZE_APIEXPORT ze_result_t ZE_APICALL zesFirmwareGetChecksum(zes_firmware_handle_t hFirmware, uint32_t *pChecksum)

Get firmware checksum.

Parameters

  • hFirmware: Handle for the component.

  • pChecksum: Calculated CRC32 checksum of the installed firmware.

  • The application may call this function from simultaneous threads.

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

Return

zesFirmwareFlash

ZE_APIEXPORT ze_result_t ZE_APICALL zesFirmwareFlash(zes_firmware_handle_t hFirmware, void *pImage, uint32_t size)

Flash a new firmware image.

Parameters

  • hFirmware: Handle for the component.

  • pImage: Image of the new firmware to flash.

  • size: Size of the flash image.

  • The application may call this function from simultaneous threads.

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

Return

Firmware Structures

zes_firmware_properties_t

struct zes_firmware_properties_t

Firmware properties.

Public Members

ze_bool_t onSubdevice

[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

uint32_t subdeviceId

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

ze_bool_t canControl

[out] Indicates if software can flash the firmware assuming the user has permissions

char name[ZES_STRING_PROPERTY_SIZE]

[out] NULL terminated string value

char version[ZES_STRING_PROPERTY_SIZE]

[out] NULL terminated string value

Frequency

Frequency Functions

zesDeviceEnumFrequencyDomains

ZE_APIEXPORT ze_result_t ZE_APICALL zesDeviceEnumFrequencyDomains(zes_device_handle_t hDevice, uint32_t *pCount, zes_freq_handle_t *phFrequency)

Get handle of frequency domains.

Parameters

  • hDevice: Sysman handle of the device.

  • pCount: pointer to the number of components of this type. if count is zero, then the driver will update the value with the total number of components of this type. if count is non-zero, then driver will only retrieve that number of components. if count is larger than the number of components available, then the driver will update the value with the correct number of components that are returned.

  • phFrequency: [optional][range(0, *pCount)] array of handle of components of this type

  • The application may call this function from simultaneous threads.

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

Return

zesFrequencyGetProperties

ZE_APIEXPORT ze_result_t ZE_APICALL zesFrequencyGetProperties(zes_freq_handle_t hFrequency, zes_freq_properties_t *pProperties)

Get frequency properties - available frequencies.

Parameters

  • hFrequency: Handle for the component.

  • pProperties: The frequency properties for the specified domain.

  • The application may call this function from simultaneous threads.

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

Return

zesFrequencyGetAvailableClocks

ZE_APIEXPORT ze_result_t ZE_APICALL zesFrequencyGetAvailableClocks(zes_freq_handle_t hFrequency, uint32_t *pCount, double *phFrequency)

Get available non-overclocked hardware clock frequencies for the frequency domain.

Parameters

  • hFrequency: Sysman handle of the device.

  • pCount: pointer to the number of frequencies. If count is zero, then the driver will update the value with the total number of frequencies available. If count is non-zero, then driver will only retrieve that number of frequencies. If count is larger than the number of frequencies available, then the driver will update the value with the correct number of frequencies available.

  • phFrequency: [optional][range(0, *pCount)] array of frequencies in units of MHz and sorted from slowest to fastest

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

Return

zesFrequencyGetRange

ZE_APIEXPORT ze_result_t ZE_APICALL zesFrequencyGetRange(zes_freq_handle_t hFrequency, zes_freq_range_t *pLimits)

Get current frequency limits.

Parameters

  • hFrequency: Handle for the component.

  • pLimits: The range between which the hardware can operate for the specified domain.

  • The application may call this function from simultaneous threads.

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

Return

zesFrequencySetRange

ZE_APIEXPORT ze_result_t ZE_APICALL zesFrequencySetRange(zes_freq_handle_t hFrequency, const zes_freq_range_t *pLimits)

Set frequency range between which the hardware can operate.

Parameters

  • hFrequency: Handle for the component.

  • pLimits: The limits between which the hardware can operate for the specified domain.

  • The application may call this function from simultaneous threads.

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

Return

zesFrequencyGetState

ZE_APIEXPORT ze_result_t ZE_APICALL zesFrequencyGetState(zes_freq_handle_t hFrequency, zes_freq_state_t *pState)

Get current frequency state - frequency request, actual frequency, TDP limits.

Parameters

  • hFrequency: Handle for the component.

  • pState: Frequency state for the specified domain.

  • The application may call this function from simultaneous threads.

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

Return

zesFrequencyGetThrottleTime

ZE_APIEXPORT ze_result_t ZE_APICALL zesFrequencyGetThrottleTime(zes_freq_handle_t hFrequency, zes_freq_throttle_time_t *pThrottleTime)

Get frequency throttle time.

Parameters

  • hFrequency: Handle for the component.

  • pThrottleTime: Will contain a snapshot of the throttle time counters for the specified domain.

  • The application may call this function from simultaneous threads.

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

Return

zesFrequencyOcGetCapabilities

ZE_APIEXPORT ze_result_t ZE_APICALL zesFrequencyOcGetCapabilities(zes_freq_handle_t hFrequency, zes_oc_capabilities_t *pOcCapabilities)

Get the overclocking capabilities.

Parameters

  • hFrequency: Handle for the component.

  • pOcCapabilities: Pointer to the capabilities structure zes_oc_capabilities_t.

  • The application may call this function from simultaneous threads.

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

Return

zesFrequencyOcGetConfig

ZE_APIEXPORT ze_result_t ZE_APICALL zesFrequencyOcGetConfig(zes_freq_handle_t hFrequency, zes_oc_config_t *pOcConfiguration)

Get the current overclocking configuration.

Parameters

  • hFrequency: Handle for the component.

  • pOcConfiguration: Pointer to the configuration structure zes_oc_config_t.

  • The application may call this function from simultaneous threads.

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

Return

zesFrequencyOcSetConfig

ZE_APIEXPORT ze_result_t ZE_APICALL zesFrequencyOcSetConfig(zes_freq_handle_t hFrequency, zes_oc_config_t *pOcConfiguration, ze_bool_t *pDeviceRestart)

Change the overclocking configuration.

Parameters

  • hFrequency: Handle for the component.

  • pOcConfiguration: Pointer to the configuration structure zes_oc_config_t.

  • pDeviceRestart: This will be set to true if the device needs to be restarted in order to enable the new overclock settings.

Return

zesFrequencyOcGetIccMax

ZE_APIEXPORT ze_result_t ZE_APICALL zesFrequencyOcGetIccMax(zes_freq_handle_t hFrequency, double *pOcIccMax)

Get the maximum current limit setting.

Parameters

  • hFrequency: Handle for the component.

  • pOcIccMax: Will contain the maximum current limit in Amperes on successful return.

  • The application may call this function from simultaneous threads.

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

Return

zesFrequencyOcSetIccMax

ZE_APIEXPORT ze_result_t ZE_APICALL zesFrequencyOcSetIccMax(zes_freq_handle_t hFrequency, double ocIccMax)

Change the maximum current limit setting.

Parameters

  • hFrequency: Handle for the component.

  • ocIccMax: The new maximum current limit in Amperes.

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

Return

zesFrequencyOcGetTjMax

ZE_APIEXPORT ze_result_t ZE_APICALL zesFrequencyOcGetTjMax(zes_freq_handle_t hFrequency, double *pOcTjMax)

Get the maximum temperature limit setting.

Parameters

  • hFrequency: Handle for the component.

  • pOcTjMax: Will contain the maximum temperature limit in degrees Celsius on successful return.

  • The application may call this function from simultaneous threads.

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

Return

zesFrequencyOcSetTjMax

ZE_APIEXPORT ze_result_t ZE_APICALL zesFrequencyOcSetTjMax(zes_freq_handle_t hFrequency, double ocTjMax)

Change the maximum temperature limit setting.

Parameters

  • hFrequency: Handle for the component.

  • ocTjMax: The new maximum temperature limit in degrees Celsius.

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

Return

Frequency Enums

zes_freq_domain_t

enum zes_freq_domain_t

Frequency domains.

Values:

ZES_FREQ_DOMAIN_GPU = 0

GPU Core Domain.

ZES_FREQ_DOMAIN_MEMORY

Local Memory Domain.

zes_freq_throttle_reasons_t

enum zes_freq_throttle_reasons_t

Frequency throttle reasons.

Values:

ZES_FREQ_THROTTLE_REASONS_NONE = 0

frequency not throttled

ZES_FREQ_THROTTLE_REASONS_AVE_PWR_CAP = ZE_BIT(0)

frequency throttled due to average power excursion (PL1)

ZES_FREQ_THROTTLE_REASONS_BURST_PWR_CAP = ZE_BIT(1)

frequency throttled due to burst power excursion (PL2)

ZES_FREQ_THROTTLE_REASONS_CURRENT_LIMIT = ZE_BIT(2)

frequency throttled due to current excursion (PL4)

ZES_FREQ_THROTTLE_REASONS_THERMAL_LIMIT = ZE_BIT(3)

frequency throttled due to thermal excursion (T > TjMax)

ZES_FREQ_THROTTLE_REASONS_PSU_ALERT = ZE_BIT(4)

frequency throttled due to power supply assertion

ZES_FREQ_THROTTLE_REASONS_SW_RANGE = ZE_BIT(5)

frequency throttled due to software supplied frequency range

ZES_FREQ_THROTTLE_REASONS_HW_RANGE = ZE_BIT(6)

range when it receives clocks

frequency throttled due to a sub block that has a lower frequency

zes_oc_mode_t

enum zes_oc_mode_t

Overclocking modes.

Values:

ZES_OC_MODE_OFF = 0

Overclocking if off - hardware is running using factory default voltages/frequencies.

ZES_OC_MODE_OVERRIDE

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.

ZES_OC_MODE_INTERPOLATIVE

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.

Frequency Structures

zes_freq_properties_t

struct zes_freq_properties_t

Frequency properties.

  • Indicates if this frequency domain can be overclocked (if true, functions such as zesFrequencyOcSetConfig() are supported).

  • The min/max hardware frequencies are specified for non-overclock configurations. For overclock configurations, use zesFrequencyOcGetConfig() to determine the maximum frequency that can be requested.

  • If step is non-zero, the available frequencies are (min, min + step, min + 2xstep, …, max). Otherwise, call zesFrequencyGetAvailableClocks() to get the list of frequencies that can be requested.

Public Members

zes_freq_domain_t type

[out] The hardware block that this frequency domain controls (GPU, memory, …)

ze_bool_t onSubdevice

[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

uint32_t subdeviceId

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

ze_bool_t canControl

[out] Indicates if software can control the frequency of this domain assuming the user has permissions

ze_bool_t isThrottleEventSupported

[out] Indicates if software can register to receive event ZES_EVENT_TYPE_FREQ_THROTTLED

double min

[out] The minimum hardware clock frequency in units of MHz

double max

[out] The maximum non-overclock hardware clock frequency in units of MHz.

double step

[out] The minimum step-size for clock frequencies in units of MHz. The hardware will clamp intermediate frequencies to lowest multiplier of this number.

zes_freq_range_t

struct zes_freq_range_t

Frequency range between which the hardware can operate.

Public Members

double min

[in,out] The min frequency in MHz below which hardware frequency management will not request frequencies. Setting to 0 will use the hardware default value.

double max

[in,out] The max frequency in MHz above which hardware frequency management will not request frequencies. Setting to 0 will use the hardware default value.

zes_freq_state_t

struct zes_freq_state_t

Frequency state.

Public Members

double request

[out] The current frequency request in MHz.

double tdp

[out] The maximum frequency in MHz supported under the current TDP conditions

double efficient

[out] The efficient minimum frequency in MHz

double actual

[out] The resolved frequency in MHz

uint32_t throttleReasons

[out] The reasons that the frequency is being limited by the hardware (Bitfield of zes_freq_throttle_reasons_t).

zes_freq_throttle_time_t

struct zes_freq_throttle_time_t

Frequency throttle time snapshot.

  • Percent time throttled is calculated by taking two snapshots (s1, s2) and using the equation: throttled = (s2.throttleTime - s1.throttleTime) / (s2.timestamp - s1.timestamp)

Public Members

uint64_t throttleTime

[out] The monotonic counter of time in microseconds that the frequency has been limited by the hardware.

uint64_t timestamp

[out] Microsecond timestamp when throttleTime was captured. No assumption should be made about the absolute value of the timestamp. It should only be used to calculate delta time between two snapshots of the same structure. Never take the delta of this timestamp with the timestamp from a different structure.

zes_oc_capabilities_t

struct zes_oc_capabilities_t

Overclocking properties.

  • Provides all the overclocking capabilities and properties supported by the device for the frequency domain.

Public Members

ze_bool_t isOcSupported

[out] Indicates if any overclocking features are supported on this frequency domain.

double maxFactoryDefaultFrequency

[out] Factory default non-overclock maximum frequency in Mhz.

double maxFactoryDefaultVoltage

[out] Factory default voltage used for the non-overclock maximum frequency in MHz.

double maxOcFrequency

[out] Maximum hardware overclocking frequency limit in Mhz.

double minOcVoltageOffset

[out] The minimum voltage offset that can be applied to the voltage/frequency curve. Note that this number can be negative.

double maxOcVoltageOffset

[out] The maximum voltage offset that can be applied to the voltage/frequency curve.

double maxOcVoltage

[out] The maximum overclock voltage that hardware supports.

ze_bool_t isTjMaxSupported

[out] Indicates if the maximum temperature limit (TjMax) can be changed for this frequency domain.

ze_bool_t isIccMaxSupported

[out] Indicates if the maximum current (IccMax) can be changed for this frequency domain.

ze_bool_t isHighVoltModeCapable

[out] Indicates if this frequency domains supports a feature to set very high voltages.

ze_bool_t isHighVoltModeEnabled

[out] Indicates if very high voltages are permitted on this frequency domain.

zes_oc_config_t

struct zes_oc_config_t

Overclocking configuration.

  • Overclock settings

Public Members

zes_oc_mode_t mode

[in,out] Overclock Mode zes_oc_mode_t.

double frequency

[in,out] Overclocking Frequency in MHz. This cannot be greater than zes_oc_capabilities_t.maxOcFrequency.

double voltageTarget

[in,out] Overclock voltage in Volts. This cannot be greater than zes_oc_capabilities_t.maxOcVoltage.

double voltageOffset

[in,out] This voltage offset is applied to all points on the voltage/frequency curve, include the new overclock voltageTarget. It can be in the range (zes_oc_capabilities_t.minOcVoltageOffset, zes_oc_capabilities_t.maxOcVoltageOffset).

Led

Led Functions

zesDeviceEnumLeds

ZE_APIEXPORT ze_result_t ZE_APICALL zesDeviceEnumLeds(zes_device_handle_t hDevice, uint32_t *pCount, zes_led_handle_t *phLed)

Get handle of LEDs.

Parameters

  • hDevice: Sysman handle of the device.

  • pCount: pointer to the number of components of this type. if count is zero, then the driver will update the value with the total number of components of this type. if count is non-zero, then driver will only retrieve that number of components. if count is larger than the number of components available, then the driver will update the value with the correct number of components that are returned.

  • phLed: [optional][range(0, *pCount)] array of handle of components of this type

  • The application may call this function from simultaneous threads.

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

Return

zesLedGetProperties

ZE_APIEXPORT ze_result_t ZE_APICALL zesLedGetProperties(zes_led_handle_t hLed, zes_led_properties_t *pProperties)

Get LED properties.

Parameters

  • hLed: Handle for the component.

  • pProperties: Will contain the properties of the LED.

  • The application may call this function from simultaneous threads.

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

Return

zesLedGetState

ZE_APIEXPORT ze_result_t ZE_APICALL zesLedGetState(zes_led_handle_t hLed, zes_led_state_t *pState)

Get current state of a LED - on/off, color.

Parameters

  • hLed: Handle for the component.

  • pState: Will contain the current state of the LED.

  • The application may call this function from simultaneous threads.

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

Return

zesLedSetState

ZE_APIEXPORT ze_result_t ZE_APICALL zesLedSetState(zes_led_handle_t hLed, const zes_led_state_t *pState)

Set state of a LED - on/off, color.

Parameters

  • hLed: Handle for the component.

  • pState: New state of the LED.

  • The application may call this function from simultaneous threads.

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

Return

Led Structures

zes_led_properties_t

struct zes_led_properties_t

LED properties.

Public Members

ze_bool_t onSubdevice

[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

uint32_t subdeviceId

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

ze_bool_t canControl

[out] Indicates if software can control the LED assuming the user has permissions

ze_bool_t haveRGB

[out] Indicates if the LED is RGB capable

zes_led_state_t

struct zes_led_state_t

LED state.

Public Members

ze_bool_t isOn

[in,out] Indicates if the LED is on or off

uint8_t red

[in,out][range(0, 255)] The LED red value

uint8_t green

[in,out][range(0, 255)] The LED green value

uint8_t blue

[in,out][range(0, 255)] The LED blue value

Memory

Memory Functions

zesDeviceEnumMemoryModules

ZE_APIEXPORT ze_result_t ZE_APICALL zesDeviceEnumMemoryModules(zes_device_handle_t hDevice, uint32_t *pCount, zes_mem_handle_t *phMemory)

Get handle of memory modules.

Parameters

  • hDevice: Sysman handle of the device.

  • pCount: pointer to the number of components of this type. if count is zero, then the driver will update the value with the total number of components of this type. if count is non-zero, then driver will only retrieve that number of components. if count is larger than the number of components available, then the driver will update the value with the correct number of components that are returned.

  • phMemory: [optional][range(0, *pCount)] array of handle of components of this type

  • The application may call this function from simultaneous threads.

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

Return

zesMemoryGetProperties

ZE_APIEXPORT ze_result_t ZE_APICALL zesMemoryGetProperties(zes_mem_handle_t hMemory, zes_mem_properties_t *pProperties)

Get memory properties.

Parameters

  • hMemory: Handle for the component.

  • pProperties: Will contain memory properties.

  • The application may call this function from simultaneous threads.

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

Return

zesMemoryGetState

ZE_APIEXPORT ze_result_t ZE_APICALL zesMemoryGetState(zes_mem_handle_t hMemory, zes_mem_state_t *pState)

Get memory state - health, allocated.

Parameters

  • hMemory: Handle for the component.

  • pState: Will contain the current health and allocated memory.

  • The application may call this function from simultaneous threads.

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

Return

zesMemoryGetBandwidth

ZE_APIEXPORT ze_result_t ZE_APICALL zesMemoryGetBandwidth(zes_mem_handle_t hMemory, zes_mem_bandwidth_t *pBandwidth)

Get memory bandwidth.

Parameters

  • hMemory: Handle for the component.

  • pBandwidth: Will contain the current health, free memory, total memory size.

  • The application may call this function from simultaneous threads.

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

Return

Memory Enums

zes_mem_type_t

enum zes_mem_type_t

Memory module types.

Values:

ZES_MEM_TYPE_HBM = 0

HBM memory.

ZES_MEM_TYPE_DDR

DDR memory.

ZES_MEM_TYPE_SRAM

SRAM memory.

ZES_MEM_TYPE_L1

L1 cache.

ZES_MEM_TYPE_L3

L3 cache.

ZES_MEM_TYPE_GRF

Execution unit register file.

ZES_MEM_TYPE_SLM

Execution unit shared local memory.

zes_mem_health_t

enum zes_mem_health_t

Memory health.

Values:

ZES_MEM_HEALTH_OK = 0

All memory channels are healthy.

ZES_MEM_HEALTH_DEGRADED

Excessive correctable errors have been detected on one or more channels. Device should be reset.

ZES_MEM_HEALTH_CRITICAL

Operating with reduced memory to cover banks with too many uncorrectable errors.

ZES_MEM_HEALTH_REPLACE

Device should be replaced due to excessive uncorrectable errors.

Memory Structures

zes_mem_properties_t

struct zes_mem_properties_t

Memory properties.

Public Members

zes_mem_type_t type

[out] The memory type

ze_bool_t onSubdevice

[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

uint32_t subdeviceId

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

uint64_t physicalSize

[out] Physical memory size in bytes

zes_mem_state_t

struct zes_mem_state_t

Memory state - health, allocated.

  • Percent allocation is given by 100 * allocatedSize / maxSize.

  • Percent free is given by 100 * (maxSize - allocatedSize) / maxSize.

Public Members

zes_mem_health_t health

[out] Indicates the health of the memory

uint64_t free

[out] The free memory in bytes

uint64_t size

[out] The total allocatable memory in bytes (can be less than zes_mem_properties_t.physicalSize)

zes_mem_bandwidth_t

struct zes_mem_bandwidth_t

Memory bandwidth.

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

Public Members

uint64_t readCounter

[out] Total bytes read from memory

uint64_t writeCounter

[out] Total bytes written to memory

uint64_t maxBandwidth

[out] Current maximum bandwidth in units of bytes/sec

uint64_t timestamp

[out] The timestamp when these measurements were sampled. No assumption should be made about the absolute value of the timestamp. It should only be used to calculate delta time between two snapshots of the same structure. Never take the delta of this timestamp with the timestamp from a different structure.

Performance

Performance Functions

zesDeviceEnumPerformanceFactorDomains

ZE_APIEXPORT ze_result_t ZE_APICALL zesDeviceEnumPerformanceFactorDomains(zes_device_handle_t hDevice, uint32_t *pCount, zes_perf_handle_t *phPerf)

Get handles to accelerator domains whose performance can be optimized via a Performance Factor.

Parameters

  • hDevice: Sysman handle of the device.

  • pCount: pointer to the number of components of this type. if count is zero, then the driver will update the value with the total number of components of this type. if count is non-zero, then driver will only retrieve that number of components. if count is larger than the number of components available, then the driver will update the value with the correct number of components that are returned.

  • phPerf: [optional][range(0, *pCount)] array of handle of components of this type

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

Return

zesPerformanceFactorGetProperties

ZE_APIEXPORT ze_result_t ZE_APICALL zesPerformanceFactorGetProperties(zes_perf_handle_t hPerf, zes_perf_properties_t *pProperties)

Get properties about a Performance Factor domain.

Parameters

  • hPerf: Handle for the Performance Factor domain.

  • pProperties: Will contain information about the specified Performance Factor domain.

  • The application may call this function from simultaneous threads.

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

Return

zesPerformanceFactorGetConfig

ZE_APIEXPORT ze_result_t ZE_APICALL zesPerformanceFactorGetConfig(zes_perf_handle_t hPerf, double *pFactor)

Get current Performance Factor for a given domain.

Parameters

  • hPerf: Handle for the Performance Factor domain.

  • pFactor: Will contain the actual Performance Factor being used by the hardware (may not be the same as the requested Performance Factor).

  • The application may call this function from simultaneous threads.

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

Return

zesPerformanceFactorSetConfig

ZE_APIEXPORT ze_result_t ZE_APICALL zesPerformanceFactorSetConfig(zes_perf_handle_t hPerf, double factor)

Change the performance factor for a domain.

Parameters

  • hPerf: Handle for the Performance Factor domain.

  • factor: The new Performance Factor.

  • 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 zesPerformanceFactorGetConfig() 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.

Return

Performance Structures

zes_perf_properties_t

struct zes_perf_properties_t

Static information about a Performance Factor domain.

Public Members

ze_bool_t onSubdevice

[out] True if this Performance Factor affects accelerators located on a sub-device

uint32_t subdeviceId

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

uint64_t engines

[out] Bitfield of accelerator engines that are affected by this Performance Factor (bitfield of 1<<zes_engine_type_t).

Power

Power Functions

zesDeviceEnumPowerDomains

ZE_APIEXPORT ze_result_t ZE_APICALL zesDeviceEnumPowerDomains(zes_device_handle_t hDevice, uint32_t *pCount, zes_pwr_handle_t *phPower)

Get handle of power domains.

Parameters

  • hDevice: Sysman handle of the device.

  • pCount: pointer to the number of components of this type. if count is zero, then the driver will update the value with the total number of components of this type. if count is non-zero, then driver will only retrieve that number of components. if count is larger than the number of components available, then the driver will update the value with the correct number of components that are returned.

  • phPower: [optional][range(0, *pCount)] array of handle of components of this type

  • The application may call this function from simultaneous threads.

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

Return

zesPowerGetProperties

ZE_APIEXPORT ze_result_t ZE_APICALL zesPowerGetProperties(zes_pwr_handle_t hPower, zes_power_properties_t *pProperties)

Get properties related to a power domain.

Parameters

  • hPower: Handle for the component.

  • pProperties: Structure that will contain property data.

  • The application may call this function from simultaneous threads.

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

Return

zesPowerGetEnergyCounter

ZE_APIEXPORT ze_result_t ZE_APICALL zesPowerGetEnergyCounter(zes_pwr_handle_t hPower, zes_power_energy_counter_t *pEnergy)

Get energy counter.

Parameters

  • hPower: Handle for the component.

  • pEnergy: Will contain the latest snapshot of the energy counter and timestamp when the last counter value was measured.

  • The application may call this function from simultaneous threads.

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

Return

zesPowerGetLimits

ZE_APIEXPORT ze_result_t ZE_APICALL zesPowerGetLimits(zes_pwr_handle_t hPower, zes_power_sustained_limit_t *pSustained, zes_power_burst_limit_t *pBurst, zes_power_peak_limit_t *pPeak)

Get power limits.

Parameters

  • hPower: Handle for the component.

  • pSustained: [optional] The sustained power limit.

  • pBurst: [optional] The burst power limit.

  • pPeak: [optional] The peak power limit.

  • The application may call this function from simultaneous threads.

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

Return

zesPowerSetLimits

ZE_APIEXPORT ze_result_t ZE_APICALL zesPowerSetLimits(zes_pwr_handle_t hPower, const zes_power_sustained_limit_t *pSustained, const zes_power_burst_limit_t *pBurst, const zes_power_peak_limit_t *pPeak)

Set power limits.

Parameters

  • hPower: Handle for the component.

  • pSustained: [optional] The sustained power limit.

  • pBurst: [optional] The burst power limit.

  • pPeak: [optional] The peak power limit.

  • The application may call this function from simultaneous threads.

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

Return

zesPowerGetEnergyThreshold

ZE_APIEXPORT ze_result_t ZE_APICALL zesPowerGetEnergyThreshold(zes_pwr_handle_t hPower, zes_energy_threshold_t *pThreshold)

Get energy threshold.

Parameters

  • hPower: Handle for the component.

  • pThreshold: Returns information about the energy threshold setting - enabled/energy threshold/process ID.

  • The application may call this function from simultaneous threads.

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

Return

zesPowerSetEnergyThreshold

ZE_APIEXPORT ze_result_t ZE_APICALL zesPowerSetEnergyThreshold(zes_pwr_handle_t hPower, double threshold)

Set energy threshold.

Parameters

  • hPower: Handle for the component.

  • threshold: The energy threshold to be set in joules.

  • An event ZES_EVENT_TYPE_ENERGY_THRESHOLD_CROSSED will be generated when the delta energy consumed starting from this call exceeds the specified threshold. Use the function zesEventSetConfig() 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 ZE_RESULT_ERROR_NOT_AVAILABLE will be returned. The function zesPowerGetEnergyThreshold() 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.

Return

Power Structures

zes_power_properties_t

struct zes_power_properties_t

Properties related to device power settings.

Public Members

ze_bool_t onSubdevice

[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

uint32_t subdeviceId

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

ze_bool_t canControl

[out] Software can change the power limits of this domain assuming the user has permissions.

ze_bool_t isEnergyThresholdSupported

[out] Indicates if this power domain supports the energy threshold event (ZES_EVENT_TYPE_ENERGY_THRESHOLD_CROSSED).

uint32_t defaultLimit

[out] The factory default TDP power limit of the part in milliwatts.

uint32_t minLimit

[out] The minimum power limit in milliwatts that can be requested.

uint32_t maxLimit

[out] The maximum power limit in milliwatts that can be requested.

zes_power_energy_counter_t

struct zes_power_energy_counter_t

Energy counter snapshot.

  • Average power is calculated by taking two snapshots (s1, s2) and using the equation: PowerWatts = (s2.energy - s1.energy) / (s2.timestamp - s1.timestamp)

Public Members

uint64_t energy

[out] The monotonic energy counter in microjoules.

uint64_t timestamp

[out] Microsecond timestamp when energy was captured. No assumption should be made about the absolute value of the timestamp. It should only be used to calculate delta time between two snapshots of the same structure. Never take the delta of this timestamp with the timestamp from a different structure.

zes_power_sustained_limit_t

struct zes_power_sustained_limit_t

Sustained power limits.

  • The power controller (Punit) will throttle the operating frequency if the power averaged over a window (typically seconds) exceeds this limit.

Public Members

ze_bool_t enabled

[in,out] indicates if the limit is enabled (true) or ignored (false)

uint32_t power

[in,out] power limit in milliwatts

uint32_t interval

[in,out] power averaging window (Tau) in milliseconds

zes_power_burst_limit_t

struct zes_power_burst_limit_t

Burst power limit.

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

Public Members

ze_bool_t enabled

[in,out] indicates if the limit is enabled (true) or ignored (false)

uint32_t power

[in,out] power limit in milliwatts

zes_power_peak_limit_t

struct zes_power_peak_limit_t

Peak power limit.

  • The power controller (Punit) will preemptively throttle the operating frequency of the device when the instantaneous power exceeds this limit. The limit is known as PL4. 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.

Public Members

uint32_t powerAC

[in,out] power limit in milliwatts for the AC power source.

uint32_t powerDC

[in,out] power limit in milliwatts for the DC power source. This is ignored if the product does not have a battery.

zes_energy_threshold_t

struct zes_energy_threshold_t

Energy threshold.

  • .

Public Members

ze_bool_t enable

[in,out] Indicates if the energy threshold is enabled.

double threshold

[in,out] The energy threshold in Joules. Will be 0.0 if no threshold has been set.

uint32_t processId

[in,out] The host process ID that set the energy threshold. Will be 0xFFFFFFFF if no threshold has been set.

Psu

Psu Functions

zesDeviceEnumPsus

ZE_APIEXPORT ze_result_t ZE_APICALL zesDeviceEnumPsus(zes_device_handle_t hDevice, uint32_t *pCount, zes_psu_handle_t *phPsu)

Get handle of power supplies.

Parameters

  • hDevice: Sysman handle of the device.

  • pCount: pointer to the number of components of this type. if count is zero, then the driver will update the value with the total number of components of this type. if count is non-zero, then driver will only retrieve that number of components. if count is larger than the number of components available, then the driver will update the value with the correct number of components that are returned.

  • phPsu: [optional][range(0, *pCount)] array of handle of components of this type

  • The application may call this function from simultaneous threads.

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

Return

zesPsuGetProperties

ZE_APIEXPORT ze_result_t ZE_APICALL zesPsuGetProperties(zes_psu_handle_t hPsu, zes_psu_properties_t *pProperties)

Get power supply properties.

Parameters

  • hPsu: Handle for the component.

  • pProperties: Will contain the properties of the power supply.

  • The application may call this function from simultaneous threads.

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

Return

zesPsuGetState

ZE_APIEXPORT ze_result_t ZE_APICALL zesPsuGetState(zes_psu_handle_t hPsu, zes_psu_state_t *pState)

Get current power supply state.

Parameters

  • hPsu: Handle for the component.

  • pState: Will contain the current state of the power supply.

  • The application may call this function from simultaneous threads.

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

Return

Psu Enums

zes_psu_voltage_status_t

enum zes_psu_voltage_status_t

PSU voltage status.

Values:

ZES_PSU_VOLTAGE_STATUS_NORMAL = 0

No unusual voltages have been detected.

ZES_PSU_VOLTAGE_STATUS_OVER

Over-voltage has occurred.

ZES_PSU_VOLTAGE_STATUS_UNDER

Under-voltage has occurred.

Psu Structures

zes_psu_properties_t

struct zes_psu_properties_t

Static properties of the power supply.

Public Members

ze_bool_t onSubdevice

[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

uint32_t subdeviceId

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

ze_bool_t haveFan

[out] True if the power supply has a fan

uint32_t ampLimit

[out] The maximum electrical current in amperes that can be drawn

zes_psu_state_t

struct zes_psu_state_t

Dynamic state of the power supply.

Public Members

zes_psu_voltage_status_t voltStatus

[out] The current PSU voltage status

ze_bool_t fanFailed

[out] Indicates if the fan has failed

uint32_t temperature

[out] Read the current heatsink temperature in degrees Celsius.

uint32_t current

[out] The amps being drawn in amperes

Ras

Ras Functions

zesDeviceEnumRasErrorSets

ZE_APIEXPORT ze_result_t ZE_APICALL zesDeviceEnumRasErrorSets(zes_device_handle_t hDevice, uint32_t *pCount, zes_ras_handle_t *phRas)

Get handle of all RAS error sets on a device.

Parameters

  • hDevice: Sysman handle of the device.

  • pCount: pointer to the number of components of this type. if count is zero, then the driver will update the value with the total number of components of this type. if count is non-zero, then driver will only retrieve that number of components. if count is larger than the number of components available, then the driver will update the value with the correct number of components that are returned.

  • phRas: [optional][range(0, *pCount)] array of handle of components of this type

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

Return

zesRasGetProperties

ZE_APIEXPORT ze_result_t ZE_APICALL zesRasGetProperties(zes_ras_handle_t hRas, zes_ras_properties_t *pProperties)

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.

Parameters

  • hRas: Handle for the component.

  • pProperties: Structure describing RAS properties

  • The application may call this function from simultaneous threads.

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

Return

zesRasGetConfig

ZE_APIEXPORT ze_result_t ZE_APICALL zesRasGetConfig(zes_ras_handle_t hRas, zes_ras_config_t *pConfig)

Get RAS error thresholds that control when RAS events are generated.

Parameters

  • hRas: Handle for the component.

  • pConfig: Will be populed with the current RAS configuration - thresholds used to trigger events

  • 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 ZES_EVENT_TYPE_RAS_CORRECTABLE_ERRORS will be triggered.

  • When a particular RAS uncorrectable error counter exceeds the configured threshold, the event ZES_EVENT_TYPE_RAS_UNCORRECTABLE_ERRORS will be triggered.

  • The application may call this function from simultaneous threads.

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

Return

zesRasSetConfig

ZE_APIEXPORT ze_result_t ZE_APICALL zesRasSetConfig(zes_ras_handle_t hRas, const zes_ras_config_t *pConfig)

Set RAS error thresholds that control when RAS events are generated.

Parameters

  • hRas: Handle for the component.

  • pConfig: Change the RAS configuration - thresholds used to trigger events

  • 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 ZES_EVENT_TYPE_RAS_CORRECTABLE_ERRORS will be generated.

  • When a particular RAS uncorrectable error counter exceeds the specified threshold, the event ZES_EVENT_TYPE_RAS_UNCORRECTABLE_ERRORS will be generated.

  • Call zesRasGetState() 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.

Return

zesRasGetState

ZE_APIEXPORT ze_result_t ZE_APICALL zesRasGetState(zes_ras_handle_t hRas, ze_bool_t clear, zes_ras_state_t *pState)

Get the current value of RAS error counters for a particular error set.

Parameters

  • hRas: Handle for the component.

  • clear: Set to 1 to clear the counters of this type

  • pState: Breakdown of where errors have occurred

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

Return

Ras Enums

zes_ras_error_type_t

enum zes_ras_error_type_t

RAS error type.

Values:

ZES_RAS_ERROR_TYPE_CORRECTABLE = 0

Errors were corrected by hardware.

ZES_RAS_ERROR_TYPE_UNCORRECTABLE

Error were not corrected.

zes_ras_error_cat_t

enum zes_ras_error_cat_t

RAS error categories.

Values:

ZES_RAS_ERROR_CAT_RESET = 0

The number of device resets that have taken place.

ZES_RAS_ERROR_CAT_PROGRAMMING_ERRORS

The number of hardware exceptions generated by the way workloads have programmed the hardware

ZES_RAS_ERROR_CAT_DRIVER_ERRORS

The number of low level driver communication errors have occurred.

ZES_RAS_ERROR_CAT_COMPUTE_ERRORS

The number of errors that have occurred in the compute accelerator hardware

ZES_RAS_ERROR_CAT_NON_COMPUTE_ERRORS

The number of errors that have occurred in the fixed-function accelerator hardware

ZES_RAS_ERROR_CAT_CACHE_ERRORS

The number of errors that have occurred in caches (L1/L3/register file/shared local memory/sampler)

ZES_RAS_ERROR_CAT_DISPLAY_ERRORS

The number of errors that have occurred in the display.

ZES_RAS_ERROR_CAT_MAX

The number of categories.

Ras Structures

zes_ras_properties_t

struct zes_ras_properties_t

RAS properties.

Public Members

zes_ras_error_type_t type

[out] The type of RAS error

ze_bool_t onSubdevice

[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

uint32_t subdeviceId

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

zes_ras_state_t

struct zes_ras_state_t

RAS error details.

Public Members

uint64_t category[ZES_RAS_ERROR_CAT_MAX]

[in][out] Breakdown of error by category

zes_ras_config_t

struct zes_ras_config_t

RAS error configuration - thresholds used for triggering RAS events (ZES_EVENT_TYPE_RAS_CORRECTABLE_ERRORS, ZES_EVENT_TYPE_RAS_UNCORRECTABLE_ERRORS)

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

Public Members

uint64_t totalThreshold

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

zes_ras_state_t detailedThresholds

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

uint32_t processId

[out] Host processId that set this configuration (ignored when setting the configuration).

Scheduler

Scheduler Functions

zesDeviceEnumSchedulers

ZE_APIEXPORT ze_result_t ZE_APICALL zesDeviceEnumSchedulers(zes_device_handle_t hDevice, uint32_t *pCount, zes_sched_handle_t *phScheduler)

Get handle to a scheduler component.

Parameters

  • hDevice: Sysman handle of the device.

  • pCount: pointer to the number of components of this type. if count is zero, then the driver will update the value with the total number of components of this type. if count is non-zero, then driver will only retrieve that number of components. if count is larger than the number of components available, then the driver will update the value with the correct number of components that are returned.

  • phScheduler: [optional][range(0, *pCount)] array of handle of components of this type

  • The application may call this function from simultaneous threads.

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

Return

zesSchedulerGetProperties

ZE_APIEXPORT ze_result_t ZE_APICALL zesSchedulerGetProperties(zes_sched_handle_t hScheduler, zes_sched_properties_t *pProperties)

Get properties related to a scheduler component.

Parameters

  • hScheduler: Handle for the component.

  • pProperties: Structure that will contain property data.

  • The application may call this function from simultaneous threads.

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

Return

zesSchedulerGetCurrentMode

ZE_APIEXPORT ze_result_t ZE_APICALL zesSchedulerGetCurrentMode(zes_sched_handle_t hScheduler, zes_sched_mode_t *pMode)

Get current scheduling mode in effect on a scheduler component.

Parameters

  • hScheduler: Sysman handle for the component.

  • pMode: Will contain the current scheduler mode.

  • The application may call this function from simultaneous threads.

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

Return

zesSchedulerGetTimeoutModeProperties

ZE_APIEXPORT ze_result_t ZE_APICALL zesSchedulerGetTimeoutModeProperties(zes_sched_handle_t hScheduler, ze_bool_t getDefaults, zes_sched_timeout_properties_t *pConfig)

Get scheduler config for mode ZES_SCHED_MODE_TIMEOUT.

Parameters

  • hScheduler: Sysman handle for the component.

  • getDefaults: If TRUE, the driver will return the system default properties for this mode, otherwise it will return the current properties.

  • pConfig: Will contain the current parameters for this mode.

  • The application may call this function from simultaneous threads.

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

Return

zesSchedulerGetTimesliceModeProperties

ZE_APIEXPORT ze_result_t ZE_APICALL zesSchedulerGetTimesliceModeProperties(zes_sched_handle_t hScheduler, ze_bool_t getDefaults, zes_sched_timeslice_properties_t *pConfig)

Get scheduler config for mode ZES_SCHED_MODE_TIMESLICE.

Parameters

  • hScheduler: Sysman handle for the component.

  • getDefaults: If TRUE, the driver will return the system default properties for this mode, otherwise it will return the current properties.

  • pConfig: Will contain the current parameters for this mode.

  • The application may call this function from simultaneous threads.

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

Return

zesSchedulerSetTimeoutMode

ZE_APIEXPORT ze_result_t ZE_APICALL zesSchedulerSetTimeoutMode(zes_sched_handle_t hScheduler, zes_sched_timeout_properties_t *pProperties, ze_bool_t *pNeedReload)

Change scheduler mode to ZES_SCHED_MODE_TIMEOUT or update scheduler mode parameters if already running in this mode.

Parameters

  • hScheduler: Sysman handle for the component.

  • pProperties: The properties to use when configurating this mode.

  • pNeedReload: Will be set to TRUE if a device driver reload is needed to apply the new scheduler mode.

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

Return

zesSchedulerSetTimesliceMode

ZE_APIEXPORT ze_result_t ZE_APICALL zesSchedulerSetTimesliceMode(zes_sched_handle_t hScheduler, zes_sched_timeslice_properties_t *pProperties, ze_bool_t *pNeedReload)

Change scheduler mode to ZES_SCHED_MODE_TIMESLICE or update scheduler mode parameters if already running in this mode.

Parameters

  • hScheduler: Sysman handle for the component.

  • pProperties: The properties to use when configurating this mode.

  • pNeedReload: Will be set to TRUE if a device driver reload is needed to apply the new scheduler mode.

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

Return

zesSchedulerSetExclusiveMode

ZE_APIEXPORT ze_result_t ZE_APICALL zesSchedulerSetExclusiveMode(zes_sched_handle_t hScheduler, ze_bool_t *pNeedReload)

Change scheduler mode to ZES_SCHED_MODE_EXCLUSIVE.

Parameters

  • hScheduler: Sysman handle for the component.

  • pNeedReload: Will be set to TRUE if a device driver reload is needed to apply the new scheduler mode.

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

Return

zesSchedulerSetComputeUnitDebugMode

ZE_APIEXPORT ze_result_t ZE_APICALL zesSchedulerSetComputeUnitDebugMode(zes_sched_handle_t hScheduler, ze_bool_t *pNeedReload)

Change scheduler mode to ZES_SCHED_MODE_COMPUTE_UNIT_DEBUG.

Parameters

  • hScheduler: Sysman handle for the component.

  • pNeedReload: Will be set to TRUE if a device driver reload is needed to apply the new scheduler mode.

  • This mode is optimized for application debug. 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.

Return

Scheduler Enums

zes_sched_mode_t

enum zes_sched_mode_t

Scheduler mode.

Values:

ZES_SCHED_MODE_TIMEOUT = 0

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.

ZES_SCHED_MODE_TIMESLICE

The scheduler attempts to fairly timeslice hardware execution time between multiple contexts submitting work to the hardware concurrently.

ZES_SCHED_MODE_EXCLUSIVE

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.

ZES_SCHED_MODE_COMPUTE_UNIT_DEBUG

Scheduler ensures that submission of workloads to the hardware is optimized for compute unit debugging.

Scheduler Structures

zes_sched_properties_t

struct zes_sched_properties_t

Properties related to scheduler component.

Public Members

ze_bool_t onSubdevice

[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

uint32_t subdeviceId

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

ze_bool_t canControl

[out] Software can change the scheduler component configuration assuming the user has permissions.

uint64_t engines

[out] Bitfield of accelerator engines that are controlled by this scheduler component (bitfield of 1<<zes_engine_type_t).

uint32_t supportedModes

[out] Bitfield of scheduler modes that can be configured for this scheduler component (bitfield of 1<<zes_sched_mode_t).

zes_sched_timeout_properties_t

struct zes_sched_timeout_properties_t

Configuration for timeout scheduler mode (ZES_SCHED_MODE_TIMEOUT)

Public Members

uint64_t watchdogTimeout

[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. If this time is exceeded, the hardware engine is reset and the context terminated. If set to ZES_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.

zes_sched_timeslice_properties_t

struct zes_sched_timeslice_properties_t

Configuration for timeslice scheduler mode (ZES_SCHED_MODE_TIMESLICE)

Public Members

uint64_t interval

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

uint64_t yieldTimeout

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

Standby

Standby Functions

zesDeviceEnumStandbyDomains

ZE_APIEXPORT ze_result_t ZE_APICALL zesDeviceEnumStandbyDomains(zes_device_handle_t hDevice, uint32_t *pCount, zes_standby_handle_t *phStandby)

Get handle of standby controls.

Parameters

  • hDevice: Sysman handle of the device.

  • pCount: pointer to the number of components of this type. if count is zero, then the driver will update the value with the total number of components of this type. if count is non-zero, then driver will only retrieve that number of components. if count is larger than the number of components available, then the driver will update the value with the correct number of components that are returned.

  • phStandby: [optional][range(0, *pCount)] array of handle of components of this type

  • The application may call this function from simultaneous threads.

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

Return

zesStandbyGetProperties

ZE_APIEXPORT ze_result_t ZE_APICALL zesStandbyGetProperties(zes_standby_handle_t hStandby, zes_standby_properties_t *pProperties)

Get standby hardware component properties.

Parameters

  • hStandby: Handle for the component.

  • pProperties: Will contain the standby hardware properties.

  • The application may call this function from simultaneous threads.

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

Return

zesStandbyGetMode

ZE_APIEXPORT ze_result_t ZE_APICALL zesStandbyGetMode(zes_standby_handle_t hStandby, zes_standby_promo_mode_t *pMode)

Get the current standby promotion mode.

Parameters

  • hStandby: Handle for the component.

  • pMode: Will contain the current standby mode.

  • The application may call this function from simultaneous threads.

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

Return

zesStandbySetMode

ZE_APIEXPORT ze_result_t ZE_APICALL zesStandbySetMode(zes_standby_handle_t hStandby, zes_standby_promo_mode_t mode)

Set standby promotion mode.

Parameters

  • hStandby: Handle for the component.

  • mode: New standby mode.

  • The application may call this function from simultaneous threads.

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

Return

Standby Enums

zes_standby_type_t

enum zes_standby_type_t

Standby hardware components.

Values:

ZES_STANDBY_TYPE_GLOBAL = 0

Control the overall standby policy of the device/sub-device.

zes_standby_promo_mode_t

enum zes_standby_promo_mode_t

Standby promotion modes.

Values:

ZES_STANDBY_PROMO_MODE_DEFAULT = 0

Best compromise between performance and energy savings.

ZES_STANDBY_PROMO_MODE_NEVER

The device/component will never shutdown. This can improve performance but uses more energy.

Standby Structures

zes_standby_properties_t

struct zes_standby_properties_t

Standby hardware component properties.

Public Members

zes_standby_type_t type

[out] Which standby hardware component this controls

ze_bool_t onSubdevice

[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

uint32_t subdeviceId

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

Temperature

Temperature Functions

zesDeviceEnumTemperatureSensors

ZE_APIEXPORT ze_result_t ZE_APICALL zesDeviceEnumTemperatureSensors(zes_device_handle_t hDevice, uint32_t *pCount, zes_temp_handle_t *phTemperature)

Get handle of temperature sensors.

Parameters

  • hDevice: Sysman handle of the device.

  • pCount: pointer to the number of components of this type. if count is zero, then the driver will update the value with the total number of components of this type. if count is non-zero, then driver will only retrieve that number of components. if count is larger than the number of components available, then the driver will update the value with the correct number of components that are returned.

  • phTemperature: [optional][range(0, *pCount)] array of handle of components of this type

  • The application may call this function from simultaneous threads.

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

Return

zesTemperatureGetProperties

ZE_APIEXPORT ze_result_t ZE_APICALL zesTemperatureGetProperties(zes_temp_handle_t hTemperature, zes_temp_properties_t *pProperties)

Get temperature sensor properties.

Parameters

  • hTemperature: Handle for the component.

  • pProperties: Will contain the temperature sensor properties.

  • The application may call this function from simultaneous threads.

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

Return

zesTemperatureGetConfig

ZE_APIEXPORT ze_result_t ZE_APICALL zesTemperatureGetConfig(zes_temp_handle_t hTemperature, zes_temp_config_t *pConfig)

Get temperature configuration for this sensor - which events are triggered and the trigger conditions.

Parameters

  • hTemperature: Handle for the component.

  • pConfig: Returns current configuration.

  • The application may call this function from simultaneous threads.

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

Return

zesTemperatureSetConfig

ZE_APIEXPORT ze_result_t ZE_APICALL zesTemperatureSetConfig(zes_temp_handle_t hTemperature, const zes_temp_config_t *pConfig)

Set temperature configuration for this sensor - indicates which events are triggered and the trigger conditions.

Parameters

  • hTemperature: Handle for the component.

  • pConfig: New configuration.

Return

zesTemperatureGetState

ZE_APIEXPORT ze_result_t ZE_APICALL zesTemperatureGetState(zes_temp_handle_t hTemperature, double *pTemperature)

Get the temperature from a specified sensor.

Parameters

  • hTemperature: Handle for the component.

  • pTemperature: Will contain the temperature read from the specified sensor in degrees Celsius.

  • The application may call this function from simultaneous threads.

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

Return

Temperature Enums

zes_temp_sensors_t

enum zes_temp_sensors_t

Temperature sensors.

Values:

ZES_TEMP_SENSORS_GLOBAL = 0

The maximum temperature across all device sensors.

ZES_TEMP_SENSORS_GPU

The maximum temperature across all sensors in the GPU.

ZES_TEMP_SENSORS_MEMORY

The maximum temperature across all sensors in the local memory.

Temperature Structures

zes_temp_properties_t

struct zes_temp_properties_t

Temperature sensor properties.

Public Members

zes_temp_sensors_t type

[out] Which part of the device the temperature sensor measures

ze_bool_t onSubdevice

[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

uint32_t subdeviceId

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

ze_bool_t isCriticalTempSupported

[out] Indicates if the critical temperature event ZES_EVENT_TYPE_TEMP_CRITICAL is supported

ze_bool_t isThreshold1Supported

[out] Indicates if the temperature threshold 1 event ZES_EVENT_TYPE_TEMP_THRESHOLD1 is supported

ze_bool_t isThreshold2Supported

[out] Indicates if the temperature threshold 2 event ZES_EVENT_TYPE_TEMP_THRESHOLD2 is supported

zes_temp_threshold_t

struct zes_temp_threshold_t

Temperature sensor threshold.

Public Members

ze_bool_t enableLowToHigh

[in,out] Trigger an event when the temperature crosses from below the threshold to above.

ze_bool_t enableHighToLow

[in,out] Trigger an event when the temperature crosses from above the threshold to below.

double threshold

[in,out] The threshold in degrees Celsius.

zes_temp_config_t

struct zes_temp_config_t

Temperature configuration - which events should be triggered and the trigger conditions.

Public Members

ze_bool_t enableCritical

[in,out] Indicates if event ZES_EVENT_TYPE_TEMP_CRITICAL should be triggered by the driver.

zes_temp_threshold_t threshold1

[in,out] Configuration controlling if and when event ZES_EVENT_TYPE_TEMP_THRESHOLD1 should be triggered by the driver.

zes_temp_threshold_t threshold2

[in,out] Configuration controlling if and when event ZES_EVENT_TYPE_TEMP_THRESHOLD2 should be triggered by the driver.

uint32_t processId

[out] Host processId that set this configuration (ignored when setting the configuration).