diff --git a/include/rocm_smi/rocm_smi.h b/include/rocm_smi/rocm_smi.h index 26d0ca86..de6761ca 100755 --- a/include/rocm_smi/rocm_smi.h +++ b/include/rocm_smi/rocm_smi.h @@ -918,6 +918,9 @@ struct metrics_table_header_t { uint8_t content_revision; /// \endcond }; +/// \cond Ignore in docs. +typedef struct metrics_table_header_t metrics_table_header_t; +/// \endcond /** * @brief The following structure holds the gpu metrics values for a device. @@ -934,9 +937,14 @@ struct metrics_table_header_t { #define RSMI_NUM_HBM_INSTANCES 4 /** - * @brief This should match kRSMI_MAX_NUM_VCN + * @brief This should match kRSMI_MAX_NUM_VCNS + */ +#define RSMI_MAX_NUM_VCNS 4 + +/** + * @brief This should match kRSMI_MAX_JPEG_ENGINES */ -#define RSMI_MAX_NUM_VCN 4 +#define RSMI_MAX_NUM_JPEG_ENGS 32 /** * @brief This should match kRSMI_MAX_NUM_CLKS @@ -1057,7 +1065,7 @@ typedef struct { uint16_t current_socket_power; // Utilization (%) - uint16_t vcn_activity[RSMI_MAX_NUM_VCN]; // VCN instances activity percent (encode/decode) + uint16_t vcn_activity[RSMI_MAX_NUM_VCNS]; // VCN instances activity percent (encode/decode) // Clock Lock Status. Each bit corresponds to clock instance uint32_t gfxclk_lock_status; @@ -1091,6 +1099,19 @@ typedef struct { uint16_t current_vclk0s[RSMI_MAX_NUM_CLKS]; uint16_t current_dclk0s[RSMI_MAX_NUM_CLKS]; + /* + * v1.5 additions + */ + // JPEG activity percent (encode/decode) + uint16_t jpeg_activity[RSMI_MAX_NUM_JPEG_ENGS]; + + // PCIE NAK sent accumulated count + uint32_t pcie_nak_sent_count_acc; + + // PCIE NAK received accumulated count + uint32_t pcie_nak_rcvd_count_acc; + + /// \endcond } rsmi_gpu_metrics_t; @@ -4366,7 +4387,8 @@ rsmi_status_t rsmi_event_notification_stop(uint32_t dv_ind); * Metric multi-valued counter types */ typedef uint16_t GPUMetricTempHbm_t[RSMI_NUM_HBM_INSTANCES]; -typedef uint16_t GPUMetricVcnActivity_t[RSMI_MAX_NUM_VCN]; +typedef uint16_t GPUMetricVcnActivity_t[RSMI_MAX_NUM_VCNS]; +typedef uint16_t GPUMetricJpegActivity_t[RSMI_MAX_NUM_JPEG_ENGS]; typedef uint64_t GPUMetricXgmiReadDataAcc_t[RSMI_MAX_NUM_XGMI_LINKS]; typedef uint64_t GPUMetricXgmiWriteDataAcc_t[RSMI_MAX_NUM_XGMI_LINKS]; typedef uint16_t GPUMetricCurrGfxClk_t[RSMI_MAX_NUM_GFX_CLKS]; @@ -4797,6 +4819,44 @@ rsmi_dev_metrics_pcie_replay_count_acc_get(uint32_t dv_ind, uint64_t* pcie_count rsmi_status_t rsmi_dev_metrics_pcie_replay_rover_count_acc_get(uint32_t dv_ind, uint64_t* pcie_count_acc_value); +/** + * @brief Get the 'pcie_nak_sent_count_acc' from the GPU metrics associated with the device + * + * @details Given a device index @p dv_ind and a pointer to a uint32_t in which + * the 'mem_max_bandwidth_usage' will stored + * + * @param[in] dv_ind a device index + * + * @param[inout] pcie_nak_sent_count_acc_value a pointer to uint32_t to which the device gpu + * metric unit will be stored + * + * @retval ::RSMI_STATUS_SUCCESS is returned upon successful call. + * ::RSMI_STATUS_NOT_SUPPORTED is returned in case the metric unit + * does not exist for the given device + * + */ +rsmi_status_t +rsmi_dev_metrics_pcie_nak_sent_count_acc_get(uint32_t dv_ind, uint32_t* pcie_nak_sent_count_acc_value); + +/** + * @brief Get the 'pcie_nak_rcvd_count_acc' from the GPU metrics associated with the device + * + * @details Given a device index @p dv_ind and a pointer to a uint32_t in which + * the 'mem_max_bandwidth_usage' will stored + * + * @param[in] dv_ind a device index + * + * @param[inout] pcie_nak_rcvd_count_acc_value a pointer to uint32_t to which the device gpu + * metric unit will be stored + * + * @retval ::RSMI_STATUS_SUCCESS is returned upon successful call. + * ::RSMI_STATUS_NOT_SUPPORTED is returned in case the metric unit + * does not exist for the given device + * + */ +rsmi_status_t +rsmi_dev_metrics_pcie_nak_rcvd_count_acc_get(uint32_t dv_ind, uint32_t* pcie_nak_rcvd_count_acc_value); + /** * @brief Get the 'curr_uclk' from the GPU metrics associated with the device * @@ -4852,7 +4912,7 @@ rsmi_dev_metrics_temp_hbm_get(uint32_t dv_ind, GPUMetricTempHbm_t* temp_hbm_valu * * @param[inout] vcn_activity_value a pointer to uint16_t to which the device gpu * metric unit will be stored - * - This is a multi-valued counter holding a 4 (RSMI_MAX_NUM_VCN) + * - This is a multi-valued counter holding a 4 (RSMI_MAX_NUM_VCNS) * element array (GPUMetricVcnActivity_t) * * @retval ::RSMI_STATUS_SUCCESS is returned upon successful call. @@ -4863,6 +4923,27 @@ rsmi_dev_metrics_temp_hbm_get(uint32_t dv_ind, GPUMetricTempHbm_t* temp_hbm_valu rsmi_status_t rsmi_dev_metrics_vcn_activity_get(uint32_t dv_ind, GPUMetricVcnActivity_t* vcn_activity_value); +/** + * @brief Get the 'jpeg_activity' from the GPU metrics associated with the device + * + * @details Given a device index @p dv_ind and a pointer to a uint16_t in which + * the 'vcn_activity' will stored + * + * @param[in] dv_ind a device index + * + * @param[inout] jpeg_activity_value a pointer to uint16_t to which the device gpu + * metric unit will be stored + * - This is a multi-valued counter holding a 32 (RSMI_MAX_NUM_JPEG_ENGS) + * element array (GPUMetricJpegActivity_t) + * + * @retval ::RSMI_STATUS_SUCCESS is returned upon successful call. + * ::RSMI_STATUS_NOT_SUPPORTED is returned in case the metric unit + * does not exist for the given device + * + */ +rsmi_status_t +rsmi_dev_metrics_jpeg_activity_get(uint32_t dv_ind, GPUMetricJpegActivity_t* jpeg_activity_value); + /** * @brief Get the 'xgmi_read_data' from the GPU metrics associated with the device * diff --git a/include/rocm_smi/rocm_smi_gpu_metrics.h b/include/rocm_smi/rocm_smi_gpu_metrics.h index 1c217917..b67f90c7 100644 --- a/include/rocm_smi/rocm_smi_gpu_metrics.h +++ b/include/rocm_smi/rocm_smi_gpu_metrics.h @@ -92,7 +92,10 @@ constexpr uint32_t kRSMI_MAX_NUM_GFX_CLKS = 8; constexpr uint32_t kRSMI_MAX_NUM_CLKS = 4; // Note: This *must* match NUM_VCN -constexpr uint32_t kRSMI_MAX_NUM_VCN = 4; +constexpr uint32_t kRSMI_MAX_NUM_VCNS = 4; + +// Note: This *must* match NUM_JPEG_ENG +constexpr uint32_t kRSMI_MAX_JPEG_ENGINES = 32; struct AMDGpuMetricsHeader_v1_t @@ -326,7 +329,7 @@ struct AMDGpuMetrics_v14_t // Utilization (%) uint16_t m_average_gfx_activity; uint16_t m_average_umc_activity; // memory controller - uint16_t m_vcn_activity[kRSMI_MAX_NUM_VCN]; // VCN instances activity percent (encode/decode) + uint16_t m_vcn_activity[kRSMI_MAX_NUM_VCNS]; // VCN instances activity percent (encode/decode) // Energy (15.259uJ (2^-16) units) uint64_t m_energy_accumulator; @@ -383,7 +386,89 @@ struct AMDGpuMetrics_v14_t uint16_t m_padding; }; -using AMGpuMetricsLatest_t = AMDGpuMetrics_v14_t; + +struct AMDGpuMetrics_v15_t +{ + ~AMDGpuMetrics_v15_t() = default; + + struct AMDGpuMetricsHeader_v1_t m_common_header; + + // Temperature (Celsius). It will be zero (0) if unsupported. + uint16_t m_temperature_hotspot; + uint16_t m_temperature_mem; + uint16_t m_temperature_vrsoc; + + // Power (Watts) + uint16_t m_current_socket_power; + + // Utilization (%) + uint16_t m_average_gfx_activity; + uint16_t m_average_umc_activity; // memory controller + uint16_t m_vcn_activity[kRSMI_MAX_NUM_VCNS]; // VCN instances activity percent (encode/decode) + uint16_t m_jpeg_activity[kRSMI_MAX_JPEG_ENGINES]; // JPEG activity percent (encode/decode) + + // Energy (15.259uJ (2^-16) units) + uint64_t m_energy_accumulator; + + // Driver attached timestamp (in ns) + uint64_t m_system_clock_counter; + + // Throttle status + uint32_t m_throttle_status; + + // Clock Lock Status. Each bit corresponds to clock instance + uint32_t m_gfxclk_lock_status; + + // Link width (number of lanes) and speed (in 0.1 GT/s) + uint16_t m_pcie_link_width; + 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; + + // Utilization Accumulated (%) + uint32_t m_gfx_activity_acc; + uint32_t m_mem_activity_acc; + + // PCIE accumulated bandwidth (GB/sec) + uint64_t m_pcie_bandwidth_acc; + + // 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; + + // PCIE NAK sent accumulated count + uint32_t m_pcie_nak_sent_count_acc; + + // PCIE NAK received accumulated count + uint32_t m_pcie_nak_rcvd_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]; + + // PMFW attached timestamp (10ns resolution) + uint64_t m_firmware_timestamp; + + // Current clocks (Mhz) + uint16_t m_current_gfxclk[kRSMI_MAX_NUM_GFX_CLKS]; + uint16_t m_current_socclk[kRSMI_MAX_NUM_CLKS]; + uint16_t m_current_vclk0[kRSMI_MAX_NUM_CLKS]; + uint16_t m_current_dclk0[kRSMI_MAX_NUM_CLKS]; + uint16_t m_current_uclk; + + uint16_t m_padding; +}; +using AMGpuMetricsLatest_t = AMDGpuMetrics_v15_t; /** * This is GPU Metrics version that gets to public access. @@ -410,6 +495,9 @@ using GPUMetricTempHbmTbl_t = GpuMetricU16Tbl_t; using GPUMetricVcnActivity_t = decltype(AMDGpuMetrics_v14_t::m_vcn_activity); using GPUMetricVcnActivityTbl_t = GpuMetricU16Tbl_t; +using GPUMetricJpegActivity_t = decltype(AMDGpuMetrics_v15_t::m_jpeg_activity); +using GPUMetricJpegActivityTbl_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 = GpuMetricU64Tbl_t; @@ -518,6 +606,7 @@ enum class AMDGpuMetricsUnitType_t : AMDGpuMetricTypeId_t kMetricGfxActivityAccumulator, kMetricMemActivityAccumulator, kMetricVcnActivity, //v1.4 + kMetricJpegActivity, //v1.5 // kGpuMetricAverageClock counters kMetricAvgGfxClockFrequency, @@ -559,6 +648,8 @@ enum class AMDGpuMetricsUnitType_t : AMDGpuMetricTypeId_t kMetricPcieL0RecovCountAccumulator, //v1.4 kMetricPcieReplayCountAccumulator, //v1.4 kMetricPcieReplayRollOverCountAccumulator, //v1.4 + kMetricPcieNakSentCountAccumulator, //v1.5 + kMetricPcieNakReceivedCountAccumulator, //v1.5 // kGpuMetricPowerEnergy counters kMetricAvgSocketPower, @@ -608,6 +699,7 @@ enum class AMDGpuMetricVersionFlags_t : AMDGpuMetricVersionFlagId_t kGpuMetricV12 = (0x1 << 2), kGpuMetricV13 = (0x1 << 3), kGpuMetricV14 = (0x1 << 4), + kGpuMetricV15 = (0x1 << 5), }; using AMDGpuMetricVersionTranslationTbl_t = std::map; using GpuMetricTypePtr_t = std::shared_ptr; @@ -780,6 +872,40 @@ class GpuMetricsBase_v14_t final : public GpuMetricsBase_t }; +class GpuMetricsBase_v15_t final : public GpuMetricsBase_t +{ + public: + ~GpuMetricsBase_v15_t() = default; + + size_t sizeof_metric_table() override { + return sizeof(AMDGpuMetrics_v15_t); + } + + GpuMetricTypePtr_t get_metrics_table() override + { + if (!m_gpu_metric_ptr) { + m_gpu_metric_ptr.reset(&m_gpu_metrics_tbl, [](AMDGpuMetrics_v15_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::kGpuMetricV15; + } + + rsmi_status_t populate_metrics_dynamic_tbl() override; + AMGpuMetricsPublicLatestTupl_t copy_internal_to_external_metrics() override; + + + private: + AMDGpuMetrics_v15_t m_gpu_metrics_tbl; + std::shared_ptr m_gpu_metric_ptr; + +}; template rsmi_status_t rsmi_dev_gpu_metrics_info_query(uint32_t dv_ind, AMDGpuMetricsUnitType_t metric_counter, T& metric_value); diff --git a/rocm_smi/example/rocm_smi_example.cc b/rocm_smi/example/rocm_smi_example.cc index 0260104b..e8781b4f 100755 --- a/rocm_smi/example/rocm_smi_example.cc +++ b/rocm_smi/example/rocm_smi_example.cc @@ -990,6 +990,7 @@ int main() { 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; @@ -1039,6 +1040,8 @@ int main() { 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); @@ -1119,6 +1122,10 @@ int main() { 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"; diff --git a/src/rocm_smi.cc b/src/rocm_smi.cc index 702d6d6a..d23d6d16 100755 --- a/src/rocm_smi.cc +++ b/src/rocm_smi.cc @@ -6332,6 +6332,60 @@ rsmi_dev_metrics_pcie_replay_rover_count_acc_get(uint32_t dv_ind, uint64_t* pcie CATCH } +rsmi_status_t +rsmi_dev_metrics_pcie_nak_sent_count_acc_get(uint32_t dv_ind, uint32_t* pcie_nak_sent_count_acc_value) +{ + TRY + std::ostringstream ostrstream; + ostrstream << __PRETTY_FUNCTION__ << "| ======= start ======="; + LOG_TRACE(ostrstream); + + assert(pcie_nak_sent_count_acc_value != nullptr); + if (pcie_nak_sent_count_acc_value == nullptr) { + return rsmi_status_t::RSMI_STATUS_INVALID_ARGS; + } + + const auto gpu_metric_unit(AMDGpuMetricsUnitType_t::kMetricPcieNakSentCountAccumulator); + auto status_code = rsmi_dev_gpu_metrics_info_query(dv_ind, gpu_metric_unit, *pcie_nak_sent_count_acc_value); + ostrstream << __PRETTY_FUNCTION__ + << " | ======= end ======= " + << " | End Result " + << " | Device #: " << dv_ind + << " | Metric Type: " << static_cast(gpu_metric_unit) + << " | Returning = " << status_code << " " << getRSMIStatusString(status_code) << " |"; + LOG_INFO(ostrstream); + + return status_code; + CATCH +} + +rsmi_status_t +rsmi_dev_metrics_pcie_nak_rcvd_count_acc_get(uint32_t dv_ind, uint32_t* pcie_nak_rcvd_count_acc_value) +{ + TRY + std::ostringstream ostrstream; + ostrstream << __PRETTY_FUNCTION__ << "| ======= start ======="; + LOG_TRACE(ostrstream); + + assert(pcie_nak_rcvd_count_acc_value != nullptr); + if (pcie_nak_rcvd_count_acc_value == nullptr) { + return rsmi_status_t::RSMI_STATUS_INVALID_ARGS; + } + + const auto gpu_metric_unit(AMDGpuMetricsUnitType_t::kMetricPcieNakReceivedCountAccumulator); + auto status_code = rsmi_dev_gpu_metrics_info_query(dv_ind, gpu_metric_unit, *pcie_nak_rcvd_count_acc_value); + ostrstream << __PRETTY_FUNCTION__ + << " | ======= end ======= " + << " | End Result " + << " | Device #: " << dv_ind + << " | Metric Type: " << static_cast(gpu_metric_unit) + << " | Returning = " << status_code << " " << getRSMIStatusString(status_code) << " |"; + LOG_INFO(ostrstream); + + return status_code; + CATCH +} + rsmi_status_t rsmi_dev_metrics_curr_uclk_get(uint32_t dv_ind, uint16_t* uclk_value) { @@ -6390,7 +6444,7 @@ rsmi_dev_metrics_temp_hbm_get(uint32_t dv_ind, GPUMetricTempHbm_t* temp_hbm_valu << "\n | Returning = " << status_code << " " << getRSMIStatusString(status_code) << " |"; LOG_INFO(ostrstream); if (status_code == rsmi_status_t::RSMI_STATUS_SUCCESS) { - std::memset(temp_hbm_value, 0, sizeof(temp_hbm_value)); + std::memset(temp_hbm_value, 0, sizeof(*temp_hbm_value)); std::copy_n(std::begin(tmp_hbl_tbl), copy_size, *temp_hbm_value); } @@ -6429,7 +6483,7 @@ rsmi_dev_metrics_vcn_activity_get(uint32_t dv_ind, GPUMetricVcnActivity_t* vcn_a << "\n | Returning = " << status_code << " " << getRSMIStatusString(status_code) << " |"; LOG_INFO(ostrstream); if (status_code == rsmi_status_t::RSMI_STATUS_SUCCESS) { - std::memset(vcn_activity_value, 0, sizeof(vcn_activity_value)); + std::memset(vcn_activity_value, 0, sizeof(*vcn_activity_value)); std::copy_n(std::begin(tmp_vcn_tbl), copy_size, *vcn_activity_value); } @@ -6437,6 +6491,45 @@ rsmi_dev_metrics_vcn_activity_get(uint32_t dv_ind, GPUMetricVcnActivity_t* vcn_a CATCH } +rsmi_status_t +rsmi_dev_metrics_jpeg_activity_get(uint32_t dv_ind, GPUMetricJpegActivity_t* jpeg_activity_value) +{ + TRY + std::ostringstream ostrstream; + ostrstream << __PRETTY_FUNCTION__ << "| ======= start ======="; + LOG_TRACE(ostrstream); + + assert(jpeg_activity_value != nullptr); + if (jpeg_activity_value == nullptr) { + return rsmi_status_t::RSMI_STATUS_INVALID_ARGS; + } + + const auto gpu_metric_unit(AMDGpuMetricsUnitType_t::kMetricVcnActivity); + amd::smi::GPUMetricJpegActivityTbl_t tmp_jpeg_tbl{}; + auto status_code = rsmi_dev_gpu_metrics_info_query(dv_ind, gpu_metric_unit, tmp_jpeg_tbl); + const auto max_num_elems = + static_cast(std::end(*jpeg_activity_value) - std::begin(*jpeg_activity_value)); + const auto copy_size = + static_cast((max_num_elems < tmp_jpeg_tbl.size()) ? max_num_elems : tmp_jpeg_tbl.size()); + ostrstream << __PRETTY_FUNCTION__ + << "\n | ======= end ======= " + << "\n | End Result " + << "\n | Device #: " << dv_ind + << "\n | Metric Type: " << static_cast(gpu_metric_unit) + << "\n | Metric Size: " << tmp_jpeg_tbl.size() + << "\n | Max num of elements: " << max_num_elems + << "\n | Copy size: " << copy_size + << "\n | Returning = " << status_code << " " << getRSMIStatusString(status_code) << " |"; + LOG_INFO(ostrstream); + if (status_code == rsmi_status_t::RSMI_STATUS_SUCCESS) { + std::memset(jpeg_activity_value, 0, sizeof(*jpeg_activity_value)); + std::copy_n(std::begin(tmp_jpeg_tbl), copy_size, *jpeg_activity_value); + } + + return status_code; + CATCH +} + rsmi_status_t rsmi_dev_metrics_xgmi_read_data_get(uint32_t dv_ind, GPUMetricXgmiReadDataAcc_t* xgmi_read_data_acc_value) { @@ -6468,7 +6561,7 @@ rsmi_dev_metrics_xgmi_read_data_get(uint32_t dv_ind, GPUMetricXgmiReadDataAcc_t* << "\n | Returning = " << status_code << " " << getRSMIStatusString(status_code) << " |"; LOG_INFO(ostrstream); if (status_code == rsmi_status_t::RSMI_STATUS_SUCCESS) { - std::memset(xgmi_read_data_acc_value, 0, sizeof(xgmi_read_data_acc_value)); + std::memset(xgmi_read_data_acc_value, 0, sizeof(*xgmi_read_data_acc_value)); std::copy_n(std::begin(tmp_xgmi_acc_tbl), copy_size, *xgmi_read_data_acc_value); } @@ -6507,7 +6600,7 @@ rsmi_dev_metrics_xgmi_write_data_get(uint32_t dv_ind, GPUMetricXgmiWriteDataAcc_ << "\n | Returning = " << status_code << " " << getRSMIStatusString(status_code) << " |"; LOG_INFO(ostrstream); if (status_code == rsmi_status_t::RSMI_STATUS_SUCCESS) { - std::memset(xgmi_write_data_acc_value, 0, sizeof(xgmi_write_data_acc_value)); + std::memset(xgmi_write_data_acc_value, 0, sizeof(*xgmi_write_data_acc_value)); std::copy_n(std::begin(tmp_xgmi_acc_tbl), copy_size, *xgmi_write_data_acc_value); } @@ -6546,7 +6639,7 @@ rsmi_dev_metrics_curr_gfxclk_get(uint32_t dv_ind, GPUMetricCurrGfxClk_t* current << "\n | Returning = " << status_code << " " << getRSMIStatusString(status_code) << " |"; LOG_INFO(ostrstream); if (status_code == rsmi_status_t::RSMI_STATUS_SUCCESS) { - std::memset(current_gfxclk_value, 0, sizeof(current_gfxclk_value)); + std::memset(current_gfxclk_value, 0, sizeof(*current_gfxclk_value)); std::copy_n(std::begin(tmp_curr_gfxclk_tbl), copy_size, *current_gfxclk_value); } @@ -6584,7 +6677,7 @@ rsmi_dev_metrics_curr_socclk_get(uint32_t dv_ind, GPUMetricCurrSocClk_t* current << "\n | Returning = " << status_code << " " << getRSMIStatusString(status_code) << " |"; LOG_INFO(ostrstream); if (status_code == rsmi_status_t::RSMI_STATUS_SUCCESS) { - std::memset(current_socclk_value, 0, sizeof(current_socclk_value)); + std::memset(current_socclk_value, 0, sizeof(*current_socclk_value)); std::copy_n(std::begin(tmp_curr_socclk_tbl), copy_size, *current_socclk_value); } @@ -6623,7 +6716,7 @@ rsmi_dev_metrics_curr_vclk0_get(uint32_t dv_ind, GPUMetricCurrVClk0_t* current_v << "\n | Returning = " << status_code << " " << getRSMIStatusString(status_code) << " |"; LOG_INFO(ostrstream); if (status_code == rsmi_status_t::RSMI_STATUS_SUCCESS) { - std::memset(current_vclk_value, 0, sizeof(current_vclk_value)); + std::memset(current_vclk_value, 0, sizeof(*current_vclk_value)); std::copy_n(std::begin(tmp_curr_vclk0_tbl), copy_size, *current_vclk_value); } @@ -6689,7 +6782,7 @@ rsmi_dev_metrics_curr_dclk0_get(uint32_t dv_ind, GPUMetricCurrDClk0_t* current_d << "\n | Returning = " << status_code << " " << getRSMIStatusString(status_code) << " |"; LOG_INFO(ostrstream); if (status_code == rsmi_status_t::RSMI_STATUS_SUCCESS) { - std::memset(current_dclk_value, 0, sizeof(current_dclk_value)); + std::memset(current_dclk_value, 0, sizeof(*current_dclk_value)); std::copy_n(std::begin(tmp_curr_dclk0_tbl), copy_size, *current_dclk_value); } diff --git a/src/rocm_smi_gpu_metrics.cc b/src/rocm_smi_gpu_metrics.cc index 48d86837..44b9a880 100755 --- a/src/rocm_smi_gpu_metrics.cc +++ b/src/rocm_smi_gpu_metrics.cc @@ -163,6 +163,7 @@ const AMDGpuMetricVersionTranslationTbl_t amdgpu_metric_version_translation_tabl {join_metrics_version(1, 2), AMDGpuMetricVersionFlags_t::kGpuMetricV12}, {join_metrics_version(1, 3), AMDGpuMetricVersionFlags_t::kGpuMetricV13}, {join_metrics_version(1, 4), AMDGpuMetricVersionFlags_t::kGpuMetricV14}, + {join_metrics_version(1, 5), AMDGpuMetricVersionFlags_t::kGpuMetricV15}, }; /** @@ -201,7 +202,8 @@ const AMDGpuMetricsUnitTypeTranslationTbl_t amdgpu_metrics_unit_type_translation {AMDGpuMetricsUnitType_t::kMetricAvgMmActivity, "AvgMmActivity"}, {AMDGpuMetricsUnitType_t::kMetricGfxActivityAccumulator, "GfxActivityAcc"}, {AMDGpuMetricsUnitType_t::kMetricMemActivityAccumulator, "MemActivityAcc"}, - {AMDGpuMetricsUnitType_t::kMetricVcnActivity, "VcnActivity"}, + {AMDGpuMetricsUnitType_t::kMetricVcnActivity, "VcnActivity"}, /* v1.4 */ + {AMDGpuMetricsUnitType_t::kMetricJpegActivity, "JpegActivity"}, /* v1.5 */ // kGpuMetricAverageClock counters {AMDGpuMetricsUnitType_t::kMetricAvgGfxClockFrequency, "AvgGfxClockFrequency"}, @@ -213,11 +215,11 @@ const AMDGpuMetricsUnitTypeTranslationTbl_t amdgpu_metrics_unit_type_translation {AMDGpuMetricsUnitType_t::kMetricAvgDClock1Frequency, "AvgDClock1Frequency"}, // kGpuMetricCurrentClock counters - {AMDGpuMetricsUnitType_t::kMetricCurrGfxClock, "CurrGfxClock"}, - {AMDGpuMetricsUnitType_t::kMetricCurrSocClock, "CurrSocClock"}, + {AMDGpuMetricsUnitType_t::kMetricCurrGfxClock, "CurrGfxClock"}, /* v1.4: Changed to array */ + {AMDGpuMetricsUnitType_t::kMetricCurrSocClock, "CurrSocClock"}, /* v1.4: Changed to array */ {AMDGpuMetricsUnitType_t::kMetricCurrUClock, "CurrUClock"}, - {AMDGpuMetricsUnitType_t::kMetricCurrVClock0, "CurrVClock0"}, - {AMDGpuMetricsUnitType_t::kMetricCurrDClock0, "CurrDClock0"}, + {AMDGpuMetricsUnitType_t::kMetricCurrVClock0, "CurrVClock0"}, /* v1.4: Changed to array */ + {AMDGpuMetricsUnitType_t::kMetricCurrDClock0, "CurrDClock0"}, /* v1.4: Changed to array */ {AMDGpuMetricsUnitType_t::kMetricCurrVClock1, "CurrVClock1"}, {AMDGpuMetricsUnitType_t::kMetricCurrDClock1, "CurrDClock1"}, @@ -226,7 +228,7 @@ const AMDGpuMetricsUnitTypeTranslationTbl_t amdgpu_metrics_unit_type_translation {AMDGpuMetricsUnitType_t::kMetricIndepThrottleStatus, "IndepThrottleStatus"}, // kGpuMetricGfxClkLockStatus counters - {AMDGpuMetricsUnitType_t::kMetricGfxClkLockStatus, "GfxClkLockStatus"}, + {AMDGpuMetricsUnitType_t::kMetricGfxClkLockStatus, "GfxClkLockStatus"}, /* v1.4 */ // kGpuMetricCurrentFanSpeed counters {AMDGpuMetricsUnitType_t::kMetricCurrFanSpeed, "CurrFanSpeed"}, @@ -234,19 +236,21 @@ const AMDGpuMetricsUnitTypeTranslationTbl_t amdgpu_metrics_unit_type_translation // kGpuMetricLinkWidthSpeed counters {AMDGpuMetricsUnitType_t::kMetricPcieLinkWidth, "PcieLinkWidth"}, {AMDGpuMetricsUnitType_t::kMetricPcieLinkSpeed, "PcieLinkSpeed"}, - {AMDGpuMetricsUnitType_t::kMetricPcieBandwidthAccumulator, "PcieBandwidthAcc"}, - {AMDGpuMetricsUnitType_t::kMetricPcieBandwidthInst, "PcieBandwidthInst"}, - {AMDGpuMetricsUnitType_t::kMetricXgmiLinkWidth, "XgmiLinkWidth"}, - {AMDGpuMetricsUnitType_t::kMetricXgmiLinkSpeed, "XgmiLinkSpeed"}, - {AMDGpuMetricsUnitType_t::kMetricXgmiReadDataAccumulator, "XgmiReadDataAcc"}, - {AMDGpuMetricsUnitType_t::kMetricXgmiWriteDataAccumulator, "XgmiWriteDataAcc"}, - {AMDGpuMetricsUnitType_t::kMetricPcieL0RecovCountAccumulator, "PcieL0RecovCountAcc"}, - {AMDGpuMetricsUnitType_t::kMetricPcieReplayCountAccumulator, "PcieReplayCountAcc"}, - {AMDGpuMetricsUnitType_t::kMetricPcieReplayRollOverCountAccumulator, "PcieReplayRollOverCountAcc"}, + {AMDGpuMetricsUnitType_t::kMetricPcieBandwidthAccumulator, "PcieBandwidthAcc"}, /* v1.4 */ + {AMDGpuMetricsUnitType_t::kMetricPcieBandwidthInst, "PcieBandwidthInst"}, /* v1.4 */ + {AMDGpuMetricsUnitType_t::kMetricXgmiLinkWidth, "XgmiLinkWidth"}, /* v1.4 */ + {AMDGpuMetricsUnitType_t::kMetricXgmiLinkSpeed, "XgmiLinkSpeed"}, /* v1.4 */ + {AMDGpuMetricsUnitType_t::kMetricXgmiReadDataAccumulator, "XgmiReadDataAcc"}, /* v1.4 */ + {AMDGpuMetricsUnitType_t::kMetricXgmiWriteDataAccumulator, "XgmiWriteDataAcc"}, /* v1.4 */ + {AMDGpuMetricsUnitType_t::kMetricPcieL0RecovCountAccumulator, "PcieL0RecovCountAcc"}, /* v1.4 */ + {AMDGpuMetricsUnitType_t::kMetricPcieReplayCountAccumulator, "PcieReplayCountAcc"}, /* v1.4 */ + {AMDGpuMetricsUnitType_t::kMetricPcieReplayRollOverCountAccumulator, "PcieReplayRollOverCountAcc"}, /* v1.4 */ + {AMDGpuMetricsUnitType_t::kMetricPcieNakSentCountAccumulator, "PcieNakSentCountAcc"}, /* v1.5 */ + {AMDGpuMetricsUnitType_t::kMetricPcieNakReceivedCountAccumulator, "PcieNakRcvdCountAcc"}, /* v1.5 */ // kGpuMetricPowerEnergy counters {AMDGpuMetricsUnitType_t::kMetricAvgSocketPower, "AvgSocketPower"}, - {AMDGpuMetricsUnitType_t::kMetricCurrSocketPower, "CurrSocketPower"}, + {AMDGpuMetricsUnitType_t::kMetricCurrSocketPower, "CurrSocketPower"}, /* v1.4 */ {AMDGpuMetricsUnitType_t::kMetricEnergyAccumulator, "EnergyAcc"}, // kGpuMetricVoltage counters @@ -343,6 +347,7 @@ AMDGpuMetricFactories_t amd_gpu_metrics_factory_table {AMDGpuMetricVersionFlags_t::kGpuMetricV12, std::make_shared(GpuMetricsBase_v12_t{})}, {AMDGpuMetricVersionFlags_t::kGpuMetricV13, std::make_shared(GpuMetricsBase_v13_t{})}, {AMDGpuMetricVersionFlags_t::kGpuMetricV14, std::make_shared(GpuMetricsBase_v14_t{})}, + {AMDGpuMetricVersionFlags_t::kGpuMetricV15, std::make_shared(GpuMetricsBase_v15_t{})}, }; GpuMetricsBasePtr amdgpu_metrics_factory(AMDGpuMetricVersionFlags_t gpu_metric_version) @@ -462,6 +467,341 @@ AMDGpuDynamicMetricTblValues_t format_metric_row(const T& metric, const std::str return multi_values; } +void GpuMetricsBase_v15_t::dump_internal_metrics_table() +{ + std::ostringstream ostrstream; + std::cout << __PRETTY_FUNCTION__ << " | ======= start ======= \n"; + ostrstream << __PRETTY_FUNCTION__ + << " | ======= DEBUG ======= " + << " | Metric Version: " << stringfy_metric_header_version(m_gpu_metrics_tbl.m_common_header) + << " | Size: " << print_unsigned_int(m_gpu_metrics_tbl.m_common_header.m_structure_size) + << " |" + << "\n"; + ostrstream << " temperature_hotspot: " << m_gpu_metrics_tbl.m_temperature_hotspot << "\n" + << " temperature_mem: " << m_gpu_metrics_tbl.m_temperature_mem << "\n" + << " temperature_vrsoc: " << m_gpu_metrics_tbl.m_temperature_vrsoc << "\n" + + << " current_socket_power: " << m_gpu_metrics_tbl.m_current_socket_power << "\n" + + << " average_gfx_activity: " << m_gpu_metrics_tbl.m_average_gfx_activity << "\n" + << " average_umc_activity: " << m_gpu_metrics_tbl.m_average_umc_activity << "\n"; + + ostrstream << " vcn_activity: " << "\n"; + auto idx = uint64_t(0); + for (const auto& temp : m_gpu_metrics_tbl.m_vcn_activity) { + ostrstream << "\t [" << idx << "]: " << temp << "\n"; + ++idx; + } + + ostrstream << " jpeg_activity: " << "\n"; + idx = 0; + for (const auto& temp : m_gpu_metrics_tbl.m_jpeg_activity) { + ostrstream << "\t [" << idx << "]: " << temp << "\n"; + ++idx; + } + + ostrstream << " energy_accumulator: " << m_gpu_metrics_tbl.m_energy_accumulator << "\n" + << " system_clock_counter: " << m_gpu_metrics_tbl.m_system_clock_counter << "\n" + + << " throttle_status: " << m_gpu_metrics_tbl.m_throttle_status << "\n" + + << " average_gfx_activity: " << m_gpu_metrics_tbl.m_average_gfx_activity << "\n" + << " average_umc_activity: " << m_gpu_metrics_tbl.m_average_umc_activity << "\n" + + << " gfxclk_lock_status: " << m_gpu_metrics_tbl.m_gfxclk_lock_status << "\n" + + << " pcie_link_width: " << m_gpu_metrics_tbl.m_pcie_link_width << "\n" + << " pcie_link_speed: " << m_gpu_metrics_tbl.m_pcie_link_speed << "\n" + + << " xgmi_link_width: " << m_gpu_metrics_tbl.m_xgmi_link_width << "\n" + << " xgmi_link_speed: " << m_gpu_metrics_tbl.m_xgmi_link_speed << "\n" + + << " gfx_activity_acc: " << m_gpu_metrics_tbl.m_gfx_activity_acc << "\n" + << " mem_activity_acc: " << m_gpu_metrics_tbl.m_mem_activity_acc << "\n" + + << " pcie_bandwidth_acc: " << m_gpu_metrics_tbl.m_pcie_bandwidth_acc << "\n" + << " pcie_bandwidth_inst: " << m_gpu_metrics_tbl.m_pcie_bandwidth_inst << "\n" + << " pcie_l0_to_recov_count_acc: " << m_gpu_metrics_tbl.m_pcie_l0_to_recov_count_acc << "\n" + << " pcie_replay_count_acc: " << m_gpu_metrics_tbl.m_pcie_replay_count_acc << "\n" + << " pcie_replay_rover_count_acc: " << m_gpu_metrics_tbl.m_pcie_replay_rover_count_acc << "\n" + << " pcie_nak_sent_count_acc: " << m_gpu_metrics_tbl.m_pcie_nak_sent_count_acc << "\n" + << " pcie_nak_rcvd_count_acc: " << m_gpu_metrics_tbl.m_pcie_nak_rcvd_count_acc << "\n"; + + ostrstream << " xgmi_read_data_acc: " << "\n"; + idx = 0; + for (const auto& temp : m_gpu_metrics_tbl.m_xgmi_read_data_acc) { + ostrstream << "\t [" << idx << "]: " << temp << "\n"; + ++idx; + } + + ostrstream << " xgmi_write_data_acc: " << "\n"; + idx = 0; + for (const auto& temp : m_gpu_metrics_tbl.m_xgmi_write_data_acc) { + ostrstream << "\t [" << idx << "]: " << temp << "\n"; + ++idx; + } + + ostrstream << " firmware_timestamp: " << m_gpu_metrics_tbl.m_firmware_timestamp << "\n"; + + ostrstream << " current_gfxclk: " << "\n"; + idx = 0; + for (const auto& temp : m_gpu_metrics_tbl.m_current_gfxclk) { + ostrstream << "\t [" << idx << "]: " << temp << "\n"; + ++idx; + } + + ostrstream << " current_socclk: " << "\n"; + idx = 0; + for (const auto& temp : m_gpu_metrics_tbl.m_current_socclk) { + ostrstream << "\t [" << idx << "]: " << temp << "\n"; + ++idx; + } + + ostrstream << " current_vclk0: " << "\n"; + idx = 0; + for (const auto& temp : m_gpu_metrics_tbl.m_current_vclk0) { + ostrstream << "\t [" << idx << "]: " << temp << "\n"; + ++idx; + } + + ostrstream << " current_dclk0: " << "\n"; + idx = 0; + for (const auto& temp : m_gpu_metrics_tbl.m_current_dclk0) { + ostrstream << "\t [" << idx << "]: " << temp << "\n"; + ++idx; + } + + ostrstream << " padding: " << m_gpu_metrics_tbl.m_padding << "\n"; + LOG_DEBUG(ostrstream); +} + +rsmi_status_t GpuMetricsBase_v15_t::populate_metrics_dynamic_tbl() +{ + std::ostringstream ostrstream; + auto status_code(rsmi_status_t::RSMI_STATUS_SUCCESS); + ostrstream << __PRETTY_FUNCTION__ << " | ======= start ======="; + LOG_TRACE(ostrstream); + + // + // Note: Any metric treatment/changes (if any) should happen before they + // get written to internal/external tables. + // + auto run_metric_adjustments_v15 = [&]() { + ostrstream << __PRETTY_FUNCTION__ << " | ======= start ======="; + const auto gpu_metrics_version = translate_flag_to_metric_version(get_gpu_metrics_version_used()); + ostrstream << __PRETTY_FUNCTION__ + << " | ======= info ======= " + << " | Applying adjustments " + << " | Metric Version: " << stringfy_metric_header_version( + disjoin_metrics_version(gpu_metrics_version)) + << " |"; + LOG_TRACE(ostrstream); + + // firmware_timestamp is at 10ns resolution + ostrstream << __PRETTY_FUNCTION__ + << " | ======= Changes ======= " + << " | {m_firmware_timestamp} from: " << m_gpu_metrics_tbl.m_firmware_timestamp + << " to: " << (m_gpu_metrics_tbl.m_firmware_timestamp * 10); + m_gpu_metrics_tbl.m_firmware_timestamp = (m_gpu_metrics_tbl.m_firmware_timestamp * 10); + LOG_DEBUG(ostrstream); + }; + + + // Adjustments/Changes specific to this version + run_metric_adjustments_v15(); + + // Temperature Info + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricTemperature] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricTempHotspot, + format_metric_row(m_gpu_metrics_tbl.m_temperature_hotspot, + "temperature_hotspot")) + ); + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricTemperature] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricTempMem, + format_metric_row(m_gpu_metrics_tbl.m_temperature_mem, + "temperature_mem")) + ); + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricTemperature] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricTempVrSoc, + format_metric_row(m_gpu_metrics_tbl.m_temperature_vrsoc, + "temperature_vrsoc")) + ); + + // Power/Energy Info + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricPowerEnergy] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricCurrSocketPower, + format_metric_row(m_gpu_metrics_tbl.m_current_socket_power, + "curr_socket_power")) + ); + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricPowerEnergy] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricEnergyAccumulator, + format_metric_row(m_gpu_metrics_tbl.m_energy_accumulator, + "energy_acc")) + ); + + // Utilization Info + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricUtilization] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricAvgGfxActivity, + format_metric_row(m_gpu_metrics_tbl.m_average_gfx_activity, + "average_gfx_activity")) + ); + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricUtilization] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricAvgUmcActivity, + format_metric_row(m_gpu_metrics_tbl.m_average_umc_activity, + "average_umc_activity")) + ); + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricUtilization] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricVcnActivity, + format_metric_row(m_gpu_metrics_tbl.m_vcn_activity, + "[average_vcn_activity]")) + ); + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricUtilization] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricJpegActivity, + format_metric_row(m_gpu_metrics_tbl.m_jpeg_activity, + "[average_jpeg_activity]")) + ); + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricUtilization] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricGfxActivityAccumulator, + format_metric_row(m_gpu_metrics_tbl.m_gfx_activity_acc, + "gfx_activity_acc")) + ); + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricUtilization] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricMemActivityAccumulator, + format_metric_row(m_gpu_metrics_tbl.m_mem_activity_acc, + "mem_activity_acc")) + ); + + // Timestamp Info + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricTimestamp] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricTSFirmware, + format_metric_row(m_gpu_metrics_tbl.m_firmware_timestamp, + "firmware_timestamp")) + ); + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricTimestamp] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricTSClockCounter, + format_metric_row(m_gpu_metrics_tbl.m_system_clock_counter, + "system_clock_counter")) + ); + + // Throttle Info + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricThrottleStatus] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricThrottleStatus, + format_metric_row(m_gpu_metrics_tbl.m_throttle_status, + "throttle_status")) + ); + + // GfxLock Info + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricGfxClkLockStatus] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricGfxClkLockStatus, + format_metric_row(m_gpu_metrics_tbl.m_gfxclk_lock_status, + "gfxclk_lock_status")) + ); + + // Link/Width/Speed Info + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricLinkWidthSpeed] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricPcieLinkWidth, + format_metric_row(m_gpu_metrics_tbl.m_pcie_link_width, + "pcie_link_width")) + ); + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricLinkWidthSpeed] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricPcieLinkSpeed, + format_metric_row(m_gpu_metrics_tbl.m_pcie_link_speed, + "pcie_link_speed")) + ); + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricLinkWidthSpeed] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricXgmiLinkWidth, + format_metric_row(m_gpu_metrics_tbl.m_xgmi_link_width, + "xgmi_link_width")) + ); + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricLinkWidthSpeed] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricXgmiLinkSpeed, + format_metric_row(m_gpu_metrics_tbl.m_xgmi_link_speed, + "xgmi_link_speed")) + ); + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricLinkWidthSpeed] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricPcieBandwidthAccumulator, + format_metric_row(m_gpu_metrics_tbl.m_pcie_bandwidth_acc, + "pcie_bandwidth_acc")) + ); + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricLinkWidthSpeed] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricPcieBandwidthInst, + format_metric_row(m_gpu_metrics_tbl.m_pcie_bandwidth_inst, + "pcie_bandwidth_inst")) + ); + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricLinkWidthSpeed] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricPcieL0RecovCountAccumulator, + format_metric_row(m_gpu_metrics_tbl.m_pcie_l0_to_recov_count_acc, + "pcie_l0_recov_count_acc")) + ); + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricLinkWidthSpeed] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricPcieReplayCountAccumulator, + format_metric_row(m_gpu_metrics_tbl.m_pcie_replay_count_acc, + "pcie_replay_count_acc")) + ); + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricLinkWidthSpeed] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricPcieReplayRollOverCountAccumulator, + format_metric_row(m_gpu_metrics_tbl.m_pcie_replay_rover_count_acc, + "pcie_replay_rollover_count_acc")) + ); + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricLinkWidthSpeed] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricPcieNakSentCountAccumulator, + format_metric_row(m_gpu_metrics_tbl.m_pcie_nak_sent_count_acc, + "pcie_nak_sent_count_acc")) + ); + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricLinkWidthSpeed] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricPcieNakReceivedCountAccumulator, + format_metric_row(m_gpu_metrics_tbl.m_pcie_nak_rcvd_count_acc, + "pcie_nak_rcvd_count_acc")) + ); + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricLinkWidthSpeed] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricXgmiReadDataAccumulator, + format_metric_row(m_gpu_metrics_tbl.m_xgmi_read_data_acc, + "[xgmi_read_data_acc]")) + ); + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricLinkWidthSpeed] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricXgmiWriteDataAccumulator, + format_metric_row(m_gpu_metrics_tbl.m_xgmi_write_data_acc, + "[xgmi_write_data_acc]")) + ); + + // CurrentClock Info + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricCurrentClock] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricCurrGfxClock, + format_metric_row(m_gpu_metrics_tbl.m_current_gfxclk, + "[current_gfxclk]")) + ); + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricCurrentClock] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricCurrSocClock, + format_metric_row(m_gpu_metrics_tbl.m_current_socclk, + "[current_socclk]")) + ); + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricCurrentClock] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricCurrVClock0, + format_metric_row(m_gpu_metrics_tbl.m_current_vclk0, + "[current_vclk0]")) + ); + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricCurrentClock] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricCurrDClock0, + format_metric_row(m_gpu_metrics_tbl.m_current_dclk0, + "[current_dclk0]")) + ); + m_metrics_dynamic_tbl[AMDGpuMetricsClassId_t::kGpuMetricCurrentClock] + .insert(std::make_pair(AMDGpuMetricsUnitType_t::kMetricCurrUClock, + format_metric_row(m_gpu_metrics_tbl.m_current_uclk, + "current_uclk")) + ); + + ostrstream << __PRETTY_FUNCTION__ + << " | ======= end ======= " + << " | Success " + << " | Returning = " << getRSMIStatusString(status_code) + << " |"; + LOG_TRACE(ostrstream); + + return status_code; +} + + void GpuMetricsBase_v14_t::dump_internal_metrics_table() { std::ostringstream ostrstream; @@ -827,6 +1167,10 @@ rsmi_status_t init_max_public_gpu_matrics(AMGpuMetricsPublicLatest_t& rsmi_gpu_m std::end(rsmi_gpu_metrics.vcn_activity), init_max_uint_types()); + std::fill(std::begin(rsmi_gpu_metrics.jpeg_activity), + std::end(rsmi_gpu_metrics.jpeg_activity), + init_max_uint_types()); + rsmi_gpu_metrics.gfxclk_lock_status = init_max_uint_types(); rsmi_gpu_metrics.xgmi_link_width = init_max_uint_types(); rsmi_gpu_metrics.xgmi_link_speed = init_max_uint_types(); @@ -860,6 +1204,10 @@ rsmi_status_t init_max_public_gpu_matrics(AMGpuMetricsPublicLatest_t& rsmi_gpu_m std::end(rsmi_gpu_metrics.current_dclk0s), init_max_uint_types()); + rsmi_gpu_metrics.pcie_nak_sent_count_acc = init_max_uint_types(); + rsmi_gpu_metrics.pcie_nak_rcvd_count_acc = init_max_uint_types(); + + ostrstream << __PRETTY_FUNCTION__ << " | ======= end ======= " << " | Success " @@ -870,6 +1218,195 @@ rsmi_status_t init_max_public_gpu_matrics(AMGpuMetricsPublicLatest_t& rsmi_gpu_m return status_code; } +AMGpuMetricsPublicLatestTupl_t GpuMetricsBase_v15_t::copy_internal_to_external_metrics() +{ + std::ostringstream ostrstream; + auto status_code(rsmi_status_t::RSMI_STATUS_SUCCESS); + ostrstream << __PRETTY_FUNCTION__ << " | ======= start ======="; + LOG_TRACE(ostrstream); + + auto copy_data_from_internal_metrics_tbl = [&]() { + AMGpuMetricsPublicLatest_t metrics_public_init{}; + + // + // Note: Initializing data members with their max. If field is max, + // no data was assigned to it. + init_max_public_gpu_matrics(metrics_public_init); + + // Header + metrics_public_init.common_header.structure_size = m_gpu_metrics_tbl.m_common_header.m_structure_size; + metrics_public_init.common_header.format_revision = m_gpu_metrics_tbl.m_common_header.m_format_revision; + metrics_public_init.common_header.content_revision = m_gpu_metrics_tbl.m_common_header.m_content_revision; + + + // Temperature + metrics_public_init.temperature_hotspot = m_gpu_metrics_tbl.m_temperature_hotspot; + metrics_public_init.temperature_mem = m_gpu_metrics_tbl.m_temperature_mem; + metrics_public_init.temperature_vrsoc = m_gpu_metrics_tbl.m_temperature_vrsoc; + + // Power + metrics_public_init.current_socket_power = m_gpu_metrics_tbl.m_current_socket_power; + + // Utilization + metrics_public_init.average_gfx_activity = m_gpu_metrics_tbl.m_average_gfx_activity; + metrics_public_init.average_umc_activity = m_gpu_metrics_tbl.m_average_umc_activity; + + // vcn_activity + const auto vcn_activity_num_elems = + static_cast( + std::end(m_gpu_metrics_tbl.m_vcn_activity) - + std::begin(m_gpu_metrics_tbl.m_vcn_activity)); + std::copy_n(std::begin(m_gpu_metrics_tbl.m_vcn_activity), + vcn_activity_num_elems, + metrics_public_init.vcn_activity); + + // jpeg_activity + const auto jpeg_activity_num_elems = + static_cast( + std::end(m_gpu_metrics_tbl.m_jpeg_activity) - + std::begin(m_gpu_metrics_tbl.m_jpeg_activity)); + std::copy_n(std::begin(m_gpu_metrics_tbl.m_jpeg_activity), + jpeg_activity_num_elems, + metrics_public_init.jpeg_activity); + + // Power/Energy + metrics_public_init.energy_accumulator = m_gpu_metrics_tbl.m_energy_accumulator; + + // Driver attached timestamp (in ns) + metrics_public_init.system_clock_counter = m_gpu_metrics_tbl.m_system_clock_counter; + + // Throttle status + metrics_public_init.throttle_status = m_gpu_metrics_tbl.m_throttle_status; + + // Clock Lock Status. Each bit corresponds to clock instance + metrics_public_init.gfxclk_lock_status = m_gpu_metrics_tbl.m_gfxclk_lock_status; + + // Link width (number of lanes) and speed + metrics_public_init.pcie_link_width = m_gpu_metrics_tbl.m_pcie_link_width; + metrics_public_init.pcie_link_speed = m_gpu_metrics_tbl.m_pcie_link_speed; + + // XGMI bus width and bitrate + metrics_public_init.xgmi_link_width = m_gpu_metrics_tbl.m_xgmi_link_width; + metrics_public_init.xgmi_link_speed = m_gpu_metrics_tbl.m_xgmi_link_speed; + + // Utilization Accumulated + metrics_public_init.gfx_activity_acc = m_gpu_metrics_tbl.m_gfx_activity_acc; + metrics_public_init.mem_activity_acc = m_gpu_metrics_tbl.m_mem_activity_acc; + + // PCIE accumulated bandwidth + metrics_public_init.pcie_bandwidth_acc = m_gpu_metrics_tbl.m_pcie_bandwidth_acc; + + // PCIE instantaneous bandwidth + metrics_public_init.pcie_bandwidth_inst = m_gpu_metrics_tbl.m_pcie_bandwidth_inst; + + // PCIE L0 to recovery state transition accumulated count + metrics_public_init.pcie_l0_to_recov_count_acc = m_gpu_metrics_tbl.m_pcie_l0_to_recov_count_acc; + + // PCIE replay accumulated count + metrics_public_init.pcie_replay_count_acc = m_gpu_metrics_tbl.m_pcie_replay_count_acc; + + // PCIE replay rollover accumulated count + metrics_public_init.pcie_replay_rover_count_acc = m_gpu_metrics_tbl.m_pcie_replay_rover_count_acc; + + // PCIE NAK sent accumulated count + metrics_public_init.pcie_nak_sent_count_acc = m_gpu_metrics_tbl.m_pcie_nak_sent_count_acc; + + // PCIE NAK received accumulated count + metrics_public_init.pcie_nak_rcvd_count_acc = m_gpu_metrics_tbl.m_pcie_nak_rcvd_count_acc; + + // XGMI accumulated data transfer size + // xgmi_read_data + const auto xgmi_read_data_num_elems = + static_cast( + std::end(m_gpu_metrics_tbl.m_xgmi_read_data_acc) - + std::begin(m_gpu_metrics_tbl.m_xgmi_read_data_acc)); + std::copy_n(std::begin(m_gpu_metrics_tbl.m_xgmi_read_data_acc), + xgmi_read_data_num_elems, + metrics_public_init.xgmi_read_data_acc); + // xgmi_write_data + const auto xgmi_write_data_num_elems = + static_cast( + std::end(m_gpu_metrics_tbl.m_xgmi_write_data_acc) - + std::begin(m_gpu_metrics_tbl.m_xgmi_write_data_acc)); + std::copy_n(std::begin(m_gpu_metrics_tbl.m_xgmi_write_data_acc), + xgmi_write_data_num_elems, + metrics_public_init.xgmi_write_data_acc); + + // PMFW attached timestamp (10ns resolution) + metrics_public_init.firmware_timestamp = m_gpu_metrics_tbl.m_firmware_timestamp; + + // Current clocks + // current_gfxclk + const auto curr_gfxclk_num_elems = + static_cast( + std::end(m_gpu_metrics_tbl.m_current_gfxclk) - + std::begin(m_gpu_metrics_tbl.m_current_gfxclk)); + std::copy_n(std::begin(m_gpu_metrics_tbl.m_current_gfxclk), + curr_gfxclk_num_elems, + metrics_public_init.current_gfxclks); + + // current_socclk + const auto curr_socclk_num_elems = + static_cast( + std::end(m_gpu_metrics_tbl.m_current_socclk) - + std::begin(m_gpu_metrics_tbl.m_current_socclk)); + std::copy_n(std::begin(m_gpu_metrics_tbl.m_current_socclk), + curr_socclk_num_elems, + metrics_public_init.current_socclks); + + // current_vclk0 + const auto curr_vclk0_num_elems = + static_cast( + std::end(m_gpu_metrics_tbl.m_current_vclk0) - + std::begin(m_gpu_metrics_tbl.m_current_vclk0)); + std::copy_n(std::begin(m_gpu_metrics_tbl.m_current_vclk0), + curr_vclk0_num_elems, + metrics_public_init.current_vclk0s); + + // current_dclk0 + const auto curr_dclk0_num_elems = + static_cast( + std::end(m_gpu_metrics_tbl.m_current_dclk0) - + std::begin(m_gpu_metrics_tbl.m_current_dclk0)); + std::copy_n(std::begin(m_gpu_metrics_tbl.m_current_dclk0), + curr_dclk0_num_elems, + metrics_public_init.current_dclk0s); + + metrics_public_init.current_uclk = m_gpu_metrics_tbl.m_current_uclk; + + // + // Note: Backwards compatibility -> Handling extra/exception cases + // related to earlier versions (1.3) + metrics_public_init.current_gfxclk = metrics_public_init.current_gfxclks[0]; + metrics_public_init.average_gfxclk_frequency = metrics_public_init.current_gfxclks[0]; + + metrics_public_init.current_socclk = metrics_public_init.current_socclks[0]; + metrics_public_init.average_socclk_frequency = metrics_public_init.current_socclks[0]; + + metrics_public_init.current_vclk0 = metrics_public_init.current_vclk0s[0]; + metrics_public_init.average_vclk0_frequency = metrics_public_init.current_vclk0s[0]; + + metrics_public_init.current_vclk1 = metrics_public_init.current_vclk0s[1]; + metrics_public_init.average_vclk1_frequency = metrics_public_init.current_vclk0s[1]; + + metrics_public_init.current_dclk0 = metrics_public_init.current_dclk0s[0]; + metrics_public_init.average_dclk0_frequency = metrics_public_init.current_dclk0s[0]; + + metrics_public_init.current_dclk1 = metrics_public_init.current_dclk0s[1]; + metrics_public_init.average_dclk1_frequency = metrics_public_init.current_dclk0s[1]; + + return metrics_public_init; + }(); + + ostrstream << __PRETTY_FUNCTION__ + << " | ======= end ======= " + << " | Success " + << " | Returning = " << getRSMIStatusString(status_code) + << " |"; + LOG_TRACE(ostrstream); + + return std::make_tuple(status_code, copy_data_from_internal_metrics_tbl); +} AMGpuMetricsPublicLatestTupl_t GpuMetricsBase_v14_t::copy_internal_to_external_metrics() { @@ -2144,11 +2681,9 @@ rsmi_status_t Device::dev_read_gpu_metrics_header_data() // 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)) || - ((now_ts - m_gpu_metrics_updated_timestamp) >= - kRSMI_GPU_METRICS_EXPIRATION_SECS)) { + if ((!m_gpu_metrics_header.m_structure_size) || + (!m_gpu_metrics_header.m_format_revision) || + (!m_gpu_metrics_header.m_content_revision)) { auto op_result = readDevInfo(DevInfoTypes::kDevGpuMetrics, sizeof(AMDGpuMetricsHeader_v1_t), &m_gpu_metrics_header); diff --git a/tests/rocm_smi_test/functional/gpu_metrics_read.cc b/tests/rocm_smi_test/functional/gpu_metrics_read.cc index 30c6d1fd..a3fa8af4 100644 --- a/tests/rocm_smi_test/functional/gpu_metrics_read.cc +++ b/tests/rocm_smi_test/functional/gpu_metrics_read.cc @@ -191,11 +191,16 @@ void TestGpuMetricsRead::Run(void) { std::cout << "\tindep_throttle_status=" << std::dec << smu.indep_throttle_status << '\n'; std::cout << "\tcurrent_socket_power=" << std::dec << smu.current_socket_power << '\n'; - for (int i = 0; i < RSMI_MAX_NUM_VCN; ++i) { + for (int i = 0; i < RSMI_MAX_NUM_VCNS; ++i) { std::cout << "\tvcn_activity[" << i << "]=" << std::dec << smu.vcn_activity[i] << '\n'; } + std::cout << "\n"; + for (int i = 0; i < RSMI_MAX_NUM_JPEG_ENGS; ++i) { + std::cout << "\tjpeg_activity[" << i << "]=" << std::dec << smu.jpeg_activity[i] << '\n'; + } std::cout << "\n"; + std::cout << "\tgfxclk_lock_status=" << std::dec << smu.gfxclk_lock_status << '\n'; std::cout << "\txgmi_link_width=" << std::dec << smu.xgmi_link_width << '\n'; std::cout << "\txgmi_link_speed=" << std::dec << smu.xgmi_link_speed << '\n'; @@ -349,6 +354,13 @@ void TestGpuMetricsRead::Run(void) { } 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) { @@ -538,6 +550,20 @@ void TestGpuMetricsRead::Run(void) { } 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) { @@ -631,6 +657,8 @@ void TestGpuMetricsRead::Run(void) { 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"; @@ -677,6 +705,8 @@ void TestGpuMetricsRead::Run(void) { 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"; diff --git a/tests/rocm_smi_test/functional/measure_api_execution_time.cc b/tests/rocm_smi_test/functional/measure_api_execution_time.cc index ff471cb2..e8bc54b0 100644 --- a/tests/rocm_smi_test/functional/measure_api_execution_time.cc +++ b/tests/rocm_smi_test/functional/measure_api_execution_time.cc @@ -173,6 +173,7 @@ void TestMeasureApiExecutionTime::Run(void) { 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; @@ -420,6 +421,23 @@ void TestMeasureApiExecutionTime::Run(void) { 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(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); @@ -879,6 +897,41 @@ void TestMeasureApiExecutionTime::Run(void) { 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(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(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); @@ -1052,7 +1105,7 @@ void TestMeasureApiExecutionTime::Run(void) { stop = std::chrono::high_resolution_clock::now(); duration = std::chrono::duration_cast(stop - start); if (!skip) { - const auto kTOTAL_GPU_METRICS_APIS = uint16_t(52); + 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));