AI/rocm-systems
2
0
انشعاب 0
کد مسائل تقاضاهای واکشی Actions Packages پروژه‌ها انتشارها دانشنامه فعالیت

fix: [rocm/rocm_smi_lib] header cleanup Remove non-unified headers

فهرست منبع 
Cleans up individual gpu metric APIs which will be implemented according to 'unified-headers' standards

Code changes related to the following:
  * 'rsmi_dev_metrics_' APIs
  * Functional tests
  * Examples

Change-Id: I7d562a95889361ee6f8f7588f8a790f42c8eb262
Signed-off-by: Oliveira, Daniel <daniel.oliveira@amd.com>
This commit is contained in:
Oliveira, Daniel
2024-02-14 17:50:26 -06:00
والد 4b5ccb57f0
کامیت ce36198cb1
6فایلهای تغییر یافته به همراه33 افزوده شده و 4154 حذف شده
دانلود پرونده وصله دانلود فایل تغییرات diff Expand all files Collapse all files
include/rocm_smi/rocm_smi.h
+3 -1051
مشاهده پرونده
تفاوت فایلی نمایش داده نمی شود زیرا این فایل بسیار بزرگ است Diff را بارگزاری کن
rocm_smi/example/rocm_smi_example.cc
+1 -149
مشاهده پرونده
@@ -1002,18 +1002,10 @@ int main() {
}
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;
GPUMetricJpegActivity_t jpeg_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";
@@ -1021,152 +1013,12 @@ int main() {
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_jpeg_activity_get(i, &jpeg_values);
std::cout << "\t -> jpeg_activity(): " << print_error_or_value(ret, jpeg_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";
ret = rsmi_dev_metrics_pcie_nak_sent_count_acc_get(i, &val_ui32);
std::cout << "\t -> pcie_nak_sent_count_accum(): " << print_error_or_value(ret, val_ui32) << "\n";
ret = rsmi_dev_metrics_pcie_nak_rcvd_count_acc_get(i, &val_ui32);
std::cout << "\t -> pcie_nak_rcvd_count_accum(): " << print_error_or_value(ret, val_ui32) << "\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";
ret = rsmi_dev_perf_level_get(i, &pfl);
CHK_AND_PRINT_RSMI_ERR_RET(ret)
std::cout << "\t**Performance Level:" <<
src/rocm_smi.cc
+3 -1549
مشاهده پرونده
تفاوت فایلی نمایش داده نمی شود زیرا این فایل بسیار بزرگ است Diff را بارگزاری کن
src/rocm_smi_gpu_metrics.cc
-1
مشاهده پرونده
@@ -2680,7 +2680,6 @@ rsmi_status_t Device::dev_read_gpu_metrics_header_data()
LOG_TRACE(ostrstream);
// Check if/when metrics table needs to be refreshed.
auto now_ts = actual_timestamp_in_secs();
if ((!m_gpu_metrics_header.m_structure_size) ||
(!m_gpu_metrics_header.m_format_revision) ||
(!m_gpu_metrics_header.m_content_revision)) {
tests/rocm_smi_test/functional/gpu_metrics_read.cc
+23 -484
مشاهده پرونده
@@ -47,6 +47,7 @@
#include <stddef.h>
#include <iostream>
#include <sstream>
#include <string>
#include <map>
@@ -119,6 +120,13 @@ auto print_error_or_value(std::string title, std::string func_name, const T& met
}
};
template <typename T>
std::string print_unsigned_int(T value) {
std::stringstream ss;
ss << static_cast<uint64_t>(value | 0);
return ss.str();
}
void TestGpuMetricsRead::Run(void) {
rsmi_status_t err;
@@ -133,8 +141,19 @@ void TestGpuMetricsRead::Run(void) {
PrintDeviceHeader(i);
IF_VERB(STANDARD) {
std::cout << "\n\n";
std::cout << "\t**GPU METRICS: Using static struct (Backwards Compatibility):\n";
metrics_table_header_t header_values;
auto ret = rsmi_dev_metrics_header_info_get(i, &header_values);
if (ret == rsmi_status_t::RSMI_STATUS_SUCCESS) {
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";
}
}
rsmi_gpu_metrics_t smu;
err = rsmi_dev_gpu_metrics_info_get(i, &smu);
if (err != RSMI_STATUS_SUCCESS) {
@@ -243,491 +262,11 @@ void TestGpuMetricsRead::Run(void) {
// Verify api support checking functionality is working
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);
std::cout << "\n\t**GPU METRICS: Using direct APIs (newer):\n";
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);
}
MetricResults.emplace("rsmi_dev_metrics_temp_edge_get", status_code);
auto temp_hotspot_value = val_ui16;
status_code = rsmi_dev_metrics_temp_hotspot_get(i, &temp_hotspot_value);
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
MetricResults.emplace("rsmi_dev_metrics_temp_hotspot_get", status_code);
auto temp_mem_value = val_ui16;
status_code = rsmi_dev_metrics_temp_mem_get(i, &temp_mem_value);
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
MetricResults.emplace("rsmi_dev_metrics_temp_mem_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_temp_vrgfx_get", status_code);
auto temp_vrsoc_value = val_ui16;
status_code = rsmi_dev_metrics_temp_vrsoc_get(i, &temp_vrsoc_value);
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
MetricResults.emplace("rsmi_dev_metrics_temp_vrsoc_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_temp_vrmem_get", status_code);
GPUMetricTempHbm_t temp_hbm_values{};
status_code = rsmi_dev_metrics_temp_hbm_get(i, &temp_hbm_values);
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
MetricResults.emplace("rsmi_dev_metrics_temp_hbm_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_curr_socket_power_get", status_code);
auto temp_energy_accum_value = val_ui64;
status_code = rsmi_dev_metrics_energy_acc_get(i, &temp_energy_accum_value);
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
MetricResults.emplace("rsmi_dev_metrics_energy_acc_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_avg_socket_power_get", 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);
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
MetricResults.emplace("rsmi_dev_metrics_avg_gfx_activity_get", 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);
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
MetricResults.emplace("rsmi_dev_metrics_avg_umc_activity_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_avg_mm_activity_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_vcn_activity_get", status_code);
GPUMetricJpegActivity_t temp_jpeg_values{};
status_code = rsmi_dev_metrics_jpeg_activity_get(i, &temp_jpeg_values);
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
MetricResults.emplace("rsmi_dev_metrics_jpeg_activity_get", 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);
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
MetricResults.emplace("rsmi_dev_metrics_mem_activity_acc_get", 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);
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
MetricResults.emplace("rsmi_dev_metrics_gfx_activity_acc_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_avg_gfx_clock_frequency_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_avg_soc_clock_frequency_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_avg_uclock_frequency_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_avg_vclock0_frequency_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_avg_dclock0_frequency_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_avg_vclock1_frequency_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_avg_dclock1_frequency_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_curr_vclk1_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_curr_dclk1_get", status_code);
auto temp_curr_uclk_value = val_ui16;
status_code = rsmi_dev_metrics_curr_uclk_get(i, &temp_curr_uclk_value);
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
MetricResults.emplace("rsmi_dev_metrics_curr_uclk_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_curr_dclk0_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_curr_gfxclk_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_curr_socclk_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_curr_vclk0_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_indep_throttle_status_get", status_code);
auto temp_throttle_status_value = val_ui32;
status_code = rsmi_dev_metrics_throttle_status_get(i, &temp_throttle_status_value);
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
MetricResults.emplace("rsmi_dev_metrics_throttle_status_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_gfxclk_lock_status_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_curr_fan_speed_get", 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);
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
MetricResults.emplace("rsmi_dev_metrics_pcie_link_width_get", 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);
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
MetricResults.emplace("rsmi_dev_metrics_pcie_link_speed_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_pcie_bandwidth_acc_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_pcie_bandwidth_inst_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_pcie_l0_recov_count_acc_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_pcie_replay_count_acc_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_pcie_replay_rover_count_acc_get", status_code);
auto temp_pcie_nak_sent_count_accum_value = val_ui32;
status_code = rsmi_dev_metrics_pcie_nak_sent_count_acc_get(i, &temp_pcie_nak_sent_count_accum_value);
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
MetricResults.emplace("rsmi_dev_metrics_pcie_nak_sent_count_acc_get", status_code);
auto temp_pcie_nak_rcvd_count_accum_value = val_ui32;
status_code = rsmi_dev_metrics_pcie_nak_rcvd_count_acc_get(i, &temp_pcie_nak_rcvd_count_accum_value);
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
MetricResults.emplace("rsmi_dev_metrics_pcie_nak_rcvd_count_acc_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_xgmi_link_width_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_xgmi_link_speed_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_xgmi_read_data_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_xgmi_write_data_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_volt_soc_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_volt_gfx_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_volt_mem_get", 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);
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
MetricResults.emplace("rsmi_dev_metrics_system_clock_counter_get", status_code);
auto temp_firmware_timestamp_value = val_ui64;
status_code = rsmi_dev_metrics_firmware_timestamp_get(i, &temp_firmware_timestamp_value);
if (status_code != RSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(status_code);
}
MetricResults.emplace("rsmi_dev_metrics_firmware_timestamp_get", 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);
}
MetricResults.emplace("rsmi_dev_metrics_xcd_counter_get", status_code);
IF_VERB(STANDARD) {
std::cout << "\n";
std::cout << "\t[Temperature]" << "\n";
std::cout << print_error_or_value("\t -> temp_edge(): ", "rsmi_dev_metrics_temp_edge_get", temp_edge_value) << "\n";
std::cout << print_error_or_value("\t -> temp_hotspot(): ", "rsmi_dev_metrics_temp_hotspot_get", temp_hotspot_value) << "\n";
std::cout << print_error_or_value("\t -> temp_mem(): ", "rsmi_dev_metrics_temp_mem_get", temp_mem_value) << "\n";
std::cout << print_error_or_value("\t -> temp_vrgfx(): ", "rsmi_dev_metrics_temp_vrgfx_get", temp_vrgfx_value) << "\n";
std::cout << print_error_or_value("\t -> temp_vrsoc(): ", "rsmi_dev_metrics_temp_vrsoc_get", temp_vrsoc_value) << "\n";
std::cout << print_error_or_value("\t -> temp_vrmem(): ", "rsmi_dev_metrics_temp_vrmem_get", temp_vrmem_value) << "\n";
std::cout << print_error_or_value("\t -> temp_hbm[]: ", "rsmi_dev_metrics_temp_hbm_get", temp_hbm_values) << "\n";
std::cout << "\n";
std::cout << "\t[Power/Energy]" << "\n";
std::cout << print_error_or_value("\t -> current_socket_power(): ", "rsmi_dev_metrics_curr_socket_power_get", temp_curr_socket_power_value) << "\n";
std::cout << print_error_or_value("\t -> energy_accum(): ", "rsmi_dev_metrics_energy_acc_get", temp_energy_accum_value) << "\n";
std::cout << print_error_or_value("\t -> average_socket_power(): ", "rsmi_dev_metrics_avg_socket_power_get", temp_avg_socket_power_value) << "\n";
std::cout << "\n";
std::cout << "\t[Utilization]" << "\n";
std::cout << print_error_or_value("\t -> average_gfx_activity(): ", "rsmi_dev_metrics_avg_gfx_activity_get", temp_avg_gfx_activity_value) << "\n";
std::cout << print_error_or_value("\t -> average_umc_activity(): ", "rsmi_dev_metrics_avg_umc_activity_get", temp_avg_umc_activity_value) << "\n";
std::cout << print_error_or_value("\t -> average_mm_activity(): ", "rsmi_dev_metrics_avg_mm_activity_get", temp_avg_mm_activity_value) << "\n";
std::cout << print_error_or_value("\t -> vcn_activity[]: ", "rsmi_dev_metrics_vcn_activity_get", temp_vcn_values) << "\n";
std::cout << print_error_or_value("\t -> jpeg_activity[]: ", "rsmi_dev_metrics_jpeg_activity_get", temp_jpeg_values) << "\n";
std::cout << "\n";
std::cout << print_error_or_value("\t -> mem_activity_accum(): ", "rsmi_dev_metrics_mem_activity_acc_get", temp_mem_activity_accum_value) << "\n";
std::cout << print_error_or_value("\t -> gfx_activity_accum(): ", "rsmi_dev_metrics_gfx_activity_acc_get", temp_gfx_activity_accum_value) << "\n";
std::cout << "\n";
std::cout << "\t[Average Clock]" << "\n";
std::cout << print_error_or_value("\t -> average_gfx_clock_frequency(): ", "rsmi_dev_metrics_avg_gfx_clock_frequency_get", temp_avg_gfx_clock_freq_value) << "\n";
std::cout << print_error_or_value("\t -> average_soc_clock_frequency(): ", "rsmi_dev_metrics_avg_soc_clock_frequency_get", temp_avg_soc_clock_freq_value) << "\n";
std::cout << print_error_or_value("\t -> average_uclock_frequency(): ", "rsmi_dev_metrics_avg_uclock_frequency_get", temp_avg_uclock_freq_value) << "\n";
std::cout << print_error_or_value("\t -> average_vclock0_frequency(): ", "rsmi_dev_metrics_avg_vclock0_frequency_get", temp_avg_vclock0_freq_value) << "\n";
std::cout << print_error_or_value("\t -> average_dclock0_frequency(): ", "rsmi_dev_metrics_avg_dclock0_frequency_get", temp_avg_dclock0_freq_value) << "\n";
std::cout << print_error_or_value("\t -> average_vclock1_frequency(): ", "rsmi_dev_metrics_avg_vclock1_frequency_get", temp_avg_vclock1_freq_value) << "\n";
std::cout << print_error_or_value("\t -> average_dclock1_frequency(): ", "rsmi_dev_metrics_avg_dclock1_frequency_get", temp_avg_dclock1_freq_value) << "\n";
std::cout << "\n";
std::cout << "\t[Current Clock]" << "\n";
std::cout << print_error_or_value("\t -> current_vclock1(): ", "rsmi_dev_metrics_curr_vclk1_get", temp_curr_vclk1_value) << "\n";
std::cout << print_error_or_value("\t -> current_dclock1(): ", "rsmi_dev_metrics_curr_dclk1_get", temp_curr_dclk1_value) << "\n";
std::cout << print_error_or_value("\t -> current_uclock(): ", "rsmi_dev_metrics_curr_uclk_get", temp_curr_uclk_value) << "\n";
std::cout << print_error_or_value("\t -> current_dclk0[]: ", "rsmi_dev_metrics_curr_dclk0_get", temp_curr_dclk0_values) << "\n";
std::cout << print_error_or_value("\t -> current_gfxclk[]: ", "rsmi_dev_metrics_curr_gfxclk_get", temp_curr_gfxclk_values) << "\n";
std::cout << print_error_or_value("\t -> current_soc_clock[]: ", "rsmi_dev_metrics_curr_socclk_get", temp_curr_socclk_values) << "\n";
std::cout << print_error_or_value("\t -> current_vclk0[]: ", "rsmi_dev_metrics_curr_vclk0_get", temp_curr_vclk0_values) << "\n";
std::cout << "\n";
std::cout << "\t[Throttle]" << "\n";
std::cout << print_error_or_value("\t -> indep_throttle_status(): ", "rsmi_dev_metrics_indep_throttle_status_get", temp_indep_throttle_status_value) << "\n";
std::cout << print_error_or_value("\t -> throttle_status(): ", "rsmi_dev_metrics_throttle_status_get", temp_throttle_status_value) << "\n";
std::cout << "\n";
std::cout << "\t[Gfx Clock Lock]" << "\n";
std::cout << print_error_or_value("\t -> gfxclk_lock_status(): ", "rsmi_dev_metrics_gfxclk_lock_status_get", temp_gfxclk_lock_status_value) << "\n";
std::cout << "\n";
std::cout << "\t[Current Fan Speed]" << "\n";
std::cout << print_error_or_value("\t -> current_fan_speed(): ", "rsmi_dev_metrics_curr_fan_speed_get", temp_curr_fan_speed_value) << "\n";
std::cout << "\n";
std::cout << "\t[Link/Bandwidth/Speed]" << "\n";
std::cout << print_error_or_value("\t -> pcie_link_width(): ", "rsmi_dev_metrics_pcie_link_width_get", temp_pcie_link_width_value) << "\n";
std::cout << print_error_or_value("\t -> pcie_link_speed(): ", "rsmi_dev_metrics_pcie_link_speed_get", temp_pcie_link_speed_value) << "\n";
std::cout << print_error_or_value("\t -> pcie_bandwidth_accum(): ", "rsmi_dev_metrics_pcie_bandwidth_acc_get", temp_pcie_bandwidth_accum_value) << "\n";
std::cout << print_error_or_value("\t -> pcie_bandwidth_inst(): ", "rsmi_dev_metrics_pcie_bandwidth_inst_get", temp_pcie_bandwidth_inst_value) << "\n";
std::cout << print_error_or_value("\t -> pcie_l0_recov_count_accum(): ", "rsmi_dev_metrics_pcie_l0_recov_count_acc_get", temp_pcie_l0_recov_count_accum_value) << "\n";
std::cout << print_error_or_value("\t -> pcie_replay_count_accum(): ", "rsmi_dev_metrics_pcie_replay_count_acc_get", temp_pcie_replay_count_accum_value) << "\n";
std::cout << print_error_or_value("\t -> pcie_replay_rollover_count_accum(): ", "rsmi_dev_metrics_pcie_replay_rover_count_acc_get", temp_pcie_replay_rover_count_accum_value) << "\n";
std::cout << print_error_or_value("\t -> pcie_nak_sent_count_accum(): ", "rsmi_dev_metrics_pcie_nak_sent_count_acc_get", temp_pcie_nak_sent_count_accum_value) << "\n";
std::cout << print_error_or_value("\t -> pcie_nak_rcvd_count_accum(): ", "rsmi_dev_metrics_pcie_nak_rcvd_count_acc_get", temp_pcie_nak_rcvd_count_accum_value) << "\n";
std::cout << print_error_or_value("\t -> xgmi_link_width(): ", "rsmi_dev_metrics_xgmi_link_width_get", temp_xgmi_link_width_value) << "\n";
std::cout << print_error_or_value("\t -> xgmi_link_speed(): ", "rsmi_dev_metrics_xgmi_link_speed_get", temp_xgmi_link_speed_value) << "\n";
std::cout << print_error_or_value("\t -> xgmi_read_data[]: ", "rsmi_dev_metrics_xgmi_read_data_get", temp_xgmi_read_values) << "\n";
std::cout << print_error_or_value("\t -> xgmi_write_data[]: ", "rsmi_dev_metrics_xgmi_write_data_get", temp_xgmi_write_values) << "\n";
std::cout << "\n";
std::cout << "\t[Voltage]" << "\n";
std::cout << print_error_or_value("\t -> voltage_soc(): ", "rsmi_dev_metrics_volt_soc_get", temp_voltage_soc_value) << "\n";
std::cout << print_error_or_value("\t -> voltage_gfx(): ", "rsmi_dev_metrics_volt_gfx_get", temp_voltage_gfx_value) << "\n";
std::cout << print_error_or_value("\t -> voltage_mem(): ", "rsmi_dev_metrics_volt_mem_get", temp_voltage_mem_value) << "\n";
std::cout << "\n";
std::cout << "\t[Timestamp]" << "\n";
std::cout << print_error_or_value("\t -> system_clock_counter(): ", "rsmi_dev_metrics_system_clock_counter_get", temp_system_clock_counter_value) << "\n";
std::cout << print_error_or_value("\t -> firmware_timestamp(): ", "rsmi_dev_metrics_firmware_timestamp_get", temp_firmware_timestamp_value) << "\n";
std::cout << "\n";
std::cout << "\t[XCD CounterVoltage]" << "\n";
std::cout << print_error_or_value("\t -> xcd_counter(): ", "rsmi_dev_metrics_xcd_counter_get", temp_xcd_counter_value) << "\n";
std::cout << "\n\n";
auto temp_xcd_counter_value = uint16_t(0);
err = rsmi_dev_metrics_xcd_counter_get(i, &temp_xcd_counter_value);
if (err != RSMI_STATUS_NOT_SUPPORTED) {
CHK_ERR_ASRT(err);
}
}
}
tests/rocm_smi_test/functional/measure_api_execution_time.cc
+3 -920
مشاهده پرونده
@@ -167,930 +167,14 @@ 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;
GPUMetricJpegActivity_t temp_jpeg_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);
}
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_jpeg_activity_get(dv_ind, &temp_jpeg_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_jpeg_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_pcie_nak_sent_count_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_pcie_nak_sent_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_nak_rcvd_count_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_pcie_nak_rcvd_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);
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;
}
@@ -1105,10 +189,9 @@ void TestMeasureApiExecutionTime::Run(void) {
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(57);
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));
EXPECT_LT(duration_api.count(), (500 * repeat));
}
skip = false;
std::cout << "============================================================================" << std::endl;