AI/rocm-systems
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
Change-Id: I3cbb787ef27d90486b212dfb1a8c77c460acc2ac
Signed-off-by: Galantsev, Dmitrii <dmitrii.galantsev@amd.com>
This commit is contained in:
Galantsev, Dmitrii
2023-12-04 15:24:34 -06:00
parent 95e057c88d
commit 434e40305d
137 changed files with 9122 additions and 10469 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/rdc_lib/RdcCacheManager.h
+28 -30
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
Executable → Regular
+4 -5
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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_