AI/rocm-systems
2
0 Forc 0
Cód Saincheisteanna Iarratais Tarraingthe Gníomhartha Pacáistí Tionscadail Scaoileann Vicí Gníomhaíocht

LINT: Add cpplint, clang-format and pre-commit support

Brabhsáil Foinse 
Change-Id: I3cbb787ef27d90486b212dfb1a8c77c460acc2ac
Signed-off-by: Galantsev, Dmitrii <dmitrii.galantsev@amd.com>
Tá an tiomantas seo le fáil i:
Galantsev, Dmitrii tiomanta 2024-01-09 11:37:11 -06:00
1 tuismitheoir 95e057c88d
tiomantas 434e40305d
137 comhad athraithe
+9122 -10469
Íoslódáil an comhad paiste Íoslódáil Comhad Diff Leathnaigh gach comhaid Laghdaigh gach comhaid

Níor tháinig aon chomhaid le do chuardach

include/rdc/rdc.h
Inrite → Rialta
+247 -268
Féach ar an gComhad
@@ -51,26 +51,26 @@ extern "C" {
* @brief Error codes returned by rocm_rdc_lib functions
*/
typedef enum {
RDC_ST_OK = 0, //!< Success
RDC_ST_NOT_SUPPORTED, //!< Not supported feature
RDC_ST_MSI_ERROR, //!< The MSI library error
RDC_ST_FAIL_LOAD_MODULE, //!< Fail to load the library
RDC_ST_INVALID_HANDLER, //!< Invalid handler
RDC_ST_BAD_PARAMETER, //!< A parameter is invalid
RDC_ST_NOT_FOUND, //!< Cannot find the value
RDC_ST_CONFLICT, //!< Conflict with current state
RDC_ST_CLIENT_ERROR, //!< The RDC client error
RDC_ST_ALREADY_EXIST, //!< The item already exists
RDC_ST_MAX_LIMIT, //!< Max limit recording for the object
RDC_ST_INSUFF_RESOURCES, //!< Not enough resources to complete
//!< operation
RDC_ST_FILE_ERROR, //!< Failed to access a file
RDC_ST_NO_DATA, //!< Data was requested,
//!< but none was found
RDC_ST_PERM_ERROR, //!< Insufficient permission to complete
//!< operation
RDC_ST_OK = 0, //!< Success
RDC_ST_NOT_SUPPORTED, //!< Not supported feature
RDC_ST_MSI_ERROR, //!< The MSI library error
RDC_ST_FAIL_LOAD_MODULE, //!< Fail to load the library
RDC_ST_INVALID_HANDLER, //!< Invalid handler
RDC_ST_BAD_PARAMETER, //!< A parameter is invalid
RDC_ST_NOT_FOUND, //!< Cannot find the value
RDC_ST_CONFLICT, //!< Conflict with current state
RDC_ST_CLIENT_ERROR, //!< The RDC client error
RDC_ST_ALREADY_EXIST, //!< The item already exists
RDC_ST_MAX_LIMIT, //!< Max limit recording for the object
RDC_ST_INSUFF_RESOURCES, //!< Not enough resources to complete
//!< operation
RDC_ST_FILE_ERROR, //!< Failed to access a file
RDC_ST_NO_DATA, //!< Data was requested,
//!< but none was found
RDC_ST_PERM_ERROR, //!< Insufficient permission to complete
//!< operation
RDC_ST_UNKNOWN_ERROR = 0xFFFFFFFF //!< Unknown error
RDC_ST_UNKNOWN_ERROR = 0xFFFFFFFF //!< Unknown error
} rdc_status_t;
/**
@@ -79,51 +79,42 @@ typedef enum {
* When run in manual mode, the user needs to periodically call
* rdc_field_update_all for data collection.
*/
typedef enum {
RDC_OPERATION_MODE_AUTO = 0,
RDC_OPERATION_MODE_MANUAL
} rdc_operation_mode_t;
typedef enum { RDC_OPERATION_MODE_AUTO = 0, RDC_OPERATION_MODE_MANUAL } rdc_operation_mode_t;
/**
* @brief type of GPU group
*/
typedef enum {
RDC_GROUP_DEFAULT = 0, //!< All GPUs on the Node
RDC_GROUP_EMPTY //!< Empty group
RDC_GROUP_DEFAULT = 0, //!< All GPUs on the Node
RDC_GROUP_EMPTY //!< Empty group
} rdc_group_type_t;
/**
* @brief the type stored in the filed value
*/
typedef enum {
INTEGER = 0,
DOUBLE,
STRING,
BLOB
} rdc_field_type_t;
typedef enum { INTEGER = 0, DOUBLE, STRING, BLOB } rdc_field_type_t;
//! ID used to represent an invalid GPU
#define GPU_ID_INVALID (-1)
#define GPU_ID_INVALID (-1)
//! Used to specify all GPUs
#define RDC_GROUP_ALL_GPUS (-1000)
#define RDC_GROUP_ALL_GPUS (-1000)
//! Used to specify all stats fields
#define RDC_JOB_STATS_FIELDS (-1000)
#define RDC_JOB_STATS_FIELDS (-1000)
/**
* @brief The max rdc field string length
*/
#define RDC_MAX_STR_LENGTH 256
#define RDC_MAX_STR_LENGTH 256
/**
* @brief The max entities in a group
*/
#define RDC_GROUP_MAX_ENTITIES 64
#define RDC_GROUP_MAX_ENTITIES 64
/**
* @brief Max number of GPUs supported by RDC
*/
#define RDC_MAX_NUM_DEVICES 16
#define RDC_MAX_NUM_DEVICES 16
/**
* @brief The max fields in a field group
@@ -133,7 +124,7 @@ typedef enum {
/**
* @brief The max number of groups
*/
#define RDC_MAX_NUM_GROUPS 64
#define RDC_MAX_NUM_GROUPS 64
/**
* @brief The max number of the field groups
@@ -144,112 +135,112 @@ typedef enum {
* These enums are used to specify a particular field to be retrieved.
*/
typedef enum {
RDC_FI_INVALID = 0, //!< Invalid field value
RDC_FI_INVALID = 0, //!< Invalid field value
//!< @brief Identifier fields
RDC_FI_GPU_COUNT = 1, //!< GPU count in the system
RDC_FI_DEV_NAME, //!< Name of the device
RDC_FI_GPU_COUNT = 1, //!< GPU count in the system
RDC_FI_DEV_NAME, //!< Name of the device
/*
* @brief Frequency related fields
*/
RDC_FI_GPU_CLOCK = 100, //!< The current clock for the GPU
RDC_FI_MEM_CLOCK, //!< Clock for the memory
RDC_FI_GPU_CLOCK = 100, //!< The current clock for the GPU
RDC_FI_MEM_CLOCK, //!< Clock for the memory
/*
* @brief Physical monitor fields
*/
RDC_FI_MEMORY_TEMP = 200, //!< Memory temperature for the device
RDC_FI_GPU_TEMP, //!< Current temperature for the device
RDC_FI_POWER_USAGE = 300, //!< Power usage for the device
RDC_FI_MEMORY_TEMP = 200, //!< Memory temperature for the device
RDC_FI_GPU_TEMP, //!< Current temperature for the device
RDC_FI_POWER_USAGE = 300, //!< Power usage for the device
/*
* @brief PCIe related fields
*/
RDC_FI_PCIE_TX = 400, //!< PCIe Tx utilization information
RDC_FI_PCIE_RX, //!< PCIe Rx utilization information
RDC_FI_PCIE_TX = 400, //!< PCIe Tx utilization information
RDC_FI_PCIE_RX, //!< PCIe Rx utilization information
/*
* @brief GPU usage related fields
*/
RDC_FI_GPU_UTIL = 500, //!< GPU Utilization
RDC_FI_GPU_MEMORY_USAGE, //!< Memory usage of the GPU instance
RDC_FI_GPU_MEMORY_TOTAL, //!< Total memory of the GPU instance
RDC_FI_GPU_UTIL = 500, //!< GPU Utilization
RDC_FI_GPU_MEMORY_USAGE, //!< Memory usage of the GPU instance
RDC_FI_GPU_MEMORY_TOTAL, //!< Total memory of the GPU instance
/**
* @brief ECC related fields
*/
RDC_FI_ECC_CORRECT_TOTAL = 600, //!< Accumulated correctable ECC errors
RDC_FI_ECC_UNCORRECT_TOTAL, //!< Accumulated uncorrectable ECC errors
RDC_FI_ECC_CORRECT_TOTAL = 600, //!< Accumulated correctable ECC errors
RDC_FI_ECC_UNCORRECT_TOTAL, //!< Accumulated uncorrectable ECC errors
RDC_FI_ECC_SDMA_SEC, //!< SDMA Single Error Correction
RDC_FI_ECC_SDMA_DED, //!< SDMA Double Error Detection
RDC_FI_ECC_SDMA_SEC, //!< SDMA Single Error Correction
RDC_FI_ECC_SDMA_DED, //!< SDMA Double Error Detection
RDC_FI_ECC_GFX_SEC, //!< GFX Single Error Correction
RDC_FI_ECC_GFX_DED, //!< GFX Double Error Detection
RDC_FI_ECC_GFX_SEC, //!< GFX Single Error Correction
RDC_FI_ECC_GFX_DED, //!< GFX Double Error Detection
RDC_FI_ECC_MMHUB_SEC, //!< MMHUB Single Error Correction
RDC_FI_ECC_MMHUB_DED, //!< MMHUB Double Error Detection
RDC_FI_ECC_MMHUB_SEC, //!< MMHUB Single Error Correction
RDC_FI_ECC_MMHUB_DED, //!< MMHUB Double Error Detection
RDC_FI_ECC_ATHUB_SEC, //!< ATHUB Single Error Correction
RDC_FI_ECC_ATHUB_DED, //!< ATHUB Double Error Detection
RDC_FI_ECC_ATHUB_SEC, //!< ATHUB Single Error Correction
RDC_FI_ECC_ATHUB_DED, //!< ATHUB Double Error Detection
RDC_FI_ECC_BIF_SEC, //!< BIF Single Error Correction
RDC_FI_ECC_BIF_DED, //!< BIF Double Error Detection
RDC_FI_ECC_BIF_SEC, //!< BIF Single Error Correction
RDC_FI_ECC_BIF_DED, //!< BIF Double Error Detection
RDC_FI_ECC_HDP_SEC, //!< HDP Single Error Correction
RDC_FI_ECC_HDP_DED, //!< HDP Double Error Detection
RDC_FI_ECC_HDP_SEC, //!< HDP Single Error Correction
RDC_FI_ECC_HDP_DED, //!< HDP Double Error Detection
RDC_FI_ECC_XGMI_WAFL_SEC, //!< XGMI WAFL Single Error Correction
RDC_FI_ECC_XGMI_WAFL_DED, //!< XGMI WAFL Double Error Detection
RDC_FI_ECC_XGMI_WAFL_SEC, //!< XGMI WAFL Single Error Correction
RDC_FI_ECC_XGMI_WAFL_DED, //!< XGMI WAFL Double Error Detection
RDC_FI_ECC_DF_SEC, //!< DF Single Error Correction
RDC_FI_ECC_DF_DED, //!< DF Double Error Detection
RDC_FI_ECC_DF_SEC, //!< DF Single Error Correction
RDC_FI_ECC_DF_DED, //!< DF Double Error Detection
RDC_FI_ECC_SMN_SEC, //!< SMN Single Error Correction
RDC_FI_ECC_SMN_DED, //!< SMN Double Error Detection
RDC_FI_ECC_SMN_SEC, //!< SMN Single Error Correction
RDC_FI_ECC_SMN_DED, //!< SMN Double Error Detection
RDC_FI_ECC_SEM_SEC, //!< SEM Single Error Correction
RDC_FI_ECC_SEM_DED, //!< SEM Double Error Detection
RDC_FI_ECC_SEM_SEC, //!< SEM Single Error Correction
RDC_FI_ECC_SEM_DED, //!< SEM Double Error Detection
RDC_FI_ECC_MP0_SEC, //!< MP0 Single Error Correction
RDC_FI_ECC_MP0_DED, //!< MP0 Double Error Detection
RDC_FI_ECC_MP0_SEC, //!< MP0 Single Error Correction
RDC_FI_ECC_MP0_DED, //!< MP0 Double Error Detection
RDC_FI_ECC_MP1_SEC, //!< MP1 Single Error Correction
RDC_FI_ECC_MP1_DED, //!< MP1 Double Error Detection
RDC_FI_ECC_MP1_SEC, //!< MP1 Single Error Correction
RDC_FI_ECC_MP1_DED, //!< MP1 Double Error Detection
RDC_FI_ECC_FUSE_SEC, //!< FUSE Single Error Correction
RDC_FI_ECC_FUSE_DED, //!< FUSE Double Error Detection
RDC_FI_ECC_FUSE_SEC, //!< FUSE Single Error Correction
RDC_FI_ECC_FUSE_DED, //!< FUSE Double Error Detection
RDC_FI_ECC_UMC_SEC, //!< UMC Single Error Correction
RDC_FI_ECC_UMC_DED, //!< UMC Double Error Detection
RDC_FI_ECC_UMC_SEC, //!< UMC Single Error Correction
RDC_FI_ECC_UMC_DED, //!< UMC Double Error Detection
/**
* @brief ROC-profiler related fields
*/
RDC_FI_PROF_ELAPSED_CYCLES = 700, //!< Number of elapsed cycles over all SMs
RDC_FI_PROF_ACTIVE_WAVES, //!< Number of Active Waves
RDC_FI_PROF_ACTIVE_CYCLES, //!< Number of Active Cycles
RDC_FI_PROF_CU_OCCUPANCY, //!< Active Waves / maximum active Waves supported
RDC_FI_PROF_CU_UTILIZATION, //!< Total active cycles / Total elapsed cycles
RDC_FI_PROF_FETCH_SIZE, //!< Number of kilobytes fetched from video memory
RDC_FI_PROF_WRITE_SIZE, //!< Number of kilobytes written to video memory
RDC_FI_PROF_FLOPS_16, //!< Number of fp16 OPS / second
RDC_FI_PROF_FLOPS_32, //!< Number of fp32 OPS / second
RDC_FI_PROF_FLOPS_64, //!< Number of fp64 OPS / second
RDC_FI_PROF_GFLOPS_16, //!< Number of fp16 GOPS / second
RDC_FI_PROF_GFLOPS_32, //!< Number of fp32 GOPS / second
RDC_FI_PROF_GFLOPS_64, //!< Number of fp64 GOPS / second
RDC_FI_PROF_MEMR_BW_KBPNS, //!< HBM Read Bandwidth in kilobytes / nanosecond
RDC_FI_PROF_MEMW_BW_KBPNS, //!< HBM Write Bandwidth in kilobytes / nanosecond
RDC_FI_PROF_ELAPSED_CYCLES = 700, //!< Number of elapsed cycles over all SMs
RDC_FI_PROF_ACTIVE_WAVES, //!< Number of Active Waves
RDC_FI_PROF_ACTIVE_CYCLES, //!< Number of Active Cycles
RDC_FI_PROF_CU_OCCUPANCY, //!< Active Waves / maximum active Waves supported
RDC_FI_PROF_CU_UTILIZATION, //!< Total active cycles / Total elapsed cycles
RDC_FI_PROF_FETCH_SIZE, //!< Number of kilobytes fetched from video memory
RDC_FI_PROF_WRITE_SIZE, //!< Number of kilobytes written to video memory
RDC_FI_PROF_FLOPS_16, //!< Number of fp16 OPS / second
RDC_FI_PROF_FLOPS_32, //!< Number of fp32 OPS / second
RDC_FI_PROF_FLOPS_64, //!< Number of fp64 OPS / second
RDC_FI_PROF_GFLOPS_16, //!< Number of fp16 GOPS / second
RDC_FI_PROF_GFLOPS_32, //!< Number of fp32 GOPS / second
RDC_FI_PROF_GFLOPS_64, //!< Number of fp64 GOPS / second
RDC_FI_PROF_MEMR_BW_KBPNS, //!< HBM Read Bandwidth in kilobytes / nanosecond
RDC_FI_PROF_MEMW_BW_KBPNS, //!< HBM Write Bandwidth in kilobytes / nanosecond
/*
* @brief Raw XGMI counter events
*/
RDC_EVNT_XGMI_0_NOP_TX = 1000, //!< NOPs sent to neighbor 0
RDC_EVNT_XGMI_0_REQ_TX, //!< Outgoing requests to
//!< neighbor 0
RDC_EVNT_XGMI_0_RESP_TX, //!< Outgoing responses to
//!< neighbor 0
RDC_EVNT_XGMI_0_NOP_TX = 1000, //!< NOPs sent to neighbor 0
RDC_EVNT_XGMI_0_REQ_TX, //!< Outgoing requests to
//!< neighbor 0
RDC_EVNT_XGMI_0_RESP_TX, //!< Outgoing responses to
//!< neighbor 0
/**
* @brief
*
@@ -265,37 +256,37 @@ typedef enum {
*/
// ie, Throughput = BEATS/time_running 10^9 bytes/sec
RDC_EVNT_XGMI_0_BEATS_TX,
RDC_EVNT_XGMI_1_NOP_TX, //!< NOPs sent to neighbor 1
RDC_EVNT_XGMI_1_REQ_TX, //!< Outgoing requests to
//!< neighbor 1
RDC_EVNT_XGMI_1_RESP_TX, //!< Outgoing responses to
//!< neighbor 1
RDC_EVNT_XGMI_1_BEATS_TX, //!< Data beats sent to
//!< neighbor 1; Each beat
//!< represents 32 bytes
RDC_EVNT_XGMI_1_NOP_TX, //!< NOPs sent to neighbor 1
RDC_EVNT_XGMI_1_REQ_TX, //!< Outgoing requests to
//!< neighbor 1
RDC_EVNT_XGMI_1_RESP_TX, //!< Outgoing responses to
//!< neighbor 1
RDC_EVNT_XGMI_1_BEATS_TX, //!< Data beats sent to
//!< neighbor 1; Each beat
//!< represents 32 bytes
// "Composite" events. These events have additional processing beyond
// the value provided by the rocm_smi library.
RDC_EVNT_XGMI_0_THRPUT = 1500, //!< Transmit throughput to XGMI
//!< neighbor 0 in byes/sec
RDC_EVNT_XGMI_1_THRPUT, //!< Transmit throughput to XGMI
//!< neighbor 1 in byes/sec
RDC_EVNT_XGMI_2_THRPUT, //!< Transmit throughput to XGMI
//!< neighbor 2 in byes/sec
RDC_EVNT_XGMI_3_THRPUT, //!< Transmit throughput to XGMI
//!< neighbor 3 in byes/sec
RDC_EVNT_XGMI_4_THRPUT, //!< Transmit throughput to XGMI
//!< neighbor 4 in byes/sec
RDC_EVNT_XGMI_5_THRPUT, //!< Transmit throughput to XGMI
//!< neighbor 5 in byes/sec
RDC_EVNT_XGMI_0_THRPUT = 1500, //!< Transmit throughput to XGMI
//!< neighbor 0 in byes/sec
RDC_EVNT_XGMI_1_THRPUT, //!< Transmit throughput to XGMI
//!< neighbor 1 in byes/sec
RDC_EVNT_XGMI_2_THRPUT, //!< Transmit throughput to XGMI
//!< neighbor 2 in byes/sec
RDC_EVNT_XGMI_3_THRPUT, //!< Transmit throughput to XGMI
//!< neighbor 3 in byes/sec
RDC_EVNT_XGMI_4_THRPUT, //!< Transmit throughput to XGMI
//!< neighbor 4 in byes/sec
RDC_EVNT_XGMI_5_THRPUT, //!< Transmit throughput to XGMI
//!< neighbor 5 in byes/sec
RDC_EVNT_NOTIF_VMFAULT = 2000, //!< VM page fault
RDC_EVNT_NOTIF_VMFAULT = 2000, //!< VM page fault
RDC_EVNT_NOTIF_FIRST = RDC_EVNT_NOTIF_VMFAULT,
RDC_EVNT_NOTIF_THERMAL_THROTTLE, //!< Clock frequency has decreased
//!< due to temperature rise
RDC_EVNT_NOTIF_PRE_RESET, //!< GPU reset is about to occur
RDC_EVNT_NOTIF_POST_RESET, //!< GPU reset just occurred
RDC_EVNT_NOTIF_THERMAL_THROTTLE, //!< Clock frequency has decreased
//!< due to temperature rise
RDC_EVNT_NOTIF_PRE_RESET, //!< GPU reset is about to occur
RDC_EVNT_NOTIF_POST_RESET, //!< GPU reset just occurred
RDC_EVNT_NOTIF_LAST = RDC_EVNT_NOTIF_POST_RESET,
} rdc_field_t;
@@ -304,153 +295,153 @@ typedef enum {
/**
* @brief handlers used in various rdc calls
*/
typedef void *rdc_handle_t; //!< Handle used for an RDC session
typedef uint32_t rdc_gpu_group_t; //!< GPU Group ID type
typedef uint32_t rdc_field_grp_t; //!< Field group ID type
typedef void* rdc_handle_t; //!< Handle used for an RDC session
typedef uint32_t rdc_gpu_group_t; //!< GPU Group ID type
typedef uint32_t rdc_field_grp_t; //!< Field group ID type
/**
* @brief Represents attributes corresponding to a device
*/
typedef struct {
char device_name[RDC_MAX_STR_LENGTH]; //!< Name of the device.
char device_name[RDC_MAX_STR_LENGTH]; //!< Name of the device.
} rdc_device_attributes_t;
/**
* @brief The structure to store the group info
*/
typedef struct {
unsigned int count; //!< count of GPUs in the group
char group_name[RDC_MAX_STR_LENGTH]; //!< group name
/**
* The list of entities in the group
*/
uint32_t entity_ids[RDC_GROUP_MAX_ENTITIES];
unsigned int count; //!< count of GPUs in the group
char group_name[RDC_MAX_STR_LENGTH]; //!< group name
/**
* The list of entities in the group
*/
uint32_t entity_ids[RDC_GROUP_MAX_ENTITIES];
} rdc_group_info_t;
/**
* @brief The structure to store summary of data
*/
typedef struct {
uint64_t max_value; //!< Maximum value measured
uint64_t min_value; //!< Minimum value measured
uint64_t average; //!< Average value measured
double standard_deviation; //!< The standard deviation
uint64_t max_value; //!< Maximum value measured
uint64_t min_value; //!< Minimum value measured
uint64_t average; //!< Average value measured
double standard_deviation; //!< The standard deviation
} rdc_stats_summary_t;
/**
* @brief The structure to hold the GPU usage information
*/
typedef struct {
uint32_t gpu_id; //!< GPU_ID_INVALID for summary information
uint64_t start_time; //!< The time to start the watching
uint64_t end_time; //!< The time to stop the watching
uint32_t gpu_id; //!< GPU_ID_INVALID for summary information
uint64_t start_time; //!< The time to start the watching
uint64_t end_time; //!< The time to stop the watching
uint64_t energy_consumed; //!< GPU Energy consumed
uint64_t ecc_correct; //!< Correctable errors
uint64_t ecc_uncorrect; //!< Uncorrectable errors
rdc_stats_summary_t pcie_tx; //!< Bytes sent over PCIe stats
rdc_stats_summary_t pcie_rx; //!< Bytes received over PCIe stats
rdc_stats_summary_t power_usage; //!< GPU Power usage stats
rdc_stats_summary_t gpu_clock; //!< GPU Clock speed stats
rdc_stats_summary_t memory_clock; //!< Mem. Clock speed stats
rdc_stats_summary_t gpu_utilization; //!< GPU Utilization stats
rdc_stats_summary_t gpu_temperature; //!< GPU temperature stats
uint64_t energy_consumed; //!< GPU Energy consumed
uint64_t ecc_correct; //!< Correctable errors
uint64_t ecc_uncorrect; //!< Uncorrectable errors
rdc_stats_summary_t pcie_tx; //!< Bytes sent over PCIe stats
rdc_stats_summary_t pcie_rx; //!< Bytes received over PCIe stats
rdc_stats_summary_t power_usage; //!< GPU Power usage stats
rdc_stats_summary_t gpu_clock; //!< GPU Clock speed stats
rdc_stats_summary_t memory_clock; //!< Mem. Clock speed stats
rdc_stats_summary_t gpu_utilization; //!< GPU Utilization stats
rdc_stats_summary_t gpu_temperature; //!< GPU temperature stats
uint64_t max_gpu_memory_used; //!< Maximum GPU memory used
rdc_stats_summary_t memory_utilization; //!< Memory Utilization statistics
} rdc_gpu_usage_info_t; //!< GPU usage statistics
uint64_t max_gpu_memory_used; //!< Maximum GPU memory used
rdc_stats_summary_t memory_utilization; //!< Memory Utilization statistics
} rdc_gpu_usage_info_t; //!< GPU usage statistics
/**
* @brief The structure to hold the job stats
*/
typedef struct {
uint32_t num_gpus; //!< Number of GPUs used by job
rdc_gpu_usage_info_t summary; //!< Job usage summary statistics
//!< (overall)
rdc_gpu_usage_info_t gpus[16]; //!< Job usage summary statistics by GPU
uint32_t num_gpus; //!< Number of GPUs used by job
rdc_gpu_usage_info_t summary; //!< Job usage summary statistics
//!< (overall)
rdc_gpu_usage_info_t gpus[16]; //!< Job usage summary statistics by GPU
} rdc_job_info_t;
/**
* @brief Field value data
*/
typedef union {
int64_t l_int;
double dbl;
char str[RDC_MAX_STR_LENGTH];
int64_t l_int;
double dbl;
char str[RDC_MAX_STR_LENGTH];
} rdc_field_value_data;
/**
* @brief The structure to store the field value
*/
typedef struct {
rdc_field_t field_id; //!< The field id of the value
int status; //!< RDC_ST_OK or error status
uint64_t ts; //!< Timestamp in usec since 1970
rdc_field_type_t type; //!< The field type
rdc_field_value_data value; //!< Value of the field. Value type
//!< depends on the field type.
rdc_field_t field_id; //!< The field id of the value
int status; //!< RDC_ST_OK or error status
uint64_t ts; //!< Timestamp in usec since 1970
rdc_field_type_t type; //!< The field type
rdc_field_value_data value; //!< Value of the field. Value type
//!< depends on the field type.
} rdc_field_value;
/**
* @brief The structure to store the field group info
*/
typedef struct {
uint32_t count; //!< count of fields in the group
char group_name[RDC_MAX_STR_LENGTH]; //!< field group name
/**
* The list of fields in the group
*/
rdc_field_t field_ids[RDC_MAX_FIELD_IDS_PER_FIELD_GROUP];
uint32_t count; //!< count of fields in the group
char group_name[RDC_MAX_STR_LENGTH]; //!< field group name
/**
* The list of fields in the group
*/
rdc_field_t field_ids[RDC_MAX_FIELD_IDS_PER_FIELD_GROUP];
} rdc_field_group_info_t;
/**
* @brief The structure to store the job info
*/
typedef struct {
char job_id[RDC_MAX_STR_LENGTH]; //!< job id
rdc_gpu_group_t group_id; //!< group name
uint64_t start_time; //!< job start time
uint64_t stop_time; //!< job stop time
char job_id[RDC_MAX_STR_LENGTH]; //!< job id
rdc_gpu_group_t group_id; //!< group name
uint64_t start_time; //!< job start time
uint64_t stop_time; //!< job stop time
} rdc_job_group_info_t;
/**
* @brief type of diagnostic level
*/
typedef enum {
RDC_DIAG_LVL_INVALID = 0, //!< invalid level
RDC_DIAG_LVL_SHORT, //!< take a few seconds to run
RDC_DIAG_LVL_MED, //!< take less than 2 minutes to run
RDC_DIAG_LVL_LONG //!< take up to 15 minutes to run
RDC_DIAG_LVL_INVALID = 0, //!< invalid level
RDC_DIAG_LVL_SHORT, //!< take a few seconds to run
RDC_DIAG_LVL_MED, //!< take less than 2 minutes to run
RDC_DIAG_LVL_LONG //!< take up to 15 minutes to run
} rdc_diag_level_t;
/**
* @brief type of diagnostic result
*/
typedef enum {
RDC_DIAG_RESULT_PASS, //!< The diagnostic test pass
RDC_DIAG_RESULT_SKIP, //!< The diagnostic test skipped
RDC_DIAG_RESULT_WARN, //!< The diagnostic test has warnings
RDC_DIAG_RESULT_FAIL //!< The diagnostic test fail
RDC_DIAG_RESULT_PASS, //!< The diagnostic test pass
RDC_DIAG_RESULT_SKIP, //!< The diagnostic test skipped
RDC_DIAG_RESULT_WARN, //!< The diagnostic test has warnings
RDC_DIAG_RESULT_FAIL //!< The diagnostic test fail
} rdc_diag_result_t;
/**
* @brief The test cases to run
*/
typedef enum {
RDC_DIAG_TEST_FIRST = 0,
//!< The diagnostic test pass
RDC_DIAG_COMPUTE_PROCESS = RDC_DIAG_TEST_FIRST,
RDC_DIAG_COMPUTE_QUEUE, //!< The Compute Queue is ready
RDC_DIAG_SYS_MEM_CHECK, //!< Check System memory
RDC_DIAG_NODE_TOPOLOGY, //!< Report node topology
RDC_DIAG_GPU_PARAMETERS, //!< GPU parameters in range
RDC_DIAG_TEST_LAST = RDC_DIAG_GPU_PARAMETERS
RDC_DIAG_TEST_FIRST = 0,
//!< The diagnostic test pass
RDC_DIAG_COMPUTE_PROCESS = RDC_DIAG_TEST_FIRST,
RDC_DIAG_COMPUTE_QUEUE, //!< The Compute Queue is ready
RDC_DIAG_SYS_MEM_CHECK, //!< Check System memory
RDC_DIAG_NODE_TOPOLOGY, //!< Report node topology
RDC_DIAG_GPU_PARAMETERS, //!< GPU parameters in range
RDC_DIAG_TEST_LAST = RDC_DIAG_GPU_PARAMETERS
} rdc_diag_test_cases_t;
/**
* @brief The maximum test cases to run
*/
#define MAX_TEST_CASES (RDC_DIAG_TEST_LAST - RDC_DIAG_TEST_FIRST + 1)
#define MAX_TEST_CASES (RDC_DIAG_TEST_LAST - RDC_DIAG_TEST_FIRST + 1)
/**
* @brief The maximum length of the diagnostic messages
@@ -461,39 +452,39 @@ typedef enum {
* @brief details of the diagnostic errors
*/
typedef struct {
char msg[MAX_DIAG_MSG_LENGTH]; //!< The test result details
uint32_t code; //!< The low level error code
char msg[MAX_DIAG_MSG_LENGTH]; //!< The test result details
uint32_t code; //!< The low level error code
} rdc_diag_detail_t;
/**
* @brief details of the per gpu diagnostic results
*/
typedef struct {
uint32_t gpu_index; //!< The GPU index
rdc_diag_detail_t gpu_result; //!< The detail results
uint32_t gpu_index; //!< The GPU index
rdc_diag_detail_t gpu_result; //!< The detail results
} rdc_diag_per_gpu_result_t;
/**
* @brief The diagnostic results for all GPUs
*/
typedef struct {
rdc_diag_result_t status; //!< The diagnostic result
rdc_diag_detail_t details; //!< The summary details
rdc_diag_test_cases_t test_case; //!< The test case to run
rdc_diag_result_t status; //!< The diagnostic result
rdc_diag_detail_t details; //!< The summary details
rdc_diag_test_cases_t test_case; //!< The test case to run
uint32_t per_gpu_result_count; //!< How many gpu_results
//!< Result details
rdc_diag_per_gpu_result_t gpu_results[RDC_MAX_NUM_DEVICES];
uint32_t per_gpu_result_count; //!< How many gpu_results
//!< Result details
rdc_diag_per_gpu_result_t gpu_results[RDC_MAX_NUM_DEVICES];
char info[MAX_DIAG_MSG_LENGTH]; //!< Detail information
char info[MAX_DIAG_MSG_LENGTH]; //!< Detail information
} rdc_diag_test_result_t;
/**
* @brief The diagnostic responses for test cases
*/
typedef struct {
uint32_t results_count;
rdc_diag_test_result_t diag_info[MAX_TEST_CASES];
uint32_t results_count;
rdc_diag_test_result_t diag_info[MAX_TEST_CASES];
} rdc_diag_response_t;
/**
@@ -524,17 +515,17 @@ rdc_status_t rdc_shutdown();
* rdc_field_update_all() when op_mode is RDC_OPERATION_MODE_MANUAL, which
* tells RDC to collect the stats.
*
* @param[in] op_mode Operation modes. When RDC_OPERATION_MODE_AUTO, RDC schedules
* background task to collect the stats. When RDC_OPERATION_MODE_MANUAL, the user
* needs to call rdc_field_update_all() periodically.
* @param[in] op_mode Operation modes. When RDC_OPERATION_MODE_AUTO, RDC
* schedules background task to collect the stats. When
* RDC_OPERATION_MODE_MANUAL, the user needs to call rdc_field_update_all()
* periodically.
*
* @param[inout] p_rdc_handle Caller provided pointer to rdc_handle_t. Upon
* successful call, the value will contain the handler for following API calls.
*
* @retval ::RDC_ST_OK is returned upon successful call.
*/
rdc_status_t rdc_start_embedded(rdc_operation_mode_t op_mode,
rdc_handle_t* p_rdc_handle);
rdc_status_t rdc_start_embedded(rdc_operation_mode_t op_mode, rdc_handle_t* p_rdc_handle);
/**
* @brief Stop embedded RDC agent.
@@ -573,8 +564,8 @@ rdc_status_t rdc_stop_embedded(rdc_handle_t p_rdc_handle);
*
* @retval ::RDC_ST_OK is returned upon successful call.
*/
rdc_status_t rdc_connect(const char *ipAndPort, rdc_handle_t* p_rdc_handle,
const char* root_ca, const char* client_cert, const char* client_key);
rdc_status_t rdc_connect(const char* ipAndPort, rdc_handle_t* p_rdc_handle, const char* root_ca,
const char* client_cert, const char* client_key);
/**
* @brief Disconnect from rdcd daemon.
@@ -606,8 +597,8 @@ rdc_status_t rdc_disconnect(rdc_handle_t p_rdc_handle);
*
* @retval ::RDC_ST_OK is returned upon successful call.
*/
rdc_status_t rdc_job_start_stats(rdc_handle_t p_rdc_handle,
rdc_gpu_group_t group_id, const char job_id[64], uint64_t update_freq);
rdc_status_t rdc_job_start_stats(rdc_handle_t p_rdc_handle, rdc_gpu_group_t group_id,
const char job_id[64], uint64_t update_freq);
/**
* @brief Get the stats of the job using the job id.
@@ -624,8 +615,8 @@ rdc_status_t rdc_job_start_stats(rdc_handle_t p_rdc_handle,
*
* @retval ::RDC_ST_OK is returned upon successful call.
*/
rdc_status_t rdc_job_get_stats(rdc_handle_t p_rdc_handle,
const char job_id[64], rdc_job_info_t* p_job_info);
rdc_status_t rdc_job_get_stats(rdc_handle_t p_rdc_handle, const char job_id[64],
rdc_job_info_t* p_job_info);
/**
* @brief Request RDC to stop watching the stats of the job
@@ -640,8 +631,7 @@ rdc_status_t rdc_job_get_stats(rdc_handle_t p_rdc_handle,
*
* @retval ::RDC_ST_OK is returned upon successful call.
*/
rdc_status_t rdc_job_stop_stats(rdc_handle_t p_rdc_handle,
const char job_id[64]);
rdc_status_t rdc_job_stop_stats(rdc_handle_t p_rdc_handle, const char job_id[64]);
/**
* @brief Request RDC to stop tracking the job given by job_id
@@ -684,8 +674,7 @@ rdc_status_t rdc_job_remove_all(rdc_handle_t p_rdc_handle);
*
* @retval ::RDC_ST_OK is returned upon successful call.
*/
rdc_status_t rdc_field_update_all(rdc_handle_t p_rdc_handle,
uint32_t wait_for_update);
rdc_status_t rdc_field_update_all(rdc_handle_t p_rdc_handle, uint32_t wait_for_update);
/**
* @brief Get indexes corresponding to all the devices on the system.
@@ -704,7 +693,7 @@ rdc_status_t rdc_field_update_all(rdc_handle_t p_rdc_handle,
* @retval ::RDC_ST_OK is returned upon successful call.
*/
rdc_status_t rdc_device_get_all(rdc_handle_t p_rdc_handle,
uint32_t gpu_index_list[RDC_MAX_NUM_DEVICES], uint32_t* count);
uint32_t gpu_index_list[RDC_MAX_NUM_DEVICES], uint32_t* count);
/**
* @brief Gets device attributes corresponding to the gpu_index.
@@ -720,8 +709,8 @@ rdc_status_t rdc_device_get_all(rdc_handle_t p_rdc_handle,
*
* @retval ::RDC_ST_OK is returned upon successful call.
*/
rdc_status_t rdc_device_get_attributes(rdc_handle_t p_rdc_handle,
uint32_t gpu_index, rdc_device_attributes_t* p_rdc_attr);
rdc_status_t rdc_device_get_attributes(rdc_handle_t p_rdc_handle, uint32_t gpu_index,
rdc_device_attributes_t* p_rdc_attr);
/**
* @brief Create a group contains multiple GPUs
@@ -744,9 +733,8 @@ rdc_status_t rdc_device_get_attributes(rdc_handle_t p_rdc_handle,
*
* @retval ::RDC_ST_OK is returned upon successful call.
*/
rdc_status_t rdc_group_gpu_create(rdc_handle_t p_rdc_handle,
rdc_group_type_t type, const char* group_name,
rdc_gpu_group_t* p_rdc_group_id);
rdc_status_t rdc_group_gpu_create(rdc_handle_t p_rdc_handle, rdc_group_type_t type,
const char* group_name, rdc_gpu_group_t* p_rdc_group_id);
/**
* @brief Add a GPU to the group
@@ -761,8 +749,8 @@ rdc_status_t rdc_group_gpu_create(rdc_handle_t p_rdc_handle,
*
* @retval ::RDC_ST_OK is returned upon successful call.
*/
rdc_status_t rdc_group_gpu_add(rdc_handle_t p_rdc_handle,
rdc_gpu_group_t group_id, uint32_t gpu_index);
rdc_status_t rdc_group_gpu_add(rdc_handle_t p_rdc_handle, rdc_gpu_group_t group_id,
uint32_t gpu_index);
/**
* @brief Get information about a GPU group
@@ -780,8 +768,8 @@ rdc_status_t rdc_group_gpu_add(rdc_handle_t p_rdc_handle,
*
* @retval ::RDC_ST_OK is returned upon successful call.
*/
rdc_status_t rdc_group_gpu_get_info(rdc_handle_t p_rdc_handle,
rdc_gpu_group_t p_rdc_group_id, rdc_group_info_t* p_rdc_group_info);
rdc_status_t rdc_group_gpu_get_info(rdc_handle_t p_rdc_handle, rdc_gpu_group_t p_rdc_group_id,
rdc_group_info_t* p_rdc_group_info);
/**
* @brief Used to get information about all GPU groups in the system.
@@ -797,8 +785,8 @@ rdc_status_t rdc_group_gpu_get_info(rdc_handle_t p_rdc_handle,
*
* @retval ::RDC_ST_OK is returned upon successful call.
*/
rdc_status_t rdc_group_get_all_ids(rdc_handle_t p_rdc_handle,
rdc_gpu_group_t group_id_list[], uint32_t* count);
rdc_status_t rdc_group_get_all_ids(rdc_handle_t p_rdc_handle, rdc_gpu_group_t group_id_list[],
uint32_t* count);
/**
* @brief Destroy GPU group represented by p_rdc_group_id
@@ -811,8 +799,7 @@ rdc_status_t rdc_group_get_all_ids(rdc_handle_t p_rdc_handle,
*
* @retval ::RDC_ST_OK is returned upon successful call.
*/
rdc_status_t rdc_group_gpu_destroy(rdc_handle_t p_rdc_handle,
rdc_gpu_group_t p_rdc_group_id);
rdc_status_t rdc_group_gpu_destroy(rdc_handle_t p_rdc_handle, rdc_gpu_group_t p_rdc_group_id);
/**
* @brief create a group of fields
@@ -834,9 +821,9 @@ rdc_status_t rdc_group_gpu_destroy(rdc_handle_t p_rdc_handle,
*
* @retval ::RDC_ST_OK is returned upon successful call.
*/
rdc_status_t rdc_group_field_create(rdc_handle_t p_rdc_handle,
uint32_t num_field_ids, rdc_field_t* field_ids,
const char* field_group_name, rdc_field_grp_t* rdc_field_group_id);
rdc_status_t rdc_group_field_create(rdc_handle_t p_rdc_handle, uint32_t num_field_ids,
rdc_field_t* field_ids, const char* field_group_name,
rdc_field_grp_t* rdc_field_group_id);
/**
* @brief Get information about a field group
@@ -854,9 +841,8 @@ rdc_status_t rdc_group_field_create(rdc_handle_t p_rdc_handle,
*
* @retval ::RDC_ST_OK is returned upon successful call.
*/
rdc_status_t rdc_group_field_get_info(rdc_handle_t p_rdc_handle,
rdc_field_grp_t rdc_field_group_id,
rdc_field_group_info_t* field_group_info);
rdc_status_t rdc_group_field_get_info(rdc_handle_t p_rdc_handle, rdc_field_grp_t rdc_field_group_id,
rdc_field_group_info_t* field_group_info);
/**
* @brief Used to get information about all field groups in the system.
@@ -873,7 +859,7 @@ rdc_status_t rdc_group_field_get_info(rdc_handle_t p_rdc_handle,
* @retval ::RDC_ST_OK is returned upon successful call.
*/
rdc_status_t rdc_group_field_get_all_ids(rdc_handle_t p_rdc_handle,
rdc_field_grp_t field_group_id_list[], uint32_t* count);
rdc_field_grp_t field_group_id_list[], uint32_t* count);
/**
* @brief Destroy field group represented by rdc_field_group_id
@@ -886,8 +872,7 @@ rdc_status_t rdc_group_field_get_all_ids(rdc_handle_t p_rdc_handle,
*
* @retval ::RDC_ST_OK is returned upon successful call.
*/
rdc_status_t rdc_group_field_destroy(rdc_handle_t p_rdc_handle,
rdc_field_grp_t rdc_field_group_id);
rdc_status_t rdc_group_field_destroy(rdc_handle_t p_rdc_handle, rdc_field_grp_t rdc_field_group_id);
/**
* @brief Request the RDC start recording updates for a given field
@@ -911,9 +896,9 @@ rdc_status_t rdc_group_field_destroy(rdc_handle_t p_rdc_handle,
*
* @retval ::RDC_ST_OK is returned upon successful call.
*/
rdc_status_t rdc_field_watch(rdc_handle_t p_rdc_handle,
rdc_gpu_group_t group_id, rdc_field_grp_t field_group_id,
uint64_t update_freq, double max_keep_age, uint32_t max_keep_samples);
rdc_status_t rdc_field_watch(rdc_handle_t p_rdc_handle, rdc_gpu_group_t group_id,
rdc_field_grp_t field_group_id, uint64_t update_freq,
double max_keep_age, uint32_t max_keep_samples);
/**
* @brief Request a latest cached field of a GPU
@@ -930,8 +915,8 @@ rdc_status_t rdc_field_watch(rdc_handle_t p_rdc_handle,
*
* @retval ::RDC_ST_OK is returned upon successful call.
*/
rdc_status_t rdc_field_get_latest_value(rdc_handle_t p_rdc_handle,
uint32_t gpu_index, rdc_field_t field, rdc_field_value* value);
rdc_status_t rdc_field_get_latest_value(rdc_handle_t p_rdc_handle, uint32_t gpu_index,
rdc_field_t field, rdc_field_value* value);
/**
* @brief Request a history cached field of a GPU
@@ -954,9 +939,9 @@ rdc_status_t rdc_field_get_latest_value(rdc_handle_t p_rdc_handle,
*
* @retval ::RDC_ST_OK is returned upon successful call.
*/
rdc_status_t rdc_field_get_value_since(rdc_handle_t p_rdc_handle,
uint32_t gpu_index, rdc_field_t field, uint64_t since_time_stamp,
uint64_t *next_since_time_stamp, rdc_field_value* value);
rdc_status_t rdc_field_get_value_since(rdc_handle_t p_rdc_handle, uint32_t gpu_index,
rdc_field_t field, uint64_t since_time_stamp,
uint64_t* next_since_time_stamp, rdc_field_value* value);
/**
* @brief Stop record updates for a given field collection.
@@ -971,8 +956,8 @@ rdc_status_t rdc_field_get_value_since(rdc_handle_t p_rdc_handle,
*
* @retval ::RDC_ST_OK is returned upon successful call.
*/
rdc_status_t rdc_field_unwatch(rdc_handle_t p_rdc_handle,
rdc_gpu_group_t group_id, rdc_field_grp_t field_group_id);
rdc_status_t rdc_field_unwatch(rdc_handle_t p_rdc_handle, rdc_gpu_group_t group_id,
rdc_field_grp_t field_group_id);
/**
* @brief Run the diagnostic test cases
@@ -991,11 +976,8 @@ rdc_status_t rdc_field_unwatch(rdc_handle_t p_rdc_handle,
*
* @retval ::RDC_ST_OK is returned upon successful call.
*/
rdc_status_t rdc_diagnostic_run(
rdc_handle_t p_rdc_handle,
rdc_gpu_group_t group_id,
rdc_diag_level_t level,
rdc_diag_response_t* response);
rdc_status_t rdc_diagnostic_run(rdc_handle_t p_rdc_handle, rdc_gpu_group_t group_id,
rdc_diag_level_t level, rdc_diag_response_t* response);
/**
* @brief Run one diagnostic test case
@@ -1012,11 +994,8 @@ rdc_status_t rdc_diagnostic_run(
*
* @retval ::RDC_ST_OK is returned upon successful call.
*/
rdc_status_t rdc_test_case_run(
rdc_handle_t p_rdc_handle,
rdc_gpu_group_t group_id,
rdc_diag_test_cases_t test_case,
rdc_diag_test_result_t* result);
rdc_status_t rdc_test_case_run(rdc_handle_t p_rdc_handle, rdc_gpu_group_t group_id,
rdc_diag_test_cases_t test_case, rdc_diag_test_result_t* result);
/**
* @brief Get a description of a provided RDC error status
include/rdc_lib/RdcCacheManager.h
+28 -30
Féach ar an gComhad
@@ -22,50 +22,48 @@ THE SOFTWARE.
#ifndef INCLUDE_RDC_LIB_RDCCACHEMANAGER_H_
#define INCLUDE_RDC_LIB_RDCCACHEMANAGER_H_
#include <memory>
#include <utility>
#include <string>
#include <vector>
#include <map>
#include "rdc_lib/rdc_common.h"
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include "rdc/rdc.h"
#include "rdc_lib/rdc_common.h"
namespace amd {
namespace rdc {
class RdcCacheManager {
public:
virtual rdc_status_t rdc_field_get_latest_value(uint32_t gpu_index,
rdc_field_t field, rdc_field_value* value) = 0;
virtual rdc_status_t rdc_field_get_value_since(uint32_t gpu_index,
rdc_field_t field, uint64_t since_time_stamp,
uint64_t *next_since_time_stamp, rdc_field_value* value) = 0;
virtual rdc_status_t rdc_update_cache(uint32_t gpu_index,
const rdc_field_value& value) = 0;
virtual rdc_status_t evict_cache(uint32_t gpu_index, rdc_field_t field_id,
uint64_t max_keep_samples, double max_keep_age) = 0;
virtual std::string get_cache_stats() = 0;
virtual rdc_status_t rdc_field_get_latest_value(uint32_t gpu_index, rdc_field_t field,
rdc_field_value* value) = 0;
virtual rdc_status_t rdc_field_get_value_since(uint32_t gpu_index, rdc_field_t field,
uint64_t since_time_stamp,
uint64_t* next_since_time_stamp,
rdc_field_value* value) = 0;
virtual rdc_status_t rdc_update_cache(uint32_t gpu_index, const rdc_field_value& value) = 0;
virtual rdc_status_t evict_cache(uint32_t gpu_index, rdc_field_t field_id,
uint64_t max_keep_samples, double max_keep_age) = 0;
virtual std::string get_cache_stats() = 0;
virtual rdc_status_t rdc_job_get_stats(const char job_id[64],
const rdc_gpu_gauges_t& gpu_gauges,
rdc_job_info_t* p_job_info) = 0;
virtual rdc_status_t rdc_job_start_stats(const char job_id[64],
const rdc_group_info_t& group,
const rdc_field_group_info_t& finfo,
const rdc_gpu_gauges_t& gpu_gauges) = 0;
virtual rdc_status_t rdc_job_stop_stats(const char job_id[64],
const rdc_gpu_gauges_t& gpu_gauge) = 0;
virtual rdc_status_t rdc_update_job_stats(uint32_t gpu_index,
const std::string& job_id, const rdc_field_value& value) = 0;
virtual rdc_status_t rdc_job_remove(const char job_id[64]) = 0;
virtual rdc_status_t rdc_job_remove_all() = 0;
virtual rdc_status_t rdc_job_get_stats(const char job_id[64], const rdc_gpu_gauges_t& gpu_gauges,
rdc_job_info_t* p_job_info) = 0;
virtual rdc_status_t rdc_job_start_stats(const char job_id[64], const rdc_group_info_t& group,
const rdc_field_group_info_t& finfo,
const rdc_gpu_gauges_t& gpu_gauges) = 0;
virtual rdc_status_t rdc_job_stop_stats(const char job_id[64],
const rdc_gpu_gauges_t& gpu_gauge) = 0;
virtual rdc_status_t rdc_update_job_stats(uint32_t gpu_index, const std::string& job_id,
const rdc_field_value& value) = 0;
virtual rdc_status_t rdc_job_remove(const char job_id[64]) = 0;
virtual rdc_status_t rdc_job_remove_all() = 0;
virtual ~RdcCacheManager() {}
virtual ~RdcCacheManager() {}
};
typedef std::shared_ptr<RdcCacheManager> RdcCacheManagerPtr;
} // namespace rdc
} // namespace amd
include/rdc_lib/RdcDiagnostic.h
+14 -19
Féach ar an gComhad
@@ -23,6 +23,7 @@ THE SOFTWARE.
#define INCLUDE_RDC_LIB_RDCDIAGNOSTIC_H_
#include <memory>
#include "rdc/rdc.h"
#include "rdc_lib/RdcDiagnosticLibInterface.h"
@@ -31,33 +32,27 @@ namespace rdc {
class RdcDiagnostic {
public:
// get support test cases
virtual rdc_status_t rdc_diag_test_cases_query(
rdc_diag_test_cases_t test_cases[MAX_TEST_CASES],
uint32_t* test_case_count) = 0;
// get support test cases
virtual rdc_status_t rdc_diag_test_cases_query(rdc_diag_test_cases_t test_cases[MAX_TEST_CASES],
uint32_t* test_case_count) = 0;
// Run a specific test case
virtual rdc_status_t rdc_test_case_run(
rdc_diag_test_cases_t test_case,
uint32_t gpu_index[RDC_MAX_NUM_DEVICES],
uint32_t gpu_count,
rdc_diag_test_result_t* result) = 0;
// Run a specific test case
virtual rdc_status_t rdc_test_case_run(rdc_diag_test_cases_t test_case,
uint32_t gpu_index[RDC_MAX_NUM_DEVICES],
uint32_t gpu_count, rdc_diag_test_result_t* result) = 0;
// Run multiple test cases
virtual rdc_status_t rdc_diagnostic_run(
const rdc_group_info_t& gpus,
rdc_diag_level_t level,
rdc_diag_response_t* response) = 0;
// Run multiple test cases
virtual rdc_status_t rdc_diagnostic_run(const rdc_group_info_t& gpus, rdc_diag_level_t level,
rdc_diag_response_t* response) = 0;
virtual rdc_status_t rdc_diag_init(uint64_t flags) = 0;
virtual rdc_status_t rdc_diag_destroy() = 0;
virtual rdc_status_t rdc_diag_init(uint64_t flags) = 0;
virtual rdc_status_t rdc_diag_destroy() = 0;
virtual ~RdcDiagnostic() {}
virtual ~RdcDiagnostic() {}
};
typedef std::shared_ptr<RdcDiagnostic> RdcDiagnosticPtr;
} // namespace rdc
} // namespace amd
#endif // INCLUDE_RDC_LIB_RDCDIAGNOSTIC_H_
include/rdc_lib/RdcDiagnosticLibInterface.h
+6 -12
Féach ar an gComhad
@@ -25,29 +25,23 @@ THE SOFTWARE.
// The telemetry interface for libraries, for example, RAS.
#include <rdc/rdc.h>
extern "C" {
// The library will implement below function
// Which test cases are supported in the library
rdc_status_t rdc_diag_test_cases_query(
rdc_diag_test_cases_t test_cases[MAX_TEST_CASES],
uint32_t* test_case_count);
rdc_status_t rdc_diag_test_cases_query(rdc_diag_test_cases_t test_cases[MAX_TEST_CASES],
uint32_t* test_case_count);
// Run a specific test case
rdc_status_t rdc_diag_test_case_run(
rdc_diag_test_cases_t test_case,
uint32_t gpu_index[RDC_MAX_NUM_DEVICES],
uint32_t gpu_count,
rdc_diag_test_result_t* result);
rdc_status_t rdc_diag_test_case_run(rdc_diag_test_cases_t test_case,
uint32_t gpu_index[RDC_MAX_NUM_DEVICES], uint32_t gpu_count,
rdc_diag_test_result_t* result);
rdc_status_t rdc_diag_init(uint64_t flags);
rdc_status_t rdc_diag_destroy();
}
#endif // INCLUDE_RDC_LIB_RDCDIAGNOSTICLIBINTERFACE_H_
#endif // INCLUDE_RDC_LIB_RDCDIAGNOSTICLIBINTERFACE_H_
include/rdc_lib/RdcException.h
+3 -3
Féach ar an gComhad
@@ -25,6 +25,7 @@ THE SOFTWARE.
#include <exception>
#include <string>
#include "rdc/rdc.h"
namespace amd {
@@ -32,8 +33,8 @@ namespace rdc {
class RdcException : public std::exception {
public:
RdcException(rdc_status_t error, const std::string description) :
err_(error), desc_(description) {}
RdcException(rdc_status_t error, const std::string description)
: err_(error), desc_(description) {}
rdc_status_t error_code() const noexcept { return err_; }
const char* what() const noexcept override { return desc_.c_str(); }
@@ -46,4 +47,3 @@ class RdcException : public std::exception {
} // namespace amd
#endif // INCLUDE_RDC_LIB_RDCEXCEPTION_H_
include/rdc_lib/RdcGroupSettings.h
+18 -24
Féach ar an gComhad
@@ -23,39 +23,33 @@ THE SOFTWARE.
#define INCLUDE_RDC_LIB_RDCGROUPSETTINGS_H_
#include <memory>
#include "rdc_lib/rdc_common.h"
#include "rdc/rdc.h"
#include "rdc_lib/rdc_common.h"
namespace amd {
namespace rdc {
class RdcGroupSettings {
public:
virtual rdc_status_t rdc_group_gpu_create(const char* group_name,
rdc_gpu_group_t* p_rdc_group_id) = 0;
virtual rdc_status_t rdc_group_gpu_destroy(
rdc_gpu_group_t p_rdc_group_id) = 0;
virtual rdc_status_t rdc_group_gpu_add(
rdc_gpu_group_t groupId, uint32_t gpu_index) = 0;
virtual rdc_status_t rdc_group_gpu_get_info(
rdc_gpu_group_t p_rdc_group_id,
rdc_group_info_t* p_rdc_group_info) = 0;
virtual rdc_status_t rdc_group_get_all_ids(
rdc_gpu_group_t group_id_list[], uint32_t* count) = 0;
virtual rdc_status_t rdc_group_gpu_create(const char* group_name,
rdc_gpu_group_t* p_rdc_group_id) = 0;
virtual rdc_status_t rdc_group_gpu_destroy(rdc_gpu_group_t p_rdc_group_id) = 0;
virtual rdc_status_t rdc_group_gpu_add(rdc_gpu_group_t groupId, uint32_t gpu_index) = 0;
virtual rdc_status_t rdc_group_gpu_get_info(rdc_gpu_group_t p_rdc_group_id,
rdc_group_info_t* p_rdc_group_info) = 0;
virtual rdc_status_t rdc_group_get_all_ids(rdc_gpu_group_t group_id_list[], uint32_t* count) = 0;
virtual rdc_status_t rdc_group_field_create(uint32_t num_field_ids, rdc_field_t* field_ids,
const char* field_group_name,
rdc_field_grp_t* rdc_field_group_id) = 0;
virtual rdc_status_t rdc_group_field_destroy(rdc_field_grp_t rdc_field_group_id) = 0;
virtual rdc_status_t rdc_group_field_get_info(rdc_field_grp_t rdc_field_group_id,
rdc_field_group_info_t* field_group_info) = 0;
virtual rdc_status_t rdc_group_field_get_all_ids(rdc_field_grp_t field_group_id_list[],
uint32_t* count) = 0;
virtual rdc_status_t rdc_group_field_create(uint32_t num_field_ids,
rdc_field_t* field_ids, const char* field_group_name,
rdc_field_grp_t* rdc_field_group_id) = 0;
virtual rdc_status_t rdc_group_field_destroy(
rdc_field_grp_t rdc_field_group_id) = 0;
virtual rdc_status_t rdc_group_field_get_info(
rdc_field_grp_t rdc_field_group_id,
rdc_field_group_info_t* field_group_info) = 0;
virtual rdc_status_t rdc_group_field_get_all_ids(
rdc_field_grp_t field_group_id_list[], uint32_t* count) = 0;
virtual ~RdcGroupSettings() {}
virtual ~RdcGroupSettings() {}
};
typedef std::shared_ptr<RdcGroupSettings> RdcGroupSettingsPtr;
include/rdc_lib/RdcHandler.h
+49 -58
Féach ar an gComhad
@@ -22,8 +22,8 @@ THE SOFTWARE.
#ifndef INCLUDE_RDC_LIB_RDCHANDLER_H_
#define INCLUDE_RDC_LIB_RDCHANDLER_H_
#include "rdc_lib/rdc_common.h"
#include "rdc/rdc.h"
#include "rdc_lib/rdc_common.h"
namespace amd {
namespace rdc {
@@ -31,70 +31,61 @@ namespace rdc {
// Interface class
class RdcHandler {
public:
// Job API
virtual rdc_status_t rdc_job_start_stats(rdc_gpu_group_t groupId,
const char job_id[64], uint64_t update_freq) = 0;
virtual rdc_status_t rdc_job_get_stats(const char jobId[64],
rdc_job_info_t* p_job_info)= 0;
virtual rdc_status_t rdc_job_stop_stats(const char job_id[64]) = 0;
virtual rdc_status_t rdc_job_remove(const char job_id[64]) = 0;
virtual rdc_status_t rdc_job_remove_all() = 0;
// Job API
virtual rdc_status_t rdc_job_start_stats(rdc_gpu_group_t groupId, const char job_id[64],
uint64_t update_freq) = 0;
virtual rdc_status_t rdc_job_get_stats(const char jobId[64], rdc_job_info_t* p_job_info) = 0;
virtual rdc_status_t rdc_job_stop_stats(const char job_id[64]) = 0;
virtual rdc_status_t rdc_job_remove(const char job_id[64]) = 0;
virtual rdc_status_t rdc_job_remove_all() = 0;
// Discovery API
virtual rdc_status_t rdc_device_get_all(
uint32_t gpu_index_list[RDC_MAX_NUM_DEVICES], uint32_t* count) = 0;
virtual rdc_status_t rdc_device_get_attributes(uint32_t gpu_index,
rdc_device_attributes_t* p_rdc_attr) = 0;
// Discovery API
virtual rdc_status_t rdc_device_get_all(uint32_t gpu_index_list[RDC_MAX_NUM_DEVICES],
uint32_t* count) = 0;
virtual rdc_status_t rdc_device_get_attributes(uint32_t gpu_index,
rdc_device_attributes_t* p_rdc_attr) = 0;
// Group API
virtual rdc_status_t rdc_group_gpu_create(rdc_group_type_t type,
const char* group_name, rdc_gpu_group_t* p_rdc_group_id) = 0;
virtual rdc_status_t rdc_group_gpu_add(rdc_gpu_group_t groupId,
uint32_t gpu_index) = 0;
virtual rdc_status_t rdc_group_field_create(uint32_t num_field_ids,
rdc_field_t* field_ids, const char* field_group_name,
rdc_field_grp_t* rdc_field_group_id) = 0;
virtual rdc_status_t rdc_group_field_get_info(
rdc_field_grp_t rdc_field_group_id,
rdc_field_group_info_t* field_group_info) = 0;
virtual rdc_status_t rdc_group_gpu_get_info(
rdc_gpu_group_t p_rdc_group_id, rdc_group_info_t* p_rdc_group_info) = 0;
virtual rdc_status_t rdc_group_get_all_ids(
rdc_gpu_group_t group_id_list[], uint32_t* count) = 0;
virtual rdc_status_t rdc_group_field_get_all_ids(
rdc_field_grp_t field_group_id_list[], uint32_t* count) = 0;
virtual rdc_status_t rdc_group_gpu_destroy(
rdc_gpu_group_t p_rdc_group_id) = 0;
virtual rdc_status_t rdc_group_field_destroy(
rdc_field_grp_t rdc_field_group_id) = 0;
// Group API
virtual rdc_status_t rdc_group_gpu_create(rdc_group_type_t type, const char* group_name,
rdc_gpu_group_t* p_rdc_group_id) = 0;
virtual rdc_status_t rdc_group_gpu_add(rdc_gpu_group_t groupId, uint32_t gpu_index) = 0;
virtual rdc_status_t rdc_group_field_create(uint32_t num_field_ids, rdc_field_t* field_ids,
const char* field_group_name,
rdc_field_grp_t* rdc_field_group_id) = 0;
virtual rdc_status_t rdc_group_field_get_info(rdc_field_grp_t rdc_field_group_id,
rdc_field_group_info_t* field_group_info) = 0;
virtual rdc_status_t rdc_group_gpu_get_info(rdc_gpu_group_t p_rdc_group_id,
rdc_group_info_t* p_rdc_group_info) = 0;
virtual rdc_status_t rdc_group_get_all_ids(rdc_gpu_group_t group_id_list[], uint32_t* count) = 0;
virtual rdc_status_t rdc_group_field_get_all_ids(rdc_field_grp_t field_group_id_list[],
uint32_t* count) = 0;
virtual rdc_status_t rdc_group_gpu_destroy(rdc_gpu_group_t p_rdc_group_id) = 0;
virtual rdc_status_t rdc_group_field_destroy(rdc_field_grp_t rdc_field_group_id) = 0;
// Field API
virtual rdc_status_t rdc_field_watch(rdc_gpu_group_t group_id,
rdc_field_grp_t field_group_id, uint64_t update_freq,
double max_keep_age, uint32_t max_keep_samples) = 0;
virtual rdc_status_t rdc_field_get_latest_value(uint32_t gpu_index,
rdc_field_t field, rdc_field_value* value) = 0;
virtual rdc_status_t rdc_field_get_value_since(uint32_t gpu_index,
rdc_field_t field, uint64_t since_time_stamp,
uint64_t *next_since_time_stamp, rdc_field_value* value) = 0;
virtual rdc_status_t rdc_field_unwatch(rdc_gpu_group_t group_id,
rdc_field_grp_t field_group_id) = 0;
// Field API
virtual rdc_status_t rdc_field_watch(rdc_gpu_group_t group_id, rdc_field_grp_t field_group_id,
uint64_t update_freq, double max_keep_age,
uint32_t max_keep_samples) = 0;
virtual rdc_status_t rdc_field_get_latest_value(uint32_t gpu_index, rdc_field_t field,
rdc_field_value* value) = 0;
virtual rdc_status_t rdc_field_get_value_since(uint32_t gpu_index, rdc_field_t field,
uint64_t since_time_stamp,
uint64_t* next_since_time_stamp,
rdc_field_value* value) = 0;
virtual rdc_status_t rdc_field_unwatch(rdc_gpu_group_t group_id,
rdc_field_grp_t field_group_id) = 0;
// Diagnostic API
virtual rdc_status_t rdc_diagnostic_run(
rdc_gpu_group_t group_id,
rdc_diag_level_t level,
rdc_diag_response_t* response) = 0;
// Diagnostic API
virtual rdc_status_t rdc_diagnostic_run(rdc_gpu_group_t group_id, rdc_diag_level_t level,
rdc_diag_response_t* response) = 0;
virtual rdc_status_t rdc_test_case_run(
rdc_gpu_group_t group_id,
rdc_diag_test_cases_t test_case,
rdc_diag_test_result_t* result) = 0;
virtual rdc_status_t rdc_test_case_run(rdc_gpu_group_t group_id, rdc_diag_test_cases_t test_case,
rdc_diag_test_result_t* result) = 0;
// Control API
virtual rdc_status_t rdc_field_update_all(uint32_t wait_for_update) = 0;
// Control API
virtual rdc_status_t rdc_field_update_all(uint32_t wait_for_update) = 0;
virtual ~RdcHandler(){}
virtual ~RdcHandler() {}
};
} // namespace rdc
include/rdc_lib/RdcLibraryLoader.h
+40 -43
Féach ar an gComhad
@@ -23,78 +23,75 @@ THE SOFTWARE.
#define INCLUDE_RDC_LIB_RDCLIBRARYLOADER_H_
#include <dlfcn.h>
#include <string.h>
#include <map>
#include <mutex> // NOLINT(build/c++11)
#include <mutex> // NOLINT(build/c++11)
#include "rdc/rdc.h"
#include "rdc_lib/RdcLogger.h"
#include "rdc_lib/rdc_common.h"
namespace amd {
namespace rdc {
class RdcLibraryLoader {
public:
RdcLibraryLoader();
RdcLibraryLoader();
rdc_status_t load(const char* filename);
rdc_status_t load(const char* filename);
template<typename T> rdc_status_t load_symbol(T* func_handler,
const char* func_name);
template <typename T>
rdc_status_t load_symbol(T* func_handler, const char* func_name);
template<typename T> rdc_status_t load(const char* filename,
T* func_make_handler);
template <typename T>
rdc_status_t load(const char* filename, T* func_make_handler);
rdc_status_t unload();
rdc_status_t unload();
~RdcLibraryLoader();
~RdcLibraryLoader();
private:
void* libHandler_;
std::mutex library_mutex_;
void* libHandler_;
std::mutex library_mutex_;
};
template<typename T> rdc_status_t RdcLibraryLoader::load_symbol(T* func_handler,
const char* func_name) {
if (!libHandler_) {
RDC_LOG(RDC_ERROR, "Must load the library before load the symbol");
return RDC_ST_FAIL_LOAD_MODULE;
}
template <typename T>
rdc_status_t RdcLibraryLoader::load_symbol(T* func_handler, const char* func_name) {
if (!libHandler_) {
RDC_LOG(RDC_ERROR, "Must load the library before load the symbol");
return RDC_ST_FAIL_LOAD_MODULE;
}
if (!func_handler || !func_name) {
return RDC_ST_FAIL_LOAD_MODULE;
}
if (!func_handler || !func_name) {
return RDC_ST_FAIL_LOAD_MODULE;
}
std::lock_guard<std::mutex> guard(library_mutex_);
std::lock_guard<std::mutex> guard(library_mutex_);
*reinterpret_cast<void**>(func_handler) =
dlsym(libHandler_, func_name);
if (*func_handler == nullptr) {
char* error = dlerror();
RDC_LOG(RDC_ERROR, "RdcLibraryLoader: Fail to load the symbol "
<< func_name << ": " << error);
return RDC_ST_FAIL_LOAD_MODULE;
}
*reinterpret_cast<void**>(func_handler) = dlsym(libHandler_, func_name);
if (*func_handler == nullptr) {
char* error = dlerror();
RDC_LOG(RDC_ERROR, "RdcLibraryLoader: Fail to load the symbol " << func_name << ": " << error);
return RDC_ST_FAIL_LOAD_MODULE;
}
return RDC_ST_OK;
return RDC_ST_OK;
}
template <typename T>
rdc_status_t RdcLibraryLoader::load(const char* filename, T* func_make_handler) {
if (filename == nullptr || func_make_handler == nullptr) {
return RDC_ST_FAIL_LOAD_MODULE;
}
template<typename T> rdc_status_t RdcLibraryLoader::load(const char* filename,
T* func_make_handler) {
if (filename == nullptr || func_make_handler == nullptr) {
return RDC_ST_FAIL_LOAD_MODULE;
}
rdc_status_t status = load(filename);
if (status != RDC_ST_OK) {
return status;
}
rdc_status_t status = load(filename);
if (status != RDC_ST_OK) {
return status;
}
return load_symbol(func_make_handler, "make_handler");
return load_symbol(func_make_handler, "make_handler");
}
} // namespace rdc
} // namespace amd
#endif // INCLUDE_RDC_LIB_RDCLIBRARYLOADER_H_
include/rdc_lib/RdcLogger.h
+11 -17
Féach ar an gComhad
@@ -21,39 +21,33 @@ THE SOFTWARE.
*/
#ifndef INCLUDE_RDC_LIB_RDCLOGGER_H_
#define INCLUDE_RDC_LIB_RDCLOGGER_H_
#include <chrono> // NOLINT
#include <iostream>
#include <string>
#include <chrono> // NOLINT
namespace amd {
namespace rdc {
class RdcLogger {
public:
explicit RdcLogger(std::ostream& os);
explicit RdcLogger(std::ostream& os);
static RdcLogger& getLogger() {
static RdcLogger logger(std::cout);
return logger;
}
static RdcLogger& getLogger() {
static RdcLogger logger(std::cout);
return logger;
}
bool should_log(uint32_t severity) {
return log_level_ >= severity;
}
bool should_log(uint32_t severity) { return log_level_ >= severity; }
std::ostream& get_ostream() {
return os_;
}
std::ostream& get_ostream() { return os_; }
std::string get_log_header(uint32_t severity,
const char* file, int line);
std::string get_log_header(uint32_t severity, const char* file, int line);
private:
std::ostream& os_;
uint32_t log_level_;
std::ostream& os_;
uint32_t log_level_;
};
} // namespace rdc
} // namespace amd
#endif // INCLUDE_RDC_LIB_RDCLOGGER_H_
include/rdc_lib/RdcMetricFetcher.h
+12 -12
Féach ar an gComhad
@@ -24,26 +24,26 @@ THE SOFTWARE.
#include <memory>
#include <vector>
#include "rdc_lib/rdc_common.h"
#include "rdc_lib/RdcTelemetryLibInterface.h"
#include "rdc/rdc.h"
#include "rdc/rdc.h"
#include "rdc_lib/RdcTelemetryLibInterface.h"
#include "rdc_lib/rdc_common.h"
namespace amd {
namespace rdc {
class RdcMetricFetcher {
class RdcMetricFetcher {
public:
virtual rdc_status_t acquire_rsmi_handle(RdcFieldKey fk) = 0;
virtual rdc_status_t delete_rsmi_handle(RdcFieldKey fk) = 0;
virtual rdc_status_t acquire_rsmi_handle(RdcFieldKey fk) = 0;
virtual rdc_status_t delete_rsmi_handle(RdcFieldKey fk) = 0;
virtual rdc_status_t fetch_smi_field(uint32_t gpu_index,
rdc_field_t field_id, rdc_field_value* value) = 0;
virtual rdc_status_t fetch_smi_field(uint32_t gpu_index, rdc_field_t field_id,
rdc_field_value* value) = 0;
virtual rdc_status_t bulk_fetch_smi_fields(
rdc_gpu_field_t* fields, uint32_t fields_count,
std::vector<rdc_gpu_field_value_t>& results) = 0; // NOLINT
virtual ~RdcMetricFetcher() {}
virtual rdc_status_t bulk_fetch_smi_fields(
rdc_gpu_field_t* fields, uint32_t fields_count,
std::vector<rdc_gpu_field_value_t>& results) = 0; // NOLINT
virtual ~RdcMetricFetcher() {}
};
typedef std::shared_ptr<RdcMetricFetcher> RdcMetricFetcherPtr;
include/rdc_lib/RdcMetricsUpdater.h
+2 -3
Féach ar an gComhad
@@ -29,8 +29,8 @@ namespace rdc {
class RdcMetricsUpdater {
public:
virtual void start() = 0;
virtual void stop() = 0;
virtual void start() = 0;
virtual void stop() = 0;
};
typedef std::shared_ptr<RdcMetricsUpdater> RdcMetricsUpdaterPtr;
@@ -38,5 +38,4 @@ typedef std::shared_ptr<RdcMetricsUpdater> RdcMetricsUpdaterPtr;
} // namespace rdc
} // namespace amd
#endif // INCLUDE_RDC_LIB_RDCMETRICSUPDATER_H_
include/rdc_lib/RdcModuleMgr.h
+5 -5
Féach ar an gComhad
@@ -23,18 +23,19 @@ THE SOFTWARE.
#define INCLUDE_RDC_LIB_RDCMODULEMGR_H_
#include <memory>
#include "rdc_lib/rdc_common.h"
#include "rdc/rdc.h"
#include "rdc_lib/RdcTelemetry.h"
#include "rdc_lib/RdcDiagnostic.h"
#include "rdc_lib/RdcTelemetry.h"
#include "rdc_lib/rdc_common.h"
namespace amd {
namespace rdc {
class RdcModuleMgr {
public:
virtual RdcTelemetryPtr get_telemetry_module() = 0;
virtual RdcDiagnosticPtr get_diagnostic_module() = 0;
virtual RdcTelemetryPtr get_telemetry_module() = 0;
virtual RdcDiagnosticPtr get_diagnostic_module() = 0;
};
typedef std::shared_ptr<RdcModuleMgr> RdcModuleMgrPtr;
@@ -42,5 +43,4 @@ typedef std::shared_ptr<RdcModuleMgr> RdcModuleMgrPtr;
} // namespace rdc
} // namespace amd
#endif // INCLUDE_RDC_LIB_RDCMODULEMGR_H_
include/rdc_lib/RdcNotification.h
+11 -13
Féach ar an gComhad
@@ -24,8 +24,9 @@ THE SOFTWARE.
#include <memory>
#include <vector>
#include "rdc_lib/rdc_common.h"
#include "rdc/rdc.h"
#include "rdc_lib/rdc_common.h"
namespace amd {
namespace rdc {
@@ -33,24 +34,22 @@ namespace rdc {
extern const uint32_t kMaxRSMIEvents;
typedef struct {
uint32_t gpu_id;
rdc_field_value field;
uint32_t gpu_id;
rdc_field_value field;
} rdc_evnt_notification_t;
class RdcNotification {
public:
virtual bool is_notification_event(rdc_field_t field) const = 0;
virtual bool is_notification_event(rdc_field_t field) const = 0;
virtual rdc_status_t
set_listen_events(const std::vector<RdcFieldKey> fk_arr) = 0;
virtual rdc_status_t set_listen_events(const std::vector<RdcFieldKey> fk_arr) = 0;
// Blocking
virtual rdc_status_t
listen(rdc_evnt_notification_t *events, uint32_t *num_events,
uint32_t timeout_ms) = 0;
// Blocking
virtual rdc_status_t listen(rdc_evnt_notification_t* events, uint32_t* num_events,
uint32_t timeout_ms) = 0;
virtual rdc_status_t stop_listening(uint32_t gpu_id) = 0;
virtual ~RdcNotification() {}
virtual rdc_status_t stop_listening(uint32_t gpu_id) = 0;
virtual ~RdcNotification() {}
};
typedef std::shared_ptr<RdcNotification> RdcNotificationPtr;
@@ -59,4 +58,3 @@ typedef std::shared_ptr<RdcNotification> RdcNotificationPtr;
} // namespace amd
#endif // INCLUDE_RDC_LIB_RDCNOTIFICATION_H_
include/rdc_lib/RdcPerfTimer.h
Inrite → Rialta
+4 -5
Féach ar an gComhad
@@ -24,9 +24,10 @@ THE SOFTWARE.
#define INCLUDE_RDC_LIB_RDCRdcPerfTimer_H_
#include <stdint.h>
#include <iostream>
#include <vector>
#include <string>
#include <vector>
/// \file
/// Timer related class.
@@ -37,9 +38,9 @@ class RdcPerfTimer {
private:
struct Timer {
std::string name; /* < name name of time object*/
uint64_t _freq; /* < _freq frequency*/
uint64_t _freq; /* < _freq frequency*/
uint64_t _clocks; /* < _clocks number of ticks at end*/
uint64_t _start; /* < _start start point ticks*/
uint64_t _start; /* < _start start point ticks*/
};
std::vector<Timer*> _timers; /*< _timers vector to Timer objects */
@@ -80,9 +81,7 @@ class RdcPerfTimer {
uint64_t MeasureTSCFreqHz();
};
} // namespace rdc
} // namespace amd
#endif // INCLUDE_RDC_LIB_RDCRdcPerfTimer_H_
include/rdc_lib/RdcTelemetry.h
+14 -14
Féach ar an gComhad
@@ -23,6 +23,7 @@ THE SOFTWARE.
#define INCLUDE_RDC_LIB_RDCTELEMETRY_H_
#include <memory>
#include "rdc/rdc.h"
#include "rdc_lib/RdcTelemetryLibInterface.h"
@@ -31,27 +32,26 @@ namespace rdc {
class RdcTelemetry {
public:
// get support field ids
virtual rdc_status_t rdc_telemetry_fields_query(
uint32_t field_ids[MAX_NUM_FIELDS],
uint32_t* field_count) = 0;
// get support field ids
virtual rdc_status_t rdc_telemetry_fields_query(uint32_t field_ids[MAX_NUM_FIELDS],
uint32_t* field_count) = 0;
// Fetch
virtual rdc_status_t rdc_telemetry_fields_value_get(rdc_gpu_field_t* fields,
uint32_t fields_count, rdc_field_value_f callback,
void* user_data) = 0;
// Fetch
virtual rdc_status_t rdc_telemetry_fields_value_get(rdc_gpu_field_t* fields,
uint32_t fields_count,
rdc_field_value_f callback,
void* user_data) = 0;
virtual rdc_status_t rdc_telemetry_fields_watch(rdc_gpu_field_t* fields,
uint32_t fields_count) = 0;
virtual rdc_status_t rdc_telemetry_fields_unwatch(rdc_gpu_field_t* fields,
uint32_t fields_count) = 0;
virtual rdc_status_t rdc_telemetry_fields_watch(rdc_gpu_field_t* fields,
uint32_t fields_count) = 0;
virtual rdc_status_t rdc_telemetry_fields_unwatch(rdc_gpu_field_t* fields,
uint32_t fields_count) = 0;
virtual ~RdcTelemetry() {}
virtual ~RdcTelemetry() {}
};
typedef std::shared_ptr<RdcTelemetry> RdcTelemetryPtr;
} // namespace rdc
} // namespace amd
#endif // INCLUDE_RDC_LIB_RDCTELEMETRY_H_
include/rdc_lib/RdcTelemetryLibInterface.h
+13 -18
Féach ar an gComhad
@@ -24,45 +24,40 @@ THE SOFTWARE.
// The telemetry interface for libraries, for example, RAS.
#include <rdc/rdc.h>
#include <cstdint>
extern "C" {
// Structure to keep both gup index and field value
typedef struct {
uint32_t gpu_index;
rdc_field_value field_value;
uint32_t gpu_index;
rdc_field_value field_value;
} rdc_gpu_field_value_t;
typedef struct {
uint32_t gpu_index;
rdc_field_t field_id;
uint32_t gpu_index;
rdc_field_t field_id;
} rdc_gpu_field_t;
#define MAX_NUM_FIELDS 8192
typedef rdc_status_t(*rdc_field_value_f)(rdc_gpu_field_value_t* values,
uint32_t num_values, void* user_data);
typedef rdc_status_t (*rdc_field_value_f)(rdc_gpu_field_value_t* values, uint32_t num_values,
void* user_data);
// The library will implement below function
rdc_status_t rdc_telemetry_fields_query(uint32_t field_ids[MAX_NUM_FIELDS],
uint32_t* field_count);
rdc_status_t rdc_telemetry_fields_query(uint32_t field_ids[MAX_NUM_FIELDS], uint32_t* field_count);
rdc_status_t rdc_telemetry_fields_value_get(rdc_gpu_field_t* fields,
uint32_t fields_count, rdc_field_value_f callback,
void* user_data);
rdc_status_t rdc_telemetry_fields_value_get(rdc_gpu_field_t* fields, uint32_t fields_count,
rdc_field_value_f callback, void* user_data);
rdc_status_t rdc_telemetry_fields_watch(rdc_gpu_field_t* fields, uint32_t fields_count);
rdc_status_t rdc_telemetry_fields_watch(rdc_gpu_field_t* fields,
uint32_t fields_count);
rdc_status_t rdc_telemetry_fields_unwatch(rdc_gpu_field_t* fields,
uint32_t fields_count);
rdc_status_t rdc_telemetry_fields_unwatch(rdc_gpu_field_t* fields, uint32_t fields_count);
rdc_status_t rdc_module_init(uint64_t flags);
rdc_status_t rdc_module_destroy();
}
#endif // INCLUDE_RDC_LIB_RDCTELEMETRYLIBINTERFACE_H_
#endif // INCLUDE_RDC_LIB_RDCTELEMETRYLIBINTERFACE_H_
include/rdc_lib/RdcWatchTable.h
+17 -17
Féach ar an gComhad
@@ -24,33 +24,33 @@ THE SOFTWARE.
#include <memory>
#include <vector>
#include "rdc_lib/rdc_common.h"
#include "rdc/rdc.h"
#include "rdc/rdc.h"
#include "rdc_lib/rdc_common.h"
namespace amd {
namespace rdc {
class RdcWatchTable {
public:
virtual rdc_status_t rdc_field_update_all() = 0;
virtual rdc_status_t rdc_field_listen_notif(uint32_t timeout_ms) = 0;
virtual rdc_status_t rdc_field_update_all() = 0;
virtual rdc_status_t rdc_field_listen_notif(uint32_t timeout_ms) = 0;
virtual rdc_status_t rdc_job_start_stats(rdc_gpu_group_t group_id,
const char job_id[64], uint64_t update_freq,
const rdc_gpu_gauges_t& gpu_gauge) = 0;
virtual rdc_status_t rdc_job_stop_stats(const char job_id[64],
const rdc_gpu_gauges_t& gpu_gauge) = 0;
virtual rdc_status_t rdc_job_remove(const char job_id[64]) = 0;
virtual rdc_status_t rdc_job_remove_all() = 0;
virtual rdc_status_t rdc_job_start_stats(rdc_gpu_group_t group_id, const char job_id[64],
uint64_t update_freq,
const rdc_gpu_gauges_t& gpu_gauge) = 0;
virtual rdc_status_t rdc_job_stop_stats(const char job_id[64],
const rdc_gpu_gauges_t& gpu_gauge) = 0;
virtual rdc_status_t rdc_job_remove(const char job_id[64]) = 0;
virtual rdc_status_t rdc_job_remove_all() = 0;
virtual rdc_status_t rdc_field_watch(rdc_gpu_group_t group_id,
rdc_field_grp_t field_group_id, uint64_t update_freq,
double max_keep_age, uint32_t max_keep_samples) = 0;
virtual rdc_status_t rdc_field_unwatch(rdc_gpu_group_t group_id,
rdc_field_grp_t field_group_id) = 0;
virtual rdc_status_t rdc_field_watch(rdc_gpu_group_t group_id, rdc_field_grp_t field_group_id,
uint64_t update_freq, double max_keep_age,
uint32_t max_keep_samples) = 0;
virtual rdc_status_t rdc_field_unwatch(rdc_gpu_group_t group_id,
rdc_field_grp_t field_group_id) = 0;
virtual ~RdcWatchTable() {}
virtual ~RdcWatchTable() {}
};
typedef std::shared_ptr<RdcWatchTable> RdcWatchTablePtr;
include/rdc_lib/impl/RdcCacheManagerImpl.h
+55 -60
Féach ar an gComhad
@@ -22,15 +22,15 @@ THE SOFTWARE.
#ifndef INCLUDE_RDC_LIB_IMPL_RDCCACHEMANAGERIMPL_H_
#define INCLUDE_RDC_LIB_IMPL_RDCCACHEMANAGERIMPL_H_
#include <map>
#include <memory>
#include <mutex> // NOLINT(build/c++11)
#include <string>
#include <vector>
#include <map>
#include "rdc/rdc.h"
#include "rdc_lib/RdcCacheManager.h"
#include "rdc_lib/rdc_common.h"
#include "rdc/rdc.h"
namespace amd {
namespace rdc {
@@ -39,89 +39,84 @@ namespace rdc {
// types and arrays (no pointers). If a pointer is added, make sure to update
// any code that copies this structure.
struct RdcCacheEntry {
uint64_t last_time;
rdc_field_type_t type;
rdc_field_value_data value;
uint64_t last_time;
rdc_field_type_t type;
rdc_field_value_data value;
};
typedef std::map<RdcFieldKey, std::vector<RdcCacheEntry>> RdcCacheSamples;
struct FieldSummaryStats {
int64_t max_value;
int64_t min_value;
int64_t total_value;
int64_t max_value;
int64_t min_value;
int64_t total_value;
// Use Welford algorithm to calculate the standard deviations.
// https://en.wikipedia.org/wiki/Standard_deviation#Rapid_calculation_methods
// https://www.johndcook.com/blog/standard_deviation/
double old_m;
double old_s;
double new_m;
double new_s;
// Use Welford algorithm to calculate the standard deviations.
// https://en.wikipedia.org/wiki/Standard_deviation#Rapid_calculation_methods
// https://www.johndcook.com/blog/standard_deviation/
double old_m;
double old_s;
double new_m;
double new_s;
uint64_t last_time;
uint64_t count;
uint64_t last_time;
uint64_t count;
};
struct GpuSummaryStats {
uint64_t energy_consumed;
uint64_t energy_last_time;
uint64_t ecc_correct_init; // Init counter when job starts
uint64_t ecc_uncorrect_init; // Init counter when job starts
std::map<uint32_t, FieldSummaryStats> field_summaries;
uint64_t energy_consumed;
uint64_t energy_last_time;
uint64_t ecc_correct_init; // Init counter when job starts
uint64_t ecc_uncorrect_init; // Init counter when job starts
std::map<uint32_t, FieldSummaryStats> field_summaries;
};
// Per job entry
struct RdcJobStatsCacheEntry {
uint64_t start_time;
uint64_t end_time;
std::map<uint32_t, GpuSummaryStats> gpu_stats;
uint64_t start_time;
uint64_t end_time;
std::map<uint32_t, GpuSummaryStats> gpu_stats;
};
// <job_id, job_stats>
typedef std::map<std::string, RdcJobStatsCacheEntry> RdcJobStatsCache;
class RdcCacheManagerImpl: public RdcCacheManager {
class RdcCacheManagerImpl : public RdcCacheManager {
public:
rdc_status_t rdc_field_get_latest_value(uint32_t gpu_index,
rdc_field_t field, rdc_field_value* value) override;
rdc_status_t rdc_field_get_value_since(uint32_t gpu_index,
rdc_field_t field, uint64_t since_time_stamp,
uint64_t *next_since_time_stamp, rdc_field_value* value) override;
rdc_status_t rdc_update_cache(uint32_t gpu_index,
const rdc_field_value& value) override;
rdc_status_t evict_cache(uint32_t gpu_index, rdc_field_t field_id,
uint64_t max_keep_samples, double max_keep_age) override;
std::string get_cache_stats() override;
rdc_status_t rdc_field_get_latest_value(uint32_t gpu_index, rdc_field_t field,
rdc_field_value* value) override;
rdc_status_t rdc_field_get_value_since(uint32_t gpu_index, rdc_field_t field,
uint64_t since_time_stamp, uint64_t* next_since_time_stamp,
rdc_field_value* value) override;
rdc_status_t rdc_update_cache(uint32_t gpu_index, const rdc_field_value& value) override;
rdc_status_t evict_cache(uint32_t gpu_index, rdc_field_t field_id, uint64_t max_keep_samples,
double max_keep_age) override;
std::string get_cache_stats() override;
rdc_status_t rdc_job_get_stats(const char job_id[64],
const rdc_gpu_gauges_t& gpu_gauges,
rdc_job_info_t* p_job_info) override;
rdc_status_t rdc_job_start_stats(const char job_id[64],
const rdc_group_info_t& group,
const rdc_field_group_info_t& finfo,
const rdc_gpu_gauges_t& gpu_gauges) override;
rdc_status_t rdc_job_stop_stats(const char job_id[64],
const rdc_gpu_gauges_t& gpu_gauge) override;
rdc_status_t rdc_update_job_stats(uint32_t gpu_index,
const std::string& job_id,
const rdc_field_value& value) override;
rdc_status_t rdc_job_remove(const char job_id[64]) override;
rdc_status_t rdc_job_remove_all() override;
rdc_status_t rdc_job_get_stats(const char job_id[64], const rdc_gpu_gauges_t& gpu_gauges,
rdc_job_info_t* p_job_info) override;
rdc_status_t rdc_job_start_stats(const char job_id[64], const rdc_group_info_t& group,
const rdc_field_group_info_t& finfo,
const rdc_gpu_gauges_t& gpu_gauges) override;
rdc_status_t rdc_job_stop_stats(const char job_id[64],
const rdc_gpu_gauges_t& gpu_gauge) override;
rdc_status_t rdc_update_job_stats(uint32_t gpu_index, const std::string& job_id,
const rdc_field_value& value) override;
rdc_status_t rdc_job_remove(const char job_id[64]) override;
rdc_status_t rdc_job_remove_all() override;
private:
void set_summary(const FieldSummaryStats & stats,
rdc_stats_summary_t& gpu, rdc_stats_summary_t& summary, // NOLINT
unsigned int adjuster);
void set_average_summary(
rdc_stats_summary_t& summary, uint32_t num_gpus); // NOLINT
RdcCacheSamples cache_samples_;
RdcJobStatsCache cache_jobs_;
std::mutex cache_mutex_;
void set_summary(const FieldSummaryStats& stats, rdc_stats_summary_t& gpu,
rdc_stats_summary_t& summary, // NOLINT
unsigned int adjuster);
void set_average_summary(rdc_stats_summary_t& summary,
uint32_t num_gpus); // NOLINT
RdcCacheSamples cache_samples_;
RdcJobStatsCache cache_jobs_;
std::mutex cache_mutex_;
};
} // namespace rdc
} // namespace amd
#endif // INCLUDE_RDC_LIB_IMPL_RDCCACHEMANAGERIMPL_H_
include/rdc_lib/impl/RdcDiagnosticModule.h
+21 -28
Féach ar an gComhad
@@ -22,10 +22,11 @@ THE SOFTWARE.
#ifndef INCLUDE_RDC_LIB_IMPL_DIAGNOSTICMODULE_H_
#define INCLUDE_RDC_LIB_IMPL_DIAGNOSTICMODULE_H_
#include <map>
#include <list>
#include <vector>
#include <map>
#include <memory>
#include <vector>
#include "rdc_lib/RdcDiagnostic.h"
#include "rdc_lib/RdcMetricFetcher.h"
#include "rdc_lib/RdcTelemetryLibInterface.h"
@@ -35,37 +36,30 @@ namespace rdc {
class RdcDiagnosticModule : public RdcDiagnostic {
public:
rdc_status_t rdc_diag_test_cases_query(
rdc_diag_test_cases_t test_cases[MAX_TEST_CASES],
uint32_t* test_case_count) override;
rdc_status_t rdc_diag_test_cases_query(rdc_diag_test_cases_t test_cases[MAX_TEST_CASES],
uint32_t* test_case_count) override;
// Run a specific test case
rdc_status_t rdc_test_case_run(
rdc_diag_test_cases_t test_case,
uint32_t gpu_index[RDC_MAX_NUM_DEVICES],
uint32_t gpu_count,
rdc_diag_test_result_t* result) override;
// Run a specific test case
rdc_status_t rdc_test_case_run(rdc_diag_test_cases_t test_case,
uint32_t gpu_index[RDC_MAX_NUM_DEVICES], uint32_t gpu_count,
rdc_diag_test_result_t* result) override;
rdc_status_t rdc_diagnostic_run(
const rdc_group_info_t& gpus,
rdc_diag_level_t level,
rdc_diag_response_t* response) override;
rdc_status_t rdc_diagnostic_run(const rdc_group_info_t& gpus, rdc_diag_level_t level,
rdc_diag_response_t* response) override;
rdc_status_t rdc_diag_init(uint64_t flags) override;
rdc_status_t rdc_diag_destroy() override;
rdc_status_t rdc_diag_init(uint64_t flags) override;
rdc_status_t rdc_diag_destroy() override;
explicit RdcDiagnosticModule(RdcMetricFetcherPtr& fetcher);
explicit RdcDiagnosticModule(RdcMetricFetcherPtr& fetcher);
private:
//< Helper function to dispatch fields to module
void get_fields_for_module(
rdc_gpu_field_t* fields,
uint32_t fields_count,
std::map<RdcDiagnosticPtr, std::vector<rdc_gpu_field_t>>
& fields_in_module,
std::vector<rdc_gpu_field_value_t>& unsupport_fields); // NOLINT
std::list<RdcDiagnosticPtr> diagnostic_modules_;
std::map<rdc_diag_test_cases_t, RdcDiagnosticPtr> testcases_to_module_;
//< Helper function to dispatch fields to module
void get_fields_for_module(
rdc_gpu_field_t* fields, uint32_t fields_count,
std::map<RdcDiagnosticPtr, std::vector<rdc_gpu_field_t>>& fields_in_module,
std::vector<rdc_gpu_field_value_t>& unsupport_fields); // NOLINT
std::list<RdcDiagnosticPtr> diagnostic_modules_;
std::map<rdc_diag_test_cases_t, RdcDiagnosticPtr> testcases_to_module_;
};
typedef std::shared_ptr<RdcDiagnosticModule> RdcDiagnosticModulePtr;
@@ -73,5 +67,4 @@ typedef std::shared_ptr<RdcDiagnosticModule> RdcDiagnosticModulePtr;
} // namespace rdc
} // namespace amd
#endif // INCLUDE_RDC_LIB_IMPL_DIAGNOSTICMODULE_H_
include/rdc_lib/impl/RdcEmbeddedHandler.h
+63 -74
Féach ar an gComhad
@@ -23,102 +23,91 @@ THE SOFTWARE.
#define INCLUDE_RDC_LIB_IMPL_RDCEMBEDDEDHANDLER_H_
#include <future> // NOLINT(build/c++11)
#include "rdc_lib/RdcHandler.h"
#include "rdc_lib/RdcGroupSettings.h"
#include "rdc_lib/RdcMetricFetcher.h"
#include "rdc_lib/RdcCacheManager.h"
#include "rdc_lib/RdcGroupSettings.h"
#include "rdc_lib/RdcHandler.h"
#include "rdc_lib/RdcMetricFetcher.h"
#include "rdc_lib/RdcMetricsUpdater.h"
#include "rdc_lib/RdcWatchTable.h"
#include "rdc_lib/RdcModuleMgr.h"
#include "rdc_lib/RdcNotification.h"
#include "rdc_lib/RdcWatchTable.h"
namespace amd {
namespace rdc {
class RdcEmbeddedHandler: public RdcHandler {
class RdcEmbeddedHandler : public RdcHandler {
public:
// Job API
rdc_status_t rdc_job_start_stats(rdc_gpu_group_t groupId,
const char job_id[64], uint64_t update_freq) override;
rdc_status_t rdc_job_get_stats(const char jobId[64],
rdc_job_info_t* p_job_info) override;
rdc_status_t rdc_job_stop_stats(const char job_id[64]) override;
rdc_status_t rdc_job_remove(const char job_id[64]) override;
rdc_status_t rdc_job_remove_all() override;
// Job API
rdc_status_t rdc_job_start_stats(rdc_gpu_group_t groupId, const char job_id[64],
uint64_t update_freq) override;
rdc_status_t rdc_job_get_stats(const char jobId[64], rdc_job_info_t* p_job_info) override;
rdc_status_t rdc_job_stop_stats(const char job_id[64]) override;
rdc_status_t rdc_job_remove(const char job_id[64]) override;
rdc_status_t rdc_job_remove_all() override;
// Discovery API
rdc_status_t rdc_device_get_all(
uint32_t gpu_index_list[RDC_MAX_NUM_DEVICES], uint32_t* count) override;
rdc_status_t rdc_device_get_attributes(uint32_t gpu_index,
rdc_device_attributes_t* p_rdc_attr) override;
// Discovery API
rdc_status_t rdc_device_get_all(uint32_t gpu_index_list[RDC_MAX_NUM_DEVICES],
uint32_t* count) override;
rdc_status_t rdc_device_get_attributes(uint32_t gpu_index,
rdc_device_attributes_t* p_rdc_attr) override;
// Group API
rdc_status_t rdc_group_gpu_create(rdc_group_type_t type,
const char* group_name,
rdc_gpu_group_t* p_rdc_group_id) override;
rdc_status_t rdc_group_gpu_add(rdc_gpu_group_t groupId,
uint32_t gpu_index) override;
rdc_status_t rdc_group_field_create(uint32_t num_field_ids,
rdc_field_t* field_ids, const char* field_group_name,
rdc_field_grp_t* rdc_field_group_id) override;
rdc_status_t rdc_group_field_get_info(
rdc_field_grp_t rdc_field_group_id,
rdc_field_group_info_t* field_group_info) override;
rdc_status_t rdc_group_gpu_get_info(rdc_gpu_group_t p_rdc_group_id,
rdc_group_info_t* p_rdc_group_info) override;
rdc_status_t rdc_group_get_all_ids(
rdc_gpu_group_t group_id_list[], uint32_t* count) override;
rdc_status_t rdc_group_field_get_all_ids(
rdc_field_grp_t field_group_id_list[], uint32_t* count) override;
rdc_status_t rdc_group_gpu_destroy(
rdc_gpu_group_t p_rdc_group_id) override;
rdc_status_t rdc_group_field_destroy(
rdc_field_grp_t rdc_field_group_id) override;
// Group API
rdc_status_t rdc_group_gpu_create(rdc_group_type_t type, const char* group_name,
rdc_gpu_group_t* p_rdc_group_id) override;
rdc_status_t rdc_group_gpu_add(rdc_gpu_group_t groupId, uint32_t gpu_index) override;
rdc_status_t rdc_group_field_create(uint32_t num_field_ids, rdc_field_t* field_ids,
const char* field_group_name,
rdc_field_grp_t* rdc_field_group_id) override;
rdc_status_t rdc_group_field_get_info(rdc_field_grp_t rdc_field_group_id,
rdc_field_group_info_t* field_group_info) override;
rdc_status_t rdc_group_gpu_get_info(rdc_gpu_group_t p_rdc_group_id,
rdc_group_info_t* p_rdc_group_info) override;
rdc_status_t rdc_group_get_all_ids(rdc_gpu_group_t group_id_list[], uint32_t* count) override;
rdc_status_t rdc_group_field_get_all_ids(rdc_field_grp_t field_group_id_list[],
uint32_t* count) override;
rdc_status_t rdc_group_gpu_destroy(rdc_gpu_group_t p_rdc_group_id) override;
rdc_status_t rdc_group_field_destroy(rdc_field_grp_t rdc_field_group_id) override;
// Field API
rdc_status_t rdc_field_watch(rdc_gpu_group_t group_id,
rdc_field_grp_t field_group_id, uint64_t update_freq,
double max_keep_age, uint32_t max_keep_samples) override;
rdc_status_t rdc_field_get_latest_value(uint32_t gpu_index,
rdc_field_t field, rdc_field_value* value) override;
rdc_status_t rdc_field_get_value_since(uint32_t gpu_index,
rdc_field_t field, uint64_t since_time_stamp,
uint64_t *next_since_time_stamp, rdc_field_value* value) override;
rdc_status_t rdc_field_unwatch(rdc_gpu_group_t group_id,
rdc_field_grp_t field_group_id) override;
// Diagnostic API
rdc_status_t rdc_diagnostic_run(
rdc_gpu_group_t group_id,
rdc_diag_level_t level,
rdc_diag_response_t* response) override;
rdc_status_t rdc_test_case_run(
rdc_gpu_group_t group_id,
rdc_diag_test_cases_t test_case,
rdc_diag_test_result_t* result) override;
// Field API
rdc_status_t rdc_field_watch(rdc_gpu_group_t group_id, rdc_field_grp_t field_group_id,
uint64_t update_freq, double max_keep_age,
uint32_t max_keep_samples) override;
rdc_status_t rdc_field_get_latest_value(uint32_t gpu_index, rdc_field_t field,
rdc_field_value* value) override;
rdc_status_t rdc_field_get_value_since(uint32_t gpu_index, rdc_field_t field,
uint64_t since_time_stamp, uint64_t* next_since_time_stamp,
rdc_field_value* value) override;
rdc_status_t rdc_field_unwatch(rdc_gpu_group_t group_id, rdc_field_grp_t field_group_id) override;
// Diagnostic API
rdc_status_t rdc_diagnostic_run(rdc_gpu_group_t group_id, rdc_diag_level_t level,
rdc_diag_response_t* response) override;
rdc_status_t rdc_test_case_run(rdc_gpu_group_t group_id, rdc_diag_test_cases_t test_case,
rdc_diag_test_result_t* result) override;
// Control API
rdc_status_t rdc_field_update_all(uint32_t wait_for_update) override;
// Control API
rdc_status_t rdc_field_update_all(uint32_t wait_for_update) override;
explicit RdcEmbeddedHandler(rdc_operation_mode_t op_mode);
~RdcEmbeddedHandler();
explicit RdcEmbeddedHandler(rdc_operation_mode_t op_mode);
~RdcEmbeddedHandler();
private:
rdc_status_t get_gpu_gauges(rdc_gpu_gauges_t* gpu_gauges);
RdcGroupSettingsPtr group_settings_;
RdcCacheManagerPtr cache_mgr_;
RdcMetricFetcherPtr metric_fetcher_;
RdcModuleMgrPtr rdc_module_mgr_;
RdcNotificationPtr rdc_notif_;
RdcWatchTablePtr watch_table_;
RdcMetricsUpdaterPtr metrics_updater_;
std::future<void> updater_;
rdc_status_t get_gpu_gauges(rdc_gpu_gauges_t* gpu_gauges);
RdcGroupSettingsPtr group_settings_;
RdcCacheManagerPtr cache_mgr_;
RdcMetricFetcherPtr metric_fetcher_;
RdcModuleMgrPtr rdc_module_mgr_;
RdcNotificationPtr rdc_notif_;
RdcWatchTablePtr watch_table_;
RdcMetricsUpdaterPtr metrics_updater_;
std::future<void> updater_;
};
} // namespace rdc
} // namespace amd
extern "C" {
amd::rdc::RdcHandler *make_handler(rdc_operation_mode_t op_mode);
amd::rdc::RdcHandler* make_handler(rdc_operation_mode_t op_mode);
}
#endif // INCLUDE_RDC_LIB_IMPL_RDCEMBEDDEDHANDLER_H_
include/rdc_lib/impl/RdcGroupSettingsImpl.h
+26 -31
Féach ar an gComhad
@@ -22,52 +22,47 @@ THE SOFTWARE.
#ifndef INCLUDE_RDC_LIB_IMPL_RDCGROUPSETTINGSIMPL_H_
#define INCLUDE_RDC_LIB_IMPL_RDCGROUPSETTINGSIMPL_H_
#include <memory>
#include <map>
#include <mutex> // NOLINT
#include <memory>
#include <mutex> // NOLINT
#include <string>
#include "rdc_lib/RdcGroupSettings.h"
namespace amd {
namespace rdc {
class RdcGroupSettingsImpl: public RdcGroupSettings {
class RdcGroupSettingsImpl : public RdcGroupSettings {
public:
rdc_status_t rdc_group_gpu_create(
const char* group_name, rdc_gpu_group_t* p_rdc_group_id) override;
rdc_status_t rdc_group_gpu_destroy(
rdc_gpu_group_t p_rdc_group_id) override;
rdc_status_t rdc_group_gpu_add(rdc_gpu_group_t groupId,
uint32_t gpu_index) override;
rdc_status_t rdc_group_gpu_get_info(rdc_gpu_group_t p_rdc_group_id,
rdc_group_info_t* p_rdc_group_info) override;
rdc_status_t rdc_group_get_all_ids(
rdc_gpu_group_t group_id_list[], uint32_t* count) override;
rdc_status_t rdc_group_gpu_create(const char* group_name,
rdc_gpu_group_t* p_rdc_group_id) override;
rdc_status_t rdc_group_gpu_destroy(rdc_gpu_group_t p_rdc_group_id) override;
rdc_status_t rdc_group_gpu_add(rdc_gpu_group_t groupId, uint32_t gpu_index) override;
rdc_status_t rdc_group_gpu_get_info(rdc_gpu_group_t p_rdc_group_id,
rdc_group_info_t* p_rdc_group_info) override;
rdc_status_t rdc_group_get_all_ids(rdc_gpu_group_t group_id_list[], uint32_t* count) override;
rdc_status_t rdc_group_field_create(uint32_t num_field_ids,
rdc_field_t* field_ids, const char* field_group_name,
rdc_field_grp_t* rdc_field_group_id) override;
rdc_status_t rdc_group_field_destroy(
rdc_field_grp_t rdc_field_group_id) override;
rdc_status_t rdc_group_field_get_info(
rdc_field_grp_t rdc_field_group_id,
rdc_field_group_info_t* field_group_info) override;
rdc_status_t rdc_group_field_get_all_ids(
rdc_field_grp_t field_group_id_list[], uint32_t* count) override;
rdc_status_t rdc_group_field_create(uint32_t num_field_ids, rdc_field_t* field_ids,
const char* field_group_name,
rdc_field_grp_t* rdc_field_group_id) override;
rdc_status_t rdc_group_field_destroy(rdc_field_grp_t rdc_field_group_id) override;
rdc_status_t rdc_group_field_get_info(rdc_field_grp_t rdc_field_group_id,
rdc_field_group_info_t* field_group_info) override;
rdc_status_t rdc_group_field_get_all_ids(rdc_field_grp_t field_group_id_list[],
uint32_t* count) override;
RdcGroupSettingsImpl();
RdcGroupSettingsImpl();
private:
std::map<rdc_gpu_group_t, rdc_group_info_t> gpu_group_;
std::map<rdc_field_grp_t, rdc_field_group_info_t> field_group_;
uint32_t cur_group_id_ = 1;
uint32_t cur_field_group_id_ = 0;
std::mutex group_mutex_;
std::mutex field_group_mutex_;
std::map<rdc_gpu_group_t, rdc_group_info_t> gpu_group_;
std::map<rdc_field_grp_t, rdc_field_group_info_t> field_group_;
uint32_t cur_group_id_ = 1;
uint32_t cur_field_group_id_ = 0;
std::mutex group_mutex_;
std::mutex field_group_mutex_;
};
} // namespace rdc
} // namespace amd
#endif // INCLUDE_RDC_LIB_IMPL_RDCGROUPSETTINGSIMPL_H_
include/rdc_lib/impl/RdcMetricFetcherImpl.h
+41 -42
Féach ar an gComhad
@@ -22,12 +22,13 @@ THE SOFTWARE.
#ifndef INCLUDE_RDC_LIB_IMPL_RDCMETRICFETCHERIMPL_H_
#define INCLUDE_RDC_LIB_IMPL_RDCMETRICFETCHERIMPL_H_
#include <mutex> // NOLINT(build/c++11)
#include <future> // NOLINT(build/c++11)
#include <memory>
#include <condition_variable> // NOLINT(build/c++11)
#include <future> // NOLINT(build/c++11)
#include <map>
#include <memory>
#include <mutex> // NOLINT(build/c++11)
#include <queue>
#include "rdc_lib/RdcMetricFetcher.h"
#include "rdc_lib/rdc_common.h"
#include "rocm_smi/rocm_smi.h"
@@ -38,9 +39,9 @@ namespace rdc {
//!< Some metrics, like PCIe throughput may take a second to retreive. The
//!< MetricValue will cache those metrics for async retreive.
struct MetricValue {
uint64_t cache_ttl;
uint64_t last_time;
rdc_field_value value;
uint64_t cache_ttl;
uint64_t last_time;
rdc_field_value value;
};
// This union represents any RSMI handles require initialization and/or
@@ -49,56 +50,54 @@ struct MetricValue {
// underlying raw event, then only one FieldRSMIData should be created,
// and it should be used by both events.
struct FieldRSMIData {
union {
rsmi_event_handle_t evt_handle;
};
union {
rsmi_counter_value_t counter_val;
};
~FieldRSMIData() {}
FieldRSMIData() : evt_handle(0), counter_val{0, 0, 0}{}
union {
rsmi_event_handle_t evt_handle;
};
union {
rsmi_counter_value_t counter_val;
};
~FieldRSMIData() {}
FieldRSMIData() : evt_handle(0), counter_val{0, 0, 0} {}
};
//!< The data structure to store the async fetch task
class RdcMetricFetcherImpl;
struct MetricTask {
RdcFieldKey field;
std::function<void(RdcMetricFetcherImpl&, RdcFieldKey)> task;
RdcFieldKey field;
std::function<void(RdcMetricFetcherImpl&, RdcFieldKey)> task;
};
class RdcMetricFetcherImpl: public RdcMetricFetcher {
class RdcMetricFetcherImpl : public RdcMetricFetcher {
public:
rdc_status_t fetch_smi_field(uint32_t gpu_index,
rdc_field_t field_id, rdc_field_value* value) override;
rdc_status_t bulk_fetch_smi_fields(
rdc_gpu_field_t* fields, uint32_t fields_count,
std::vector<rdc_gpu_field_value_t>& results) override; // NOLINT
RdcMetricFetcherImpl();
~RdcMetricFetcherImpl();
rdc_status_t fetch_smi_field(uint32_t gpu_index, rdc_field_t field_id,
rdc_field_value* value) override;
rdc_status_t bulk_fetch_smi_fields(
rdc_gpu_field_t* fields, uint32_t fields_count,
std::vector<rdc_gpu_field_value_t>& results) override; // NOLINT
RdcMetricFetcherImpl();
~RdcMetricFetcherImpl();
rdc_status_t acquire_rsmi_handle(RdcFieldKey fk) override;
rdc_status_t delete_rsmi_handle(RdcFieldKey fk) override;
rdc_status_t acquire_rsmi_handle(RdcFieldKey fk) override;
rdc_status_t delete_rsmi_handle(RdcFieldKey fk) override;
private:
std::shared_ptr<FieldRSMIData> get_rsmi_data(RdcFieldKey key);
std::shared_ptr<FieldRSMIData> get_rsmi_data(RdcFieldKey key);
uint64_t now();
void get_ecc_error(uint32_t gpu_index,
rdc_field_t field_id, rdc_field_value* value);
uint64_t now();
void get_ecc_error(uint32_t gpu_index, rdc_field_t field_id, rdc_field_value* value);
//!< return true if starting async_get
bool async_get_pcie_throughput(uint32_t gpu_index,
rdc_field_t field_id, rdc_field_value* value);
void get_pcie_throughput(const RdcFieldKey& key);
//!< return true if starting async_get
bool async_get_pcie_throughput(uint32_t gpu_index, rdc_field_t field_id, rdc_field_value* value);
void get_pcie_throughput(const RdcFieldKey& key);
//!< Async metric retreive
std::map<RdcFieldKey, MetricValue> async_metrics_;
std::map<RdcFieldKey, std::shared_ptr<FieldRSMIData>> rsmi_data_;
std::queue<MetricTask> updated_tasks_;
std::mutex task_mutex_;
std::future<void> updater_; // keep the future of updater
std::condition_variable cv_;
std::atomic<bool> task_started_;
//!< Async metric retreive
std::map<RdcFieldKey, MetricValue> async_metrics_;
std::map<RdcFieldKey, std::shared_ptr<FieldRSMIData>> rsmi_data_;
std::queue<MetricTask> updated_tasks_;
std::mutex task_mutex_;
std::future<void> updater_; // keep the future of updater
std::condition_variable cv_;
std::atomic<bool> task_started_;
};
rdc_status_t Rsmi2RdcError(rsmi_status_t rsmi);
include/rdc_lib/impl/RdcMetricsUpdaterImpl.h
+12 -10
Féach ar an gComhad
@@ -24,24 +24,26 @@ THE SOFTWARE.
#include <future> // NOLINT(build/c++11)
#include <memory>
#include "rdc_lib/RdcMetricsUpdater.h"
#include "rdc_lib/RdcWatchTable.h"
namespace amd {
namespace rdc {
class RdcMetricsUpdaterImpl: public RdcMetricsUpdater {
class RdcMetricsUpdaterImpl : public RdcMetricsUpdater {
public:
void start() override;
void stop() override;
explicit RdcMetricsUpdaterImpl(const RdcWatchTablePtr& watch_table,
const uint32_t check_frequency);
void start() override;
void stop() override;
explicit RdcMetricsUpdaterImpl(const RdcWatchTablePtr& watch_table,
const uint32_t check_frequency);
private:
RdcWatchTablePtr watch_table_;
std::atomic<bool> started_;
std::future<void> updater_; // keep the future of updater
std::future<void> notif_updater_; // keep the future of notif updater
const uint32_t _check_frequency; // Check frequency in milliseconds
RdcWatchTablePtr watch_table_;
std::atomic<bool> started_;
std::future<void> updater_; // keep the future of updater
std::future<void> notif_updater_; // keep the future of notif updater
const uint32_t _check_frequency; // Check frequency in milliseconds
};
} // namespace rdc
include/rdc_lib/impl/RdcModuleMgrImpl.h
+8 -8
Féach ar an gComhad
@@ -36,17 +36,17 @@ namespace rdc {
class RdcModuleMgrImpl : public RdcModuleMgr {
public:
RdcTelemetryPtr get_telemetry_module() override;
RdcDiagnosticPtr get_diagnostic_module() override;
explicit RdcModuleMgrImpl(const RdcMetricFetcherPtr& fetcher);
RdcTelemetryPtr get_telemetry_module() override;
RdcDiagnosticPtr get_diagnostic_module() override;
explicit RdcModuleMgrImpl(const RdcMetricFetcherPtr& fetcher);
private:
// Function module
RdcTelemetryPtr rdc_telemetry_module_;
RdcDiagnosticPtr rdc_diagnostic_module_;
// Function module
RdcTelemetryPtr rdc_telemetry_module_;
RdcDiagnosticPtr rdc_diagnostic_module_;
// Domain module
RdcMetricFetcherPtr fetcher_;
// Domain module
RdcMetricFetcherPtr fetcher_;
};
} // namespace rdc
include/rdc_lib/impl/RdcNotificationImpl.h
+14 -18
Féach ar an gComhad
@@ -22,40 +22,36 @@ THE SOFTWARE.
#ifndef INCLUDE_RDC_LIB_IMPL_RDCNOTIFICATIONIMPL_H_
#define INCLUDE_RDC_LIB_IMPL_RDCNOTIFICATIONIMPL_H_
#include <memory>
#include <vector>
#include <map>
#include <memory>
#include <mutex>
#include <vector>
#include "rdc_lib/rdc_common.h"
#include "rdc_lib/RdcNotification.h"
#include "rdc/rdc.h"
#include "rdc_lib/RdcNotification.h"
#include "rdc_lib/rdc_common.h"
namespace amd {
namespace rdc {
class RdcNotificationImpl : public RdcNotification {
public:
RdcNotificationImpl();
~RdcNotificationImpl();
RdcNotificationImpl();
~RdcNotificationImpl();
bool is_notification_event(rdc_field_t field) const override;
rdc_status_t set_listen_events(
const std::vector<RdcFieldKey> fk_arr) override;
// Blocking
rdc_status_t listen(rdc_evnt_notification_t *events,
uint32_t *num_events, uint32_t timeout_ms) override;
rdc_status_t stop_listening(uint32_t gpu_id) override;
bool is_notification_event(rdc_field_t field) const override;
rdc_status_t set_listen_events(const std::vector<RdcFieldKey> fk_arr) override;
// Blocking
rdc_status_t listen(rdc_evnt_notification_t* events, uint32_t* num_events,
uint32_t timeout_ms) override;
rdc_status_t stop_listening(uint32_t gpu_id) override;
private:
std::map<uint32_t, uint64_t> gpu_evnt_notif_masks_;
std::mutex notif_mutex_;
std::map<uint32_t, uint64_t> gpu_evnt_notif_masks_;
std::mutex notif_mutex_;
};
} // namespace rdc
} // namespace amd
#endif // INCLUDE_RDC_LIB_IMPL_RDCNOTIFICATIONIMPL_H_
include/rdc_lib/impl/RdcRasLib.h
+35 -45
Féach ar an gComhad
@@ -22,76 +22,66 @@ THE SOFTWARE.
#ifndef INCLUDE_RDC_LIB_IMPL_RDCRASLIB_H_
#define INCLUDE_RDC_LIB_IMPL_RDCRASLIB_H_
#include <map>
#include <list>
#include <vector>
#include <memory>
#include <algorithm>
#include <list>
#include <map>
#include <memory>
#include <string>
#include <vector>
#include "rdc_lib/RdcDiagnostic.h"
#include "rdc_lib/RdcLibraryLoader.h"
#include "rdc_lib/RdcTelemetry.h"
#include "rdc_lib/RdcDiagnostic.h"
namespace amd {
namespace rdc {
class RdcRasLib: public RdcTelemetry, public RdcDiagnostic {
class RdcRasLib : public RdcTelemetry, public RdcDiagnostic {
public:
// get support field ids
rdc_status_t rdc_telemetry_fields_query(uint32_t field_ids[MAX_NUM_FIELDS],
uint32_t* field_count) override;
// get support field ids
rdc_status_t rdc_telemetry_fields_query(uint32_t field_ids[MAX_NUM_FIELDS],
uint32_t* field_count) override;
// Fetch
rdc_status_t rdc_telemetry_fields_value_get(rdc_gpu_field_t* fields,
uint32_t fields_count, rdc_field_value_f callback,
void* user_data) override;
// Fetch
rdc_status_t rdc_telemetry_fields_value_get(rdc_gpu_field_t* fields, uint32_t fields_count,
rdc_field_value_f callback, void* user_data) override;
rdc_status_t rdc_telemetry_fields_watch(rdc_gpu_field_t* fields,
uint32_t fields_count) override;
rdc_status_t rdc_telemetry_fields_watch(rdc_gpu_field_t* fields, uint32_t fields_count) override;
rdc_status_t rdc_telemetry_fields_unwatch(rdc_gpu_field_t* fields,
uint32_t fields_count) override;
rdc_status_t rdc_telemetry_fields_unwatch(rdc_gpu_field_t* fields,
uint32_t fields_count) override;
rdc_status_t rdc_diag_test_cases_query(
rdc_diag_test_cases_t test_cases[MAX_TEST_CASES],
uint32_t* test_case_count) override;
rdc_status_t rdc_diag_test_cases_query(rdc_diag_test_cases_t test_cases[MAX_TEST_CASES],
uint32_t* test_case_count) override;
// Run a specific test case
rdc_status_t rdc_test_case_run(
rdc_diag_test_cases_t test_case,
uint32_t gpu_index[RDC_MAX_NUM_DEVICES],
uint32_t gpu_count,
rdc_diag_test_result_t* result) override;
// Run a specific test case
rdc_status_t rdc_test_case_run(rdc_diag_test_cases_t test_case,
uint32_t gpu_index[RDC_MAX_NUM_DEVICES], uint32_t gpu_count,
rdc_diag_test_result_t* result) override;
rdc_status_t rdc_diagnostic_run(
const rdc_group_info_t& gpus,
rdc_diag_level_t level,
rdc_diag_response_t* response) override;
rdc_status_t rdc_diagnostic_run(const rdc_group_info_t& gpus, rdc_diag_level_t level,
rdc_diag_response_t* response) override;
rdc_status_t rdc_diag_init(uint64_t flags) override;
rdc_status_t rdc_diag_destroy() override;
rdc_status_t rdc_diag_init(uint64_t flags) override;
rdc_status_t rdc_diag_destroy() override;
explicit RdcRasLib();
RdcRasLib();
~RdcRasLib();
~RdcRasLib();
private:
RdcLibraryLoader lib_loader_;
rdc_status_t (*fields_value_get_)(rdc_gpu_field_t*,
uint32_t, rdc_field_value_f, void*);
rdc_status_t (*fields_query_)(uint32_t[MAX_NUM_FIELDS], uint32_t*);
RdcLibraryLoader lib_loader_;
rdc_status_t (*fields_value_get_)(rdc_gpu_field_t*, uint32_t, rdc_field_value_f, void*);
rdc_status_t (*fields_query_)(uint32_t[MAX_NUM_FIELDS], uint32_t*);
rdc_status_t (*fields_watch_)(rdc_gpu_field_t*, uint32_t);
rdc_status_t (*fields_unwatch_)(rdc_gpu_field_t*, uint32_t);
rdc_status_t (*fields_watch_)(rdc_gpu_field_t*, uint32_t);
rdc_status_t (*fields_unwatch_)(rdc_gpu_field_t*, uint32_t);
rdc_status_t (*rdc_module_init_)(uint64_t);
rdc_status_t (*rdc_module_destroy_)();
rdc_status_t (*rdc_module_init_)(uint64_t);
rdc_status_t (*rdc_module_destroy_)();
};
typedef std::shared_ptr<RdcRasLib> RdcRasLibPtr;
} // namespace rdc
} // namespace amd
#endif // INCLUDE_RDC_LIB_IMPL_RDCRASLIB_H_
include/rdc_lib/impl/RdcRocpLib.h
+28 -43
Féach ar an gComhad
@@ -34,63 +34,48 @@ namespace rdc {
class RdcRocpLib : public RdcTelemetry {
public:
/* Telemetry */
/* Telemetry */
// get support field ids
rdc_status_t rdc_telemetry_fields_query(
uint32_t field_ids[MAX_NUM_FIELDS],
uint32_t* field_count) override;
// get support field ids
rdc_status_t rdc_telemetry_fields_query(uint32_t field_ids[MAX_NUM_FIELDS],
uint32_t* field_count) override;
// Fetch
rdc_status_t rdc_telemetry_fields_value_get(
rdc_gpu_field_t* fields,
uint32_t fields_count,
rdc_field_value_f callback,
void* user_data) override;
// Fetch
rdc_status_t rdc_telemetry_fields_value_get(rdc_gpu_field_t* fields, uint32_t fields_count,
rdc_field_value_f callback, void* user_data) override;
rdc_status_t rdc_telemetry_fields_watch(
rdc_gpu_field_t* fields,
uint32_t fields_count) override;
rdc_status_t rdc_telemetry_fields_watch(rdc_gpu_field_t* fields, uint32_t fields_count) override;
rdc_status_t rdc_telemetry_fields_unwatch(
rdc_gpu_field_t* fields,
uint32_t fields_count) override;
rdc_status_t rdc_telemetry_fields_unwatch(rdc_gpu_field_t* fields,
uint32_t fields_count) override;
explicit RdcRocpLib(const char* lib_name);
explicit RdcRocpLib(const char* lib_name);
~RdcRocpLib();
~RdcRocpLib();
private:
RdcLibraryLoader lib_loader_;
RdcLibraryLoader lib_loader_;
rdc_status_t (*telemetry_fields_query_)(
uint32_t field_ids[MAX_NUM_FIELDS],
uint32_t* field_count);
rdc_status_t (*telemetry_fields_query_)(uint32_t field_ids[MAX_NUM_FIELDS],
uint32_t* field_count);
rdc_status_t (*telemetry_fields_value_get_)(
rdc_gpu_field_t* fields,
uint32_t fields_count,
rdc_field_value_f callback,
void* user_data);
rdc_status_t (*telemetry_fields_value_get_)(rdc_gpu_field_t* fields, uint32_t fields_count,
rdc_field_value_f callback, void* user_data);
rdc_status_t (*telemetry_fields_watch_)(
rdc_gpu_field_t* fields,
uint32_t fields_count);
rdc_status_t (*telemetry_fields_watch_)(rdc_gpu_field_t* fields, uint32_t fields_count);
rdc_status_t (*telemetry_fields_unwatch_)(
rdc_gpu_field_t* fields,
uint32_t fields_count);
rdc_status_t (*telemetry_fields_unwatch_)(rdc_gpu_field_t* fields, uint32_t fields_count);
/**
* @brief Extract current ROCM_PATH from library or the environment
*/
std::string get_rocm_path();
/**
* @brief Extract current ROCM_PATH from library or the environment
*/
std::string get_rocm_path();
/**
* @brief Set ROCMTOOLS_METRICS_PATH environment variable needed by
* librocmtools
*/
rdc_status_t set_rocmtools_path();
/**
* @brief Set ROCMTOOLS_METRICS_PATH environment variable needed by
* librocmtools
*/
rdc_status_t set_rocmtools_path();
};
using RdcRocpLibPtr = std::shared_ptr<RdcRocpLib>;
include/rdc_lib/impl/RdcRocrLib.h
+21 -27
Féach ar an gComhad
@@ -22,48 +22,42 @@ THE SOFTWARE.
#ifndef INCLUDE_RDC_LIB_IMPL_RDCROCRLIB_H_
#define INCLUDE_RDC_LIB_IMPL_RDCROCRLIB_H_
#include <vector>
#include <memory>
#include "rdc_lib/RdcLibraryLoader.h"
#include <vector>
#include "rdc_lib/RdcDiagnostic.h"
#include "rdc_lib/RdcLibraryLoader.h"
namespace amd {
namespace rdc {
class RdcRocrLib : public RdcDiagnostic {
public:
rdc_status_t rdc_diag_test_cases_query(
rdc_diag_test_cases_t test_cases[MAX_TEST_CASES],
uint32_t* test_case_count) override;
rdc_status_t rdc_diag_test_cases_query(rdc_diag_test_cases_t test_cases[MAX_TEST_CASES],
uint32_t* test_case_count) override;
// Run a specific test case
rdc_status_t rdc_test_case_run(
rdc_diag_test_cases_t test_case,
uint32_t gpu_index[RDC_MAX_NUM_DEVICES],
uint32_t gpu_count,
rdc_diag_test_result_t* result) override;
// Run a specific test case
rdc_status_t rdc_test_case_run(rdc_diag_test_cases_t test_case,
uint32_t gpu_index[RDC_MAX_NUM_DEVICES], uint32_t gpu_count,
rdc_diag_test_result_t* result) override;
rdc_status_t rdc_diagnostic_run(
const rdc_group_info_t& gpus,
rdc_diag_level_t level,
rdc_diag_response_t* response) override;
rdc_status_t rdc_diagnostic_run(const rdc_group_info_t& gpus, rdc_diag_level_t level,
rdc_diag_response_t* response) override;
rdc_status_t rdc_diag_init(uint64_t flags) override;
rdc_status_t rdc_diag_destroy() override;
rdc_status_t rdc_diag_init(uint64_t flags) override;
rdc_status_t rdc_diag_destroy() override;
explicit RdcRocrLib();
RdcRocrLib();
~RdcRocrLib();
~RdcRocrLib();
private:
RdcLibraryLoader lib_loader_;
rdc_status_t (*test_case_run_)(rdc_diag_test_cases_t,
uint32_t[RDC_MAX_NUM_DEVICES], uint32_t,
rdc_diag_test_result_t*);
rdc_status_t (*diag_test_cases_query_)(
rdc_diag_test_cases_t[MAX_TEST_CASES], uint32_t*);
rdc_status_t (*diag_init_)(uint64_t);
rdc_status_t (*diag_destroy_)();
RdcLibraryLoader lib_loader_;
rdc_status_t (*test_case_run_)(rdc_diag_test_cases_t, uint32_t[RDC_MAX_NUM_DEVICES], uint32_t,
rdc_diag_test_result_t*);
rdc_status_t (*diag_test_cases_query_)(rdc_diag_test_cases_t[MAX_TEST_CASES], uint32_t*);
rdc_status_t (*diag_init_)(uint64_t);
rdc_status_t (*diag_destroy_)();
};
typedef std::shared_ptr<RdcRocrLib> RdcRocrLibPtr;
include/rdc_lib/impl/RdcSmiDiagnosticImpl.h
+17 -26
Féach ar an gComhad
@@ -23,8 +23,9 @@ THE SOFTWARE.
#define INCLUDE_RDC_LIB_IMPL_RDCSMIDIAGNOSTICIMPL_H_
#include <memory>
#include <string>
#include "rdc_lib/rdc_common.h"
#include "rdc/rdc.h"
#include "rdc_lib/rdc_common.h"
#include "rocm_smi/rocm_smi.h"
namespace amd {
@@ -32,35 +33,25 @@ namespace rdc {
class RdcSmiDiagnosticImpl {
public:
RdcSmiDiagnosticImpl();
RdcSmiDiagnosticImpl();
rdc_status_t check_rsmi_process_info(
uint32_t gpu_index[RDC_MAX_NUM_DEVICES],
uint32_t gpu_count,
rdc_diag_test_result_t* result);
rdc_status_t check_rsmi_topo_info(
uint32_t gpu_index[RDC_MAX_NUM_DEVICES],
uint32_t gpu_count,
rdc_diag_test_result_t* result);
rdc_status_t check_rsmi_param_info(
uint32_t gpu_index[RDC_MAX_NUM_DEVICES],
uint32_t gpu_count,
rdc_diag_test_result_t* result);
rdc_status_t check_rsmi_process_info(uint32_t gpu_index[RDC_MAX_NUM_DEVICES], uint32_t gpu_count,
rdc_diag_test_result_t* result);
rdc_status_t check_rsmi_topo_info(uint32_t gpu_index[RDC_MAX_NUM_DEVICES], uint32_t gpu_count,
rdc_diag_test_result_t* result);
rdc_status_t check_rsmi_param_info(uint32_t gpu_index[RDC_MAX_NUM_DEVICES], uint32_t gpu_count,
rdc_diag_test_result_t* result);
private:
rdc_diag_result_t check_temperature_level(uint32_t gpu_index
, rsmi_temperature_type_t type
, char msg[MAX_DIAG_MSG_LENGTH]
, char per_gpu_msg[MAX_DIAG_MSG_LENGTH]);
std::string get_temperature_string(
rsmi_temperature_type_t type) const;
rdc_diag_result_t check_temperature_level(uint32_t gpu_index, rsmi_temperature_type_t type,
char msg[MAX_DIAG_MSG_LENGTH],
char per_gpu_msg[MAX_DIAG_MSG_LENGTH]);
std::string get_temperature_string(rsmi_temperature_type_t type) const;
rdc_diag_result_t check_voltage_level(uint32_t gpu_index
, rsmi_voltage_type_t type
, char msg[MAX_DIAG_MSG_LENGTH]
, char per_gpu_msg[MAX_DIAG_MSG_LENGTH]);
std::string get_voltage_string(
rsmi_voltage_type_t type) const;
rdc_diag_result_t check_voltage_level(uint32_t gpu_index, rsmi_voltage_type_t type,
char msg[MAX_DIAG_MSG_LENGTH],
char per_gpu_msg[MAX_DIAG_MSG_LENGTH]);
std::string get_voltage_string(rsmi_voltage_type_t type) const;
};
typedef std::shared_ptr<RdcSmiDiagnosticImpl> RdcSmiDiagnosticPtr;
include/rdc_lib/impl/RdcSmiLib.h
+26 -32
Féach ar an gComhad
@@ -22,11 +22,12 @@ THE SOFTWARE.
#ifndef INCLUDE_RDC_LIB_IMPL_RDCSMILIB_H_
#define INCLUDE_RDC_LIB_IMPL_RDCSMILIB_H_
#include <vector>
#include <memory>
#include <vector>
#include "rdc_lib/RdcDiagnostic.h"
#include "rdc_lib/RdcMetricFetcher.h"
#include "rdc_lib/RdcTelemetry.h"
#include "rdc_lib/RdcDiagnostic.h"
#include "rdc_lib/impl/RdcSmiDiagnosticImpl.h"
namespace amd {
@@ -34,45 +35,38 @@ namespace rdc {
class RdcSmiLib : public RdcTelemetry, public RdcDiagnostic {
public:
// get support field ids
rdc_status_t rdc_telemetry_fields_query(
uint32_t field_ids[MAX_NUM_FIELDS], uint32_t* field_count) override;
// get support field ids
rdc_status_t rdc_telemetry_fields_query(uint32_t field_ids[MAX_NUM_FIELDS],
uint32_t* field_count) override;
// Fetch
rdc_status_t rdc_telemetry_fields_value_get(rdc_gpu_field_t* fields,
uint32_t fields_count, rdc_field_value_f callback,
void* user_data) override;
// Fetch
rdc_status_t rdc_telemetry_fields_value_get(rdc_gpu_field_t* fields, uint32_t fields_count,
rdc_field_value_f callback, void* user_data) override;
rdc_status_t rdc_telemetry_fields_watch(rdc_gpu_field_t* fields,
uint32_t fields_count) override;
rdc_status_t rdc_telemetry_fields_unwatch(rdc_gpu_field_t* fields,
uint32_t fields_count) override;
rdc_status_t rdc_telemetry_fields_watch(rdc_gpu_field_t* fields, uint32_t fields_count) override;
rdc_status_t rdc_telemetry_fields_unwatch(rdc_gpu_field_t* fields,
uint32_t fields_count) override;
rdc_status_t rdc_diag_test_cases_query(
rdc_diag_test_cases_t test_cases[MAX_TEST_CASES],
uint32_t* test_case_count) override;
rdc_status_t rdc_diag_test_cases_query(rdc_diag_test_cases_t test_cases[MAX_TEST_CASES],
uint32_t* test_case_count) override;
// Run a specific test case
rdc_status_t rdc_test_case_run(
rdc_diag_test_cases_t test_case,
uint32_t gpu_index[RDC_MAX_NUM_DEVICES],
uint32_t gpu_count,
rdc_diag_test_result_t* result) override;
// Run a specific test case
rdc_status_t rdc_test_case_run(rdc_diag_test_cases_t test_case,
uint32_t gpu_index[RDC_MAX_NUM_DEVICES], uint32_t gpu_count,
rdc_diag_test_result_t* result) override;
rdc_status_t rdc_diagnostic_run(
const rdc_group_info_t& gpus,
rdc_diag_level_t level,
rdc_diag_response_t* response) override;
rdc_status_t rdc_diagnostic_run(const rdc_group_info_t& gpus, rdc_diag_level_t level,
rdc_diag_response_t* response) override;
rdc_status_t rdc_diag_init(uint64_t flags) override;
rdc_status_t rdc_diag_destroy() override;
rdc_status_t rdc_diag_init(uint64_t flags) override;
rdc_status_t rdc_diag_destroy() override;
explicit RdcSmiLib(const RdcMetricFetcherPtr& mf);
explicit RdcSmiLib(const RdcMetricFetcherPtr& mf);
private:
RdcMetricFetcherPtr metric_fetcher_;
bool bulk_fetch_enabled_;
RdcSmiDiagnosticPtr smi_diag_;
RdcMetricFetcherPtr metric_fetcher_;
bool bulk_fetch_enabled_;
RdcSmiDiagnosticPtr smi_diag_;
};
typedef std::shared_ptr<RdcSmiLib> RdcSmiLibPtr;
include/rdc_lib/impl/RdcStandaloneHandler.h
+56 -69
Féach ar an gComhad
@@ -22,98 +22,85 @@ THE SOFTWARE.
#ifndef INCLUDE_RDC_LIB_IMPL_RDCSTANDALONEHANDLER_H_
#define INCLUDE_RDC_LIB_IMPL_RDCSTANDALONEHANDLER_H_
#include <grpcpp/grpcpp.h>
#include <memory>
#include "rdc.grpc.pb.h" // NOLINT
#include "rdc_lib/RdcHandler.h"
namespace amd {
namespace rdc {
class RdcStandaloneHandler: public RdcHandler {
class RdcStandaloneHandler : public RdcHandler {
public:
// Job RdcAPI
rdc_status_t rdc_job_start_stats(rdc_gpu_group_t groupId,
const char job_id[64], uint64_t update_freq) override;
rdc_status_t rdc_job_get_stats(const char jobId[64],
rdc_job_info_t* p_job_info) override;
rdc_status_t rdc_job_stop_stats(const char job_id[64]) override;
rdc_status_t rdc_job_remove(const char job_id[64]) override;
rdc_status_t rdc_job_remove_all() override;
// Job RdcAPI
rdc_status_t rdc_job_start_stats(rdc_gpu_group_t groupId, const char job_id[64],
uint64_t update_freq) override;
rdc_status_t rdc_job_get_stats(const char jobId[64], rdc_job_info_t* p_job_info) override;
rdc_status_t rdc_job_stop_stats(const char job_id[64]) override;
rdc_status_t rdc_job_remove(const char job_id[64]) override;
rdc_status_t rdc_job_remove_all() override;
// Discovery RdcAPI
rdc_status_t rdc_device_get_all(
uint32_t gpu_index_list[RDC_MAX_NUM_DEVICES], uint32_t* count) override;
rdc_status_t rdc_device_get_attributes(uint32_t gpu_index,
rdc_device_attributes_t* p_rdc_attr) override;
// Discovery RdcAPI
rdc_status_t rdc_device_get_all(uint32_t gpu_index_list[RDC_MAX_NUM_DEVICES],
uint32_t* count) override;
rdc_status_t rdc_device_get_attributes(uint32_t gpu_index,
rdc_device_attributes_t* p_rdc_attr) override;
// Group RdcAPI
rdc_status_t rdc_group_gpu_create(rdc_group_type_t type,
const char* group_name,
rdc_gpu_group_t* p_rdc_group_id) override;
rdc_status_t rdc_group_gpu_add(rdc_gpu_group_t groupId,
uint32_t gpu_index) override;
rdc_status_t rdc_group_field_create(uint32_t num_field_ids,
rdc_field_t* field_ids, const char* field_group_name,
rdc_field_grp_t* rdc_field_group_id) override;
rdc_status_t rdc_group_field_get_info(
rdc_field_grp_t rdc_field_group_id,
rdc_field_group_info_t* field_group_info) override;
rdc_status_t rdc_group_gpu_get_info(rdc_gpu_group_t p_rdc_group_id,
rdc_group_info_t* p_rdc_group_info) override;
rdc_status_t rdc_group_get_all_ids(
rdc_gpu_group_t group_id_list[], uint32_t* count) override;
rdc_status_t rdc_group_field_get_all_ids(
rdc_field_grp_t field_group_id_list[], uint32_t* count) override;
rdc_status_t rdc_group_gpu_destroy(
rdc_gpu_group_t p_rdc_group_id) override;
rdc_status_t rdc_group_field_destroy(
rdc_field_grp_t rdc_field_group_id) override;
// Group RdcAPI
rdc_status_t rdc_group_gpu_create(rdc_group_type_t type, const char* group_name,
rdc_gpu_group_t* p_rdc_group_id) override;
rdc_status_t rdc_group_gpu_add(rdc_gpu_group_t groupId, uint32_t gpu_index) override;
rdc_status_t rdc_group_field_create(uint32_t num_field_ids, rdc_field_t* field_ids,
const char* field_group_name,
rdc_field_grp_t* rdc_field_group_id) override;
rdc_status_t rdc_group_field_get_info(rdc_field_grp_t rdc_field_group_id,
rdc_field_group_info_t* field_group_info) override;
rdc_status_t rdc_group_gpu_get_info(rdc_gpu_group_t p_rdc_group_id,
rdc_group_info_t* p_rdc_group_info) override;
rdc_status_t rdc_group_get_all_ids(rdc_gpu_group_t group_id_list[], uint32_t* count) override;
rdc_status_t rdc_group_field_get_all_ids(rdc_field_grp_t field_group_id_list[],
uint32_t* count) override;
rdc_status_t rdc_group_gpu_destroy(rdc_gpu_group_t p_rdc_group_id) override;
rdc_status_t rdc_group_field_destroy(rdc_field_grp_t rdc_field_group_id) override;
// Field RdcAPI
rdc_status_t rdc_field_watch(rdc_gpu_group_t group_id,
rdc_field_grp_t field_group_id, uint64_t update_freq,
double max_keep_age, uint32_t max_keep_samples) override;
rdc_status_t rdc_field_get_latest_value(uint32_t gpu_index,
rdc_field_t field, rdc_field_value* value) override;
rdc_status_t rdc_field_get_value_since(uint32_t gpu_index,
rdc_field_t field, uint64_t since_time_stamp,
uint64_t *next_since_time_stamp, rdc_field_value* value) override;
rdc_status_t rdc_field_unwatch(rdc_gpu_group_t group_id,
rdc_field_grp_t field_group_id) override;
// Diagnostic API
rdc_status_t rdc_diagnostic_run(
rdc_gpu_group_t group_id,
rdc_diag_level_t level,
rdc_diag_response_t* response) override;
rdc_status_t rdc_test_case_run(
rdc_gpu_group_t group_id,
rdc_diag_test_cases_t test_case,
rdc_diag_test_result_t* result) override;
// Field RdcAPI
rdc_status_t rdc_field_watch(rdc_gpu_group_t group_id, rdc_field_grp_t field_group_id,
uint64_t update_freq, double max_keep_age,
uint32_t max_keep_samples) override;
rdc_status_t rdc_field_get_latest_value(uint32_t gpu_index, rdc_field_t field,
rdc_field_value* value) override;
rdc_status_t rdc_field_get_value_since(uint32_t gpu_index, rdc_field_t field,
uint64_t since_time_stamp, uint64_t* next_since_time_stamp,
rdc_field_value* value) override;
rdc_status_t rdc_field_unwatch(rdc_gpu_group_t group_id, rdc_field_grp_t field_group_id) override;
// Diagnostic API
rdc_status_t rdc_diagnostic_run(rdc_gpu_group_t group_id, rdc_diag_level_t level,
rdc_diag_response_t* response) override;
rdc_status_t rdc_test_case_run(rdc_gpu_group_t group_id, rdc_diag_test_cases_t test_case,
rdc_diag_test_result_t* result) override;
// Control RdcAPI
rdc_status_t rdc_field_update_all(uint32_t wait_for_update) override;
// Control RdcAPI
rdc_status_t rdc_field_update_all(uint32_t wait_for_update) override;
explicit RdcStandaloneHandler(const char* ip_and_port,
const char* root_ca, const char* client_cert, const char* client_key);
explicit RdcStandaloneHandler(const char* ip_and_port, const char* root_ca,
const char* client_cert, const char* client_key);
private:
// Helper function to handle the error
rdc_status_t error_handle(::grpc::Status status, uint32_t rdc_status);
// Helper function to handle the error
rdc_status_t error_handle(::grpc::Status status, uint32_t rdc_status);
bool copy_gpu_usage_info(
const ::rdc::GpuUsageInfo& src,
rdc_gpu_usage_info_t* target);
bool copy_gpu_usage_info(const ::rdc::GpuUsageInfo& src, rdc_gpu_usage_info_t* target);
std::unique_ptr<::rdc::RdcAPI::Stub> stub_;
std::unique_ptr<::rdc::RdcAPI::Stub> stub_;
};
} // namespace rdc
} // namespace amd
extern "C" {
amd::rdc::RdcHandler *make_handler(const char* ip_port,
const char* root_ca, const char* client_cert, const char* client_key);
amd::rdc::RdcHandler* make_handler(const char* ip_port, const char* root_ca,
const char* client_cert, const char* client_key);
}
#endif // INCLUDE_RDC_LIB_IMPL_RDCSTANDALONEHANDLER_H_
include/rdc_lib/impl/RdcTelemetryModule.h
+18 -23
Féach ar an gComhad
@@ -22,45 +22,41 @@ THE SOFTWARE.
#ifndef INCLUDE_RDC_LIB_IMPL_RDCTELEMETRYMODULE_H_
#define INCLUDE_RDC_LIB_IMPL_RDCTELEMETRYMODULE_H_
#include <map>
#include <list>
#include <vector>
#include <map>
#include <memory>
#include <vector>
#include "rdc_lib/RdcMetricFetcher.h"
#include "rdc_lib/RdcTelemetry.h"
#include "rdc_lib/impl/RdcRasLib.h"
#include "rdc_lib/impl/RdcSmiLib.h"
#include "rdc_lib/RdcMetricFetcher.h"
namespace amd {
namespace rdc {
class RdcTelemetryModule : public RdcTelemetry {
public:
rdc_status_t rdc_telemetry_fields_value_get(rdc_gpu_field_t* fields,
uint32_t fields_count, rdc_field_value_f callback,
void* user_data);
rdc_status_t rdc_telemetry_fields_value_get(rdc_gpu_field_t* fields, uint32_t fields_count,
rdc_field_value_f callback, void* user_data);
rdc_status_t rdc_telemetry_fields_query(uint32_t field_ids[MAX_NUM_FIELDS],
uint32_t* field_count);
rdc_status_t rdc_telemetry_fields_query(uint32_t field_ids[MAX_NUM_FIELDS],
uint32_t* field_count);
rdc_status_t rdc_telemetry_fields_watch(rdc_gpu_field_t* fields,
uint32_t fields_count);
rdc_status_t rdc_telemetry_fields_watch(rdc_gpu_field_t* fields, uint32_t fields_count);
rdc_status_t rdc_telemetry_fields_unwatch(rdc_gpu_field_t* fields,
uint32_t fields_count);
rdc_status_t rdc_telemetry_fields_unwatch(rdc_gpu_field_t* fields, uint32_t fields_count);
RdcTelemetryModule(RdcMetricFetcherPtr fetcher);
explicit RdcTelemetryModule(RdcMetricFetcherPtr fetcher);
private:
//< Helper function to dispatch fields to module
void get_fields_for_module(
rdc_gpu_field_t* fields,
uint32_t fields_count,
std::map<RdcTelemetryPtr, std::vector<rdc_gpu_field_t>>
& fields_in_module,
std::vector<rdc_gpu_field_value_t>& unsupport_fields); // NOLINT
std::list<RdcTelemetryPtr> telemetry_modules_;
std::map<uint32_t, RdcTelemetryPtr> fields_id_module_;
//< Helper function to dispatch fields to module
void get_fields_for_module(
rdc_gpu_field_t* fields, uint32_t fields_count,
std::map<RdcTelemetryPtr, std::vector<rdc_gpu_field_t>>& fields_in_module,
std::vector<rdc_gpu_field_value_t>& unsupport_fields); // NOLINT
std::list<RdcTelemetryPtr> telemetry_modules_;
std::map<uint32_t, RdcTelemetryPtr> fields_id_module_;
};
typedef std::shared_ptr<RdcTelemetryModule> RdcTelemetryModulePtr;
@@ -68,5 +64,4 @@ typedef std::shared_ptr<RdcTelemetryModule> RdcTelemetryModulePtr;
} // namespace rdc
} // namespace amd
#endif // INCLUDE_RDC_LIB_IMPL_RDCTELEMETRYMODULE_H_
include/rdc_lib/impl/RdcWatchTableImpl.h
+70 -78
Féach ar an gComhad
@@ -22,19 +22,20 @@ THE SOFTWARE.
#ifndef INCLUDE_RDC_LIB_IMPL_RDCWATCHTABLEIMPL_H_
#define INCLUDE_RDC_LIB_IMPL_RDCWATCHTABLEIMPL_H_
#include <string>
#include <atomic>
#include <map>
#include <vector>
#include <utility>
#include <memory>
#include <mutex> // NOLINT
#include <atomic>
#include "rdc_lib/RdcWatchTable.h"
#include "rdc_lib/RdcGroupSettings.h"
#include <string>
#include <utility>
#include <vector>
#include "rdc_lib/RdcCacheManager.h"
#include "rdc_lib/RdcGroupSettings.h"
#include "rdc_lib/RdcMetricFetcher.h"
#include "rdc_lib/RdcModuleMgr.h"
#include "rdc_lib/RdcNotification.h"
#include "rdc_lib/RdcWatchTable.h"
#include "rocm_smi/rocm_smi.h"
namespace amd {
@@ -42,104 +43,95 @@ namespace rdc {
//!< The settings for a field or a group of field in the watch table.
struct FieldSettings {
uint64_t update_freq;
uint32_t max_keep_samples;
double max_keep_age;
bool is_watching;
uint64_t last_update_time;
uint64_t update_freq;
uint32_t max_keep_samples;
double max_keep_age;
bool is_watching;
uint64_t last_update_time;
};
struct JobWatchTableEntry {
uint32_t group_id;
std::vector<RdcFieldKey> fields; //< store fields for faster query
uint32_t group_id;
std::vector<RdcFieldKey> fields; //< store fields for faster query
};
class RdcWatchTableImpl : public RdcWatchTable {
public:
rdc_status_t rdc_job_start_stats(rdc_gpu_group_t group_id,
const char job_id[64], uint64_t update_freq,
const rdc_gpu_gauges_t& gpu_gauge) override;
rdc_status_t rdc_job_stop_stats(const char job_id[64],
const rdc_gpu_gauges_t& gpu_gauge) override;
rdc_status_t rdc_job_remove(const char job_id[64]) override;
rdc_status_t rdc_job_remove_all() override;
rdc_status_t rdc_job_start_stats(rdc_gpu_group_t group_id, const char job_id[64],
uint64_t update_freq,
const rdc_gpu_gauges_t& gpu_gauge) override;
rdc_status_t rdc_job_stop_stats(const char job_id[64],
const rdc_gpu_gauges_t& gpu_gauge) override;
rdc_status_t rdc_job_remove(const char job_id[64]) override;
rdc_status_t rdc_job_remove_all() override;
rdc_status_t rdc_field_watch(rdc_gpu_group_t group_id,
rdc_field_grp_t field_group_id, uint64_t update_freq,
double max_keep_age, uint32_t max_keep_samples) override;
rdc_status_t rdc_field_watch(rdc_gpu_group_t group_id, rdc_field_grp_t field_group_id,
uint64_t update_freq, double max_keep_age,
uint32_t max_keep_samples) override;
//!< rdc_field_unwatch() will not remove the entry from watch_table.
//!< The unwatched entry is still kept until the max_keep_age of the entry
//!< is reached, which will be handled in the clean_up() function.
rdc_status_t rdc_field_unwatch(rdc_gpu_group_t group_id,
rdc_field_grp_t field_group_id) override;
//!< rdc_field_unwatch() will not remove the entry from watch_table.
//!< The unwatched entry is still kept until the max_keep_age of the entry
//!< is reached, which will be handled in the clean_up() function.
rdc_status_t rdc_field_unwatch(rdc_gpu_group_t group_id, rdc_field_grp_t field_group_id) override;
//!< When the RDC is running as RDC_OPERATION_MODE_MANUAL, the user will
//!< call this function periodically. Instead of providing other APIs to
//!< cleanup the cache, this function will update and cleanup the cache.
//!<
//!< This function may be called very frequently, and the cache cleanup
//!< is expensive. Internally, this function will throttle the cleanup to
//!< once per second.
rdc_status_t rdc_field_update_all() override;
rdc_status_t rdc_field_listen_notif(uint32_t timeout_ms) override;
//!< When the RDC is running as RDC_OPERATION_MODE_MANUAL, the user will
//!< call this function periodically. Instead of providing other APIs to
//!< cleanup the cache, this function will update and cleanup the cache.
//!<
//!< This function may be called very frequently, and the cache cleanup
//!< is expensive. Internally, this function will throttle the cleanup to
//!< once per second.
rdc_status_t rdc_field_update_all() override;
rdc_status_t rdc_field_listen_notif(uint32_t timeout_ms) override;
RdcWatchTableImpl(const RdcGroupSettingsPtr& group_settings,
const RdcCacheManagerPtr& cache_mgr,
const RdcModuleMgrPtr& module_mgr,
const RdcNotificationPtr& notif);
RdcWatchTableImpl(const RdcGroupSettingsPtr& group_settings, const RdcCacheManagerPtr& cache_mgr,
const RdcModuleMgrPtr& module_mgr, const RdcNotificationPtr& notif);
private:
//!< Helper function to Update the fields_in_table when unwatch tables
rdc_status_t update_field_in_table_when_unwatch(
const RdcFieldGroupKey& entry);
//!< Helper function to Update the fields_in_table when unwatch tables
rdc_status_t update_field_in_table_when_unwatch(const RdcFieldGroupKey& entry);
//!< Helper function to clean up the watch table and cache
void clean_up();
//!< Helper function to clean up the watch table and cache
void clean_up();
//!< Helper function for debug information in watch table and cache
void debug_status();
//!< Helper function for debug information in watch table and cache
void debug_status();
//!< Helper function to get the fields using the group and the field group.
rdc_status_t get_fields_from_group(rdc_gpu_group_t group_id,
rdc_field_grp_t field_group_id,
std::vector<RdcFieldKey> & fields); // NOLINT
//!< Helper function to get the fields using the group and the field group.
rdc_status_t get_fields_from_group(rdc_gpu_group_t group_id, rdc_field_grp_t field_group_id,
std::vector<RdcFieldKey>& fields); // NOLINT
bool is_job_watch_field(uint32_t gpu_index, rdc_field_t field_id,
std::string& job_id) const; // NOLINT
bool is_job_watch_field(uint32_t gpu_index, rdc_field_t field_id,
std::string& job_id) const; // NOLINT
rdc_status_t rdc_notif_update_cache(rdc_evnt_notification_t *events,
uint32_t num_events);
//!< The function will be pass as the callback for bulk fetch
static rdc_status_t handle_fields(rdc_gpu_field_value_t* values,
uint32_t num_values, void* user_data);
rdc_status_t rdc_notif_update_cache(rdc_evnt_notification_t* events, uint32_t num_events);
//!< The function will be pass as the callback for bulk fetch
static rdc_status_t handle_fields(rdc_gpu_field_value_t* values, uint32_t num_values,
void* user_data);
RdcGroupSettingsPtr group_settings_;
RdcCacheManagerPtr cache_mgr_;
RdcModuleMgrPtr rdc_module_mgr_;
RdcNotificationPtr notifications_;
RdcGroupSettingsPtr group_settings_;
RdcCacheManagerPtr cache_mgr_;
RdcModuleMgrPtr rdc_module_mgr_;
RdcNotificationPtr notifications_;
//!< The watch table to store the watch settings.
std::map<RdcFieldGroupKey, FieldSettings> watch_table_;
//!< The watch table to store the watch settings.
std::map<RdcFieldGroupKey, FieldSettings> watch_table_;
//!< <job_id, gpu_group_id> pairs
std::map<std::string, JobWatchTableEntry> job_watch_table_;
//!< <job_id, gpu_group_id> pairs
std::map<std::string, JobWatchTableEntry> job_watch_table_;
//!< The settings for each field can be deduced from watch_table. But every
//!< rdc_field_update_all() call needs to deduce them. To improve the
//!< performance, the fields_to_watch_ is used to track the field settings.
//!< Those settings will only be updated when watching or unwatching.
std::map<RdcFieldKey, FieldSettings> fields_to_watch_;
//!< The settings for each field can be deduced from watch_table. But every
//!< rdc_field_update_all() call needs to deduce them. To improve the
//!< performance, the fields_to_watch_ is used to track the field settings.
//!< Those settings will only be updated when watching or unwatching.
std::map<RdcFieldKey, FieldSettings> fields_to_watch_;
//!< The last clean up time
std::atomic<uint64_t> last_cleanup_time_;
std::mutex watch_mutex_;
//!< The last clean up time
std::atomic<uint64_t> last_cleanup_time_;
std::mutex watch_mutex_;
};
} // namespace rdc
} // namespace amd
#endif // INCLUDE_RDC_LIB_IMPL_RDCWATCHTABLEIMPL_H_
include/rdc_lib/impl/RsmiUtils.h
-1
Féach ar an gComhad
@@ -34,4 +34,3 @@ rdc_status_t Rsmi2RdcError(rsmi_status_t rsmi);
} // namespace amd
#endif // INCLUDE_RDC_LIB_IMPL_RSMIUTILS_H_
include/rdc_lib/rdc_common.h
+12 -13
Féach ar an gComhad
@@ -28,18 +28,18 @@ THE SOFTWARE.
#include "rdc/rdc.h"
#define RDC_ERROR 0
#define RDC_INFO 1
#define RDC_DEBUG 2
#define RDC_ERROR 0
#define RDC_INFO 1
#define RDC_DEBUG 2
#define RDC_LOG(debug_level, msg) do { \
auto& logger = amd::rdc::RdcLogger::getLogger(); \
if (logger.should_log((debug_level))) { \
logger.get_ostream() << \
logger.get_log_header((debug_level), __FILE__, __LINE__) << \
msg << std::endl; \
} \
} while (0)
#define RDC_LOG(debug_level, msg) \
do { \
auto& logger = amd::rdc::RdcLogger::getLogger(); \
if (logger.should_log((debug_level))) { \
logger.get_ostream() << logger.get_log_header((debug_level), __FILE__, __LINE__) << msg \
<< std::endl; \
} \
} while (0)
//<! The key to identify the field with <gpu_id, field_id>
typedef std::pair<uint32_t, rdc_field_t> RdcFieldKey;
@@ -64,7 +64,6 @@ typedef std::map<RdcFieldKey, uint64_t> rdc_gpu_gauges_t;
*
* @retval Return a pointer to the destination string.
*/
char *strncpy_with_null(char *dest, const char *src, size_t n);
char* strncpy_with_null(char* dest, const char* src, size_t n);
#endif // INCLUDE_RDC_LIB_RDC_COMMON_H_
include/rdc_modules/rdc_rocp/RdcRocpBase.h
+56 -58
Féach ar an gComhad
@@ -23,6 +23,7 @@ THE SOFTWARE.
#ifndef RDC_MODULES_RDC_ROCP_RDCROCPBASE_H_
#define RDC_MODULES_RDC_ROCP_RDCROCPBASE_H_
#include <rocmtools.h>
#include <chrono>
#include <cstdint>
#include <cstdio>
@@ -30,6 +31,7 @@ THE SOFTWARE.
#include <string>
#include <typeinfo>
#include <unordered_map>
#include "rdc/rdc.h"
namespace amd {
@@ -62,73 +64,69 @@ static const std::unordered_map<rdc_field_t, const char*> counter_map_k = {
/// Common interface for RocP tests and samples
class RdcRocpBase {
typedef std::pair<uint32_t, rdc_field_t> pair_gpu_field_t;
typedef struct session_info_t {
rocmtools_session_id_t id{};
std::chrono::
time_point<std::chrono::system_clock, std::chrono::nanoseconds>
start_time;
std::chrono::
time_point<std::chrono::system_clock, std::chrono::nanoseconds>
stop_time;
} session_info_t;
typedef std::pair<uint32_t, rdc_field_t> pair_gpu_field_t;
typedef struct session_info_t {
rocmtools_session_id_t id{};
std::chrono::time_point<std::chrono::system_clock, std::chrono::nanoseconds> start_time;
std::chrono::time_point<std::chrono::system_clock, std::chrono::nanoseconds> stop_time;
} session_info_t;
public:
RdcRocpBase();
RdcRocpBase(const RdcRocpBase&) = default;
RdcRocpBase(RdcRocpBase&&) = delete;
RdcRocpBase& operator=(const RdcRocpBase&) = delete;
RdcRocpBase& operator=(RdcRocpBase&&) = delete;
~RdcRocpBase();
RdcRocpBase();
RdcRocpBase(const RdcRocpBase&) = default;
RdcRocpBase(RdcRocpBase&&) = delete;
RdcRocpBase& operator=(const RdcRocpBase&) = delete;
RdcRocpBase& operator=(RdcRocpBase&&) = delete;
~RdcRocpBase();
/**
* @brief Lookup ROCProfiler counter
*
* @param[in] field An existing field already added to sessions dictionary
* @param[out] value A pointer that will be populated with returned value
*
* @retval ::ROCMTOOLS_STATUS_SUCCESS The function has been executed
* successfully.
*/
rdc_status_t rocp_lookup(pair_gpu_field_t gpu_field, double* value);
/**
* @brief Lookup ROCProfiler counter
*
* @param[in] field An existing field already added to sessions dictionary
* @param[out] value A pointer that will be populated with returned value
*
* @retval ::ROCMTOOLS_STATUS_SUCCESS The function has been executed
* successfully.
*/
rdc_status_t rocp_lookup(pair_gpu_field_t gpu_field, double* value);
/**
* @brief Destroy ROCmTools session responsible for monitoring a given
* field
*
* @details While rocmtools supports multiple fields per ID - it has a
* limit to how many counters it can query internally.
* To avoid concerning ourselves with said limit, we limit each session to
* 1 field.
* In the future this can be optimized to allow for multiple fields per
* session.
*
* @param[in] field A field to start monitoring
*
* @retval ::ROCMTOOLS_STATUS_SUCCESS The function has been executed
* successfully.
*/
rdc_status_t create_session(pair_gpu_field_t gpu_field);
/**
* @brief Destroy ROCmTools session responsible for monitoring a given
* field
*
* @details While rocmtools supports multiple fields per ID - it has a
* limit to how many counters it can query internally.
* To avoid concerning ourselves with said limit, we limit each session to
* 1 field.
* In the future this can be optimized to allow for multiple fields per
* session.
*
* @param[in] field A field to start monitoring
*
* @retval ::ROCMTOOLS_STATUS_SUCCESS The function has been executed
* successfully.
*/
rdc_status_t create_session(pair_gpu_field_t gpu_field);
/**
* @brief Destroy ROCmTools session responsible for monitoring a given
* field
*
* @param[in] field A field to stop monitoring
*
* @retval ::ROCMTOOLS_STATUS_SUCCESS The function has been executed
* successfully.
*/
rdc_status_t destroy_session(pair_gpu_field_t gpu_field);
/**
* @brief Destroy ROCmTools session responsible for monitoring a given
* field
*
* @param[in] field A field to stop monitoring
*
* @retval ::ROCMTOOLS_STATUS_SUCCESS The function has been executed
* successfully.
*/
rdc_status_t destroy_session(pair_gpu_field_t gpu_field);
protected:
private:
std::map<pair_gpu_field_t, session_info_t> sessions;
std::map<pair_gpu_field_t, session_info_t> sessions;
/**
* @brief Convert from rocmtools status into RDC status
*/
rdc_status_t Rocp2RdcError(rocmtools_status_t rocm_status);
/**
* @brief Convert from rocmtools status into RDC status
*/
rdc_status_t Rocp2RdcError(rocmtools_status_t rocm_status);
};
} // namespace rdc
include/rdc_modules/rdc_rocr/ComputeQueueTest.h
Inrite → Rialta
+9 -12
Féach ar an gComhad
@@ -22,8 +22,8 @@ THE SOFTWARE.
#ifndef RDC_MODULES_RDC_ROCR_COMPUTEQUEUETEST_H_
#define RDC_MODULES_RDC_ROCR_COMPUTEQUEUETEST_H_
#include "rdc_modules/rdc_rocr/TestBase.h"
#include "hsa/hsa.h"
#include "rdc_modules/rdc_rocr/TestBase.h"
namespace amd {
namespace rdc {
@@ -65,11 +65,10 @@ typedef struct BinarySearch {
// Other items we need to populate AQL packet
uint64_t kernel_object;
uint32_t group_segment_size; ///< Kernel group seg size
uint32_t private_segment_size; ///< Kernel private seg size
uint32_t group_segment_size; ///< Kernel group seg size
uint32_t private_segment_size; ///< Kernel private seg size
} BinarySearch;
class ComputeQueueTest : public TestBase {
public:
explicit ComputeQueueTest(uint32_t gpu_index);
@@ -101,14 +100,12 @@ class ComputeQueueTest : public TestBase {
hsa_status_t LoadKernelFromObjFile(BinarySearch* bs);
hsa_status_t Run(BinarySearch* bs);
hsa_status_t CleanUp(BinarySearch* bs);
void PopulateAQLPacket(BinarySearch const* bs,
hsa_kernel_dispatch_packet_t* aql);
hsa_status_t AgentMemcpy(void* dst, const void* src,
size_t size, hsa_agent_t dst_ag, hsa_agent_t src_ag);
hsa_status_t AllocAndSetKernArgs(BinarySearch* bs, void* args,
size_t arg_size, void** aql_buf_ptr);
void WriteAQLToQueue(hsa_kernel_dispatch_packet_t const* in_aql,
hsa_queue_t* q);
void PopulateAQLPacket(BinarySearch const* bs, hsa_kernel_dispatch_packet_t* aql);
hsa_status_t AgentMemcpy(void* dst, const void* src, size_t size, hsa_agent_t dst_ag,
hsa_agent_t src_ag);
hsa_status_t AllocAndSetKernArgs(BinarySearch* bs, void* args, size_t arg_size,
void** aql_buf_ptr);
void WriteAQLToQueue(hsa_kernel_dispatch_packet_t const* in_aql, hsa_queue_t* q);
};
} // namespace rdc
include/rdc_modules/rdc_rocr/MemoryAccess.h
Inrite → Rialta
+3 -7
Féach ar an gComhad
@@ -23,9 +23,8 @@ THE SOFTWARE.
#ifndef RDC_MODULES_RDC_ROCR_MEMORYACCESS_H_
#define RDC_MODULES_RDC_ROCR_MEMORYACCESS_H_
#include "rdc_modules/rdc_rocr/TestBase.h"
#include "hsa/hsa.h"
#include "rdc_modules/rdc_rocr/TestBase.h"
namespace amd {
namespace rdc {
@@ -51,18 +50,15 @@ class MemoryAccessTest : public TestBase {
// @Brief: Display information about what this test does
virtual void DisplayTestInfo(void);
// @Brief: This test verify that CPU is able to Read & write GPU memory
void CPUAccessToGPUMemoryTest(void);
// @Brief: This test verify that GPU is able to Read & write CPU memory
void GPUAccessToCPUMemoryTest(void);
private:
void CPUAccessToGPUMemoryTest(hsa_agent_t cpuAgent,
hsa_agent_t gpuAgent,
hsa_amd_memory_pool_t pool);
void CPUAccessToGPUMemoryTest(hsa_agent_t cpuAgent, hsa_agent_t gpuAgent,
hsa_amd_memory_pool_t pool);
void GPUAccessToCPUMemoryTest(hsa_agent_t cpuAgent, hsa_agent_t gpuAgent);
};
include/rdc_modules/rdc_rocr/MemoryTest.h
Inrite → Rialta
+2 -3
Féach ar an gComhad
@@ -22,8 +22,8 @@ THE SOFTWARE.
#ifndef RDC_MODULES_RDC_ROCR_MEMORYTEST_H_
#define RDC_MODULES_RDC_ROCR_MEMORYTEST_H_
#include "rdc_modules/rdc_rocr/TestBase.h"
#include "hsa/hsa.h"
#include "rdc_modules/rdc_rocr/TestBase.h"
namespace amd {
namespace rdc {
@@ -54,8 +54,7 @@ class MemoryTest : public TestBase {
hsa_status_t TestAllocate(hsa_amd_memory_pool_t pool, size_t sz);
private:
hsa_status_t MaxSingleAllocationTest(hsa_agent_t ag,
hsa_amd_memory_pool_t pool);
hsa_status_t MaxSingleAllocationTest(hsa_agent_t ag, hsa_amd_memory_pool_t pool);
};
} // namespace rdc
include/rdc_modules/rdc_rocr/RdcDiagnosticLib.h
-1
Féach ar an gComhad
@@ -24,5 +24,4 @@ THE SOFTWARE.
#include "rdc/rdc.h"
#include "rdc_lib/RdcDiagnosticLibInterface.h"
#endif // RDC_MODULES_RDC_DIAGNOSTIC_RDCDIAGNOSTICLIB_H_
include/rdc_modules/rdc_rocr/RdcRocrBase.h
+75 -165
Féach ar an gComhad
@@ -24,10 +24,12 @@ THE SOFTWARE.
#define RDC_MODULES_RDC_ROCR_RDCROCRBASE_H_
#include <stdint.h>
#include <stdio.h>
#include <string>
#include "rdc_lib/RdcPerfTimer.h"
#include "hsa/hsa.h"
#include "hsa/hsa_ext_amd.h"
#include "rdc_lib/RdcPerfTimer.h"
namespace amd {
namespace rdc {
@@ -41,226 +43,134 @@ class RdcRocrBase {
///< Setters and Getters
void set_gpu_device1(hsa_agent_t in_dev) {
gpu_device1_.handle = in_dev.handle;
}
hsa_agent_t* gpu_device1(void) {
return &gpu_device1_;
}
void set_gpu_device1(hsa_agent_t in_dev) { gpu_device1_.handle = in_dev.handle; }
hsa_agent_t* gpu_device1(void) { return &gpu_device1_; }
void set_cpu_device(hsa_agent_t in_dev) {
cpu_device_.handle = in_dev.handle;
}
hsa_agent_t* cpu_device(void) {
return &cpu_device_;
}
void set_cpu_device(hsa_agent_t in_dev) { cpu_device_.handle = in_dev.handle; }
hsa_agent_t* cpu_device(void) { return &cpu_device_; }
void set_kernel_file_name(const char* in_file_name) {
kernel_file_name_ = in_file_name;
}
std::string const kernel_file_name(void) const {
return kernel_file_name_;
}
void set_kernel_file_name(const char* in_file_name) { kernel_file_name_ = in_file_name; }
std::string const kernel_file_name(void) const { return kernel_file_name_; }
void set_kernel_name(std::string in_kernel_name) {
kernel_name_ = in_kernel_name;
}
std::string const kernel_name(void) const {
return kernel_name_;
}
void set_kernel_name(std::string in_kernel_name) { kernel_name_ = in_kernel_name; }
std::string const kernel_name(void) const { return kernel_name_; }
void set_agent_name(std::string in_agent_name) {
agent_name_ = in_agent_name;
}
void set_agent_name(std::string in_agent_name) { agent_name_ = in_agent_name; }
std::string const get_agent_name(void) const {
return agent_name_;
}
std::string const get_agent_name(void) const { return agent_name_; }
void set_kernel_object(uint64_t in_kernel_object) {
kernel_object_ = in_kernel_object;
}
uint64_t kernel_object(void) const {
return kernel_object_;
}
void set_kernel_object(uint64_t in_kernel_object) { kernel_object_ = in_kernel_object; }
uint64_t kernel_object(void) const { return kernel_object_; }
void set_profile(hsa_profile_t in_prof) {
profile_ = in_prof;
}
hsa_profile_t profile(void) const {
return profile_;
}
void set_profile(hsa_profile_t in_prof) { profile_ = in_prof; }
hsa_profile_t profile(void) const { return profile_; }
uint32_t private_segment_size(void) const {
return private_segment_size_;
}
void set_private_segment_size(uint32_t sz) {
private_segment_size_ = sz;
}
uint32_t private_segment_size(void) const { return private_segment_size_; }
void set_private_segment_size(uint32_t sz) { private_segment_size_ = sz; }
void set_group_segment_size(uint32_t sz) {
group_segment_size_ = sz;
}
uint32_t group_segment_size(void) const {
return group_segment_size_;
}
void set_group_segment_size(uint32_t sz) { group_segment_size_ = sz; }
uint32_t group_segment_size(void) const { return group_segment_size_; }
void set_group_size(uint32_t sz) {
group_size_ = sz;
}
uint32_t group_size(void) const {
return group_size_;
}
void set_group_size(uint32_t sz) { group_size_ = sz; }
uint32_t group_size(void) const { return group_size_; }
void set_main_queue(hsa_queue_t* q) {
main_queue_ = q;
}
hsa_queue_t* main_queue(void) const {
return main_queue_;
}
void set_main_queue(hsa_queue_t* q) { main_queue_ = q; }
hsa_queue_t* main_queue(void) const { return main_queue_; }
hsa_kernel_dispatch_packet_t& aql(void) {
return aql_;
}
hsa_kernel_dispatch_packet_t& aql(void) { return aql_; }
void set_num_iteration(int num) {
num_iteration_ = num;
}
uint32_t num_iteration(void) const {
return num_iteration_;
}
void set_num_iteration(int num) { num_iteration_ = num; }
uint32_t num_iteration(void) const { return num_iteration_; }
hsa_amd_memory_pool_t& device_pool(void) {
return device_pool_;
}
hsa_amd_memory_pool_t& device_pool(void) { return device_pool_; }
hsa_amd_memory_pool_t& cpu_pool(void) {
return cpu_pool_;
}
hsa_amd_memory_pool_t& cpu_pool(void) { return cpu_pool_; }
hsa_amd_memory_pool_t& kern_arg_pool(void) {
return kern_arg_pool_;
}
hsa_amd_memory_pool_t& kern_arg_pool(void) { return kern_arg_pool_; }
void set_kernarg_size(uint32_t sz) {
kernarg_size_ = sz;
}
uint32_t kernarg_size(void) const {
return kernarg_size_;
}
void set_kernarg_size(uint32_t sz) { kernarg_size_ = sz; }
uint32_t kernarg_size(void) const { return kernarg_size_; }
void set_kernarg_align(uint32_t align) {
kernarg_align_ = align;
}
uint32_t kernarg_align(void) const {
return kernarg_align_;
}
void set_kernarg_align(uint32_t align) { kernarg_align_ = align; }
uint32_t kernarg_align(void) const { return kernarg_align_; }
void* kernarg_buffer(void) const {
return kernarg_buffer_;
}
void set_kernarg_buffer(void* buffer) {
kernarg_buffer_ = buffer;
}
void* kernarg_buffer(void) const { return kernarg_buffer_; }
void set_kernarg_buffer(void* buffer) { kernarg_buffer_ = buffer; }
int32_t requires_profile(void) const {
return requires_profile_;
}
int32_t requires_profile(void) const { return requires_profile_; }
char* orig_hsa_enable_interrupt() const {
return orig_hsa_enable_interrupt_;
}
char* orig_hsa_enable_interrupt() const { return orig_hsa_enable_interrupt_; }
bool enable_interrupt() const {
return enable_interrupt_;
}
bool enable_interrupt() const { return enable_interrupt_; }
void set_title(std::string name) {
title_ = name;
}
std::string title(void) const {
return title_;
}
void set_title(std::string name) { title_ = name; }
std::string title(void) const { return title_; }
RdcPerfTimer* hsa_timer(void) {
return &hsa_timer_;
}
RdcPerfTimer* hsa_timer(void) { return &hsa_timer_; }
void set_verbosity(uint32_t v) {
verbosity_ = v;
}
uint32_t verbosity(void) const {
return verbosity_;
}
void set_verbosity(uint32_t v) { verbosity_ = v; }
uint32_t verbosity(void) const { return verbosity_; }
void set_monitor_verbosity(uint32_t m) {
monitor_verbosity_ = m;
}
uint32_t monitor_verbosity(void) const {
return monitor_verbosity_;
}
void set_monitor_verbosity(uint32_t m) { monitor_verbosity_ = m; }
uint32_t monitor_verbosity(void) const { return monitor_verbosity_; }
protected:
void set_requires_profile(int32_t reqd_prof) {
requires_profile_ = reqd_prof;
}
void set_requires_profile(int32_t reqd_prof) { requires_profile_ = reqd_prof; }
void set_enable_interrupt(bool doEnable) {
enable_interrupt_ = doEnable;
}
void set_enable_interrupt(bool doEnable) { enable_interrupt_ = doEnable; }
private:
uint64_t num_iteration_; ///< Number of times to execute test
uint64_t num_iteration_; ///< Number of times to execute test
hsa_queue_t* main_queue_; ///< AQL queue used for packets
hsa_queue_t* main_queue_; ///< AQL queue used for packets
hsa_agent_t gpu_device1_; ///< Handle to first GPU found
hsa_agent_t gpu_device1_; ///< Handle to first GPU found
hsa_agent_t cpu_device_; ///< Handle to CPU
hsa_agent_t cpu_device_; ///< Handle to CPU
hsa_amd_memory_pool_t device_pool_; ///< Memory pool on gpu pool list
hsa_amd_memory_pool_t device_pool_; ///< Memory pool on gpu pool list
hsa_amd_memory_pool_t cpu_pool_; ///< Memory pool on cpu pool list
hsa_amd_memory_pool_t cpu_pool_; ///< Memory pool on cpu pool list
hsa_amd_memory_pool_t kern_arg_pool_; ///< Memory pool suitable for args
hsa_amd_memory_pool_t kern_arg_pool_; ///< Memory pool suitable for args
uint64_t kernel_object_; ///< Handle to kernel code
uint64_t kernel_object_; ///< Handle to kernel code
std::string kernel_file_name_; ///< Code object file name
std::string kernel_file_name_; ///< Code object file name
std::string kernel_name_; ///< Kernel name
std::string kernel_name_; ///< Kernel name
std::string agent_name_; ///< Agent name
std::string agent_name_; ///< Agent name
hsa_kernel_dispatch_packet_t aql_; ///< Kernel dispatch packet
hsa_kernel_dispatch_packet_t aql_; ///< Kernel dispatch packet
uint32_t group_segment_size_; ///< Kernel group seg size
uint32_t group_segment_size_; ///< Kernel group seg size
uint32_t kernarg_size_; ///< Kernarg memory size
uint32_t kernarg_size_; ///< Kernarg memory size
uint32_t kernarg_align_; ///< Alignment for kern argument memory
uint32_t kernarg_align_; ///< Alignment for kern argument memory
void* kernarg_buffer_; ///< Unaligned allocated kernel arg. buffer
void* kernarg_buffer_; ///< Unaligned allocated kernel arg. buffer
hsa_profile_t profile_; ///< Device profile.
hsa_profile_t profile_; ///< Device profile.
uint32_t group_size_; ///< Number of work items in one group
uint32_t group_size_; ///< Number of work items in one group
uint32_t private_segment_size_; ///< Kernel private seg size
uint32_t private_segment_size_; ///< Kernel private seg size
int32_t requires_profile_; ///< Profile required by test (-1 if no req.)
int32_t requires_profile_; ///< Profile required by test (-1 if no req.)
char* orig_hsa_enable_interrupt_; ///< Orig. value of HSA_ENABLE_INTERRUPT
char* orig_hsa_enable_interrupt_; ///< Orig. value of HSA_ENABLE_INTERRUPT
bool enable_interrupt_; ///< Whether to enable/disable interrupts for test
bool enable_interrupt_; ///< Whether to enable/disable interrupts for test
std::string title_; ///< Displayed title of test
std::string title_; ///< Displayed title of test
uint32_t verbosity_; ///< How much additional output to produce
uint32_t verbosity_; ///< How much additional output to produce
uint32_t monitor_verbosity_; ///< verbose or not
uint32_t monitor_verbosity_; ///< verbose or not
RdcPerfTimer hsa_timer_; ///< Timer to be used for timing parts of test
RdcPerfTimer hsa_timer_; ///< Timer to be used for timing parts of test
};
} // namespace rdc
include/rdc_modules/rdc_rocr/TestBase.h
Inrite → Rialta
+6 -5
Féach ar an gComhad
@@ -22,9 +22,10 @@ THE SOFTWARE.
#ifndef RDC_MODULES_RDC_ROCR_TESTBASE_H_
#define RDC_MODULES_RDC_ROCR_TESTBASE_H_
#include <string>
#include <memory>
#include <string>
#include <vector>
#include "rdc_modules/rdc_rocr/RdcRocrBase.h"
namespace amd {
@@ -36,7 +37,7 @@ class TestBase : public RdcRocrBase {
virtual ~TestBase(void);
enum VerboseLevel {VERBOSE_MIN = 0, VERBOSE_STANDARD, VERBOSE_PROGRESS};
enum VerboseLevel { VERBOSE_MIN = 0, VERBOSE_STANDARD, VERBOSE_PROGRESS };
// @Brief: Before run the core measure codes, do something to set up
// i.e. init runtime, prepare packet...
@@ -54,12 +55,12 @@ class TestBase : public RdcRocrBase {
// @Brief: Display information about the test
virtual void DisplayTestInfo(void);
const std::string & description(void) const {return description_;}
const std::string& description(void) const { return description_; }
void set_description(std::string d);
const std::string & get_gpu_info() const { return gpu_info_;}
const std::string & get_per_gpu_info() const { return per_gpu_info_;}
const std::string& get_gpu_info() const { return gpu_info_; }
const std::string& get_per_gpu_info() const { return per_gpu_info_; }
hsa_status_t FindGPUIndex(hsa_agent_t agent, void* data);
// Return the agent by GPU index in rocm_smi
include/rdc_modules/rdc_rocr/base_rocr_utils.h
Inrite → Rialta
+15 -19
Féach ar an gComhad
@@ -26,10 +26,11 @@ THE SOFTWARE.
/// \file
/// Prototypes of utility functions that act on RdcRocrBase objects.
#include "rdc_modules/rdc_rocr/RdcRocrBase.h"
#include <string>
#include "rdc_modules/rdc_rocr/common.h"
#include "hsa/hsa.h"
#include "rdc_modules/rdc_rocr/RdcRocrBase.h"
#include "rdc_modules/rdc_rocr/common.h"
namespace amd {
namespace rdc {
@@ -58,8 +59,7 @@ hsa_status_t SetDefaultAgents(RdcRocrBase* test);
/// \param[in] do_profile [Optional] Specificy whether profiled queue should
/// be created
/// \returns HSA_STATUS_SUCCESS if no errors encountered
hsa_status_t CreateQueue(hsa_agent_t device, hsa_queue_t** queue,
uint32_t num_pkts = 0);
hsa_status_t CreateQueue(hsa_agent_t device, hsa_queue_t** queue, uint32_t num_pkts = 0);
/// This function sets some reasonable default values for an AQL packet.
/// Override any field as necessary after calling this function.
@@ -68,18 +68,16 @@ hsa_status_t CreateQueue(hsa_agent_t device, hsa_queue_t** queue,
/// \param[inout] aql Caller provided pointer to aql packet that will be
/// populated
/// \returns Appropriate hsa_status_t
hsa_status_t InitializeAQLPacket(const RdcRocrBase* test,
hsa_kernel_dispatch_packet_t* aql);
hsa_status_t InitializeAQLPacket(const RdcRocrBase* test, hsa_kernel_dispatch_packet_t* aql);
/// This function writes all of the aql packet fields to the queue besides
/// "setup" and "header". This assumes all the aql fields have be set
/// appropriately.
/// \param[in] test Test containing the queue and aql packet to be written.
/// \returns Pointer to dispatch packet in queue that was written to
hsa_kernel_dispatch_packet_t* WriteAQLToQueue(RdcRocrBase* test, uint64_t *ind);
hsa_kernel_dispatch_packet_t* WriteAQLToQueue(RdcRocrBase* test, uint64_t* ind);
void WriteAQLToQueueLoc(hsa_queue_t *queue, uint64_t indx,
hsa_kernel_dispatch_packet_t *aql_pkt);
void WriteAQLToQueueLoc(hsa_queue_t* queue, uint64_t indx, hsa_kernel_dispatch_packet_t* aql_pkt);
/// This function writes the first 32 bits of an aql packet to the provided
/// aql packet. This function is meant to be called immediately before
/// ringing door_bell signal.
@@ -89,9 +87,9 @@ void WriteAQLToQueueLoc(hsa_queue_t *queue, uint64_t indx,
/// be written
/// \returns void
inline void AtomicSetPacketHeader(uint16_t header, uint16_t setup,
hsa_kernel_dispatch_packet_t* queue_packet) {
__atomic_store_n(reinterpret_cast<uint32_t*>(queue_packet),
header | (setup <<16), __ATOMIC_RELEASE);
hsa_kernel_dispatch_packet_t* queue_packet) {
__atomic_store_n(reinterpret_cast<uint32_t*>(queue_packet), header | (setup << 16),
__ATOMIC_RELEASE);
}
/// Perform common operations to clean up after executing a test. Specifically,
@@ -121,8 +119,7 @@ bool CheckProfile(RdcRocrBase const* test);
/// \param arg_size Size of the kernel arg data (including padding) to be
/// written
/// \returns HSA_STATUS_SUCCESS if no errors
hsa_status_t AllocAndSetKernArgs(RdcRocrBase* test, void* args,
size_t arg_size);
hsa_status_t AllocAndSetKernArgs(RdcRocrBase* test, void* args, size_t arg_size);
/// Verify that the machine running the test has the required profile.
/// This function will verify that the execution machine meets any specific
@@ -149,8 +146,9 @@ hsa_status_t SetPoolsTypical(RdcRocrBase* test);
/// \param[in] test Test that has handles to cpu and gpu agents that can own
/// either source or destination of fill
/// \returns HSA_STATUS_OK if not errors
hsa_status_t hsa_memory_fill_workaround_gen(void* ptr, uint32_t value,
size_t count, hsa_agent_t dst_ag, hsa_agent_t src_ag, RdcRocrBase* test);
hsa_status_t hsa_memory_fill_workaround_gen(void* ptr, uint32_t value, size_t count,
hsa_agent_t dst_ag, hsa_agent_t src_ag,
RdcRocrBase* test);
/// Get the library directory which is loaded by current process.
/// It will search /proc/self/maps for it.
@@ -162,11 +160,9 @@ std::string get_app_dir();
// Search multiple folder for the hsaco file
// Return empty if cannot find it.
std::string search_hsaco_full_path(const char* hsaco_file_name,
const char* agent_name);
std::string search_hsaco_full_path(const char* hsaco_file_name, const char* agent_name);
} // namespace rdc
} // namespace amd
#endif // RDC_MODULES_RDC_ROCR_BASE_ROCR_UTILS_H_
include/rdc_modules/rdc_rocr/common.h
Inrite → Rialta
+35 -40
Féach ar an gComhad
@@ -28,12 +28,13 @@ THE SOFTWARE.
#include <stdio.h>
#include <string.h>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <vector>
#include <string>
#include <memory>
#include <string>
#include <vector>
#include "hsa/hsa.h"
#include "hsa/hsa_ext_amd.h"
@@ -45,13 +46,13 @@ namespace rdc {
#define ALIGNED_(x) __declspec(align(x))
#else
#if defined(__GNUC__)
#define ALIGNED_(x) __attribute__ ((aligned(x)))
#define ALIGNED_(x) __attribute__((aligned(x)))
#endif // __GNUC__
#endif // _MSC_VER
#define MULTILINE(...) # __VA_ARGS__
#define MULTILINE(...) #__VA_ARGS__
#define ASSERT_EQ(a, b) (a==b)
#define ASSERT_EQ(a, b) (a == b)
void SetEnv(const char* env_var_name, const char* env_var_value);
intptr_t AlignDown(intptr_t value, size_t alignment);
@@ -66,39 +67,35 @@ void* AlignUp(void* value, size_t alignment);
// related calls, and is later used for reference when displaying the
// information.
typedef struct pool_info_t_ {
uint32_t segment;
size_t size;
bool alloc_allowed;
size_t alloc_granule;
size_t alloc_alignment;
bool accessible_by_all;
uint32_t global_flag;
uint64_t aggregate_alloc_max;
inline bool operator==(const pool_info_t_ &a) {
if (a.segment == segment && a.size == size
&& a.alloc_allowed == alloc_allowed
&& a.alloc_granule == alloc_granule
&& a.alloc_alignment == alloc_alignment
&& a.accessible_by_all == accessible_by_all
&& a.aggregate_alloc_max == aggregate_alloc_max
&& a.global_flag == global_flag )
return true;
else
return false;
}
uint32_t segment;
size_t size;
bool alloc_allowed;
size_t alloc_granule;
size_t alloc_alignment;
bool accessible_by_all;
uint32_t global_flag;
uint64_t aggregate_alloc_max;
inline bool operator==(const pool_info_t_& a) {
if (a.segment == segment && a.size == size && a.alloc_allowed == alloc_allowed &&
a.alloc_granule == alloc_granule && a.alloc_alignment == alloc_alignment &&
a.accessible_by_all == accessible_by_all && a.aggregate_alloc_max == aggregate_alloc_max &&
a.global_flag == global_flag)
return true;
else
return false;
}
} pool_info_t;
struct agent_pools_t{
hsa_agent_t agent;
std::vector<hsa_amd_memory_pool_t> pools;
struct agent_pools_t {
hsa_agent_t agent;
std::vector<hsa_amd_memory_pool_t> pools;
};
/// Fill in the pool_info_t structure for the provided pool.
/// \param[in] pool Pool for which information will be retrieved
/// \param[out] pool_i Pointer to structure where pool info will be stored
/// \returns HSA_STATUS_SUCCESS if no errors are encountered.
hsa_status_t AcquirePoolInfo(hsa_amd_memory_pool_t pool, pool_info_t *pool_i);
hsa_status_t AcquirePoolInfo(hsa_amd_memory_pool_t pool, pool_info_t* pool_i);
/// If the provided agent is associated with a GPU, return that agent through
/// output parameter. This function is meant to be the call-back function used
@@ -128,7 +125,7 @@ hsa_status_t FindGlobalPool(hsa_amd_memory_pool_t pool, void* data);
/// \param[out] data If agent is associated with a CPU, this pointer will point
/// to the agent upon return
/// \returns HSA_STATUS_SUCCESS if no errors are encountered.
hsa_status_t IterateCPUAgents(hsa_agent_t agent, void *data);
hsa_status_t IterateCPUAgents(hsa_agent_t agent, void* data);
/// If the provided agent is associated with a GPU, return that agent through
/// output parameter. This function is meant to be the call-back function used
@@ -137,7 +134,7 @@ hsa_status_t IterateCPUAgents(hsa_agent_t agent, void *data);
/// \param[out] data If agent is associated with a GPU, this pointer will point
/// to the agent upon return
/// \returns HSA_STATUS_SUCCESS if no errors are encountered.
hsa_status_t IterateGPUAgents(hsa_agent_t agent, void *data);
hsa_status_t IterateGPUAgents(hsa_agent_t agent, void* data);
/// Find a GLOBAL memory pool. By this, we mean not a kernel args pool.
/// This function is meant to be the call-back function used
@@ -163,7 +160,6 @@ hsa_status_t GetGlobalMemoryPool(hsa_amd_memory_pool_t pool, void* data);
/// -else return an appropriate error code for any error encountered
hsa_status_t GetKernArgMemoryPool(hsa_amd_memory_pool_t pool, void* data);
/// Find a "standard" pool. By this, we mean not a kernel args pool.
/// The pool found will have the following properties:
/// HSA_AMD_MEMORY_POOL_INFO_ACCESSIBLE_BY_ALL: Don't care
@@ -201,16 +197,14 @@ hsa_status_t FindKernArgPool(hsa_amd_memory_pool_t pool, void* data);
/// \param[in] pool Pool to gather and dump information for
/// \param[in] indent Number of spaces to indent output.
/// \returns hsa_status_t HSA_STATUS_SUCCESS if no errors
hsa_status_t DumpMemoryPoolInfo(const pool_info_t *pool_i,
uint32_t indent = 0);
hsa_status_t DumpMemoryPoolInfo(const pool_info_t* pool_i, uint32_t indent = 0);
/// Dump information about a provided pointer to STDOUT.
/// \param[in] ptr Pointer about which information is dumped.
/// \returns HSA_STATUS_SUCCESS if there are no errors
hsa_status_t DumpPointerInfo(void* ptr);
hsa_status_t GetAgentPools(
std::vector<std::shared_ptr<agent_pools_t>> *agent_pools);
hsa_status_t GetAgentPools(std::vector<std::shared_ptr<agent_pools_t>>* agent_pools);
void throw_if_error(hsa_status_t err, const std::string& msg = "");
@@ -219,10 +213,11 @@ void throw_if_skip(const std::string& msg);
// The customize exception when the test has to be skipped
class SkipException : public std::exception {
public:
explicit SkipException(const char* msg): _msg(msg) {}
virtual const char* what() const noexcept { return _msg.c_str(); }
explicit SkipException(const char* msg) : _msg(msg) {}
virtual const char* what() const noexcept { return _msg.c_str(); }
private:
std::string _msg;
std::string _msg;
};
} // namespace rdc