/**
* @brief Initializes PQoS library
*
* To satisfy dlock_init() requirements CAT is reset here.
* More sophisticated solution would be to look for unused CLOS here and
* pass it on to dlock_init().
*
* @return Operation status
* @retval 0 OK
* @retval <0 error
*/
static int init_pqos(void)
{
const struct pqos_cpuinfo *p_cpu = NULL;
const struct pqos_cap *p_cap = NULL;
struct pqos_config cfg;
int ret;
memset(&cfg, 0, sizeof(cfg));
cfg.fd_log = STDOUT_FILENO;
cfg.verbose = 0;
ret = pqos_init(&cfg);
if (ret != PQOS_RETVAL_OK) {
printf("Error initializing PQoS library!\n");
return -1;
}
/* Get CMT capability and CPU info pointer */
ret = pqos_cap_get(&p_cap, &p_cpu);
if (ret != PQOS_RETVAL_OK) {
pqos_fini();
printf("Error retrieving PQoS capabilities!\n");
return -1;
}
/* Reset CAT */
ret = pqos_alloc_reset(PQOS_REQUIRE_CDP_ANY);
if (ret != PQOS_RETVAL_OK) {
pqos_fini();
printf("Error resetting CAT!\n");
return -1;
}
return 0;
}
int main(int argc, char *argv[])
{
struct pqos_config cfg;
const struct pqos_cpuinfo *p_cpu = NULL;
const struct pqos_cap *p_cap = NULL;
unsigned sock_count, sockets[PQOS_MAX_SOCKETS];
int ret, exit_val = EXIT_SUCCESS;
memset(&cfg, 0, sizeof(cfg));
cfg.fd_log = STDOUT_FILENO;
cfg.verbose = 0;
/* PQoS Initialization - Check and initialize CAT and CMT capability */
ret = pqos_init(&cfg);
if (ret != PQOS_RETVAL_OK) {
printf("Error initializing PQoS library!\n");
exit_val = EXIT_FAILURE;
goto error_exit;
}
/* Get CMT capability and CPU info pointer */
ret = pqos_cap_get(&p_cap, &p_cpu);
if (ret != PQOS_RETVAL_OK) {
printf("Error retrieving PQoS capabilities!\n");
exit_val = EXIT_FAILURE;
goto error_exit;
}
/* Get CPU socket information to set COS */
ret = pqos_cpu_get_sockets(p_cpu, PQOS_MAX_SOCKETS,
&sock_count,
sockets);
if (ret != PQOS_RETVAL_OK) {
printf("Error retrieving CPU socket information!\n");
exit_val = EXIT_FAILURE;
goto error_exit;
}
/* Get input from user */
allocation_get_input(argc, argv);
if (sel_l3ca_cos_num != 0) {
/* Set bit mask for COS allocation */
ret = set_allocation_class(sock_count, sockets);
if (ret < 0) {
printf("Allocation configuration error!\n");
goto error_exit;
}
printf("Allocation configuration altered.\n");
}
/* Print COS and associated bit mask */
ret = print_allocation_config(sock_count, sockets);
if (ret != PQOS_RETVAL_OK) {
printf("Allocation capability not detected!\n");
exit_val = EXIT_FAILURE;
goto error_exit;
}
error_exit:
/* reset and deallocate all the resources */
ret = pqos_fini();
if (ret != PQOS_RETVAL_OK)
printf("Error shutting down PQoS library!\n");
return exit_val;
}
int main(int argc, char *argv[])
{
struct pqos_config cfg;
const struct pqos_cpuinfo *p_cpu = NULL;
const struct pqos_cap *p_cap = NULL;
const struct pqos_capability *cap_l3ca = NULL;
unsigned sock_count, *sockets = NULL;
int ret, exit_val = EXIT_SUCCESS;
memset(&cfg, 0, sizeof(cfg));
cfg.fd_log = STDOUT_FILENO;
cfg.verbose = 0;
/* PQoS Initialization - Check and initialize CAT and CMT capability */
ret = pqos_init(&cfg);
if (ret != PQOS_RETVAL_OK) {
printf("Error initializing PQoS library!\n");
exit_val = EXIT_FAILURE;
goto error_exit;
}
/* Get CMT capability and CPU info pointer */
ret = pqos_cap_get(&p_cap, &p_cpu);
if (ret != PQOS_RETVAL_OK) {
printf("Error retrieving PQoS capabilities!\n");
exit_val = EXIT_FAILURE;
goto error_exit;
}
if (argc == 2 && (!strcmp(argv[1], "-h") || !strcmp(argv[1], "-H"))) {
printf("Usage: %s\n\n", argv[0]);
goto error_exit;
}
/* Reset Api */
ret = pqos_alloc_reset(PQOS_REQUIRE_CDP_ANY, PQOS_REQUIRE_CDP_ANY,
PQOS_MBA_ANY);
if (ret != PQOS_RETVAL_OK)
printf("CAT reset failed!\n");
else
printf("CAT reset successful\n");
/* Get CPU socket information to set COS */
sockets = pqos_cpu_get_sockets(p_cpu, &sock_count);
if (sockets == NULL) {
printf("Error retrieving CPU socket information!\n");
exit_val = EXIT_FAILURE;
goto error_exit;
}
(void) pqos_cap_get_type(p_cap, PQOS_CAP_TYPE_L3CA, &cap_l3ca);
/* Print COS and associated cores */
print_allocation_config(cap_l3ca, sock_count, sockets, p_cpu);
error_exit:
/* reset and deallocate all the resources */
ret = pqos_fini();
if (ret != PQOS_RETVAL_OK)
printf("Error shutting down PQoS library!\n");
if (sockets != NULL)
free(sockets);
return exit_val;
}
/**
* @brief CTRL-C handler for infinite monitoring loop
*
* @param [in] signo signal number
*/
static void monitoring_ctrlc(int signo)
{
printf("\nExiting[%d]...\n", signo);
stop_monitoring();
if (pqos_fini() != PQOS_RETVAL_OK) {
printf("Error shutting down PQoS library!\n");
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}
/**
* @brief Closes PQoS library
*
* @return Operation status
* @retval 0 OK
* @retval <0 error
*/
static int close_pqos(void)
{
int ret_val = 0;
if (pqos_fini() != PQOS_RETVAL_OK) {
printf("Error shutting down PQoS library!\n");
ret_val = -1;
}
return ret_val;
}
int main(int argc, char *argv[])
{
struct pqos_config config;
const struct pqos_cpuinfo *p_cpu = NULL;
const struct pqos_cap *p_cap = NULL;
int ret, exit_val = EXIT_SUCCESS;
const struct pqos_capability *cap_mon = NULL;
memset(&config, 0, sizeof(config));
config.fd_log = STDOUT_FILENO;
config.verbose = 0;
/* PQoS Initialization - Check and initialize CAT and CMT capability */
ret = pqos_init(&config);
if (ret != PQOS_RETVAL_OK) {
printf("Error initializing PQoS library!\n");
exit_val = EXIT_FAILURE;
goto error_exit;
}
/* Get CMT capability and CPU info pointer */
ret = pqos_cap_get(&p_cap, &p_cpu);
if (ret != PQOS_RETVAL_OK) {
printf("Error retrieving PQoS capabilities!\n");
exit_val = EXIT_FAILURE;
goto error_exit;
}
/* Get input from user */
monitoring_get_input(argc, argv);
(void) pqos_cap_get_type(p_cap, PQOS_CAP_TYPE_MON, &cap_mon);
/* Setup the monitoring resources */
ret = setup_monitoring(p_cpu, cap_mon);
if (ret != PQOS_RETVAL_OK) {
printf("Error Setting up monitoring!\n");
exit_val = EXIT_FAILURE;
goto error_exit;
}
/* Start Monitoring */
monitoring_loop();
/* Stop Monitoring */
stop_monitoring();
error_exit:
ret = pqos_fini();
if (ret != PQOS_RETVAL_OK)
printf("Error shutting down PQoS library!\n");
return exit_val;
}
static int rdt_preinit(void) {
int ret;
if (g_rdt != NULL) {
/* already initialized if config callback was called before init callback */
return (0);
}
g_rdt = calloc(1, sizeof(*g_rdt));
if (g_rdt == NULL) {
ERROR(RDT_PLUGIN ": Failed to allocate memory for rdt context.");
return (-ENOMEM);
}
/* In case previous instance of the application was not closed properly
* call fini and ignore return code. */
pqos_fini();
/* TODO:
* stdout should not be used here. Will be reworked when support of log
* callback is added to PQoS library.
*/
ret = pqos_init(&(struct pqos_config){.fd_log = STDOUT_FILENO});
int main(int argc, char *argv[])
{
struct pqos_config cfg;
int ret, exit_val = EXIT_SUCCESS;
memset(&cfg, 0, sizeof(cfg));
cfg.fd_log = STDOUT_FILENO;
cfg.verbose = 0;
/* PQoS Initialization - Check and initialize CAT and CMT capability */
ret = pqos_init(&cfg);
if (ret != PQOS_RETVAL_OK) {
printf("Error initializing PQoS library!\n");
exit_val = EXIT_FAILURE;
goto error_exit;
}
/* Get input from user */
enforcement_get_input(argc, argv);
if (sel_l3ca_assoc_num) {
/* Enforce COS to the associated cores */
ret = set_allocation_assoc();
if (ret < 0) {
printf("CAT association error!\n");
goto error_exit;
}
printf("Allocation configuration altered.\n");
}
/* Print COS and associated cores */
print_allocation_config();
error_exit:
/* reset and deallocate all the resources */
ret = pqos_fini();
if (ret != PQOS_RETVAL_OK)
printf("Error shutting down PQoS library!\n");
return exit_val;
}
static int rdt_preinit(void) {
int ret;
if (g_rdt != NULL) {
/* already initialized if config callback was called before init callback */
return 0;
}
g_rdt = calloc(1, sizeof(*g_rdt));
if (g_rdt == NULL) {
ERROR(RDT_PLUGIN ": Failed to allocate memory for rdt context.");
return -ENOMEM;
}
struct pqos_config pqos = {.fd_log = -1,
.callback_log = rdt_pqos_log,
.context_log = NULL,
.verbose = 0};
ret = pqos_init(&pqos);
if (ret != PQOS_RETVAL_OK) {
ERROR(RDT_PLUGIN ": Error initializing PQoS library!");
goto rdt_preinit_error1;
}
ret = pqos_cap_get(&g_rdt->pqos_cap, &g_rdt->pqos_cpu);
if (ret != PQOS_RETVAL_OK) {
ERROR(RDT_PLUGIN ": Error retrieving PQoS capabilities.");
goto rdt_preinit_error2;
}
ret = pqos_cap_get_type(g_rdt->pqos_cap, PQOS_CAP_TYPE_MON, &g_rdt->cap_mon);
if (ret == PQOS_RETVAL_PARAM) {
ERROR(RDT_PLUGIN ": Error retrieving monitoring capabilities.");
goto rdt_preinit_error2;
}
if (g_rdt->cap_mon == NULL) {
ERROR(
RDT_PLUGIN
": Monitoring capability not detected. Nothing to do for the plugin.");
goto rdt_preinit_error2;
}
/* Reset pqos monitoring groups registers */
pqos_mon_reset();
return 0;
rdt_preinit_error2:
pqos_fini();
rdt_preinit_error1:
sfree(g_rdt);
return -1;
}
static int rdt_config(oconfig_item_t *ci) {
if (rdt_preinit() != 0) {
g_state = CONFIGURATION_ERROR;
/* if we return -1 at this point collectd
reports a failure in configuration and
aborts
*/
return (0);
}
for (int i = 0; i < ci->children_num; i++) {
oconfig_item_t *child = ci->children + i;
if (strcasecmp("Cores", child->key) == 0) {
if (rdt_config_cgroups(child) != 0) {
g_state = CONFIGURATION_ERROR;
/* if we return -1 at this point collectd
reports a failure in configuration and
aborts
*/
return (0);
}
#if COLLECT_DEBUG
rdt_dump_cgroups();
#endif /* COLLECT_DEBUG */
} else {
ERROR(RDT_PLUGIN ": Unknown configuration parameter \"%s\".", child->key);
}
}
return 0;
}
static void rdt_submit_derive(const char *cgroup, const char *type,
const char *type_instance, derive_t value) {
value_list_t vl = VALUE_LIST_INIT;
vl.values = &(value_t){.derive = value};
vl.values_len = 1;
sstrncpy(vl.plugin, RDT_PLUGIN, sizeof(vl.plugin));
snprintf(vl.plugin_instance, sizeof(vl.plugin_instance), "%s", cgroup);
sstrncpy(vl.type, type, sizeof(vl.type));
if (type_instance)
sstrncpy(vl.type_instance, type_instance, sizeof(vl.type_instance));
plugin_dispatch_values(&vl);
}
int main(int argc, char **argv)
{
struct pqos_config cfg;
const struct pqos_cpuinfo *p_cpu = NULL;
const struct pqos_cap *p_cap = NULL;
const struct pqos_capability *cap_mon = NULL, *cap_l3ca = NULL;
unsigned sock_count, sockets[PQOS_MAX_SOCKETS];
int cmd, ret, exit_val = EXIT_SUCCESS;
int opt_index = 0;
m_cmd_name = argv[0];
print_warning();
while ((cmd = getopt_long(argc, argv,
"Hhf:i:m:Tt:l:o:u:e:c:a:p:S:srvVR",
long_cmd_opts, &opt_index)) != -1) {
switch (cmd) {
case 'h':
print_help(1);
return EXIT_SUCCESS;
case 'H':
profile_l3ca_list(stdout);
return EXIT_SUCCESS;
case 'S':
selfn_set_config(optarg);
break;
case 'f':
if (sel_config_file != NULL) {
printf("Only one config file argument is "
"accepted!\n");
return EXIT_FAILURE;
}
selfn_strdup(&sel_config_file, optarg);
parse_config_file(sel_config_file);
break;
case 'i':
selfn_monitor_interval(optarg);
break;
case 'p':
selfn_monitor_pids(optarg);
break;
case 'm':
selfn_monitor_cores(optarg);
break;
case 't':
selfn_monitor_time(optarg);
break;
case 'T':
selfn_monitor_top_like(NULL);
break;
case 'l':
selfn_log_file(optarg);
break;
case 'o':
selfn_monitor_file(optarg);
break;
case 'u':
selfn_monitor_file_type(optarg);
break;
case 'e':
selfn_allocation_class(optarg);
break;
case 'r':
sel_free_in_use_rmid = 1;
break;
case 'R':
selfn_reset_cat(NULL);
break;
case 'a':
selfn_allocation_assoc(optarg);
break;
case 'c':
selfn_allocation_select(optarg);
break;
case 's':
selfn_show_allocation(NULL);
break;
case 'v':
selfn_verbose_mode(NULL);
break;
case 'V':
selfn_super_verbose_mode(NULL);
break;
default:
printf("Unsupported option: -%c. "
"See option -h for help.\n", optopt);
return EXIT_FAILURE;
break;
case '?':
print_help(0);
return EXIT_SUCCESS;
break;
}
}
memset(&cfg, 0, sizeof(cfg));
cfg.verbose = sel_verbose_mode;
cfg.free_in_use_rmid = sel_free_in_use_rmid;
cfg.cdp_cfg = selfn_cdp_config;
/**
* Set up file descriptor for message log
*/
if (sel_log_file == NULL) {
cfg.fd_log = STDOUT_FILENO;
} else {
cfg.fd_log = open(sel_log_file, O_WRONLY|O_CREAT,
S_IRUSR|S_IWUSR);
if (cfg.fd_log == -1) {
printf("Error opening %s log file!\n", sel_log_file);
exit_val = EXIT_FAILURE;
goto error_exit_2;
}
}
ret = pqos_init(&cfg);
if (ret != PQOS_RETVAL_OK) {
printf("Error initializing PQoS library!\n");
exit_val = EXIT_FAILURE;
goto error_exit_1;
}
ret = pqos_cap_get(&p_cap, &p_cpu);
if (ret != PQOS_RETVAL_OK) {
printf("Error retrieving PQoS capabilities!\n");
exit_val = EXIT_FAILURE;
goto error_exit_2;
}
ret = pqos_cpu_get_sockets(p_cpu, PQOS_MAX_SOCKETS,
&sock_count,
sockets);
if (ret != PQOS_RETVAL_OK) {
printf("Error retrieving CPU socket information!\n");
exit_val = EXIT_FAILURE;
goto error_exit_2;
}
ret = pqos_cap_get_type(p_cap, PQOS_CAP_TYPE_MON, &cap_mon);
if (ret == PQOS_RETVAL_PARAM) {
printf("Error retrieving monitoring capabilities!\n");
exit_val = EXIT_FAILURE;
goto error_exit_2;
}
ret = pqos_cap_get_type(p_cap, PQOS_CAP_TYPE_L3CA, &cap_l3ca);
if (ret == PQOS_RETVAL_PARAM) {
printf("Error retrieving allocation capabilities!\n");
exit_val = EXIT_FAILURE;
goto error_exit_2;
}
if (sel_reset_CAT) {
/**
* Reset CAT configuration to after-reset state and exit
*/
if (pqos_l3ca_reset(p_cap, p_cpu) != PQOS_RETVAL_OK) {
exit_val = EXIT_FAILURE;
printf("CAT reset failed!\n");
} else
printf("CAT reset successful\n");
goto allocation_exit;
}
if (sel_show_allocation_config) {
/**
* Show info about allocation config and exit
*/
alloc_print_config(cap_mon, cap_l3ca, sock_count,
sockets, p_cpu);
goto allocation_exit;
}
if (sel_allocation_profile != NULL) {
if (profile_l3ca_apply(sel_allocation_profile, cap_l3ca) != 0) {
exit_val = EXIT_FAILURE;
goto error_exit_2;
}
}
switch (alloc_apply(cap_l3ca, sock_count, sockets)) {
case 0: /* nothing to apply */
break;
case 1: /* new allocation config applied and all is good */
goto allocation_exit;
break;
case -1: /* something went wrong */
default:
exit_val = EXIT_FAILURE;
goto error_exit_2;
break;
}
/**
* Just monitoring option left on the table now
*/
if (cap_mon == NULL) {
printf("Monitoring capability not detected!\n");
exit_val = EXIT_FAILURE;
goto error_exit_2;
}
if (monitor_setup(p_cpu, cap_mon) != 0) {
exit_val = EXIT_FAILURE;
goto error_exit_2;
}
monitor_loop(p_cap);
monitor_stop();
allocation_exit:
error_exit_2:
ret = pqos_fini();
ASSERT(ret == PQOS_RETVAL_OK);
if (ret != PQOS_RETVAL_OK)
printf("Error shutting down PQoS library!\n");
error_exit_1:
monitor_cleanup();
/**
* Close file descriptor for message log
*/
if (cfg.fd_log > 0 && cfg.fd_log != STDOUT_FILENO)
close(cfg.fd_log);
/**
* Free allocated memory
*/
if (sel_allocation_profile != NULL)
free(sel_allocation_profile);
if (sel_log_file != NULL)
free(sel_log_file);
if (sel_config_file != NULL)
free(sel_config_file);
return exit_val;
}
static int rdt_preinit(void) {
int ret;
if (g_rdt != NULL) {
/* already initialized if config callback was called before init callback */
return (0);
}
g_rdt = calloc(1, sizeof(*g_rdt));
if (g_rdt == NULL) {
ERROR(RDT_PLUGIN ": Failed to allocate memory for rdt context.");
return (-ENOMEM);
}
struct pqos_config pqos = {.fd_log = -1,
.callback_log = rdt_pqos_log,
.context_log = NULL,
.verbose = 0};
ret = pqos_init(&pqos);
if (ret != PQOS_RETVAL_OK) {
ERROR(RDT_PLUGIN ": Error initializing PQoS library!");
goto rdt_preinit_error1;
}
ret = pqos_cap_get(&g_rdt->pqos_cap, &g_rdt->pqos_cpu);
if (ret != PQOS_RETVAL_OK) {
ERROR(RDT_PLUGIN ": Error retrieving PQoS capabilities.");
goto rdt_preinit_error2;
}
ret = pqos_cap_get_type(g_rdt->pqos_cap, PQOS_CAP_TYPE_MON, &g_rdt->cap_mon);
if (ret == PQOS_RETVAL_PARAM) {
ERROR(RDT_PLUGIN ": Error retrieving monitoring capabilities.");
goto rdt_preinit_error2;
}
if (g_rdt->cap_mon == NULL) {
ERROR(
RDT_PLUGIN
": Monitoring capability not detected. Nothing to do for the plugin.");
goto rdt_preinit_error2;
}
/* Reset pqos monitoring groups registers */
pqos_mon_reset();
return (0);
rdt_preinit_error2:
pqos_fini();
rdt_preinit_error1:
sfree(g_rdt);
return (-1);
}
static int rdt_config(oconfig_item_t *ci) {
int ret = 0;
ret = rdt_preinit();
if (ret != 0) {
g_state = CONFIGURATION_ERROR;
/* if we return -1 at this point collectd
reports a failure in configuration and
aborts
*/
goto exit;
}
for (int i = 0; i < ci->children_num; i++) {
oconfig_item_t *child = ci->children + i;
if (strcasecmp("Cores", child->key) == 0) {
ret = rdt_config_cgroups(child);
if (ret != 0) {
g_state = CONFIGURATION_ERROR;
/* if we return -1 at this point collectd
reports a failure in configuration and
aborts
*/
goto exit;
}
#if COLLECT_DEBUG
rdt_dump_cgroups();
#endif /* COLLECT_DEBUG */
} else {
ERROR(RDT_PLUGIN ": Unknown configuration parameter \"%s\".", child->key);
}
}
exit:
return (0);
}