def test_get_sockets(self, lib):
"Tests get_sockets() method."
sockets_mock = [ctypes.c_uint(socket) for socket in [0, 1, 2, 3]]
sockets_arr = ctypes_build_array(sockets_mock)
def pqos_cpu_get_sockets_m(_p_cpu, count_ref):
"Mock pqos_cpu_get_sockets()."
ctypes_ref_set_int(count_ref, len(sockets_arr))
return ctypes.cast(sockets_arr, ctypes.POINTER(ctypes.c_uint))
lib.pqos_cap_get = MagicMock(return_value=0)
lib.pqos_cpu_get_sockets = MagicMock(side_effect=pqos_cpu_get_sockets_m)
cpu = PqosCpuInfo()
with patch('pqos.cpuinfo.free_memory'):
sockets = cpu.get_sockets()
self.assertEqual(len(sockets), 4)
self.assertEqual(sockets[0], 0)
self.assertEqual(sockets[1], 1)
self.assertEqual(sockets[2], 2)
self.assertEqual(sockets[3], 3)
def test_get_cores(self, lib):
"Tests get_cores() method."
cores_mock = [ctypes.c_uint(core) for core in [8, 7, 3]]
cores_arr = ctypes_build_array(cores_mock)
def pqos_cpu_get_cores_m(_p_cpu, socket, count_ref):
"Mock pqos_cpu_get_cores()."
self.assertEqual(socket, 0)
ctypes_ref_set_int(count_ref, len(cores_arr))
return ctypes.cast(cores_arr, ctypes.POINTER(ctypes.c_uint))
lib.pqos_cap_get = MagicMock(return_value=0)
lib.pqos_cpu_get_cores = MagicMock(side_effect=pqos_cpu_get_cores_m)
cpu = PqosCpuInfo()
with patch('pqos.cpuinfo.free_memory'):
cores = cpu.get_cores(0)
self.assertEqual(len(cores), 3)
self.assertEqual(cores[0], 8)
self.assertEqual(cores[1], 7)
self.assertEqual(cores[2], 3)
lib.pqos_cpu_get_cores.assert_called_once()
def test_get_l2ids(self, lib):
"Tests get_l2ids() method."
l2ids_mock = [ctypes.c_uint(l2id) for l2id in [7, 2, 3, 5]]
l2ids_arr = ctypes_build_array(l2ids_mock)
def pqos_cpu_get_l2ids_m(_p_cpu, count_ref):
"Mock pqos_cpu_get_l2ids()."
ctypes_ref_set_int(count_ref, len(l2ids_arr))
return ctypes.cast(l2ids_arr, ctypes.POINTER(ctypes.c_uint))
lib.pqos_cap_get = MagicMock(return_value=0)
lib.pqos_cpu_get_l2ids = MagicMock(side_effect=pqos_cpu_get_l2ids_m)
cpu = PqosCpuInfo()
with patch('pqos.cpuinfo.free_memory'):
l2ids = cpu.get_l2ids()
self.assertEqual(len(l2ids), 4)
self.assertEqual(l2ids[0], 7)
self.assertEqual(l2ids[1], 2)
self.assertEqual(l2ids[2], 3)
self.assertEqual(l2ids[3], 5)
def test_get_cores(self, lib):
"Tests get_cores() method."
cores_mock = [ctypes.c_uint(core) for core in [8, 7, 3]]
cores_arr = ctypes_build_array(cores_mock)
def pqos_cpu_get_cores_m(_p_cpu, socket, count_ref):
"Mock pqos_cpu_get_cores()."
self.assertEqual(socket, 0)
ctypes_ref_set_int(count_ref, len(cores_arr))
return ctypes.cast(cores_arr, ctypes.POINTER(ctypes.c_uint))
lib.pqos_cap_get = MagicMock(return_value=0)
lib.pqos_cpu_get_cores = MagicMock(side_effect=pqos_cpu_get_cores_m)
cpu = PqosCpuInfo()
with patch('pqos.cpuinfo.free_memory'):
cores = cpu.get_cores(0)
self.assertEqual(len(cores), 3)
self.assertEqual(cores[0], 8)
self.assertEqual(cores[1], 7)
self.assertEqual(cores[2], 3)
lib.pqos_cpu_get_cores.assert_called_once()
def test_get_l2ids(self, lib):
"Tests get_l2ids() method."
l2ids_mock = [ctypes.c_uint(l2id) for l2id in [7, 2, 3, 5]]
l2ids_arr = ctypes_build_array(l2ids_mock)
def pqos_cpu_get_l2ids_m(_p_cpu, count_ref):
"Mock pqos_cpu_get_l2ids()."
ctypes_ref_set_int(count_ref, len(l2ids_arr))
return ctypes.cast(l2ids_arr, ctypes.POINTER(ctypes.c_uint))
lib.pqos_cap_get = MagicMock(return_value=0)
lib.pqos_cpu_get_l2ids = MagicMock(side_effect=pqos_cpu_get_l2ids_m)
cpu = PqosCpuInfo()
with patch('pqos.cpuinfo.free_memory'):
l2ids = cpu.get_l2ids()
self.assertEqual(len(l2ids), 4)
self.assertEqual(l2ids[0], 7)
self.assertEqual(l2ids[1], 2)
self.assertEqual(l2ids[2], 3)
self.assertEqual(l2ids[3], 5)
def test_get_sockets(self, lib):
"Tests get_sockets() method."
sockets_mock = [ctypes.c_uint(socket) for socket in [0, 1, 2, 3]]
sockets_arr = ctypes_build_array(sockets_mock)
def pqos_cpu_get_sockets_m(_p_cpu, count_ref):
"Mock pqos_cpu_get_sockets()."
ctypes_ref_set_int(count_ref, len(sockets_arr))
return ctypes.cast(sockets_arr, ctypes.POINTER(ctypes.c_uint))
lib.pqos_cap_get = MagicMock(return_value=0)
lib.pqos_cpu_get_sockets = MagicMock(side_effect=pqos_cpu_get_sockets_m)
cpu = PqosCpuInfo()
with patch('pqos.cpuinfo.free_memory'):
sockets = cpu.get_sockets()
self.assertEqual(len(sockets), 4)
self.assertEqual(sockets[0], 0)
self.assertEqual(sockets[1], 1)
self.assertEqual(sockets[2], 2)
self.assertEqual(sockets[3], 3)
def test_get_core_info(self, lib):
"Tests get_core_info() method."
coreinfo_mock = CPqosCoreInfo(lcore=1,
socket=0,
l3_id=1,
l2_id=7,
l3cat_id=1,
mba_id=1)
def pqos_get_core_info_m(_p_cpu, core):
"Mock pqos_cpu_get_core_info()."
self.assertEqual(core, 1)
return ctypes.pointer(coreinfo_mock)
lib.pqos_cap_get = MagicMock(return_value=0)
lib.pqos_cpu_get_core_info = MagicMock(
side_effect=pqos_get_core_info_m)
cpu = PqosCpuInfo()
coreinfo = cpu.get_core_info(1)
self.assertEqual(coreinfo.core, 1)
self.assertEqual(coreinfo.socket, 0)
self.assertEqual(coreinfo.l3_id, 1)
self.assertEqual(coreinfo.l2_id, 7)
lib.pqos_cpu_get_core_info.assert_called_once()
def test_get_vendor(self, lib):
lib.pqos_cap_get = MagicMock(return_value=0)
lib.pqos_get_vendor = MagicMock(return_value=1)
cpu = PqosCpuInfo()
self.assertEqual(cpu.get_vendor(), "INTEL")
def main():
args = parse_args()
try:
with PqosContextManager(args.interface):
cpu = PqosCpuInfo()
l2_ids = cpu.get_l2ids()
set_allocation_class(l2_ids, args.class_id, args.mask)
print_allocation_config(l2_ids)
except:
print("Error!")
raise
def main():
args = parse_args()
try:
with PqosContextManager(args.interface):
cpu = PqosCpuInfo()
sockets = cpu.get_sockets()
set_allocation_class(sockets, args.class_id, args.mb_max)
print_allocation_config(sockets)
except:
print("Error!")
raise
def init(self, iface, force_iface=False):
"""
Initializes libpqos
Returns:
0 on success
-1 otherwise
"""
if not force_iface and not iface in self.supported_iface():
log.error("RDT does not support '%s' interface!" % (iface))
return -1
# deinitialize lib first
if self.shared_dict['current_iface']:
self.fini()
# umount restcrl to improve caps detection
if platform.system() == 'FreeBSD':
result = os.system(
"/sbin/umount -a -t resctrl") # nosec - string literal
else:
result = os.system(
"/bin/umount -a -t resctrl") # nosec - string literal
if result:
log.error("Failed to umount resctrl fs! status code: %d"\
% (os.WEXITSTATUS(result)))
return -1
# attempt to initialize libpqos
try:
self.pqos.init(iface.upper())
self.cap = PqosCap()
self.l3ca = PqosCatL3()
self.mba = PqosMba()
self.alloc = PqosAlloc()
self.cpuinfo = PqosCpuInfo()
except Exception as ex:
log.error(str(ex))
return -1
# save current interface type in shared dict
self.shared_dict['current_iface'] = iface
# Reread MBA BW status from libpqos
self.refresh_mba_bw_status()
return 0
def get_all_cores():
"""
Returns all available cores.
Returns:
a list of available cores
"""
cores = []
cpu = PqosCpuInfo()
sockets = cpu.get_sockets()
for socket in sockets:
cores += cpu.get_cores(socket)
return cores
def test_check_core_invalid(self, lib):
"Tests check_core() method when the given core is invalid."
def pqos_cpu_check_core_m(_p_cpu, core):
"Mock pqos_cpu_check_core()."
self.assertEqual(core, 99999)
return 1
lib.pqos_cap_get = MagicMock(return_value=0)
lib.pqos_cpu_check_core = MagicMock(side_effect=pqos_cpu_check_core_m)
cpu = PqosCpuInfo()
result = cpu.check_core(99999)
self.assertFalse(result)
lib.pqos_cpu_check_core.assert_called_once()
def test_check_core_invalid(self, lib):
"Tests check_core() method when the given core is invalid."
def pqos_cpu_check_core_m(_p_cpu, core):
"Mock pqos_cpu_check_core()."
self.assertEqual(core, 99999)
return 1
lib.pqos_cap_get = MagicMock(return_value=0)
lib.pqos_cpu_check_core = MagicMock(side_effect=pqos_cpu_check_core_m)
cpu = PqosCpuInfo()
result = cpu.check_core(99999)
self.assertFalse(result)
lib.pqos_cpu_check_core.assert_called_once()
def test_get_one_core(self, lib):
"Tests get_one_core() method."
def pqos_get_one_core_m(_p_cpu, socket, core_ref):
"Mock pqos_cpu_get_one_core()."
self.assertEqual(socket, 1)
ctypes_ref_set_int(core_ref, 5)
return 0
lib.pqos_cap_get = MagicMock(return_value=0)
lib.pqos_cpu_get_one_core = MagicMock(side_effect=pqos_get_one_core_m,
__name__=u'pqos_cpu_get_one_core')
cpu = PqosCpuInfo()
core = cpu.get_one_core(1)
self.assertEqual(core, 5)
lib.pqos_cpu_get_one_core.assert_called_once()
def test_get_one_core(self, lib):
"Tests get_one_core() method."
def pqos_get_one_core_m(_p_cpu, socket, core_ref):
"Mock pqos_cpu_get_one_core()."
self.assertEqual(socket, 1)
ctypes_ref_set_int(core_ref, 5)
return 0
lib.pqos_cap_get = MagicMock(return_value=0)
lib.pqos_cpu_get_one_core = MagicMock(side_effect=pqos_get_one_core_m,
__name__=u'pqos_cpu_get_one_core')
cpu = PqosCpuInfo()
core = cpu.get_one_core(1)
self.assertEqual(core, 5)
lib.pqos_cpu_get_one_core.assert_called_once()
def test_get_socketid(self, lib):
"Tests get_socketid() method."
def pqos_get_socketid_m(_p_cpu, core, socket_ref):
"Mock pqos_cpu_get_socketid()."
self.assertEqual(core, 3)
ctypes_ref_set_int(socket_ref, 4)
return 0
lib.pqos_cap_get = MagicMock(return_value=0)
lib.pqos_cpu_get_socketid = MagicMock(side_effect=pqos_get_socketid_m,
__name__=u'pqos_cpu_get_socketid')
cpu = PqosCpuInfo()
socket = cpu.get_socketid(3)
self.assertEqual(socket, 4)
lib.pqos_cpu_get_socketid.assert_called_once()
def test_get_socketid(self, lib):
"Tests get_socketid() method."
def pqos_get_socketid_m(_p_cpu, core, socket_ref):
"Mock pqos_cpu_get_socketid()."
self.assertEqual(core, 3)
ctypes_ref_set_int(socket_ref, 4)
return 0
lib.pqos_cap_get = MagicMock(return_value=0)
lib.pqos_cpu_get_socketid = MagicMock(side_effect=pqos_get_socketid_m,
__name__=u'pqos_cpu_get_socketid')
cpu = PqosCpuInfo()
socket = cpu.get_socketid(3)
self.assertEqual(socket, 4)
lib.pqos_cpu_get_socketid.assert_called_once()
def test_get_one_by_l2id(self, lib):
"Tests get_one_by_l2id() method."
def pqos_get_by_l2id_m(_p_cpu, l2_id, core_ref):
"Mock pqos_cpu_get_one_core()."
self.assertEqual(l2_id, 8)
ctypes_ref_set_int(core_ref, 15)
return 0
lib.pqos_cap_get = MagicMock(return_value=0)
func_mock = MagicMock(side_effect=pqos_get_by_l2id_m,
__name__=u'pqos_cpu_get_one_by_l2id')
lib.pqos_cpu_get_one_by_l2id = func_mock
cpu = PqosCpuInfo()
core = cpu.get_one_by_l2id(8)
self.assertEqual(core, 15)
lib.pqos_cpu_get_one_by_l2id.assert_called_once()
def test_get_clusterid(self, lib):
"Tests get_clusterid() method."
def pqos_get_clusterid_m(_p_cpu, core, cluster_ref):
"Mock pqos_cpu_get_clusterid()."
self.assertEqual(core, 1)
ctypes_ref_set_int(cluster_ref, 0)
return 0
lib.pqos_cap_get = MagicMock(return_value=0)
func_mock = MagicMock(side_effect=pqos_get_clusterid_m,
__name__=u'pqos_cpu_get_clusterid')
lib.pqos_cpu_get_clusterid = func_mock
cpu = PqosCpuInfo()
cluster = cpu.get_clusterid(1)
self.assertEqual(cluster, 0)
lib.pqos_cpu_get_clusterid.assert_called_once()
def init(self):
"""
Initializes libpqos
Returns:
0 on success
-1 otherwise
"""
try:
self.pqos.init('MSR')
self.cap = PqosCap()
self.l3ca = PqosCatL3()
self.mba = PqosMba()
self.alloc = PqosAlloc()
self.cpuinfo = PqosCpuInfo()
except Exception as ex:
log.error(str(ex))
return -1
return 0
def test_get_clusterid(self, lib):
"Tests get_clusterid() method."
def pqos_get_clusterid_m(_p_cpu, core, cluster_ref):
"Mock pqos_cpu_get_clusterid()."
self.assertEqual(core, 1)
ctypes_ref_set_int(cluster_ref, 0)
return 0
lib.pqos_cap_get = MagicMock(return_value=0)
func_mock = MagicMock(side_effect=pqos_get_clusterid_m,
__name__=u'pqos_cpu_get_clusterid')
lib.pqos_cpu_get_clusterid = func_mock
cpu = PqosCpuInfo()
cluster = cpu.get_clusterid(1)
self.assertEqual(cluster, 0)
lib.pqos_cpu_get_clusterid.assert_called_once()
def test_get_one_by_l2id(self, lib):
"Tests get_one_by_l2id() method."
def pqos_get_by_l2id_m(_p_cpu, l2_id, core_ref):
"Mock pqos_cpu_get_one_core()."
self.assertEqual(l2_id, 8)
ctypes_ref_set_int(core_ref, 15)
return 0
lib.pqos_cap_get = MagicMock(return_value=0)
func_mock = MagicMock(side_effect=pqos_get_by_l2id_m,
__name__=u'pqos_cpu_get_one_by_l2id')
lib.pqos_cpu_get_one_by_l2id = func_mock
cpu = PqosCpuInfo()
core = cpu.get_one_by_l2id(8)
self.assertEqual(core, 15)
lib.pqos_cpu_get_one_by_l2id.assert_called_once()
def print_allocation_config():
"""
Prints allocation configuration.
"""
l3ca = PqosCatL3()
alloc = PqosAlloc()
cpuinfo = PqosCpuInfo()
sockets = cpuinfo.get_sockets()
for socket in sockets:
try:
coses = l3ca.get(socket)
print("L3CA COS definitions for Socket %u:" % socket)
for cos in coses:
cos_params = (cos.class_id, cos.mask)
print(" L3CA COS%u => MASK 0x%x" % cos_params)
except:
print("Error")
raise
for socket in sockets:
try:
print("Core information for socket %u:" % socket)
cores = cpuinfo.get_cores(socket)
for core in cores:
class_id = alloc.assoc_get(core)
try:
print(" Core %u => COS%u" % (core, class_id))
except:
print(" Core %u => ERROR" % core)
except:
print("Error")
raise
def test_get_core_info(self, lib):
"Tests get_core_info() method."
coreinfo_mock = CPqosCoreInfo(lcore=1, socket=0, l3_id=1, l2_id=7)
def pqos_get_core_info_m(_p_cpu, core):
"Mock pqos_cpu_get_core_info()."
self.assertEqual(core, 1)
return ctypes.pointer(coreinfo_mock)
lib.pqos_cap_get = MagicMock(return_value=0)
lib.pqos_cpu_get_core_info = MagicMock(side_effect=pqos_get_core_info_m)
cpu = PqosCpuInfo()
coreinfo = cpu.get_core_info(1)
self.assertEqual(coreinfo.core, 1)
self.assertEqual(coreinfo.socket, 0)
self.assertEqual(coreinfo.l3_id, 1)
self.assertEqual(coreinfo.l2_id, 7)
lib.pqos_cpu_get_core_info.assert_called_once()
def print_allocation_config():
"""
Prints allocation configuration.
"""
alloc = PqosAlloc()
cpuinfo = PqosCpuInfo()
sockets = cpuinfo.get_sockets()
for socket in sockets:
try:
print("Core information for socket %u:" % socket)
cores = cpuinfo.get_cores(socket)
for core in cores:
class_id = alloc.assoc_get(core)
try:
print(" Core %u => COS%u" % (core, class_id))
except:
print(" Core %u => ERROR" % core)
except:
print("Error")
raise
def test_init(self, lib):
"""
Tests if the pointer to CPU information object given
to PQoS library APIs is the same returned from pqos_cap_get() API during
an initialization of PqosCpuInfo.
"""
builder = PqosCpuInfoMockBuilder()
p_cpu = builder.build()
def pqos_cap_get_mock(_cap_ref, cpu_ref):
"Mock pqos_cap_get()."
ctypes.memmove(cpu_ref, ctypes.addressof(p_cpu),
ctypes.sizeof(p_cpu))
return 0
def pqos_socketid_m(cpu_ref, _core, _socket_ref):
"Mock pqos_cpu_get_socketid()."
cpu_ref_addr = ctypes.addressof(cpu_ref.contents)
p_cpu_addr = ctypes.addressof(p_cpu.contents)
self.assertEqual(cpu_ref_addr, p_cpu_addr)
return 1
lib.pqos_cap_get = MagicMock(side_effect=pqos_cap_get_mock)
lib.pqos_cpu_get_socketid = MagicMock(side_effect=pqos_socketid_m,
__name__=u'pqos_cpu_get_socketid')
pqos_cpu = PqosCpuInfo()
with self.assertRaises(PqosError):
pqos_cpu.get_socketid(0)
lib.pqos_cpu_get_socketid.assert_called_once()
lib.pqos_cap_get.assert_called_once()
def test_init(self, lib):
"""
Tests if the pointer to CPU information object given
to PQoS library APIs is the same returned from pqos_cap_get() API during
an initialization of PqosCpuInfo.
"""
builder = PqosCpuInfoMockBuilder()
p_cpu = builder.build()
def pqos_cap_get_mock(_cap_ref, cpu_ref):
"Mock pqos_cap_get()."
ctypes.memmove(cpu_ref, ctypes.addressof(p_cpu),
ctypes.sizeof(p_cpu))
return 0
def pqos_socketid_m(cpu_ref, _core, _socket_ref):
"Mock pqos_cpu_get_socketid()."
cpu_ref_addr = ctypes.addressof(cpu_ref.contents)
p_cpu_addr = ctypes.addressof(p_cpu.contents)
self.assertEqual(cpu_ref_addr, p_cpu_addr)
return 1
lib.pqos_cap_get = MagicMock(side_effect=pqos_cap_get_mock)
lib.pqos_cpu_get_socketid = MagicMock(side_effect=pqos_socketid_m,
__name__=u'pqos_cpu_get_socketid')
pqos_cpu = PqosCpuInfo()
with self.assertRaises(PqosError):
pqos_cpu.get_socketid(0)
lib.pqos_cpu_get_socketid.assert_called_once()
lib.pqos_cap_get.assert_called_once()
class PqosApi:
# pylint: disable=too-many-instance-attributes
"""
Wrapper for libpqos wrapper.
"""
def __init__(self):
self.pqos = Pqos()
self.cap = None
self.l3ca = None
self.mba = None
self.alloc = None
self.cpuinfo = None
self._supported_iface = []
# dict to share interface type and MBA BW status
# between REST API process and "backend"
self.shared_dict = common.MANAGER.dict()
self.shared_dict['current_iface'] = None
self.shared_dict['mba_bw_supported'] = None
self.shared_dict['mba_bw_enabled'] = None
def detect_supported_ifaces(self):
"""
Detects supported RDT interfaces
"""
for iface in ["msr", "os"]:
if not self.init(iface, True):
log.info("Interface %s, MBA BW: %ssupported."\
% (iface.upper(), "un" if not self.is_mba_bw_supported() else ""))
self.fini()
self._supported_iface.append(iface)
log.info("Supported RDT interfaces: " + str(self.supported_iface()))
def init(self, iface, force_iface=False):
"""
Initializes libpqos
Returns:
0 on success
-1 otherwise
"""
if not force_iface and not iface in self.supported_iface():
log.error("RDT does not support '%s' interface!" % (iface))
return -1
# deinitialize lib first
if self.shared_dict['current_iface']:
self.fini()
# umount restcrl to improve caps detection
if platform.system() == 'FreeBSD':
result = os.system(
"/sbin/umount -a -t resctrl") # nosec - string literal
else:
result = os.system(
"/bin/umount -a -t resctrl") # nosec - string literal
if result:
log.error("Failed to umount resctrl fs! status code: %d"\
% (os.WEXITSTATUS(result)))
return -1
# attempt to initialize libpqos
try:
self.pqos.init(iface.upper())
self.cap = PqosCap()
self.l3ca = PqosCatL3()
self.mba = PqosMba()
self.alloc = PqosAlloc()
self.cpuinfo = PqosCpuInfo()
except Exception as ex:
log.error(str(ex))
return -1
# save current interface type in shared dict
self.shared_dict['current_iface'] = iface
# Reread MBA BW status from libpqos
self.refresh_mba_bw_status()
return 0
def refresh_mba_bw_status(self):
"""
Reads MBA BW status from libpqos
and save results in shared dict
Returns:
0 on success
-1 otherwise
"""
try:
supported, enabled = self.cap.is_mba_ctrl_enabled()
# convert None to False
supported = bool(supported)
self.shared_dict['mba_bw_supported'] = supported
self.shared_dict['mba_bw_enabled'] = enabled
except Exception as ex:
log.error("libpqos is_mba_ctrl_enabled(..) call failed!")
log.error(str(ex))
return -1
return 0
def current_iface(self):
"""
Returns current RDT interface
Returns:
interface name on success
None when libpqos is not initialized
"""
return self.shared_dict['current_iface']
def supported_iface(self):
"""
Returns list of supported RDT interfaces
Returns:
list of supported interfaces
"""
# no need to keep it in shared dict as it does not changed
# during runtime.
return self._supported_iface
def is_mba_bw_supported(self):
"""
Returns MBA BW support status
Returns:
MBA BW support status
"""
return self.shared_dict['mba_bw_supported']
def is_mba_bw_enabled(self):
"""
Returns MBA BW enabled status
Returns:
MBA BW enabled status
"""
return self.shared_dict['mba_bw_enabled']
def enable_mba_bw(self, enable):
"""
Change MBA BW enabled status
Returns:
0 on success
-1 otherwise
"""
try:
# call libpqos alloc reset
self.alloc.reset("any", "any", "ctrl" if enable else "default")
except Exception as ex:
log.error("libpqos reset(..) call failed!")
log.error(str(ex))
return -1
# Reread MBA BW status from libpqos
self.refresh_mba_bw_status()
return 0
def fini(self):
"""
De-initializes libpqos
"""
self.pqos.fini()
self.shared_dict['current_iface'] = None
return 0
def release(self, cores):
"""
Release cores, assigns cores to CoS#0
Parameters:
cores: list of cores to be released
Returns:
0 on success
-1 otherwise
"""
if cores is None:
return 0
try:
self.alloc.release(cores)
except Exception as ex:
log.error(str(ex))
return -1
return 0
def alloc_assoc_set(self, cores, cos):
"""
Assigns cores to CoS
Parameters:
cores: list of cores to be assigned to cos
cos: Class of Service
Returns:
0 on success
-1 otherwise
"""
if not cores:
return 0
try:
for core in cores:
self.alloc.assoc_set(core, cos)
except Exception as ex:
log.error(str(ex))
return -1
return 0
def l3ca_set(self, sockets, cos_id, ways_mask):
"""
Configures L3 CAT for CoS
Parameters:
sockets: sockets list on which to configure L3 CAT
cos_id: Class of Service
ways_mask: L3 CAT CBM to set
Returns:
0 on success
-1 otherwise
"""
try:
cos = self.l3ca.COS(cos_id, ways_mask)
for socket in sockets:
self.l3ca.set(socket, [cos])
except Exception as ex:
log.error(str(ex))
return -1
return 0
def mba_set(self, sockets, cos_id, mb_max, ctrl=False):
"""
Configures MBA rate for CoS
Parameters:
sockets: sockets list on which to configure L3 CAT
cos_id: Class of Service
mb_max: MBA rate to set
Returns:
0 on success
-1 otherwise
"""
try:
cos = self.mba.COS(cos_id, mb_max, ctrl)
for socket in sockets:
self.mba.set(socket, [cos])
except Exception as ex:
log.error(str(ex))
return -1
return 0
def is_mba_supported(self):
"""
Checks for MBA support
Returns:
True if supported
False otherwise
"""
try:
return bool(self.get_mba_num_cos())
except Exception as ex:
log.error(str(ex))
return False
def is_l3_cat_supported(self):
"""
Checks for L3 CAT support
Returns:
True if supported
False otherwise
"""
try:
return bool(self.get_l3ca_num_cos())
except Exception as ex:
log.error(str(ex))
return False
def is_multicore(self):
"""
Checks if system is multicore
Returns:
True if multicore
False otherwise
"""
return self.get_num_cores() > 1
def get_num_cores(self):
"""
Gets number of cores in system
Returns:
num of cores
None otherwise
"""
try:
sockets = self.cpuinfo.get_sockets()
return sum(
[len(self.cpuinfo.get_cores(socket)) for socket in sockets])
except Exception as ex:
log.error(str(ex))
return None
def check_core(self, core):
"""
Verifies if a specified core is a valid logical core ID.
Parameters:
core: core ID
Returns:
True/False a given core number is valid/invalid
None otherwise
"""
try:
return self.cpuinfo.check_core(core)
except Exception as ex:
log.error(str(ex))
return None
def get_sockets(self):
"""
Gets list of sockets
Returns:
sockets list,
None otherwise
"""
try:
return self.cpuinfo.get_sockets()
except Exception as ex:
log.error(str(ex))
return None
def get_l3ca_num_cos(self):
"""
Gets number of COS for L3 CAT
Returns:
num of COS for L3 CAT
None otherwise
"""
try:
return self.cap.get_l3ca_cos_num()
except Exception as ex:
log.error(str(ex))
return None
def get_mba_num_cos(self):
"""
Gets number of COS for MBA
Returns:
num of COS for MBA
None otherwise
"""
try:
return self.cap.get_mba_cos_num()
except Exception as ex:
log.error(str(ex))
return None
def get_max_cos_id(self, alloc_type):
"""
Gets max COS# (id) that can be used to configure set of allocation technologies
Returns:
Available COS# to be used
None otherwise
"""
max_cos_num = None
max_cos_cat = self.get_l3ca_num_cos()
max_cos_mba = self.get_mba_num_cos()
if common.CAT_CAP not in alloc_type and common.MBA_CAP not in alloc_type:
return None
if common.CAT_CAP in alloc_type and not max_cos_cat:
return None
if common.MBA_CAP in alloc_type and not max_cos_mba:
return None
if common.CAT_CAP in alloc_type:
max_cos_num = max_cos_cat
if common.MBA_CAP in alloc_type:
if max_cos_num is not None:
max_cos_num = min(max_cos_mba, max_cos_num)
else:
max_cos_num = max_cos_mba
return max_cos_num - 1
def get_max_l3_cat_cbm(self):
"""
Gets Max L3 CAT CBM
Returns:
Max L3 CAT CBM
None otherwise
"""
if not self.is_l3_cat_supported():
return None
try:
l3ca_caps = self.cap.get_type("l3ca")
return 2**l3ca_caps.num_ways - 1
except Exception as ex:
log.error(str(ex))
return None
# 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.
################################################################################
from pqos import Pqos
from pqos.cpuinfo import PqosCpuInfo
# Initialize PQoS library
pqos = Pqos()
pqos.init('MSR')
cpuinfo = PqosCpuInfo()
# Get number of sockets
sockets = cpuinfo.get_sockets()
print('Number of sockets: %d' % len(sockets))
# Get number of cores
num_cores = sum([len(cpuinfo.get_cores(socket)) for socket in sockets])
print('Number of cores: %d' % num_cores)
# Check if core 89 is a valid core
result = cpuinfo.check_core(89)
print('Is 89 a valid core? %s' % ('Yes' if result else 'No'))
# Finalize PQoS library
pqos.fini()
# 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.
################################################################################
from pqos import Pqos
from pqos.cpuinfo import PqosCpuInfo
# Initialize PQoS library
pqos = Pqos()
pqos.init('MSR')
cpuinfo = PqosCpuInfo()
# Get number of sockets
sockets = cpuinfo.get_sockets()
print('Number of sockets: %d' % len(sockets))
# Get number of cores
num_cores = sum([len(cpuinfo.get_cores(socket)) for socket in sockets])
print('Number of cores: %d' % num_cores)
# Check if core 89 is a valid core
result = cpuinfo.check_core(89)
print('Is 89 a valid core? %s' % ('Yes' if result else 'No'))
# Finalize PQoS library
pqos.fini()
class PqosApi:
"""
Wrapper for libpqos wrapper.
"""
def __init__(self):
self.pqos = Pqos()
self.cap = None
self.l3ca = None
self.mba = None
self.alloc = None
self.cpuinfo = None
def init(self):
"""
Initializes libpqos
Returns:
0 on success
-1 otherwise
"""
try:
self.pqos.init('MSR')
self.cap = PqosCap()
self.l3ca = PqosCatL3()
self.mba = PqosMba()
self.alloc = PqosAlloc()
self.cpuinfo = PqosCpuInfo()
except Exception as ex:
log.error(str(ex))
return -1
return 0
def fini(self):
"""
De-initializes libpqos
"""
self.pqos.fini()
return 0
def release(self, cores):
"""
Release cores, assigns cores to CoS#0
Parameters:
cores: list of cores to be released
Returns:
0 on success
-1 otherwise
"""
if cores is None:
return 0
try:
self.alloc.release(cores)
except Exception as ex:
log.error(str(ex))
return -1
return 0
def alloc_assoc_set(self, cores, cos):
"""
Assigns cores to CoS
Parameters:
cores: list of cores to be assigned to cos
cos: Class of Service
Returns:
0 on success
-1 otherwise
"""
if not cores:
return 0
try:
for core in cores:
self.alloc.assoc_set(core, cos)
except Exception as ex:
log.error(str(ex))
return -1
return 0
def l3ca_set(self, sockets, cos_id, ways_mask):
"""
Configures L3 CAT for CoS
Parameters:
sockets: sockets list on which to configure L3 CAT
cos_id: Class of Service
ways_mask: L3 CAT CBM to set
Returns:
0 on success
-1 otherwise
"""
try:
cos = self.l3ca.COS(cos_id, ways_mask)
for socket in sockets:
self.l3ca.set(socket, [cos])
except Exception as ex:
log.error(str(ex))
return -1
return 0
def mba_set(self, sockets, cos_id, mb_max):
"""
Configures MBA for CoS
Parameters:
sockets: sockets list on which to configure L3 CAT
cos_id: Class of Service
mb_max: MBA to set
Returns:
0 on success
-1 otherwise
"""
try:
cos = self.mba.COS(cos_id, mb_max)
for socket in sockets:
self.mba.set(socket, [cos])
except Exception as ex:
log.error(str(ex))
return -1
return 0
def is_mba_supported(self):
"""
Checks for MBA support
Returns:
1 if supported
0 otherwise
"""
try:
return self.get_mba_num_cos() != 0
except Exception as ex:
log.error(str(ex))
return 0
def is_l3_cat_supported(self):
"""
Checks for L3 CAT support
Returns:
1 if supported
0 otherwise
"""
try:
return self.get_l3ca_num_cos() != 0
except Exception as ex:
log.error(str(ex))
return 0
def is_multicore(self):
"""
Checks if system is multicore
Returns:
True if multicore
False otherwise
"""
return self.get_num_cores() > 1
def get_num_cores(self):
"""
Gets number of cores in system
Returns:
num of cores
0 otherwise
"""
try:
sockets = self.cpuinfo.get_sockets()
return sum([len(self.cpuinfo.get_cores(socket)) for socket in sockets])
except Exception as ex:
log.error(str(ex))
return None
def check_core(self, core):
"""
Verifies if a specified core is a valid logical core ID.
Parameters:
core: core ID
Returns:
True/False a given core number is valid/invalid
None otherwise
"""
try:
return self.cpuinfo.check_core(core)
except Exception as ex:
log.error(str(ex))
return None
def get_sockets(self):
"""
Gets list of sockets
Returns:
sockets list,
None otherwise
"""
try:
return self.cpuinfo.get_sockets()
except Exception as ex:
log.error(str(ex))
return None
def get_l3ca_num_cos(self):
"""
Gets number of COS for L3 CAT
Returns:
num of COS for L3 CAT
None otherwise
"""
try:
return self.cap.get_l3ca_cos_num()
except Exception as ex:
log.error(str(ex))
return None
def get_mba_num_cos(self):
"""
Gets number of COS for MBA
Returns:
num of COS for MBA
None otherwise
"""
try:
return self.cap.get_mba_cos_num()
except Exception as ex:
log.error(str(ex))
return None
def get_max_cos_id(self, alloc_type):
"""
Gets max COS# (id) that can be used to configure set of allocation technologies
Returns:
Available COS# to be used
None otherwise
"""
max_cos_num = None
max_cos_cat = self.get_l3ca_num_cos()
max_cos_mba = self.get_mba_num_cos()
if common.CAT_CAP not in alloc_type and common.MBA_CAP not in alloc_type:
return None
if common.CAT_CAP in alloc_type and not max_cos_cat:
return None
if common.MBA_CAP in alloc_type and not max_cos_mba:
return None
if common.CAT_CAP in alloc_type:
max_cos_num = max_cos_cat
if common.MBA_CAP in alloc_type:
if max_cos_num is not None:
max_cos_num = min(max_cos_mba, max_cos_num)
else:
max_cos_num = max_cos_mba
return max_cos_num - 1
def get_max_l3_cat_cbm(self):
"""
Gets Max L3 CAT CBM
Returns:
Max L3 CAT CBM
None otherwise
"""
if not self.is_l3_cat_supported():
return None
try:
l3ca_caps = self.cap.get_type("l3ca")
return 2**l3ca_caps.num_ways - 1
except Exception as ex:
log.error(str(ex))
return None