Merge amd-staging into amd-master 20231121
Change-Id: I400dfcdbf7fd1afcb020805342a4389038ce3917 Signed-off-by: Galantsev, Dmitrii <dmitrii.galantsev@amd.com>
Tento commit je obsažen v:
Galantsev, Dmitrii
@@ -35,12 +35,15 @@ find_program (GIT NAMES git)
|
||||
|
||||
## Setup the package version based on git tags.
|
||||
set(PKG_VERSION_GIT_TAG_PREFIX "rsmi_pkg_ver")
|
||||
get_package_version_number("6.1.0" ${PKG_VERSION_GIT_TAG_PREFIX} GIT)
|
||||
get_package_version_number("7.0.0" ${PKG_VERSION_GIT_TAG_PREFIX} GIT)
|
||||
message("Package version: ${PKG_VERSION_STR}")
|
||||
set(${ROCM_SMI_LIBS_TARGET}_VERSION_MAJOR "${VERSION_MAJOR}")
|
||||
set(${ROCM_SMI_LIBS_TARGET}_VERSION_MINOR "${VERSION_MINOR}")
|
||||
set(${ROCM_SMI_LIBS_TARGET}_VERSION_PATCH "0")
|
||||
set(${ROCM_SMI_LIBS_TARGET}_VERSION_MAJOR "${CPACK_PACKAGE_VERSION_MAJOR}")
|
||||
set(${ROCM_SMI_LIBS_TARGET}_VERSION_MINOR "${CPACK_PACKAGE_VERSION_MINOR}")
|
||||
set(${ROCM_SMI_LIBS_TARGET}_VERSION_PATCH "${CPACK_PACKAGE_VERSION_PATCH}")
|
||||
set(${ROCM_SMI_LIBS_TARGET}_VERSION_BUILD "0")
|
||||
set(${ROCM_SMI_LIBS_TARGET}_VERSION_HASH "${PKG_VERSION_HASH}")
|
||||
|
||||
set(${ROCM_SMI_LIBS_TARGET}_VERSION_STRING "${${ROCM_SMI_LIBS_TARGET}_VERSION_MAJOR}.${${ROCM_SMI_LIBS_TARGET}_VERSION_MINOR}.${${ROCM_SMI_LIBS_TARGET}_VERSION_PATCH}+${${ROCM_SMI_LIBS_TARGET}_VERSION_HASH}")
|
||||
|
||||
# The following default version values should be updated as appropriate for
|
||||
# ABI breaks (update MAJOR and MINOR), and ABI/API additions (update MINOR).
|
||||
@@ -48,7 +51,7 @@ set(${ROCM_SMI_LIBS_TARGET}_VERSION_BUILD "0")
|
||||
# by git tags (through "git describe") when they are present.
|
||||
set(PKG_VERSION_MAJOR "${VERSION_MAJOR}")
|
||||
set(PKG_VERSION_MINOR "${VERSION_MINOR}")
|
||||
set(PKG_VERSION_PATCH 0)
|
||||
set(PKG_VERSION_PATCH "${CPACK_PACKAGE_VERSION_PATCH}")
|
||||
set(PKG_VERSION_NUM_COMMIT 0)
|
||||
|
||||
## Define default variable and variables for the optional build target
|
||||
|
||||
@@ -159,6 +159,7 @@ function(get_package_version_number DEFAULT_VERSION_STRING VERSION_PREFIX GIT)
|
||||
endif()
|
||||
set(PKG_VERSION_STR "${PKG_VERSION_STR}-${VERSION_HASH}")
|
||||
set(PKG_VERSION_STR ${PKG_VERSION_STR} PARENT_SCOPE)
|
||||
set(PKG_VERSION_HASH ${VERSION_HASH} PARENT_SCOPE)
|
||||
set(CPACK_PACKAGE_VERSION_MAJOR ${VERSION_MAJOR} PARENT_SCOPE)
|
||||
set(CPACK_PACKAGE_VERSION_MINOR ${VERSION_MINOR} PARENT_SCOPE)
|
||||
set(CPACK_PACKAGE_VERSION_PATCH ${VERSION_PATCH} PARENT_SCOPE)
|
||||
|
||||
+1199
-68
Rozdílový obsah nebyl zobrazen, protože je příliš veliký
Načíst rozdílové porovnání
@@ -53,6 +53,7 @@
|
||||
#include <unordered_set>
|
||||
#include <map>
|
||||
#include <type_traits>
|
||||
#include <optional>
|
||||
|
||||
#include "rocm_smi/rocm_smi_monitor.h"
|
||||
#include "rocm_smi/rocm_smi_power_mon.h"
|
||||
@@ -220,7 +221,7 @@ class Device {
|
||||
void set_evt_notif_anon_fd(uint32_t fd) {
|
||||
evt_notif_anon_fd_ = static_cast<int>(fd);}
|
||||
int evt_notif_anon_fd(void) const {return evt_notif_anon_fd_;}
|
||||
metrics_table_header_t &gpu_metrics_ver(void) {return gpu_metrics_ver_;}
|
||||
|
||||
void fillSupportedFuncs(void);
|
||||
void DumpSupportedFunctions(void);
|
||||
bool DeviceAPISupported(std::string name, uint64_t variant,
|
||||
@@ -230,17 +231,15 @@ class Device {
|
||||
template <typename T> std::string readBootPartitionState(uint32_t dv_ind);
|
||||
rsmi_status_t check_amdgpu_property_reinforcement_query(uint32_t dev_idx, AMDGpuVerbTypes_t verb_type);
|
||||
|
||||
void dev_set_gpu_metric(GpuMetricsBasePtr gpu_metrics_ptr) { m_gpu_metrics_ptr = gpu_metrics_ptr; };
|
||||
void dev_set_gpu_metric(GpuMetricsBasePtr gpu_metrics_ptr) { m_gpu_metrics_ptr = std::move(gpu_metrics_ptr); };
|
||||
GpuMetricsBasePtr& dev_get_gpu_metric() { return m_gpu_metrics_ptr; };
|
||||
const AMDGpuMetricsHeader_v1_t& dev_get_metrics_header() {return m_gpu_metrics_header; }
|
||||
rsmi_status_t setup_gpu_metrics_reading();
|
||||
rsmi_status_t dev_read_gpu_metrics_header_data();
|
||||
rsmi_status_t dev_read_gpu_metrics_all_data();
|
||||
rsmi_status_t dev_log_gpu_metrics();
|
||||
rsmi_status_t run_internal_gpu_metrics_query(AMDGpuMetricsUnitType_t metric_counter, AMDGpuDynamicMetricTblValues_t& values);
|
||||
|
||||
template<typename T>
|
||||
rsmi_status_t dev_run_gpu_metrics_query(AMDGpuMetricsUnitType_t metric_counter, T& metric_value);
|
||||
rsmi_status_t dev_log_gpu_metrics(std::ostringstream& outstream_metrics);
|
||||
AMGpuMetricsPublicLatestTupl_t dev_copy_internal_to_external_metrics();
|
||||
|
||||
|
||||
private:
|
||||
@@ -265,7 +264,6 @@ class Device {
|
||||
bool returnWriteErr = false);
|
||||
rsmi_status_t run_amdgpu_property_reinforcement_query(const AMDGpuPropertyQuery_t& amdgpu_property_query);
|
||||
|
||||
|
||||
uint64_t bdfid_;
|
||||
uint64_t kfd_gpu_id_;
|
||||
std::unordered_set<rsmi_event_group_t,
|
||||
@@ -276,8 +274,6 @@ class Device {
|
||||
int evt_notif_anon_fd_;
|
||||
FILE *evt_notif_anon_file_ptr_;
|
||||
|
||||
struct metrics_table_header_t gpu_metrics_ver_;
|
||||
|
||||
GpuMetricsBasePtr m_gpu_metrics_ptr;
|
||||
AMDGpuMetricsHeader_v1_t m_gpu_metrics_header;
|
||||
uint64_t m_gpu_metrics_updated_timestamp;
|
||||
|
||||
@@ -47,10 +47,16 @@
|
||||
#include "rocm_smi/rocm_smi_common.h"
|
||||
#include "rocm_smi/rocm_smi.h"
|
||||
|
||||
#include <array>
|
||||
#include <algorithm>
|
||||
#include <cassert>
|
||||
#include <cstdint>
|
||||
#include <cstring>
|
||||
#include <map>
|
||||
#include <memory>
|
||||
#include <type_traits>
|
||||
#include <tuple>
|
||||
#include <variant>
|
||||
#include <vector>
|
||||
|
||||
|
||||
@@ -96,15 +102,14 @@ struct AMDGpuMetricsHeader_v1_t
|
||||
uint8_t m_content_revision;
|
||||
};
|
||||
|
||||
|
||||
struct AMDGpuMetricsBase_t;
|
||||
using AMDGpuMetricsBaseRef = AMDGpuMetricsBase_t&;
|
||||
struct AMDGpuMetricsBase_t
|
||||
{
|
||||
virtual ~AMDGpuMetricsBase_t() = default;
|
||||
};
|
||||
using AMDGpuMetricsBaseRef = AMDGpuMetricsBase_t&;
|
||||
|
||||
struct AMDGpuMetrics_v11_t : AMDGpuMetricsBase_t
|
||||
|
||||
struct AMDGpuMetrics_v11_t
|
||||
{
|
||||
~AMDGpuMetrics_v11_t() = default;
|
||||
|
||||
@@ -166,7 +171,7 @@ struct AMDGpuMetrics_v11_t : AMDGpuMetricsBase_t
|
||||
uint16_t m_temperature_hbm[kRSMI_MAX_NUM_HBM_INSTANCES];
|
||||
};
|
||||
|
||||
struct AMDGpuMetrics_v12_t : AMDGpuMetricsBase_t
|
||||
struct AMDGpuMetrics_v12_t
|
||||
{
|
||||
~AMDGpuMetrics_v12_t() = default;
|
||||
|
||||
@@ -226,11 +231,11 @@ struct AMDGpuMetrics_v12_t : AMDGpuMetricsBase_t
|
||||
uint32_t m_mem_activity_acc; // new in v1
|
||||
uint16_t m_temperature_hbm[kRSMI_MAX_NUM_HBM_INSTANCES]; // new in v1
|
||||
|
||||
// PMFW attached timestamp (10ns resolution)
|
||||
// PMFW attached timestamp (10ns resolution)
|
||||
uint64_t m_firmware_timestamp;
|
||||
};
|
||||
|
||||
struct AMDGpuMetrics_v13_t : AMDGpuMetricsBase_t
|
||||
struct AMDGpuMetrics_v13_t
|
||||
{
|
||||
~AMDGpuMetrics_v13_t() = default;
|
||||
|
||||
@@ -304,7 +309,7 @@ struct AMDGpuMetrics_v13_t : AMDGpuMetricsBase_t
|
||||
uint64_t m_indep_throttle_status;
|
||||
};
|
||||
|
||||
struct AMDGpuMetrics_v14_t : AMDGpuMetricsBase_t
|
||||
struct AMDGpuMetrics_v14_t
|
||||
{
|
||||
~AMDGpuMetrics_v14_t() = default;
|
||||
|
||||
@@ -316,7 +321,7 @@ struct AMDGpuMetrics_v14_t : AMDGpuMetricsBase_t
|
||||
uint16_t m_temperature_vrsoc;
|
||||
|
||||
// Power (Watts)
|
||||
uint16_t m_curr_socket_power;
|
||||
uint16_t m_current_socket_power;
|
||||
|
||||
// Utilization (%)
|
||||
uint16_t m_average_gfx_activity;
|
||||
@@ -340,8 +345,8 @@ struct AMDGpuMetrics_v14_t : AMDGpuMetricsBase_t
|
||||
uint16_t m_pcie_link_speed; // in 0.1 GT/s
|
||||
|
||||
// XGMI bus width and bitrate (in Gbps)
|
||||
uint16_t m_xgmi_link_width;
|
||||
uint16_t m_xgmi_link_speed;
|
||||
uint16_t m_xgmi_link_width;
|
||||
uint16_t m_xgmi_link_speed;
|
||||
|
||||
// Utilization Accumulated (%)
|
||||
uint32_t m_gfx_activity_acc;
|
||||
@@ -353,6 +358,15 @@ struct AMDGpuMetrics_v14_t : AMDGpuMetricsBase_t
|
||||
// PCIE instantaneous bandwidth (GB/sec)
|
||||
uint64_t m_pcie_bandwidth_inst;
|
||||
|
||||
// PCIE L0 to recovery state transition accumulated count
|
||||
uint64_t m_pcie_l0_to_recov_count_acc;
|
||||
|
||||
// PCIE replay accumulated count
|
||||
uint64_t m_pcie_replay_count_acc;
|
||||
|
||||
// PCIE replay rollover accumulated count
|
||||
uint64_t m_pcie_replay_rover_count_acc;
|
||||
|
||||
// XGMI accumulated data transfer size(KiloBytes)
|
||||
uint64_t m_xgmi_read_data_acc[kRSMI_MAX_NUM_XGMI_LINKS];
|
||||
uint64_t m_xgmi_write_data_acc[kRSMI_MAX_NUM_XGMI_LINKS];
|
||||
@@ -371,33 +385,52 @@ struct AMDGpuMetrics_v14_t : AMDGpuMetricsBase_t
|
||||
};
|
||||
using AMGpuMetricsLatest_t = AMDGpuMetrics_v14_t;
|
||||
|
||||
/**
|
||||
* This is GPU Metrics version that gets to public access.
|
||||
* It is a unique/unified version (joined) of the previous
|
||||
* versions (1.2 to latest 1.4). Data fields not used/relevant
|
||||
* for the current driver version and GPU metrics version will
|
||||
* not be populated, and therefore 0s (zeroes).
|
||||
*
|
||||
* If/in case anything new is added to a new version and there is
|
||||
* a requirement to make it publicly available, into a single static
|
||||
* table/form/struct, then it should be added here.
|
||||
*
|
||||
*/
|
||||
using AMGpuMetricsPublicLatest_t = rsmi_gpu_metrics_t;
|
||||
using AMGpuMetricsPublicLatestTupl_t = std::tuple<rsmi_status_t, AMGpuMetricsPublicLatest_t>;
|
||||
|
||||
using GpuMetricU16Tbl_t = std::vector<uint16_t>;
|
||||
using GpuMetricU32Tbl_t = std::vector<uint32_t>;
|
||||
using GpuMetricU64Tbl_t = std::vector<uint64_t>;
|
||||
|
||||
using GPUMetricTempHbm_t = decltype(AMDGpuMetrics_v13_t::m_temperature_hbm);
|
||||
using GPUMetricTempHbmTbl_t = std::array<uint16_t, kRSMI_MAX_NUM_HBM_INSTANCES>;
|
||||
using GPUMetricTempHbmTbl_t = GpuMetricU16Tbl_t;
|
||||
|
||||
using GPUMetricVcnActivity_t = decltype(AMDGpuMetrics_v14_t::m_vcn_activity);
|
||||
using GPUMetricVcnActivityTbl_t = std::array<uint16_t, kRSMI_MAX_NUM_VCN>;
|
||||
using GPUMetricVcnActivityTbl_t = GpuMetricU16Tbl_t;
|
||||
|
||||
using GPUMetricXgmiReadDataAcc_t = decltype(AMDGpuMetrics_v14_t::m_xgmi_read_data_acc);
|
||||
using GPUMetricXgmiWriteDataAcc_t = decltype(AMDGpuMetrics_v14_t::m_xgmi_write_data_acc);
|
||||
using GPUMetricXgmiAccTbl_t = std::array<uint64_t, kRSMI_MAX_NUM_XGMI_LINKS>;
|
||||
using GPUMetricXgmiAccTbl_t = GpuMetricU64Tbl_t;
|
||||
|
||||
using GPUMetricCurrGfxClk_t = decltype(AMDGpuMetrics_v14_t::m_current_gfxclk);
|
||||
using GPUMetricCurrGfxClkTbl_t = std::array<uint16_t, kRSMI_MAX_NUM_GFX_CLKS>;
|
||||
using GPUMetricCurrGfxClkTbl_t = GpuMetricU16Tbl_t;
|
||||
|
||||
using GPUMetricCurrSocClk_t = decltype(AMDGpuMetrics_v14_t::m_current_socclk);
|
||||
using GPUMetricCurrSocClkTbl_t = std::array<uint16_t, kRSMI_MAX_NUM_CLKS>;
|
||||
using GPUMetricCurrSocClkTbl_t = GpuMetricU16Tbl_t;
|
||||
|
||||
using GPUMetricCurrVClk0_t = decltype(AMDGpuMetrics_v14_t::m_current_vclk0);
|
||||
using GPUMetricCurrVClkTbl_t = std::array<uint16_t, kRSMI_MAX_NUM_CLKS>;
|
||||
using GPUMetricCurrVClkTbl_t = GpuMetricU16Tbl_t;
|
||||
|
||||
using GPUMetricCurrDClk0_t = decltype(AMDGpuMetrics_v14_t::m_current_dclk0);
|
||||
using GPUMetricCurrDClkTbl_t = std::array<uint16_t, kRSMI_MAX_NUM_CLKS>;
|
||||
using GPUMetricCurrDClkTbl_t = GpuMetricU16Tbl_t;
|
||||
|
||||
|
||||
/*
|
||||
////
|
||||
/************************************************************
|
||||
* When a new metric table is released, we have to update: *
|
||||
1. Constants related to the new metrics added;
|
||||
1. Constants related to the new metrics added (if any);
|
||||
(ie: kRSMI_MAX_NUM_XGMI_LINKS)
|
||||
2. Constants related to new version:
|
||||
(ie: kRSMI_GPU_METRICS_API_CONTENT_MAJOR_VER_1)
|
||||
@@ -411,19 +444,35 @@ using GPUMetricCurrDClkTbl_t = std::array<uint16_t, kRSMI_MAX_NUM_CLKS>;
|
||||
5. AMGpuMetricsLatest_t -> Newest AMDGpuMetrics_v1x_t
|
||||
6. AMDGpuMetricVersionFlags_t
|
||||
(ie: AMDGpuMetricVersionFlags_t::kGpuMetricV14)
|
||||
7. Create the proper API using granular controls used by
|
||||
rsmi_dev_gpu_metrics_info_query() (ie: rsmi_dev_temp_hotspot_get())
|
||||
|
||||
-> Remember to check/update:
|
||||
- AMDGpuMetricsUnitType_t
|
||||
- amdgpu_metrics_unit_type_translation_table
|
||||
- AMDGpuMetrics_v1X_t structure in question
|
||||
- populate_metrics_dynamic_tbl()
|
||||
- copy_internal_to_external_metrics()
|
||||
- init_max_public_gpu_matrics()
|
||||
*/
|
||||
|
||||
using AMDGpuMetricTypeId_t = uint32_t;
|
||||
using AMDGpuMetricTypeIdSeq_t = uint32_t;
|
||||
using AMDGpuMetricVersionFlagId_t = uint32_t;
|
||||
|
||||
////
|
||||
/*
|
||||
*
|
||||
* These are used as Metric class, so Metric Units can be properly grouped.
|
||||
* Each Metric Unit (or a set of them) is related to a Metric class.
|
||||
*
|
||||
*/
|
||||
enum class AMDGpuMetricsClassId_t : AMDGpuMetricTypeId_t
|
||||
{
|
||||
kGpuMetricHeader = 0,
|
||||
kGpuMetricHeader,
|
||||
kGpuMetricTemperature,
|
||||
kGpuMetricUtilization,
|
||||
kGpuMetricPowerEnergy,
|
||||
kGpuMetricSystemClockCounter,
|
||||
kGpuMetricAverageClock,
|
||||
kGpuMetricCurrentClock,
|
||||
kGpuMetricThrottleStatus,
|
||||
@@ -435,6 +484,22 @@ enum class AMDGpuMetricsClassId_t : AMDGpuMetricTypeId_t
|
||||
};
|
||||
using AMDGpuMetricsClassIdTranslationTbl_t = std::map<AMDGpuMetricsClassId_t, std::string>;
|
||||
|
||||
/*
|
||||
*
|
||||
* These are the Metric units. Each one represents a specific metric we want
|
||||
* to either store or retrieve.
|
||||
*
|
||||
* This also gives a more granular control over to what exactly is needed,
|
||||
* helping to generalize metric queries.
|
||||
*
|
||||
* Each type a new (non-existing metric unit) metric is added, it should be
|
||||
* updated here.
|
||||
* - Their names matches (closely, regardless of their version) the name of
|
||||
* the data structure members they represent.
|
||||
*
|
||||
* All metric units not flagged as v1.4 were either part of the base or
|
||||
* added/changed up to v1.3
|
||||
*/
|
||||
enum class AMDGpuMetricsUnitType_t : AMDGpuMetricTypeId_t
|
||||
{
|
||||
// kGpuMetricTemperature counters
|
||||
@@ -452,7 +517,7 @@ enum class AMDGpuMetricsUnitType_t : AMDGpuMetricTypeId_t
|
||||
kMetricAvgMmActivity,
|
||||
kMetricGfxActivityAccumulator,
|
||||
kMetricMemActivityAccumulator,
|
||||
kMetricVcnActivity,
|
||||
kMetricVcnActivity, //v1.4
|
||||
|
||||
// kGpuMetricAverageClock counters
|
||||
kMetricAvgGfxClockFrequency,
|
||||
@@ -464,11 +529,11 @@ enum class AMDGpuMetricsUnitType_t : AMDGpuMetricTypeId_t
|
||||
kMetricAvgDClock1Frequency,
|
||||
|
||||
// kGpuMetricCurrentClock counters
|
||||
kMetricCurrGfxClock,
|
||||
kMetricCurrSocClock,
|
||||
kMetricCurrGfxClock, //v1.4: Changed to multi-valued
|
||||
kMetricCurrSocClock, //v1.4: Changed to multi-valued
|
||||
kMetricCurrUClock,
|
||||
kMetricCurrVClock0,
|
||||
kMetricCurrDClock0,
|
||||
kMetricCurrVClock0, //v1.4: Changed to multi-valued
|
||||
kMetricCurrDClock0, //v1.4: Changed to multi-valued
|
||||
kMetricCurrVClock1,
|
||||
kMetricCurrDClock1,
|
||||
|
||||
@@ -477,7 +542,7 @@ enum class AMDGpuMetricsUnitType_t : AMDGpuMetricTypeId_t
|
||||
kMetricIndepThrottleStatus,
|
||||
|
||||
// kGpuMetricGfxClkLockStatus counters
|
||||
kMetricGfxClkLockStatus,
|
||||
kMetricGfxClkLockStatus, //v1.4
|
||||
|
||||
// kGpuMetricCurrentFanSpeed counters
|
||||
kMetricCurrFanSpeed,
|
||||
@@ -485,22 +550,25 @@ enum class AMDGpuMetricsUnitType_t : AMDGpuMetricTypeId_t
|
||||
// kGpuMetricLinkWidthSpeed counters
|
||||
kMetricPcieLinkWidth,
|
||||
kMetricPcieLinkSpeed,
|
||||
kMetricPcieBandwidthAccumulator,
|
||||
kMetricPcieBandwidthInst,
|
||||
kMetricXgmiLinkWidth,
|
||||
kMetricXgmiLinkSpeed,
|
||||
kMetricXgmiReadDataAccumulator,
|
||||
kMetricXgmiWriteDataAccumulator,
|
||||
kMetricPcieBandwidthAccumulator, //v1.4
|
||||
kMetricPcieBandwidthInst, //v1.4
|
||||
kMetricXgmiLinkWidth, //v1.4
|
||||
kMetricXgmiLinkSpeed, //v1.4
|
||||
kMetricXgmiReadDataAccumulator, //v1.4
|
||||
kMetricXgmiWriteDataAccumulator, //v1.4
|
||||
kMetricPcieL0RecovCountAccumulator, //v1.4
|
||||
kMetricPcieReplayCountAccumulator, //v1.4
|
||||
kMetricPcieReplayRollOverCountAccumulator, //v1.4
|
||||
|
||||
// kGpuMetricPowerEnergy counters
|
||||
kMetricAvgSocketPower,
|
||||
kMetricCurrSocketPower,
|
||||
kMetricEnergyAccumulator,
|
||||
kMetricCurrSocketPower, //v1.4
|
||||
kMetricEnergyAccumulator, //v1.4
|
||||
|
||||
// kGpuMetricVoltage counters
|
||||
kMetricVoltageSoc,
|
||||
kMetricVoltageGfx,
|
||||
kMetricVoltageMem,
|
||||
kMetricVoltageSoc, //v1.3
|
||||
kMetricVoltageGfx, //v1.3
|
||||
kMetricVoltageMem, //v1.3
|
||||
|
||||
// kGpuMetricTimestamp counters
|
||||
kMetricTSClockCounter,
|
||||
@@ -526,8 +594,12 @@ struct AMDGpuDynamicMetricsValue_t
|
||||
using AMDGpuDynamicMetricTblValues_t = std::vector<AMDGpuDynamicMetricsValue_t>;
|
||||
using AMDGpuDynamicMetricsTbl_t = std::map<AMDGpuMetricsClassId_t, std::map<AMDGpuMetricsUnitType_t, AMDGpuDynamicMetricTblValues_t>>;
|
||||
|
||||
// Note: All supported metric versions are listed her
|
||||
// If not here, they are not supported
|
||||
|
||||
/*
|
||||
*
|
||||
* Note: All supported metric versions are listed here, otherwise unsupported
|
||||
*
|
||||
*/
|
||||
enum class AMDGpuMetricVersionFlags_t : AMDGpuMetricVersionFlagId_t
|
||||
{
|
||||
kGpuMetricNone = 0x0,
|
||||
@@ -537,21 +609,19 @@ enum class AMDGpuMetricVersionFlags_t : AMDGpuMetricVersionFlagId_t
|
||||
kGpuMetricV13 = (0x1 << 3),
|
||||
kGpuMetricV14 = (0x1 << 4),
|
||||
};
|
||||
using AMDGpuMetricVersionTranslationTbl_t = std::map<uint64_t, AMDGpuMetricVersionFlags_t>;
|
||||
|
||||
|
||||
class GpuMetricsBase_t;
|
||||
using GpuMetricsBasePtr = std::shared_ptr<GpuMetricsBase_t>;
|
||||
using AMDGpuMetricVersionTranslationTbl_t = std::map<uint16_t, AMDGpuMetricVersionFlags_t>;
|
||||
using GpuMetricTypePtr_t = std::shared_ptr<void>;
|
||||
|
||||
class GpuMetricsBase_t
|
||||
{
|
||||
public:
|
||||
virtual ~GpuMetricsBase_t() = default;
|
||||
virtual size_t sizeof_metric_table() = 0;
|
||||
virtual AMDGpuMetricsBaseRef get_metrics_table() = 0;
|
||||
virtual GpuMetricTypePtr_t get_metrics_table() = 0;
|
||||
virtual void dump_internal_metrics_table() = 0;
|
||||
virtual AMDGpuMetricVersionFlags_t get_gpu_metrics_version_used() = 0;
|
||||
virtual rsmi_status_t populate_metrics_dynamic_tbl() = 0;
|
||||
|
||||
virtual AMGpuMetricsPublicLatestTupl_t copy_internal_to_external_metrics() = 0;
|
||||
virtual AMDGpuDynamicMetricsTbl_t get_metrics_dynamic_tbl() {
|
||||
return m_metrics_dynamic_tbl;
|
||||
}
|
||||
@@ -561,21 +631,31 @@ class GpuMetricsBase_t
|
||||
uint64_t m_metrics_timestamp;
|
||||
|
||||
};
|
||||
using GpuMetricsBasePtr = std::shared_ptr<GpuMetricsBase_t>;
|
||||
using AMDGpuMetricFactories_t = std::map<AMDGpuMetricVersionFlags_t, GpuMetricsBasePtr>;
|
||||
|
||||
|
||||
class GpuMetricsBase_v11_t final : public GpuMetricsBase_t
|
||||
{
|
||||
public:
|
||||
~GpuMetricsBase_v11_t() = default;
|
||||
virtual ~GpuMetricsBase_v11_t() = default;
|
||||
|
||||
size_t sizeof_metric_table() override {
|
||||
return sizeof(AMDGpuMetrics_v11_t);
|
||||
}
|
||||
|
||||
AMDGpuMetricsBaseRef get_metrics_table() override
|
||||
GpuMetricTypePtr_t get_metrics_table() override
|
||||
{
|
||||
return m_gpu_metrics_tbl;
|
||||
if (!m_gpu_metric_ptr) {
|
||||
m_gpu_metric_ptr.reset(&m_gpu_metrics_tbl, [](AMDGpuMetrics_v11_t*){});
|
||||
}
|
||||
assert(m_gpu_metric_ptr != nullptr);
|
||||
return m_gpu_metric_ptr;
|
||||
}
|
||||
|
||||
void dump_internal_metrics_table() override
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
AMDGpuMetricVersionFlags_t get_gpu_metrics_version_used() override
|
||||
@@ -584,10 +664,12 @@ class GpuMetricsBase_v11_t final : public GpuMetricsBase_t
|
||||
}
|
||||
|
||||
rsmi_status_t populate_metrics_dynamic_tbl() override;
|
||||
AMGpuMetricsPublicLatestTupl_t copy_internal_to_external_metrics() override;
|
||||
|
||||
|
||||
private:
|
||||
AMDGpuMetrics_v11_t m_gpu_metrics_tbl;
|
||||
std::shared_ptr<AMDGpuMetrics_v11_t> m_gpu_metric_ptr;
|
||||
|
||||
};
|
||||
|
||||
@@ -600,9 +682,18 @@ class GpuMetricsBase_v12_t final : public GpuMetricsBase_t
|
||||
return sizeof(AMDGpuMetrics_v12_t);
|
||||
}
|
||||
|
||||
AMDGpuMetricsBaseRef get_metrics_table() override
|
||||
GpuMetricTypePtr_t get_metrics_table() override
|
||||
{
|
||||
return m_gpu_metrics_tbl;
|
||||
if (!m_gpu_metric_ptr) {
|
||||
m_gpu_metric_ptr.reset(&m_gpu_metrics_tbl, [](AMDGpuMetrics_v12_t*){});
|
||||
}
|
||||
assert(m_gpu_metric_ptr != nullptr);
|
||||
return m_gpu_metric_ptr;
|
||||
}
|
||||
|
||||
void dump_internal_metrics_table() override
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
AMDGpuMetricVersionFlags_t get_gpu_metrics_version_used() override
|
||||
@@ -611,10 +702,11 @@ class GpuMetricsBase_v12_t final : public GpuMetricsBase_t
|
||||
}
|
||||
|
||||
rsmi_status_t populate_metrics_dynamic_tbl() override;
|
||||
|
||||
AMGpuMetricsPublicLatestTupl_t copy_internal_to_external_metrics() override;
|
||||
|
||||
private:
|
||||
AMDGpuMetrics_v12_t m_gpu_metrics_tbl;
|
||||
std::shared_ptr<AMDGpuMetrics_v12_t> m_gpu_metric_ptr;
|
||||
|
||||
};
|
||||
|
||||
@@ -627,21 +719,29 @@ class GpuMetricsBase_v13_t final : public GpuMetricsBase_t
|
||||
return sizeof(AMDGpuMetrics_v13_t);
|
||||
}
|
||||
|
||||
AMDGpuMetricsBaseRef get_metrics_table() override
|
||||
GpuMetricTypePtr_t get_metrics_table() override
|
||||
{
|
||||
return m_gpu_metrics_tbl;
|
||||
if (!m_gpu_metric_ptr) {
|
||||
m_gpu_metric_ptr.reset(&m_gpu_metrics_tbl, [](AMDGpuMetrics_v13_t*){});
|
||||
}
|
||||
assert(m_gpu_metric_ptr != nullptr);
|
||||
return (m_gpu_metric_ptr);
|
||||
}
|
||||
|
||||
void dump_internal_metrics_table() override;
|
||||
|
||||
AMDGpuMetricVersionFlags_t get_gpu_metrics_version_used() override
|
||||
{
|
||||
return AMDGpuMetricVersionFlags_t::kGpuMetricV13;
|
||||
}
|
||||
|
||||
rsmi_status_t populate_metrics_dynamic_tbl() override;
|
||||
AMGpuMetricsPublicLatestTupl_t copy_internal_to_external_metrics() override;
|
||||
|
||||
|
||||
private:
|
||||
AMDGpuMetrics_v13_t m_gpu_metrics_tbl;
|
||||
std::shared_ptr<AMDGpuMetrics_v13_t> m_gpu_metric_ptr;
|
||||
|
||||
};
|
||||
|
||||
@@ -654,28 +754,41 @@ class GpuMetricsBase_v14_t final : public GpuMetricsBase_t
|
||||
return sizeof(AMDGpuMetrics_v14_t);
|
||||
}
|
||||
|
||||
AMDGpuMetricsBaseRef get_metrics_table() override
|
||||
GpuMetricTypePtr_t get_metrics_table() override
|
||||
{
|
||||
return m_gpu_metrics_tbl;
|
||||
if (!m_gpu_metric_ptr) {
|
||||
m_gpu_metric_ptr.reset(&m_gpu_metrics_tbl, [](AMDGpuMetrics_v14_t*){});
|
||||
}
|
||||
assert(m_gpu_metric_ptr != nullptr);
|
||||
return m_gpu_metric_ptr;
|
||||
}
|
||||
|
||||
void dump_internal_metrics_table() override;
|
||||
|
||||
AMDGpuMetricVersionFlags_t get_gpu_metrics_version_used() override
|
||||
{
|
||||
return AMDGpuMetricVersionFlags_t::kGpuMetricV14;
|
||||
}
|
||||
|
||||
rsmi_status_t populate_metrics_dynamic_tbl() override;
|
||||
AMGpuMetricsPublicLatestTupl_t copy_internal_to_external_metrics() override;
|
||||
|
||||
|
||||
private:
|
||||
AMDGpuMetrics_v14_t m_gpu_metrics_tbl;
|
||||
std::shared_ptr<AMDGpuMetrics_v14_t> m_gpu_metric_ptr;
|
||||
|
||||
};
|
||||
|
||||
|
||||
template<typename T>
|
||||
rsmi_status_t rsmi_dev_gpu_metrics_info_query(uint32_t dv_ind, AMDGpuMetricsUnitType_t metric_counter, T& metric_value);
|
||||
|
||||
} // namespace amd::smi
|
||||
|
||||
#endif // ROCM_SMI_ROCM_SMI_GPU_METRICS_H_
|
||||
|
||||
rsmi_status_t
|
||||
rsmi_dev_gpu_metrics_header_info_get(uint32_t dv_ind, metrics_table_header_t& header_value);
|
||||
|
||||
|
||||
#endif // ROCM_SMI_ROCM_SMI_GPU_METRICS_H_
|
||||
|
||||
@@ -1,6 +1,4 @@
|
||||
## Synopsis
|
||||
|
||||
Radeon Open Compute Platform - System Management Interface - Command Line tool.
|
||||
## Radeon Open Compute (ROCm) - System Management Interface - Command Line Tool
|
||||
|
||||
This tool acts as a command line interface for manipulating
|
||||
and monitoring the amdgpu kernel, and is intended to replace
|
||||
|
||||
@@ -29,10 +29,12 @@ from rsmiBindings import *
|
||||
# Major version - Increment when backwards-compatibility breaks
|
||||
# Minor version - Increment when adding a new feature, set to 0 when major is incremented
|
||||
# Patch version - Increment when adding a fix, set to 0 when minor is incremented
|
||||
SMI_MAJ = 1
|
||||
SMI_MIN = 5
|
||||
# Hash version - Shortened commit hash. Print here and not with lib for consistency with amd-smi
|
||||
SMI_MAJ = 2
|
||||
SMI_MIN = 0
|
||||
SMI_PAT = 0
|
||||
__version__ = '%s.%s.%s' % (SMI_MAJ, SMI_MIN, SMI_PAT)
|
||||
# SMI_HASH is provided by rsmiBindings
|
||||
__version__ = '%s.%s.%s+%s' % (SMI_MAJ, SMI_MIN, SMI_PAT, SMI_HASH)
|
||||
|
||||
# Set to 1 if an error occurs
|
||||
RETCODE = 0
|
||||
@@ -828,23 +830,20 @@ def printTableRow(space, displayString, v_delim=" "):
|
||||
|
||||
def checkIfSecondaryDie(device):
|
||||
""" Checks if GCD(die) is the secondary die in a MCM.
|
||||
MI200 device specific feature check.
|
||||
The secondary dies lacks power management features.
|
||||
|
||||
Secondary dies lack power management features.
|
||||
TODO: switch to more robust way to check for primary/secondary die, when implemented in Kernel and rocm_smi_lib.
|
||||
@param device: The device to check
|
||||
"""
|
||||
power_cap = c_uint64()
|
||||
# secondary die can currently be determined by checking if all power1_* (power cap) values are equal to zero.
|
||||
ret = rocmsmi.rsmi_dev_power_cap_get(device, 0, byref(power_cap))
|
||||
if not (rsmi_ret_ok(ret, None, 'get_power_cap', False) and power_cap.value == 0):
|
||||
return False
|
||||
ret = rocmsmi.rsmi_dev_power_cap_default_get(device, byref(power_cap))
|
||||
if not (rsmi_ret_ok(ret, None, 'get_power_cap_default', False) and power_cap.value == 0):
|
||||
return False
|
||||
ret = rocmsmi.rsmi_dev_power_ave_get(device, 0, byref(power_cap))
|
||||
if not (rsmi_ret_ok(ret, None, 'get_power_avg', False) and power_cap.value == 0):
|
||||
return False
|
||||
return True
|
||||
energy_count = c_uint64()
|
||||
counter_resoution = c_float()
|
||||
timestamp = c_uint64()
|
||||
|
||||
# secondary die can be determined by checking if energy counter == 0
|
||||
ret = rocmsmi.rsmi_dev_energy_count_get(device, byref(energy_count), byref(counter_resoution), byref(timestamp))
|
||||
if (rsmi_ret_ok(ret, None, 'energy_count_secondary_die_check', silent=False)) and (energy_count.value == 0):
|
||||
return True
|
||||
return False
|
||||
|
||||
def resetClocks(deviceList):
|
||||
""" Reset clocks to default
|
||||
|
||||
@@ -55,6 +55,8 @@ dv_id = c_uint64()
|
||||
# GPU ID
|
||||
gpu_id = c_uint32(0)
|
||||
|
||||
SMI_HASH = '@PKG_VERSION_HASH@'
|
||||
|
||||
|
||||
# Policy enums
|
||||
RSMI_MAX_NUM_FREQUENCIES = 33
|
||||
|
||||
@@ -48,10 +48,11 @@ if ( ${ROCM_PATCH_VERSION} )
|
||||
else()
|
||||
set(SO_VERSION_STRING "${VERSION_MAJOR}.${VERSION_MINOR}")
|
||||
endif ()
|
||||
set(${ROCM_SMI}_VERSION_MAJOR "${VERSION_MAJOR}")
|
||||
set(${ROCM_SMI}_VERSION_MINOR "${VERSION_MINOR}")
|
||||
set(${ROCM_SMI}_VERSION_PATCH "0")
|
||||
set(${ROCM_SMI}_VERSION_MAJOR "${CPACK_PACKAGE_VERSION_MAJOR}")
|
||||
set(${ROCM_SMI}_VERSION_MINOR "${CPACK_PACKAGE_VERSION_MINOR}")
|
||||
set(${ROCM_SMI}_VERSION_PATCH "${CPACK_PACKAGE_VERSION_PATCH}")
|
||||
set(${ROCM_SMI}_VERSION_BUILD "0")
|
||||
set(${ROCM_SMI}_VERSION_HASH "${PKG_VERSION_HASH}")
|
||||
message("SOVERSION: ${SO_VERSION_STRING}")
|
||||
|
||||
# Configure rsmiBindings.py.in with SO major version:
|
||||
|
||||
@@ -47,10 +47,12 @@
|
||||
#include <stdint.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include <vector>
|
||||
#include <iostream>
|
||||
#include <algorithm>
|
||||
#include <bitset>
|
||||
#include <iostream>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
#include <type_traits>
|
||||
|
||||
#include "rocm_smi/rocm_smi.h"
|
||||
#include "rocm_smi/rocm_smi_utils.h"
|
||||
@@ -166,9 +168,9 @@ void print_function_header_with_rsmi_ret(
|
||||
}
|
||||
|
||||
static void print_test_header(const char *str, uint32_t dv_ind) {
|
||||
std::cout << "********************************" << "\n";
|
||||
std::cout << "******************************************" << "\n";
|
||||
std::cout << "*** " << str << "\n";
|
||||
std::cout << "********************************" << "\n";
|
||||
std::cout << "******************************************" << "\n";
|
||||
std::cout << "Device index: " << dv_ind << "\n";
|
||||
}
|
||||
|
||||
@@ -728,6 +730,40 @@ template<typename T> constexpr float convert_mw_to_w(T mw) {
|
||||
return static_cast<float>(mw / 1000.0);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
auto print_error_or_value(rsmi_status_t status_code, const T& metric) {
|
||||
if (status_code == rsmi_status_t::RSMI_STATUS_SUCCESS) {
|
||||
if constexpr (std::is_array_v<T>) {
|
||||
auto idx = uint16_t(0);
|
||||
auto str_values = std::string();
|
||||
const auto num_elems = static_cast<uint16_t>(std::end(metric) - std::begin(metric));
|
||||
str_values = ("\n\t\t num of values: " + std::to_string(num_elems) + "\n");
|
||||
for (const auto& el : metric) {
|
||||
str_values += "\t\t [" + std::to_string(idx) + "]: " + std::to_string(el) + "\n";
|
||||
++idx;
|
||||
}
|
||||
return str_values;
|
||||
}
|
||||
else if constexpr ((std::is_same_v<T, std::uint16_t>) ||
|
||||
(std::is_same_v<T, std::uint32_t>) ||
|
||||
(std::is_same_v<T, std::uint64_t>)) {
|
||||
return std::to_string(metric);
|
||||
}
|
||||
}
|
||||
else {
|
||||
return ("\n\t\tStatus: [" + std::to_string(status_code) + "] " + "-> " + amd::smi::getRSMIStatusString(status_code));
|
||||
}
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
std::string print_unsigned_int(T value) {
|
||||
std::stringstream ss;
|
||||
ss << static_cast<uint64_t>(value | 0);
|
||||
|
||||
return ss.str();
|
||||
}
|
||||
|
||||
|
||||
int main() {
|
||||
rsmi_status_t ret;
|
||||
|
||||
@@ -742,7 +778,7 @@ int main() {
|
||||
rsmi_dev_perf_level_t pfl;
|
||||
rsmi_frequencies_t f;
|
||||
uint32_t num_monitor_devs = 0;
|
||||
rsmi_gpu_metrics_t p;
|
||||
rsmi_gpu_metrics_t gpu_metrics;
|
||||
std::string val_str;
|
||||
RSMI_POWER_TYPE power_type = RSMI_INVALID_POWER;
|
||||
|
||||
@@ -804,43 +840,308 @@ int main() {
|
||||
std::cout << "Not Supported\n";
|
||||
}
|
||||
|
||||
ret = rsmi_dev_gpu_metrics_info_get(i, &p);
|
||||
print_test_header("GPU METRICS", i);
|
||||
print_function_header_with_rsmi_ret(ret,
|
||||
"rsmi_dev_gpu_metrics_info_get(" + std::to_string(i) + ", &p)");
|
||||
std::cout << "\t**p.common_header.content_revision: " << std::dec
|
||||
<< p.common_header.content_revision << "\n";
|
||||
std::cout << "\t**p.common_header.format_revision: " << std::dec
|
||||
<< p.common_header.format_revision << "\n";
|
||||
std::cout << "\t**p.average_gfxclk_frequency: " << std::dec
|
||||
<< p.average_gfxclk_frequency << "\n";
|
||||
std::cout << "\t**p.average_socclk_frequency: " << std::dec
|
||||
<< p.average_socclk_frequency << "\n";
|
||||
std::cout << "\t**p.average_uclk_frequency: " << std::dec
|
||||
<< p.average_uclk_frequency << "\n";
|
||||
std::cout << "\t**p.average_vclk0_frequency: " << std::dec
|
||||
<< p.average_vclk0_frequency << "\n";
|
||||
std::cout << "\t**p.average_dclk0_frequency: " << std::dec
|
||||
<< p.average_dclk0_frequency << "\n";
|
||||
std::cout << "\t**p.average_vclk1_frequency: " << std::dec
|
||||
<< p.average_vclk1_frequency << "\n";
|
||||
std::cout << "\t**p.average_dclk1_frequency: " << std::dec
|
||||
<< p.average_dclk1_frequency << "\n";
|
||||
//
|
||||
std::cout << "\n";
|
||||
print_test_header("GPU METRICS: Using static struct (Backwards Compatibility) ", i);
|
||||
print_function_header_with_rsmi_ret(ret, "rsmi_dev_gpu_metrics_info_get(" + std::to_string(i) + ", &gpu_metrics)");
|
||||
rsmi_dev_gpu_metrics_info_get(i, &gpu_metrics);
|
||||
|
||||
std::cout << "\t**.common_header.format_revision : "
|
||||
<< print_unsigned_int(gpu_metrics.common_header.format_revision) << "\n";
|
||||
std::cout << "\t**.common_header.content_revision : "
|
||||
<< print_unsigned_int(gpu_metrics.common_header.content_revision) << "\n";
|
||||
|
||||
std::cout << "\t**.temperature_edge : " << std::dec
|
||||
<< gpu_metrics.temperature_edge << "\n";
|
||||
std::cout << "\t**.temperature_hotspot : " << std::dec
|
||||
<< gpu_metrics.temperature_hotspot << "\n";
|
||||
std::cout << "\t**.temperature_mem : " << std::dec
|
||||
<< gpu_metrics.temperature_mem << "\n";
|
||||
std::cout << "\t**.temperature_vrgfx : " << std::dec
|
||||
<< gpu_metrics.temperature_vrgfx << "\n";
|
||||
std::cout << "\t**.temperature_vrsoc : " << std::dec
|
||||
<< gpu_metrics.temperature_vrsoc << "\n";
|
||||
std::cout << "\t**.temperature_vrmem : " << std::dec
|
||||
<< gpu_metrics.temperature_vrmem << "\n";
|
||||
std::cout << "\t**.average_gfx_activity : " << std::dec
|
||||
<< gpu_metrics.average_gfx_activity << "\n";
|
||||
std::cout << "\t**.average_umc_activity : " << std::dec
|
||||
<< gpu_metrics.average_umc_activity << "\n";
|
||||
std::cout << "\t**.average_mm_activity : " << std::dec
|
||||
<< gpu_metrics.average_mm_activity << "\n";
|
||||
std::cout << "\t**.average_socket_power : " << std::dec
|
||||
<< gpu_metrics.average_socket_power << "\n";
|
||||
std::cout << "\t**.energy_accumulator : " << std::dec
|
||||
<< gpu_metrics.energy_accumulator << "\n";
|
||||
std::cout << "\t**.system_clock_counter : " << std::dec
|
||||
<< gpu_metrics.system_clock_counter << "\n";
|
||||
std::cout << "\t**.average_gfxclk_frequency : " << std::dec
|
||||
<< gpu_metrics.average_gfxclk_frequency << "\n";
|
||||
std::cout << "\t**.average_socclk_frequency : " << std::dec
|
||||
<< gpu_metrics.average_socclk_frequency << "\n";
|
||||
std::cout << "\t**.average_uclk_frequency : " << std::dec
|
||||
<< gpu_metrics.average_uclk_frequency << "\n";
|
||||
std::cout << "\t**.average_vclk0_frequency : " << std::dec
|
||||
<< gpu_metrics.average_vclk0_frequency<< "\n";
|
||||
std::cout << "\t**.average_dclk0_frequency : " << std::dec
|
||||
<< gpu_metrics.average_dclk0_frequency << "\n";
|
||||
std::cout << "\t**.average_vclk1_frequency : " << std::dec
|
||||
<< gpu_metrics.average_vclk1_frequency << "\n";
|
||||
std::cout << "\t**.average_dclk1_frequency : " << std::dec
|
||||
<< gpu_metrics.average_dclk1_frequency << "\n";
|
||||
std::cout << "\t**.current_gfxclk : " << std::dec
|
||||
<< gpu_metrics.current_gfxclk << "\n";
|
||||
std::cout << "\t**.current_socclk : " << std::dec
|
||||
<< gpu_metrics.current_socclk << "\n";
|
||||
std::cout << "\t**.current_uclk : " << std::dec
|
||||
<< gpu_metrics.current_uclk << "\n";
|
||||
std::cout << "\t**.current_vclk0 : " << std::dec
|
||||
<< gpu_metrics.current_vclk0 << "\n";
|
||||
std::cout << "\t**.current_dclk0 : " << std::dec
|
||||
<< gpu_metrics.current_dclk0 << "\n";
|
||||
std::cout << "\t**.current_vclk1 : " << std::dec
|
||||
<< gpu_metrics.current_vclk1 << "\n";
|
||||
std::cout << "\t**.current_dclk1 : " << std::dec
|
||||
<< gpu_metrics.current_dclk1 << "\n";
|
||||
std::cout << "\t**.throttle_status : " << std::dec
|
||||
<< gpu_metrics.throttle_status << "\n";
|
||||
std::cout << "\t**.current_fan_speed : " << std::dec
|
||||
<< gpu_metrics.current_fan_speed << "\n";
|
||||
std::cout << "\t**.pcie_link_width : " << std::dec
|
||||
<< gpu_metrics.pcie_link_width << "\n";
|
||||
std::cout << "\t**.pcie_link_speed : " << std::dec
|
||||
<< gpu_metrics.pcie_link_speed << "\n";
|
||||
std::cout << "\t**.gfx_activity_acc : " << std::dec
|
||||
<< gpu_metrics.gfx_activity_acc << "\n";
|
||||
std::cout << "\t**.mem_activity_acc : " << std::dec
|
||||
<< gpu_metrics.mem_activity_acc << "\n";
|
||||
std::cout << "\t**.firmware_timestamp : " << std::dec
|
||||
<< gpu_metrics.firmware_timestamp << "\n";
|
||||
std::cout << "\t**.voltage_soc : " << std::dec
|
||||
<< gpu_metrics.voltage_soc << "\n";
|
||||
std::cout << "\t**.voltage_gfx : " << std::dec
|
||||
<< gpu_metrics.voltage_gfx << "\n";
|
||||
std::cout << "\t**.voltage_mem : " << std::dec
|
||||
<< gpu_metrics.voltage_mem << "\n";
|
||||
std::cout << "\t**.indep_throttle_status : " << std::dec
|
||||
<< gpu_metrics.indep_throttle_status << "\n";
|
||||
std::cout << "\t**.current_socket_power : " << std::dec
|
||||
<< gpu_metrics.current_socket_power << "\n";
|
||||
std::cout << "\t**.gfxclk_lock_status : " << std::dec
|
||||
<< gpu_metrics.gfxclk_lock_status << "\n";
|
||||
std::cout << "\t**.xgmi_link_width : " << std::dec
|
||||
<< gpu_metrics.xgmi_link_width << "\n";
|
||||
std::cout << "\t**.xgmi_link_speed : " << std::dec
|
||||
<< gpu_metrics.xgmi_link_speed << "\n";
|
||||
std::cout << "\t**.pcie_bandwidth_acc : " << std::dec
|
||||
<< gpu_metrics.pcie_bandwidth_acc << "\n";
|
||||
std::cout << "\t**.pcie_bandwidth_inst : " << std::dec
|
||||
<< gpu_metrics.pcie_bandwidth_inst << "\n";
|
||||
std::cout << "\t**.pcie_l0_to_recov_count_acc : " << std::dec
|
||||
<< gpu_metrics.pcie_l0_to_recov_count_acc << "\n";
|
||||
std::cout << "\t**.pcie_replay_count_acc : " << std::dec
|
||||
<< gpu_metrics.pcie_replay_count_acc << "\n";
|
||||
std::cout << "\t**.pcie_replay_rover_count_acc : " << std::dec
|
||||
<< gpu_metrics.pcie_replay_rover_count_acc << "\n";
|
||||
|
||||
std::cout << "\t**.temperature_hbm[] : " << std::dec << "\n";
|
||||
for (const auto& temp : gpu_metrics.temperature_hbm) {
|
||||
std::cout << "\t -> " << std::dec << temp << "\n";
|
||||
}
|
||||
|
||||
std::cout << "\t**.vcn_activity[] : " << std::dec << "\n";
|
||||
for (const auto& vcn : gpu_metrics.vcn_activity) {
|
||||
std::cout << "\t -> " << std::dec << vcn << "\n";
|
||||
}
|
||||
|
||||
std::cout << "\t**.xgmi_read_data_acc[] : " << std::dec << "\n";
|
||||
for (const auto& read_data : gpu_metrics.xgmi_read_data_acc) {
|
||||
std::cout << "\t -> " << std::dec << read_data << "\n";
|
||||
}
|
||||
|
||||
std::cout << "\t**.xgmi_write_data_acc[] : " << std::dec << "\n";
|
||||
for (const auto& write_data : gpu_metrics.xgmi_write_data_acc) {
|
||||
std::cout << "\t -> " << std::dec << write_data << "\n";
|
||||
}
|
||||
|
||||
std::cout << "\t**.current_gfxclks[] : " << std::dec << "\n";
|
||||
for (const auto& gfxclk : gpu_metrics.current_gfxclks) {
|
||||
std::cout << "\t -> " << std::dec << gfxclk << "\n";
|
||||
}
|
||||
|
||||
std::cout << "\t**.current_socclks[] : " << std::dec << "\n";
|
||||
for (const auto& socclk : gpu_metrics.current_socclks) {
|
||||
std::cout << "\t -> " << std::dec << socclk << "\n";
|
||||
}
|
||||
|
||||
std::cout << "\t**.current_vclk0s[] : " << std::dec << "\n";
|
||||
for (const auto& vclk : gpu_metrics.current_vclk0s) {
|
||||
std::cout << "\t -> " << std::dec << vclk << "\n";
|
||||
}
|
||||
|
||||
std::cout << "\t**.current_dclk0s[] : " << std::dec << "\n";
|
||||
for (const auto& dclk : gpu_metrics.current_dclk0s) {
|
||||
std::cout << "\t -> " << std::dec << dclk << "\n";
|
||||
}
|
||||
std::cout << " ** Note: Values MAX'ed out (UINTX MAX are unsupported for the version in question) ** " << "\n";
|
||||
|
||||
std::cout << "\n\n";
|
||||
print_test_header("GPU METRICS: Using direct APIs (newer)", i);
|
||||
metrics_table_header_t header_values;
|
||||
GPUMetricTempHbm_t hbm_values;
|
||||
GPUMetricVcnActivity_t vcn_values;
|
||||
GPUMetricXgmiReadDataAcc_t xgmi_read_values;
|
||||
GPUMetricXgmiWriteDataAcc_t xgmi_write_values;
|
||||
GPUMetricCurrGfxClk_t curr_gfxclk_values;
|
||||
GPUMetricCurrSocClk_t curr_socclk_values;
|
||||
GPUMetricCurrVClk0_t curr_vclk0_values;
|
||||
GPUMetricCurrDClk0_t curr_dclk0_values;
|
||||
|
||||
ret = rsmi_dev_metrics_header_info_get(i, &header_values);
|
||||
std::cout << "\t[Metrics Header]" << "\n";
|
||||
std::cout << "\t -> format_revision : " << print_unsigned_int(header_values.format_revision) << "\n";
|
||||
std::cout << "\t -> content_revision : " << print_unsigned_int(header_values.content_revision) << "\n";
|
||||
std::cout << "\t--------------------" << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Temperature]" << "\n";
|
||||
ret = rsmi_dev_metrics_temp_edge_get(i, &val_ui16);
|
||||
std::cout << "\t -> temp_edge(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_temp_hotspot_get(i, &val_ui16);
|
||||
std::cout << "\t -> temp_hotspot(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_temp_mem_get(i, &val_ui16);
|
||||
std::cout << "\t -> temp_mem(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_temp_vrgfx_get(i, &val_ui16);
|
||||
std::cout << "\t -> temp_vrgfx(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_temp_vrsoc_get(i, &val_ui16);
|
||||
std::cout << "\t -> temp_vrsoc(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_temp_vrmem_get(i, &val_ui16);
|
||||
std::cout << "\t -> temp_vrmem(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_temp_hbm_get(i, &hbm_values);
|
||||
std::cout << "\t -> temp_hbm(): " << print_error_or_value(ret, hbm_values) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Power/Energy]" << "\n";
|
||||
ret = rsmi_dev_metrics_curr_socket_power_get(i, &val_ui16);
|
||||
std::cout << "\t -> current_socket_power(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_energy_acc_get(i, &val_ui64);
|
||||
std::cout << "\t -> energy_accum(): " << print_error_or_value(ret, val_ui64) << "\n";
|
||||
ret = rsmi_dev_metrics_avg_socket_power_get(i, &val_ui16);
|
||||
std::cout << "\t -> average_socket_power(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Utilization]" << "\n";
|
||||
ret = rsmi_dev_metrics_avg_gfx_activity_get(i, &val_ui16);
|
||||
std::cout << "\t -> average_gfx_activity(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_avg_umc_activity_get(i, &val_ui16);
|
||||
std::cout << "\t -> average_umc_activity(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_avg_mm_activity_get(i, &val_ui16);
|
||||
std::cout << "\t -> average_mm_activity(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_vcn_activity_get(i, &vcn_values);
|
||||
std::cout << "\t -> vcn_activity(): " << print_error_or_value(ret, vcn_values) << "\n";
|
||||
ret = rsmi_dev_metrics_mem_activity_acc_get(i, &val_ui32);
|
||||
std::cout << "\t -> mem_activity_accum(): " << print_error_or_value(ret, val_ui32) << "\n";
|
||||
ret = rsmi_dev_metrics_gfx_activity_acc_get(i, &val_ui32);
|
||||
std::cout << "\t -> gfx_activity_accum(): " << print_error_or_value(ret, val_ui32) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Average Clock]" << "\n";
|
||||
ret = rsmi_dev_metrics_avg_gfx_clock_frequency_get(i, &val_ui16);
|
||||
std::cout << "\t -> average_gfx_clock_frequency(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_avg_soc_clock_frequency_get(i, &val_ui16);
|
||||
std::cout << "\t -> average_soc_clock_frequency(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_avg_uclock_frequency_get(i, &val_ui16);
|
||||
std::cout << "\t -> average_uclock_frequency(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_avg_vclock0_frequency_get(i, &val_ui16);
|
||||
std::cout << "\t -> average_vclock0_frequency(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_avg_dclock0_frequency_get(i, &val_ui16);
|
||||
std::cout << "\t -> average_dclock0_frequency(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_avg_vclock1_frequency_get(i, &val_ui16);
|
||||
std::cout << "\t -> average_vclock1_frequency(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_avg_dclock1_frequency_get(i, &val_ui16);
|
||||
std::cout << "\t -> average_dclock1_frequency(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Current Clock]" << "\n";
|
||||
ret = rsmi_dev_metrics_curr_vclk1_get(i, &val_ui16);
|
||||
std::cout << "\t -> current_vclock1(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_curr_dclk1_get(i, &val_ui16);
|
||||
std::cout << "\t -> current_dclock1(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_curr_uclk_get(i, &val_ui16);
|
||||
std::cout << "\t -> current_uclock(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_curr_dclk0_get(i, &curr_dclk0_values);
|
||||
std::cout << "\t -> current_dclk0(): " << print_error_or_value(ret, curr_dclk0_values) << "\n";
|
||||
ret = rsmi_dev_metrics_curr_gfxclk_get(i, &curr_gfxclk_values);
|
||||
std::cout << "\t -> current_gfxclk(): " << print_error_or_value(ret, curr_gfxclk_values) << "\n";
|
||||
ret = rsmi_dev_metrics_curr_socclk_get(i, &curr_socclk_values);
|
||||
std::cout << "\t -> current_soc_clock(): " << print_error_or_value(ret, curr_socclk_values) << "\n";
|
||||
ret = rsmi_dev_metrics_curr_vclk0_get(i, &curr_vclk0_values);
|
||||
std::cout << "\t -> current_vclk0(): " << print_error_or_value(ret, curr_vclk0_values) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Throttle]" << "\n";
|
||||
ret = rsmi_dev_metrics_indep_throttle_status_get(i, &val_ui64);
|
||||
std::cout << "\t -> indep_throttle_status(): " << print_error_or_value(ret, val_ui64) << "\n";
|
||||
ret = rsmi_dev_metrics_throttle_status_get(i, &val_ui32);
|
||||
std::cout << "\t -> throttle_status(): " << print_error_or_value(ret, val_ui32) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Gfx Clock Lock]" << "\n";
|
||||
ret = rsmi_dev_metrics_gfxclk_lock_status_get(i, &val_ui32);
|
||||
std::cout << "\t -> gfxclk_lock_status(): " << print_error_or_value(ret, val_ui32) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Current Fan Speed]" << "\n";
|
||||
ret = rsmi_dev_metrics_curr_fan_speed_get(i, &val_ui16);
|
||||
std::cout << "\t -> current_fan_speed(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Link/Bandwidth/Speed]" << "\n";
|
||||
ret = rsmi_dev_metrics_pcie_link_width_get(i, &val_ui16);
|
||||
std::cout << "\t -> pcie_link_width(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_pcie_link_speed_get(i, &val_ui16);
|
||||
std::cout << "\t -> pcie_link_speed(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_pcie_bandwidth_acc_get(i, &val_ui64);
|
||||
std::cout << "\t -> pcie_bandwidth_accum(): " << print_error_or_value(ret, val_ui64) << "\n";
|
||||
ret = rsmi_dev_metrics_pcie_bandwidth_inst_get(i, &val_ui64);
|
||||
std::cout << "\t -> pcie_bandwidth_inst(): " << print_error_or_value(ret, val_ui64) << "\n";
|
||||
ret = rsmi_dev_metrics_pcie_l0_recov_count_acc_get(i, &val_ui64);
|
||||
std::cout << "\t -> pcie_l0_recov_count_accum(): " << print_error_or_value(ret, val_ui64) << "\n";
|
||||
ret = rsmi_dev_metrics_pcie_replay_count_acc_get(i, &val_ui64);
|
||||
std::cout << "\t -> pcie_replay_count_accum(): " << print_error_or_value(ret, val_ui64) << "\n";
|
||||
ret = rsmi_dev_metrics_pcie_replay_rover_count_acc_get(i, &val_ui64);
|
||||
std::cout << "\t -> pcie_replay_rollover_count_accum(): " << print_error_or_value(ret, val_ui64) << "\n";
|
||||
ret = rsmi_dev_metrics_xgmi_link_width_get(i, &val_ui16);
|
||||
std::cout << "\t -> xgmi_link_width(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_xgmi_link_speed_get(i, &val_ui16);
|
||||
std::cout << "\t -> xgmi_link_speed(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_xgmi_read_data_get(i, &xgmi_read_values);
|
||||
std::cout << "\t -> xgmi_read_data(): " << print_error_or_value(ret, xgmi_read_values) << "\n";
|
||||
ret = rsmi_dev_metrics_xgmi_write_data_get(i, &xgmi_write_values);
|
||||
std::cout << "\t -> xgmi_write_data(): " << print_error_or_value(ret, xgmi_write_values) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Voltage]" << "\n";
|
||||
ret = rsmi_dev_metrics_volt_soc_get(i, &val_ui16);
|
||||
std::cout << "\t -> voltage_soc(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_volt_gfx_get(i, &val_ui16);
|
||||
std::cout << "\t -> voltage_gfx(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
ret = rsmi_dev_metrics_volt_mem_get(i, &val_ui16);
|
||||
std::cout << "\t -> voltage_mem(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Timestamp]" << "\n";
|
||||
ret = rsmi_dev_metrics_system_clock_counter_get(i, &val_ui64);
|
||||
std::cout << "\t -> system_clock_counter(): " << print_error_or_value(ret, val_ui64) << "\n";
|
||||
ret = rsmi_dev_metrics_firmware_timestamp_get(i, &val_ui64);
|
||||
std::cout << "\t -> firmware_timestamp(): " << print_error_or_value(ret, val_ui64) << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[XCD CounterVoltage]" << "\n";
|
||||
ret = rsmi_dev_metrics_xcd_counter_get(i, &val_ui16);
|
||||
std::cout << "\t -> xcd_counter(): " << print_error_or_value(ret, val_ui16) << "\n";
|
||||
std::cout << "\n\n";
|
||||
|
||||
std::cout << "\t**p.current_gfxclk: " << std::dec
|
||||
<< p.current_gfxclk << "\n";
|
||||
std::cout << "\t**p.current_socclk: " << std::dec
|
||||
<< p.current_socclk << "\n";
|
||||
std::cout << "\t**p.current_uclk: " << std::dec
|
||||
<< p.current_uclk << "\n";
|
||||
std::cout << "\t**p.current_vclk0: " << std::dec
|
||||
<< p.current_vclk0 << "\n";
|
||||
std::cout << "\t**p.current_dclk0: " << std::dec
|
||||
<< p.current_dclk0 << "\n";
|
||||
std::cout << "\t**p.current_vclk1: " << std::dec
|
||||
<< p.current_vclk1 << "\n";
|
||||
std::cout << "\t**p.current_dclk1: " << std::dec
|
||||
<< p.current_dclk1 << "\n";
|
||||
|
||||
ret = rsmi_dev_perf_level_get(i, &pfl);
|
||||
CHK_AND_PRINT_RSMI_ERR_RET(ret)
|
||||
|
||||
+958
-64
Rozdílový obsah nebyl zobrazen, protože je příliš veliký
Načíst rozdílové porovnání
@@ -52,5 +52,6 @@
|
||||
#define rocm_smi_VERSION_MINOR @rocm_smi_VERSION_MINOR@
|
||||
#define rocm_smi_VERSION_PATCH @rocm_smi_VERSION_PATCH@
|
||||
#define rocm_smi_VERSION_BUILD "@rocm_smi_VERSION_BUILD@"
|
||||
#define rocm_smi_VERSION_HASH "@rocm_smi_VERSION_HASH@"
|
||||
|
||||
#endif // INCLUDE_ROCM_SMI_ROCM_SMI64CONFIG_H_
|
||||
#endif // INCLUDE_ROCM_SMI_ROCM_SMI64CONFIG_H_
|
||||
|
||||
@@ -530,7 +530,7 @@ static const std::map<const char *, dev_depends_t> kDevFuncDependsMap = {
|
||||
|
||||
Device::Device(std::string p, RocmSMI_env_vars const *e) :
|
||||
monitor_(nullptr), path_(p), env_(e), evt_notif_anon_fd_(-1),
|
||||
gpu_metrics_ver_{0, 0, 0} {
|
||||
m_gpu_metrics_header{0, 0, 0} {
|
||||
#ifndef DEBUG
|
||||
env_ = nullptr;
|
||||
#endif
|
||||
@@ -875,7 +875,14 @@ int Device::readDevInfoBinary(DevInfoTypes type, std::size_t b_size,
|
||||
if ((num*b_size) != b_size) {
|
||||
ss << "Could not read DevInfoBinary for DevInfoType ("
|
||||
<< RocmSMI::devInfoTypesStrings.at(type) << ") - SYSFS ("
|
||||
<< sysfs_path << "), binary size error, "
|
||||
<< sysfs_path << "), binary size error; "
|
||||
<< "[buff: "
|
||||
<< p_binary_data
|
||||
<< " size: "
|
||||
<< b_size
|
||||
<< " read: "
|
||||
<< num
|
||||
<< "]"
|
||||
<< ", returning ENOENT (" << std::strerror(ENOENT) << ")";
|
||||
LOG_ERROR(ss);
|
||||
return ENOENT;
|
||||
|
||||
+1891
-701
Rozdílový obsah nebyl zobrazen, protože je příliš veliký
Načíst rozdílové porovnání
@@ -100,7 +100,7 @@ void TestGpuMetricsRead::Run(void) {
|
||||
PrintDeviceHeader(i);
|
||||
|
||||
IF_VERB(STANDARD) {
|
||||
std::cout << "\t**GPU METRICS:\n";
|
||||
std::cout << "\t**GPU METRICS: Using static struct (Backwards Compatibility):\n";
|
||||
}
|
||||
rsmi_gpu_metrics_t smu;
|
||||
err = rsmi_dev_gpu_metrics_info_get(i, &smu);
|
||||
@@ -191,4 +191,380 @@ void TestGpuMetricsRead::Run(void) {
|
||||
err = rsmi_dev_gpu_metrics_info_get(i, nullptr);
|
||||
ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
auto val_ui16 = uint16_t(0);
|
||||
auto val_ui32 = uint32_t(0);
|
||||
auto val_ui64 = uint64_t(0);
|
||||
auto status_code(rsmi_status_t::RSMI_STATUS_SUCCESS);
|
||||
for (uint32_t i = 0; i < num_monitor_devs(); ++i) {
|
||||
PrintDeviceHeader(i);
|
||||
|
||||
auto temp_edge_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_temp_edge_get(i, &temp_edge_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
auto temp_hotspot_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_temp_hotspot_get(i, &temp_hotspot_value);
|
||||
CHK_ERR_ASRT(status_code);
|
||||
|
||||
auto temp_mem_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_temp_mem_get(i, &temp_mem_value);
|
||||
CHK_ERR_ASRT(status_code);
|
||||
|
||||
auto temp_vrgfx_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_temp_vrgfx_get(i, &temp_vrgfx_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
auto temp_vrsoc_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_temp_vrsoc_get(i, &temp_vrsoc_value);
|
||||
CHK_ERR_ASRT(status_code);
|
||||
|
||||
auto temp_vrmem_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_temp_vrmem_get(i, &temp_vrmem_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
GPUMetricTempHbm_t temp_hbm_values;
|
||||
status_code = rsmi_dev_metrics_temp_hbm_get(i, &temp_hbm_values);
|
||||
CHK_ERR_ASRT(status_code);
|
||||
|
||||
auto temp_curr_socket_power_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_curr_socket_power_get(i, &temp_curr_socket_power_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
auto temp_energy_accum_value = val_ui64;
|
||||
status_code = rsmi_dev_metrics_energy_acc_get(i, &temp_energy_accum_value);
|
||||
CHK_ERR_ASRT(status_code);
|
||||
|
||||
auto temp_avg_socket_power_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_avg_socket_power_get(i, &temp_avg_socket_power_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
auto temp_avg_gfx_activity_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_avg_gfx_activity_get(i, &temp_avg_gfx_activity_value);
|
||||
CHK_ERR_ASRT(status_code);
|
||||
|
||||
auto temp_avg_umc_activity_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_avg_umc_activity_get(i, &temp_avg_umc_activity_value);
|
||||
CHK_ERR_ASRT(status_code);
|
||||
|
||||
auto temp_avg_mm_activity_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_avg_mm_activity_get(i, &temp_avg_mm_activity_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
GPUMetricVcnActivity_t temp_vcn_values;
|
||||
status_code = rsmi_dev_metrics_vcn_activity_get(i, &temp_vcn_values);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
auto temp_mem_activity_accum_value = val_ui32;
|
||||
status_code = rsmi_dev_metrics_mem_activity_acc_get(i, &temp_mem_activity_accum_value);
|
||||
CHK_ERR_ASRT(status_code);
|
||||
|
||||
auto temp_gfx_activity_accum_value = val_ui32;
|
||||
status_code = rsmi_dev_metrics_gfx_activity_acc_get(i, &temp_gfx_activity_accum_value);
|
||||
CHK_ERR_ASRT(status_code);
|
||||
|
||||
auto temp_avg_gfx_clock_freq_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_avg_gfx_clock_frequency_get(i, &temp_avg_gfx_clock_freq_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
auto temp_avg_soc_clock_freq_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_avg_soc_clock_frequency_get(i, &temp_avg_soc_clock_freq_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
auto temp_avg_uclock_freq_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_avg_uclock_frequency_get(i, &temp_avg_uclock_freq_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
auto temp_avg_vclock0_freq_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_avg_vclock0_frequency_get(i, &temp_avg_vclock0_freq_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
auto temp_avg_dclock0_freq_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_avg_dclock0_frequency_get(i, &temp_avg_dclock0_freq_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
auto temp_avg_vclock1_freq_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_avg_vclock1_frequency_get(i, &temp_avg_vclock1_freq_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
auto temp_avg_dclock1_freq_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_avg_dclock1_frequency_get(i, &temp_avg_dclock1_freq_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
auto temp_curr_vclk1_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_curr_vclk1_get(i, &temp_curr_vclk1_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
auto temp_curr_dclk1_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_curr_dclk1_get(i, &temp_curr_dclk1_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
auto temp_curr_uclk_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_curr_uclk_get(i, &temp_curr_uclk_value);
|
||||
CHK_ERR_ASRT(status_code);
|
||||
|
||||
GPUMetricCurrDClk0_t temp_curr_dclk0_values;
|
||||
status_code = rsmi_dev_metrics_curr_dclk0_get(i, &temp_curr_dclk0_values);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
GPUMetricCurrGfxClk_t temp_curr_gfxclk_values;
|
||||
status_code = rsmi_dev_metrics_curr_gfxclk_get(i, &temp_curr_gfxclk_values);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
GPUMetricCurrSocClk_t temp_curr_socclk_values;
|
||||
status_code = rsmi_dev_metrics_curr_socclk_get(i, &temp_curr_socclk_values);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
GPUMetricCurrVClk0_t temp_curr_vclk0_values;
|
||||
status_code = rsmi_dev_metrics_curr_vclk0_get(i, &temp_curr_vclk0_values);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
auto temp_indep_throttle_status_value = val_ui64;
|
||||
status_code = rsmi_dev_metrics_indep_throttle_status_get(i, &temp_indep_throttle_status_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
auto temp_throttle_status_value = val_ui32;
|
||||
status_code = rsmi_dev_metrics_throttle_status_get(i, &temp_throttle_status_value);
|
||||
CHK_ERR_ASRT(status_code);
|
||||
|
||||
auto temp_gfxclk_lock_status_value = val_ui32;
|
||||
status_code = rsmi_dev_metrics_gfxclk_lock_status_get(i, &temp_gfxclk_lock_status_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
auto temp_curr_fan_speed_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_curr_fan_speed_get(i, &temp_curr_fan_speed_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
auto temp_pcie_link_width_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_pcie_link_width_get(i, &temp_pcie_link_width_value);
|
||||
CHK_ERR_ASRT(status_code);
|
||||
|
||||
auto temp_pcie_link_speed_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_pcie_link_speed_get(i, &temp_pcie_link_speed_value);
|
||||
CHK_ERR_ASRT(status_code);
|
||||
|
||||
auto temp_pcie_bandwidth_accum_value = val_ui64;
|
||||
status_code = rsmi_dev_metrics_pcie_bandwidth_acc_get(i, &temp_pcie_bandwidth_accum_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
auto temp_pcie_bandwidth_inst_value = val_ui64;
|
||||
status_code = rsmi_dev_metrics_pcie_bandwidth_inst_get(i, &temp_pcie_bandwidth_inst_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
auto temp_pcie_l0_recov_count_accum_value = val_ui64;
|
||||
status_code = rsmi_dev_metrics_pcie_l0_recov_count_acc_get(i, &temp_pcie_l0_recov_count_accum_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
auto temp_pcie_replay_count_accum_value = val_ui64;
|
||||
status_code = rsmi_dev_metrics_pcie_replay_count_acc_get(i, &temp_pcie_replay_count_accum_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
auto temp_pcie_replay_rover_count_accum_value = val_ui64;
|
||||
status_code = rsmi_dev_metrics_pcie_replay_rover_count_acc_get(i, &temp_pcie_replay_rover_count_accum_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
auto temp_xgmi_link_width_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_xgmi_link_width_get(i, &temp_xgmi_link_width_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
auto temp_xgmi_link_speed_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_xgmi_link_speed_get(i, &temp_xgmi_link_speed_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
GPUMetricXgmiReadDataAcc_t temp_xgmi_read_values;
|
||||
status_code = rsmi_dev_metrics_xgmi_read_data_get(i, &temp_xgmi_read_values);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
GPUMetricXgmiWriteDataAcc_t temp_xgmi_write_values;
|
||||
status_code = rsmi_dev_metrics_xgmi_write_data_get(i, &temp_xgmi_write_values);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
auto temp_voltage_soc_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_volt_soc_get(i, &temp_voltage_soc_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
auto temp_voltage_gfx_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_volt_gfx_get(i, &temp_voltage_gfx_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
auto temp_voltage_mem_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_volt_mem_get(i, &temp_voltage_mem_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
auto temp_system_clock_counter_value = val_ui64;
|
||||
status_code = rsmi_dev_metrics_system_clock_counter_get(i, &temp_system_clock_counter_value);
|
||||
CHK_ERR_ASRT(status_code);
|
||||
|
||||
auto temp_firmware_timestamp_value = val_ui64;
|
||||
status_code = rsmi_dev_metrics_firmware_timestamp_get(i, &temp_firmware_timestamp_value);
|
||||
CHK_ERR_ASRT(status_code);
|
||||
|
||||
auto temp_xcd_counter_value = val_ui16;
|
||||
status_code = rsmi_dev_metrics_xcd_counter_get(i, &temp_xcd_counter_value);
|
||||
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
|
||||
CHK_ERR_ASRT(status_code);
|
||||
}
|
||||
|
||||
IF_VERB(STANDARD) {
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Temperature]" << "\n";
|
||||
std::cout << "\t -> temp_edge(): " << temp_edge_value << "\n";
|
||||
std::cout << "\t -> temp_hotspot(): " << temp_hotspot_value << "\n";
|
||||
std::cout << "\t -> temp_mem(): " << temp_mem_value << "\n";
|
||||
std::cout << "\t -> temp_vrgfx(): " << temp_vrgfx_value << "\n";
|
||||
std::cout << "\t -> temp_vrsoc(): " << temp_vrsoc_value << "\n";
|
||||
std::cout << "\t -> temp_vrmem(): " << temp_vrmem_value << "\n";
|
||||
std::cout << "\t -> temp_hbm(): " << temp_hbm_values << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Power/Energy]" << "\n";
|
||||
std::cout << "\t -> current_socket_power(): " << temp_curr_socket_power_value << "\n";
|
||||
std::cout << "\t -> energy_accum(): " << temp_energy_accum_value << "\n";
|
||||
std::cout << "\t -> average_socket_power(): " << temp_avg_socket_power_value << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Utilization]" << "\n";
|
||||
std::cout << "\t -> average_gfx_activity(): " << temp_avg_gfx_activity_value << "\n";
|
||||
std::cout << "\t -> average_umc_activity(): " << temp_avg_umc_activity_value << "\n";
|
||||
std::cout << "\t -> average_mm_activity(): " << temp_avg_mm_activity_value << "\n";
|
||||
std::cout << "\t -> vcn_activity(): " << temp_vcn_values << "\n";
|
||||
std::cout << "\t -> mem_activity_accum(): " << temp_mem_activity_accum_value << "\n";
|
||||
std::cout << "\t -> gfx_activity_accum(): " << temp_gfx_activity_accum_value << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Average Clock]" << "\n";
|
||||
std::cout << "\t -> average_gfx_clock_frequency(): " << temp_avg_gfx_clock_freq_value << "\n";
|
||||
std::cout << "\t -> average_soc_clock_frequency(): " << temp_avg_soc_clock_freq_value << "\n";
|
||||
std::cout << "\t -> average_uclock_frequency(): " << temp_avg_uclock_freq_value << "\n";
|
||||
std::cout << "\t -> average_vclock0_frequency(): " << temp_avg_vclock0_freq_value << "\n";
|
||||
std::cout << "\t -> average_dclock0_frequency(): " << temp_avg_dclock0_freq_value << "\n";
|
||||
std::cout << "\t -> average_vclock1_frequency(): " << temp_avg_vclock1_freq_value << "\n";
|
||||
std::cout << "\t -> average_dclock1_frequency(): " << temp_avg_dclock1_freq_value << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Current Clock]" << "\n";
|
||||
std::cout << "\t -> current_vclock1(): " << temp_curr_vclk1_value << "\n";
|
||||
std::cout << "\t -> current_dclock1(): " << temp_curr_dclk1_value << "\n";
|
||||
std::cout << "\t -> current_uclock(): " << temp_curr_uclk_value << "\n";
|
||||
std::cout << "\t -> current_dclk0(): " << temp_curr_dclk0_values << "\n";
|
||||
std::cout << "\t -> current_gfxclk(): " << temp_curr_gfxclk_values << "\n";
|
||||
std::cout << "\t -> current_soc_clock(): " << temp_curr_socclk_values << "\n";
|
||||
std::cout << "\t -> current_vclk0(): " << temp_curr_vclk0_values << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Throttle]" << "\n";
|
||||
std::cout << "\t -> indep_throttle_status(): " << temp_indep_throttle_status_value << "\n";
|
||||
std::cout << "\t -> throttle_status(): " << temp_throttle_status_value << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Gfx Clock Lock]" << "\n";
|
||||
std::cout << "\t -> gfxclk_lock_status(): " << temp_gfxclk_lock_status_value << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Current Fan Speed]" << "\n";
|
||||
std::cout << "\t -> current_fan_speed(): " << temp_curr_fan_speed_value << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Link/Bandwidth/Speed]" << "\n";
|
||||
std::cout << "\t -> pcie_link_width(): " << temp_pcie_link_width_value << "\n";
|
||||
std::cout << "\t -> pcie_link_speed(): " << temp_pcie_link_speed_value << "\n";
|
||||
std::cout << "\t -> pcie_bandwidth_accum(): " << temp_pcie_bandwidth_accum_value << "\n";
|
||||
std::cout << "\t -> pcie_bandwidth_inst(): " << temp_pcie_bandwidth_inst_value << "\n";
|
||||
std::cout << "\t -> pcie_l0_recov_count_accum(): " << temp_pcie_l0_recov_count_accum_value << "\n";
|
||||
std::cout << "\t -> pcie_replay_count_accum(): " << temp_pcie_replay_count_accum_value << "\n";
|
||||
std::cout << "\t -> pcie_replay_rollover_count_accum(): " << temp_pcie_replay_rover_count_accum_value << "\n";
|
||||
std::cout << "\t -> xgmi_link_width(): " << temp_xgmi_link_width_value << "\n";
|
||||
std::cout << "\t -> xgmi_link_speed(): " << temp_xgmi_link_speed_value << "\n";
|
||||
std::cout << "\t -> xgmi_read_data(): " << temp_xgmi_read_values << "\n";
|
||||
std::cout << "\t -> xgmi_write_data(): " << temp_xgmi_write_values << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Voltage]" << "\n";
|
||||
std::cout << "\t -> voltage_soc(): " << temp_voltage_soc_value << "\n";
|
||||
std::cout << "\t -> voltage_gfx(): " << temp_voltage_gfx_value << "\n";
|
||||
std::cout << "\t -> voltage_mem(): " << temp_voltage_mem_value << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[Timestamp]" << "\n";
|
||||
std::cout << "\t -> system_clock_counter(): " << temp_system_clock_counter_value << "\n";
|
||||
std::cout << "\t -> firmware_timestamp(): " << temp_firmware_timestamp_value << "\n";
|
||||
|
||||
std::cout << "\n";
|
||||
std::cout << "\t[XCD CounterVoltage]" << "\n";
|
||||
std::cout << "\t -> xcd_counter(): " << temp_xcd_counter_value << "\n";
|
||||
std::cout << "\n\n";
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -167,7 +167,900 @@ void TestMeasureApiExecutionTime::Run(void) {
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
//Test execution time for each individual gpu metric
|
||||
auto val_ui16 = uint16_t(0);
|
||||
auto val_ui32 = uint32_t(0);
|
||||
auto val_ui64 = uint64_t(0);
|
||||
GPUMetricTempHbm_t temp_hbm_values;
|
||||
GPUMetricVcnActivity_t temp_vcn_values;
|
||||
GPUMetricCurrDClk0_t temp_curr_dclk0_values;
|
||||
GPUMetricCurrGfxClk_t temp_curr_gfxclk_values;
|
||||
GPUMetricCurrSocClk_t temp_curr_socclk_values;
|
||||
GPUMetricCurrVClk0_t temp_curr_vclk0_values;
|
||||
GPUMetricXgmiReadDataAcc_t temp_xgmi_read_values;
|
||||
GPUMetricXgmiWriteDataAcc_t temp_xgmi_write_values;
|
||||
auto status_code(rsmi_status_t::RSMI_STATUS_SUCCESS);
|
||||
|
||||
start = std::chrono::high_resolution_clock::now();
|
||||
auto start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_temp_edge_get(dv_ind, &val_ui16);
|
||||
}
|
||||
std::cout.precision(prev);
|
||||
auto stop_api = std::chrono::high_resolution_clock::now();
|
||||
auto duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_temp_edge_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_temp_hotspot_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_temp_hotspot_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_temp_mem_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_temp_mem_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_temp_vrgfx_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_temp_vrgfx_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_temp_vrsoc_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_temp_vrsoc_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_temp_vrmem_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_temp_vrmem_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_temp_hbm_get(dv_ind, &temp_hbm_values);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_temp_hbm_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_curr_socket_power_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_curr_socket_power_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_energy_acc_get(dv_ind, &val_ui64);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_energy_acc_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_avg_socket_power_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_avg_socket_power_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_avg_gfx_activity_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_avg_gfx_activity_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_avg_umc_activity_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_avg_umc_activity_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_avg_mm_activity_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_avg_mm_activity_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_vcn_activity_get(dv_ind, &temp_vcn_values);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_vcn_activity_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_mem_activity_acc_get(dv_ind, &val_ui32);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_mem_activity_acc_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_gfx_activity_acc_get(dv_ind, &val_ui32);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_gfx_activity_acc_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_avg_gfx_clock_frequency_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_avg_gfx_clock_frequency_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_avg_soc_clock_frequency_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_avg_soc_clock_frequency_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_avg_uclock_frequency_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_avg_uclock_frequency_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_avg_vclock0_frequency_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_avg_vclock0_frequency_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_avg_dclock0_frequency_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_avg_dclock0_frequency_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_avg_vclock1_frequency_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_avg_vclock1_frequency_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_avg_dclock1_frequency_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_avg_dclock1_frequency_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_curr_vclk1_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_curr_vclk1_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_curr_dclk1_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_curr_dclk1_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_curr_uclk_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_curr_uclk_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_curr_dclk0_get(dv_ind, &temp_curr_dclk0_values);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_curr_dclk0_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_curr_gfxclk_get(dv_ind, &temp_curr_gfxclk_values);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_curr_gfxclk_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_curr_socclk_get(dv_ind, &temp_curr_socclk_values);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_curr_socclk_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_curr_vclk0_get(dv_ind, &temp_curr_vclk0_values);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_curr_vclk0_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_indep_throttle_status_get(dv_ind, &val_ui64);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_indep_throttle_status_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_throttle_status_get(dv_ind, &val_ui32);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_throttle_status_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_gfxclk_lock_status_get(dv_ind, &val_ui32);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_gfxclk_lock_status_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_curr_fan_speed_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_curr_fan_speed_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_pcie_link_width_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_pcie_link_width_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_pcie_link_speed_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_pcie_link_speed_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_pcie_bandwidth_acc_get(dv_ind, &val_ui64);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_pcie_bandwidth_acc_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_pcie_bandwidth_inst_get(dv_ind, &val_ui64);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_pcie_bandwidth_inst_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_pcie_l0_recov_count_acc_get(dv_ind, &val_ui64);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_pcie_l0_recov_count_acc_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_pcie_replay_count_acc_get(dv_ind, &val_ui64);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_pcie_replay_count_acc_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_pcie_replay_rover_count_acc_get(dv_ind, &val_ui64);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_pcie_replay_rover_count_acc_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_xgmi_link_width_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_xgmi_link_width_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_xgmi_link_speed_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_xgmi_link_speed_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_xgmi_read_data_get(dv_ind, &temp_xgmi_read_values);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_xgmi_read_data_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_xgmi_write_data_get(dv_ind, &temp_xgmi_write_values);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_xgmi_write_data_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_volt_soc_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_volt_soc_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_volt_gfx_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_volt_gfx_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_volt_mem_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_volt_mem_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_system_clock_counter_get(dv_ind, &val_ui64);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_system_clock_counter_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_firmware_timestamp_get(dv_ind, &val_ui64);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_firmware_timestamp_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
start_api = std::chrono::high_resolution_clock::now();
|
||||
for (int i=0; i < repeat; ++i) {
|
||||
status_code = rsmi_dev_metrics_xcd_counter_get(dv_ind, &val_ui16);
|
||||
}
|
||||
stop_api = std::chrono::high_resolution_clock::now();
|
||||
duration_api = std::chrono::duration_cast<std::chrono::microseconds>(stop_api - start_api);
|
||||
if (status_code != rsmi_status_t::RSMI_STATUS_SUCCESS){
|
||||
skip = true;
|
||||
}
|
||||
if (!skip) {
|
||||
std::cout << "\rsmi_dev_metrics_xcd_counter_get() execution time: "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * repeat);
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "----------------------------------------------------------------------------" << std::endl;
|
||||
|
||||
stop = std::chrono::high_resolution_clock::now();
|
||||
duration = std::chrono::duration_cast<std::chrono::microseconds>(stop - start);
|
||||
if (!skip) {
|
||||
const auto kTOTAL_GPU_METRICS_APIS = uint16_t(52);
|
||||
std::cout << "\rTotal execution time (All APIs): "
|
||||
<< (float(duration_api.count()) / repeat) << " microseconds" << std::endl;
|
||||
EXPECT_LT(duration_api.count(), 500 * (repeat * kTOTAL_GPU_METRICS_APIS));
|
||||
}
|
||||
skip = false;
|
||||
std::cout << "============================================================================" << std::endl;
|
||||
|
||||
}
|
||||
std::cout.precision(prev);
|
||||
|
||||
}
|
||||
|
||||
@@ -106,7 +106,7 @@ void TestTempRead::Run(void) {
|
||||
return;
|
||||
}
|
||||
|
||||
uint32_t type;
|
||||
uint32_t type(0);
|
||||
for (uint32_t x = 0; x < num_iterations(); ++x) {
|
||||
for (uint32_t i = 0; i < num_monitor_devs(); ++i) {
|
||||
PrintDeviceHeader(i);
|
||||
|
||||
Odkázat v novém úkolu
Zablokovat Uživatele