rocm_smi_lib: Fix gpu_metrics_v1_5 support
Adds support and implement APIs for 'gpu_metrics_v1_5' Code changes related to the following: * gpu metrics 1.5 support * Unit tests * Examples Build changes related to the following: None Change-Id: Ie8917dd63c1dd1a94467b100fa44b634cebe62b6 Signed-off-by: Oliveira, Daniel <daniel.oliveira@amd.com>
This commit is contained in:
Oliveira, Daniel
@@ -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_VCN 4
|
||||
#define RSMI_MAX_NUM_VCNS 4
|
||||
|
||||
/**
|
||||
* @brief This should match kRSMI_MAX_JPEG_ENGINES
|
||||
*/
|
||||
#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
|
||||
*
|
||||
|
||||
@@ -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<uint16_t, AMDGpuMetricVersionFlags_t>;
|
||||
using GpuMetricTypePtr_t = std::shared_ptr<void>;
|
||||
@@ -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<AMDGpuMetrics_v15_t> m_gpu_metric_ptr;
|
||||
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
rsmi_status_t rsmi_dev_gpu_metrics_info_query(uint32_t dv_ind, AMDGpuMetricsUnitType_t metric_counter, T& metric_value);
|
||||
|
||||
@@ -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";
|
||||
|
||||
+101
-8
@@ -6334,6 +6334,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<AMDGpuMetricTypeId_t>(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<AMDGpuMetricTypeId_t>(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)
|
||||
{
|
||||
@@ -6392,7 +6446,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);
|
||||
}
|
||||
|
||||
@@ -6431,7 +6485,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);
|
||||
}
|
||||
|
||||
@@ -6439,6 +6493,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<uint16_t>(std::end(*jpeg_activity_value) - std::begin(*jpeg_activity_value));
|
||||
const auto copy_size =
|
||||
static_cast<uint16_t>((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<AMDGpuMetricTypeId_t>(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)
|
||||
{
|
||||
@@ -6470,7 +6563,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);
|
||||
}
|
||||
|
||||
@@ -6509,7 +6602,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);
|
||||
}
|
||||
|
||||
@@ -6548,7 +6641,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);
|
||||
}
|
||||
|
||||
@@ -6586,7 +6679,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);
|
||||
}
|
||||
|
||||
@@ -6625,7 +6718,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);
|
||||
}
|
||||
|
||||
@@ -6691,7 +6784,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);
|
||||
}
|
||||
|
||||
|
||||
+556
-21
@@ -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>(GpuMetricsBase_v12_t{})},
|
||||
{AMDGpuMetricVersionFlags_t::kGpuMetricV13, std::make_shared<GpuMetricsBase_v13_t>(GpuMetricsBase_v13_t{})},
|
||||
{AMDGpuMetricVersionFlags_t::kGpuMetricV14, std::make_shared<GpuMetricsBase_v14_t>(GpuMetricsBase_v14_t{})},
|
||||
{AMDGpuMetricVersionFlags_t::kGpuMetricV15, std::make_shared<GpuMetricsBase_v15_t>(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::uint16_t>());
|
||||
|
||||
std::fill(std::begin(rsmi_gpu_metrics.jpeg_activity),
|
||||
std::end(rsmi_gpu_metrics.jpeg_activity),
|
||||
init_max_uint_types<std::uint16_t>());
|
||||
|
||||
rsmi_gpu_metrics.gfxclk_lock_status = init_max_uint_types<decltype(rsmi_gpu_metrics.gfxclk_lock_status)>();
|
||||
rsmi_gpu_metrics.xgmi_link_width = init_max_uint_types<decltype(rsmi_gpu_metrics.xgmi_link_width)>();
|
||||
rsmi_gpu_metrics.xgmi_link_speed = init_max_uint_types<decltype(rsmi_gpu_metrics.xgmi_link_speed)>();
|
||||
@@ -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<std::uint16_t>());
|
||||
|
||||
rsmi_gpu_metrics.pcie_nak_sent_count_acc = init_max_uint_types<decltype(rsmi_gpu_metrics.pcie_nak_sent_count_acc)>();
|
||||
rsmi_gpu_metrics.pcie_nak_rcvd_count_acc = init_max_uint_types<decltype(rsmi_gpu_metrics.pcie_nak_rcvd_count_acc)>();
|
||||
|
||||
|
||||
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<uint16_t>(
|
||||
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<uint16_t>(
|
||||
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<uint16_t>(
|
||||
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<uint16_t>(
|
||||
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<uint16_t>(
|
||||
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<uint16_t>(
|
||||
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<uint16_t>(
|
||||
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<uint16_t>(
|
||||
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);
|
||||
|
||||
@@ -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";
|
||||
|
||||
@@ -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<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);
|
||||
@@ -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<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);
|
||||
@@ -1052,7 +1105,7 @@ 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(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));
|
||||
|
||||
Referens i nytt ärende
Block a user