/*
* BSD LICENSE
*
* Copyright(c) 2014-2020 Intel Corporation. All rights reserved.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**
* @brief Set of utility functions to operate on Platform QoS (pqos) data
* structures.
*
* These functions need no synchronization mechanisms.
*
*/
#include <stdlib.h>
#include <string.h>
#include "pqos.h"
#include "types.h"
#include "utils.h"
#include "cpuinfo.h"
#define TOPO_OBJ_SOCKET 0
#define TOPO_OBJ_L2_CLUSTER 2
#define TOPO_OBJ_L3_CLUSTER 3
static int m_interface = PQOS_INTER_MSR;
int
_pqos_utils_init(int interface)
{
if (interface == PQOS_INTER_OS_RESCTRL_MON)
m_interface = PQOS_INTER_OS;
else
m_interface = interface;
return PQOS_RETVAL_OK;
}
unsigned *
pqos_cpu_get_mba_ids(const struct pqos_cpuinfo *cpu, unsigned *count)
{
unsigned mba_id_count = 0, i = 0;
unsigned *mba_ids = NULL;
ASSERT(cpu != NULL);
ASSERT(count != NULL);
if (cpu == NULL || count == NULL)
return NULL;
mba_ids = (unsigned *)malloc(sizeof(mba_ids[0]) * cpu->num_cores);
if (mba_ids == NULL)
return NULL;
for (i = 0; i < cpu->num_cores; i++) {
unsigned j = 0;
/**
* Check if this mba id is already on the \a mbas list
*/
for (j = 0; j < mba_id_count && mba_id_count > 0; j++)
if (cpu->cores[i].mba_id == mba_ids[j])
break;
if (j >= mba_id_count || mba_id_count == 0) {
/**
* This mba_id wasn't reported before
*/
mba_ids[mba_id_count++] = cpu->cores[i].mba_id;
}
}
*count = mba_id_count;
return mba_ids;
}
unsigned *
pqos_cpu_get_l3cat_ids(const struct pqos_cpuinfo *cpu, unsigned *count)
{
unsigned l3cat_count = 0, i = 0;
unsigned *l3cat_ids = NULL;
ASSERT(cpu != NULL);
ASSERT(count != NULL);
if (cpu == NULL || count == NULL)
return NULL;
l3cat_ids = (unsigned *)malloc(sizeof(l3cat_ids[0]) * cpu->num_cores);
if (l3cat_ids == NULL)
return NULL;
for (i = 0; i < cpu->num_cores; i++) {
unsigned j = 0;
/**
* Check if this l3cat id is already on the \a l3cat_ids list
*/
for (j = 0; j < l3cat_count && l3cat_count > 0; j++)
if (cpu->cores[i].l3cat_id == l3cat_ids[j])
break;
if (j >= l3cat_count || l3cat_count == 0) {
/**
* This l3cat_id wasn't reported before
*/
l3cat_ids[l3cat_count++] = cpu->cores[i].l3cat_id;
}
}
*count = l3cat_count;
return l3cat_ids;
}
unsigned *
pqos_cpu_get_sockets(const struct pqos_cpuinfo *cpu, unsigned *count)
{
unsigned scount = 0, i = 0;
unsigned *sockets = NULL;
ASSERT(cpu != NULL);
ASSERT(count != NULL);
if (cpu == NULL || count == NULL)
return NULL;
sockets = (unsigned *)malloc(sizeof(sockets[0]) * cpu->num_cores);
if (sockets == NULL)
return NULL;
for (i = 0; i < cpu->num_cores; i++) {
unsigned j = 0;
/**
* Check if this socket id is already on the \a sockets list
*/
for (j = 0; j < scount && scount > 0; j++)
if (cpu->cores[i].socket == sockets[j])
break;
if (j >= scount || scount == 0) {
/**
* This socket wasn't reported before
*/
sockets[scount++] = cpu->cores[i].socket;
}
}
*count = scount;
return sockets;
}
unsigned *
pqos_cpu_get_l2ids(const struct pqos_cpuinfo *cpu, unsigned *count)
{
unsigned l2count = 0, i = 0;
unsigned *l2ids = NULL;
ASSERT(cpu != NULL);
ASSERT(count != NULL);
if (cpu == NULL || count == NULL)
return NULL;
l2ids = (unsigned *)malloc(sizeof(l2ids[0]) * cpu->num_cores);
if (l2ids == NULL)
return NULL;
for (i = 0; i < cpu->num_cores; i++) {
unsigned j = 0;
/**
* Check if this L2 id is already on the list
*/
for (j = 0; j < l2count && l2count > 0; j++)
if (cpu->cores[i].l2_id == l2ids[j])
break;
if (j >= l2count || l2count == 0) {
/**
* This l2id wasn't reported before
*/
l2ids[l2count++] = cpu->cores[i].l2_id;
}
}
*count = l2count;
return l2ids;
}
/**
* @brief Creates list of cores belonging to given topology object
*
* @param [in] cpu CPU topology
* @param [in] type CPU topology object type to search cores for
* TOPO_OBJ_SOCKET - sockets
* TOPO_OBJ_L2_CLUSTER - L2 cache clusters
* TOPO_OBJ_L3_CLUSTER - L3 cache clusters
* @param [in] id CPU topology object ID to search cores for
* @param [out] count place to put number of objects found
*
* @return Pointer to list of cores for given topology object
* @retval NULL on error or if no core found
*/
static unsigned *
__get_cores_per_topology_obj(const struct pqos_cpuinfo *cpu,
const int type,
const unsigned id,
unsigned *count)
{
unsigned num = 0, i = 0;
unsigned *core_list = NULL;
ASSERT(cpu != NULL);
ASSERT(count != NULL);
if (cpu == NULL || count == NULL)
return NULL;
core_list = (unsigned *)malloc(cpu->num_cores * sizeof(core_list[0]));
if (core_list == NULL)
return NULL;
for (i = 0; i < cpu->num_cores; i++)
if ((type == TOPO_OBJ_L3_CLUSTER &&
id == cpu->cores[i].l3_id) ||
(type == TOPO_OBJ_L2_CLUSTER &&
id == cpu->cores[i].l2_id) ||
(type == TOPO_OBJ_SOCKET && id == cpu->cores[i].socket))
core_list[num++] = cpu->cores[i].lcore;
if (num == 0) {
free(core_list);
return NULL;
}
*count = num;
return core_list;
}
unsigned *
pqos_cpu_get_cores_l3id(const struct pqos_cpuinfo *cpu,
const unsigned l3_id,
unsigned *count)
{
return __get_cores_per_topology_obj(cpu, TOPO_OBJ_L3_CLUSTER, l3_id,
count);
}
unsigned *
pqos_cpu_get_cores(const struct pqos_cpuinfo *cpu,
const unsigned socket,
unsigned *count)
{
unsigned i = 0, cnt = 0;
unsigned *cores = NULL;
ASSERT(cpu != NULL);
ASSERT(count != NULL);
if (cpu == NULL || count == NULL)
return NULL;
cores = (unsigned *)malloc(cpu->num_cores * sizeof(cores[0]));
if (cores == NULL)
return NULL;
for (i = 0; i < cpu->num_cores; i++)
if (cpu->cores[i].socket == socket)
cores[cnt++] = cpu->cores[i].lcore;
if (!cnt) {
free(cores);
return NULL;
}
*count = cnt;
return cores;
}
const struct pqos_coreinfo *
pqos_cpu_get_core_info(const struct pqos_cpuinfo *cpu, unsigned lcore)
{
unsigned i;
ASSERT(cpu != NULL);
if (cpu == NULL)
return NULL;
for (i = 0; i < cpu->num_cores; i++)
if (cpu->cores[i].lcore == lcore)
return &cpu->cores[i];
return NULL;
}
int
pqos_cpu_get_one_core(const struct pqos_cpuinfo *cpu,
const unsigned socket,
unsigned *lcore)
{
unsigned i = 0;
ASSERT(cpu != NULL);
ASSERT(lcore != NULL);
if (cpu == NULL || lcore == NULL)
return PQOS_RETVAL_PARAM;
for (i = 0; i < cpu->num_cores; i++)
if (cpu->cores[i].socket == socket) {
*lcore = cpu->cores[i].lcore;
return PQOS_RETVAL_OK;
}
return PQOS_RETVAL_ERROR;
}
int
pqos_cpu_get_one_by_l3cat_id(const struct pqos_cpuinfo *cpu,
const unsigned l3cat_id,
unsigned *lcore)
{
unsigned i = 0;
ASSERT(cpu != NULL);
ASSERT(lcore != NULL);
if (cpu == NULL || lcore == NULL)
return PQOS_RETVAL_PARAM;
for (i = 0; i < cpu->num_cores; i++)
if (cpu->cores[i].l3cat_id == l3cat_id) {
*lcore = cpu->cores[i].lcore;
return PQOS_RETVAL_OK;
}
return PQOS_RETVAL_ERROR;
}
int
pqos_cpu_get_one_by_mba_id(const struct pqos_cpuinfo *cpu,
const unsigned mba_id,
unsigned *lcore)
{
unsigned i = 0;
ASSERT(cpu != NULL);
ASSERT(lcore != NULL);
if (cpu == NULL || lcore == NULL)
return PQOS_RETVAL_PARAM;
for (i = 0; i < cpu->num_cores; i++)
if (cpu->cores[i].mba_id == mba_id) {
*lcore = cpu->cores[i].lcore;
return PQOS_RETVAL_OK;
}
return PQOS_RETVAL_ERROR;
}
int
pqos_cpu_get_one_by_l2id(const struct pqos_cpuinfo *cpu,
const unsigned l2id,
unsigned *lcore)
{
unsigned i = 0;
ASSERT(cpu != NULL);
ASSERT(lcore != NULL);
if (cpu == NULL || lcore == NULL)
return PQOS_RETVAL_PARAM;
for (i = 0; i < cpu->num_cores; i++)
if (cpu->cores[i].l2_id == l2id) {
*lcore = cpu->cores[i].lcore;
return PQOS_RETVAL_OK;
}
return PQOS_RETVAL_ERROR;
}
int
pqos_cpu_check_core(const struct pqos_cpuinfo *cpu, const unsigned lcore)
{
unsigned i = 0;
ASSERT(cpu != NULL);
if (cpu == NULL)
return PQOS_RETVAL_PARAM;
for (i = 0; i < cpu->num_cores; i++)
if (cpu->cores[i].lcore == lcore)
return PQOS_RETVAL_OK;
return PQOS_RETVAL_ERROR;
}
int
pqos_cpu_get_socketid(const struct pqos_cpuinfo *cpu,
const unsigned lcore,
unsigned *socket)
{
unsigned i = 0;
if (cpu == NULL || socket == NULL)
return PQOS_RETVAL_PARAM;
for (i = 0; i < cpu->num_cores; i++)
if (cpu->cores[i].lcore == lcore) {
*socket = cpu->cores[i].socket;
return PQOS_RETVAL_OK;
}
return PQOS_RETVAL_ERROR;
}
int
pqos_cpu_get_clusterid(const struct pqos_cpuinfo *cpu,
const unsigned lcore,
unsigned *cluster)
{
unsigned i = 0;
if (cpu == NULL || cluster == NULL)
return PQOS_RETVAL_PARAM;
for (i = 0; i < cpu->num_cores; i++)
if (cpu->cores[i].lcore == lcore) {
*cluster = cpu->cores[i].l3_id;
return PQOS_RETVAL_OK;
}
return PQOS_RETVAL_ERROR;
}
int
pqos_cap_get_type(const struct pqos_cap *cap,
const enum pqos_cap_type type,
const struct pqos_capability **cap_item)
{
int ret = PQOS_RETVAL_RESOURCE;
unsigned i;
ASSERT(cap != NULL && cap_item != NULL);
if (cap == NULL || cap_item == NULL)
return PQOS_RETVAL_PARAM;
*cap_item = NULL;
ASSERT(type < PQOS_CAP_TYPE_NUMOF);
if (type >= PQOS_CAP_TYPE_NUMOF)
return PQOS_RETVAL_PARAM;
for (i = 0; i < cap->num_cap; i++) {
if (cap->capabilities[i].type != type)
continue;
*cap_item = &cap->capabilities[i];
ret = PQOS_RETVAL_OK;
break;
}
return ret;
}
int
pqos_cap_get_event(const struct pqos_cap *cap,
const enum pqos_mon_event event,
const struct pqos_monitor **p_mon)
{
const struct pqos_capability *cap_item = NULL;
const struct pqos_cap_mon *mon = NULL;
int ret = PQOS_RETVAL_OK;
unsigned i;
if (cap == NULL || p_mon == NULL)
return PQOS_RETVAL_PARAM;
ret = pqos_cap_get_type(cap, PQOS_CAP_TYPE_MON, &cap_item);
if (ret != PQOS_RETVAL_OK)
return ret;
ASSERT(cap_item != NULL);
mon = cap_item->u.mon;
ret = PQOS_RETVAL_ERROR;
for (i = 0; i < mon->num_events; i++) {
if (mon->events[i].type != event)
continue;
*p_mon = &mon->events[i];
ret = PQOS_RETVAL_OK;
break;
}
return ret;
}
int
pqos_l3ca_get_cos_num(const struct pqos_cap *cap, unsigned *cos_num)
{
const struct pqos_capability *item = NULL;
int ret = PQOS_RETVAL_OK;
ASSERT(cap != NULL && cos_num != NULL);
if (cap == NULL || cos_num == NULL)
return PQOS_RETVAL_PARAM;
ret = pqos_cap_get_type(cap, PQOS_CAP_TYPE_L3CA, &item);
if (ret != PQOS_RETVAL_OK)
return ret; /**< no L3CA capability */
ASSERT(item != NULL);
*cos_num = item->u.l3ca->num_classes;
return ret;
}
int
pqos_l2ca_get_cos_num(const struct pqos_cap *cap, unsigned *cos_num)
{
const struct pqos_capability *item = NULL;
int ret = PQOS_RETVAL_OK;
ASSERT(cap != NULL && cos_num != NULL);
if (cap == NULL || cos_num == NULL)
return PQOS_RETVAL_PARAM;
ret = pqos_cap_get_type(cap, PQOS_CAP_TYPE_L2CA, &item);
if (ret != PQOS_RETVAL_OK)
return ret; /**< no L2CA capability */
ASSERT(item != NULL);
*cos_num = item->u.l2ca->num_classes;
return ret;
}
int
pqos_mba_get_cos_num(const struct pqos_cap *cap, unsigned *cos_num)
{
const struct pqos_capability *item = NULL;
int ret = PQOS_RETVAL_OK;
ASSERT(cap != NULL && cos_num != NULL);
if (cap == NULL || cos_num == NULL)
return PQOS_RETVAL_PARAM;
ret = pqos_cap_get_type(cap, PQOS_CAP_TYPE_MBA, &item);
if (ret != PQOS_RETVAL_OK)
return ret; /**< no MBA capability */
ASSERT(item != NULL);
*cos_num = item->u.mba->num_classes;
return ret;
}
int
pqos_l3ca_cdp_enabled(const struct pqos_cap *cap,
int *cdp_supported,
int *cdp_enabled)
{
const struct pqos_capability *item = NULL;
int ret = PQOS_RETVAL_OK;
ASSERT(cap != NULL && (cdp_enabled != NULL || cdp_supported != NULL));
if (cap == NULL || (cdp_enabled == NULL && cdp_supported == NULL))
return PQOS_RETVAL_PARAM;
ret = pqos_cap_get_type(cap, PQOS_CAP_TYPE_L3CA, &item);
if (ret != PQOS_RETVAL_OK)
return ret; /**< no L3CA capability */
ASSERT(item != NULL);
if (cdp_supported != NULL)
*cdp_supported = item->u.l3ca->cdp;
if (cdp_enabled != NULL)
*cdp_enabled = item->u.l3ca->cdp_on;
return ret;
}
int
pqos_l2ca_cdp_enabled(const struct pqos_cap *cap,
int *cdp_supported,
int *cdp_enabled)
{
const struct pqos_capability *l2ca = NULL;
int ret = PQOS_RETVAL_OK;
ASSERT(cap != NULL && (cdp_enabled != NULL || cdp_supported != NULL));
if (cap == NULL || (cdp_enabled == NULL && cdp_supported == NULL))
return PQOS_RETVAL_PARAM;
ret = pqos_cap_get_type(cap, PQOS_CAP_TYPE_L2CA, &l2ca);
if (ret != PQOS_RETVAL_OK)
return ret; /**< no L2CA capability */
ASSERT(l2ca != NULL);
if (cdp_supported != NULL)
*cdp_supported = l2ca->u.l2ca->cdp;
if (cdp_enabled != NULL)
*cdp_enabled = l2ca->u.l2ca->cdp_on;
return ret;
}
int
pqos_mba_ctrl_enabled(const struct pqos_cap *cap,
int *ctrl_supported,
int *ctrl_enabled)
{
const struct pqos_capability *mba_cap = NULL;
int ret = PQOS_RETVAL_OK;
ASSERT(cap != NULL && (ctrl_supported != NULL || ctrl_enabled != NULL));
if (cap == NULL || (ctrl_supported == NULL && ctrl_enabled == NULL))
return PQOS_RETVAL_PARAM;
ret = pqos_cap_get_type(cap, PQOS_CAP_TYPE_MBA, &mba_cap);
if (ret != PQOS_RETVAL_OK)
return ret; /**< no MBA capability */
ASSERT(mba_cap != NULL);
if (ctrl_supported != NULL)
*ctrl_supported = mba_cap->u.mba->ctrl;
if (ctrl_enabled != NULL)
*ctrl_enabled = mba_cap->u.mba->ctrl_on;
return PQOS_RETVAL_OK;
}
enum pqos_vendor
pqos_get_vendor(const struct pqos_cpuinfo *m_cpu)
{
return m_cpu->vendor;
}