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
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 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_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_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 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 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 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 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
# 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()
