def test_init(self, lib): """ Tests if the pointer to capabilities object given to PQoS library APIs is the same returned from pqos_cap_get() API during an initialization of PqosCap. """ builder = PqosCapMockBuilder() p_cap = builder.build() def pqos_cap_get_mock(cap_ref, _cpu_ref): "Mock pqos_cap_get()." ctypes.memmove(cap_ref, ctypes.addressof(p_cap), ctypes.sizeof(p_cap)) return 0 def pqos_cap_get_type_mock(cap_ref, _type_enum, _p_cap_item_ref): "Mock pqos_cap_get_type()." cap_ref_addr = ctypes.addressof(cap_ref.contents) p_cap_addr = ctypes.addressof(p_cap.contents) self.assertEqual(cap_ref_addr, p_cap_addr) return 1 lib.pqos_cap_get = MagicMock(side_effect=pqos_cap_get_mock) lib.pqos_cap_get_type = MagicMock(side_effect=pqos_cap_get_type_mock) pqos_cap = PqosCap() with self.assertRaises(PqosError): pqos_cap.get_type('mba')
def test_get_type_mba(self, lib): "Tests get_type() method for MBA." mba = CPqosCapabilityMBA(mem_size=ctypes.sizeof(CPqosCapabilityMBA), num_classes=2, throttle_max=95, throttle_step=15, is_linear=1, ctrl=1, ctrl_on=0) mba_u = CPqosCapabilityUnion(mba=ctypes.pointer(mba)) mba_cap = CPqosCapability(type=CPqosCapability.PQOS_CAP_TYPE_MBA, u=mba_u) _prepare_get_type(lib, mba_cap) pqos_cap = PqosCap() mba_capability = pqos_cap.get_type('mba') self.assertEqual(mba_capability.num_classes, 2) self.assertEqual(mba_capability.throttle_max, 95) self.assertEqual(mba_capability.throttle_step, 15) self.assertEqual(mba_capability.is_linear, True) self.assertEqual(mba_capability.ctrl, True) self.assertEqual(mba_capability.ctrl_on, False)
def get_supported_events(): """ Returns a list of supported monitoring events. Returns: a list of supported monitoring events """ cap = PqosCap() mon_cap = cap.get_type('mon') events = [get_event_name(event.type) for event in mon_cap.events] # Filter out perf events events = list(filter(lambda event: 'perf' not in event, events)) return events
def test_get_type_l3ca(self, lib): "Tests get_type() method for L3 cache allocation." l3ca = CPqosCapabilityL3(mem_size=ctypes.sizeof(CPqosCapabilityL3), num_classes=2, num_ways=8, way_size=1024*1024, way_contention=0, cdp=1, cdp_on=0) l3ca_u = CPqosCapabilityUnion(l3ca=ctypes.pointer(l3ca)) l3ca_cap = CPqosCapability(type=CPqosCapability.PQOS_CAP_TYPE_L3CA, u=l3ca_u) _prepare_get_type(lib, l3ca_cap) pqos_cap = PqosCap() l3ca_capability = pqos_cap.get_type('l3ca') self.assertEqual(l3ca_capability.num_classes, 2) self.assertEqual(l3ca_capability.num_ways, 8) self.assertEqual(l3ca_capability.way_size, 1024*1024) self.assertEqual(l3ca_capability.way_contention, 0) self.assertEqual(l3ca_capability.cdp, True) self.assertEqual(l3ca_capability.cdp_on, False)
def test_get_type_l2ca(self, lib): "Tests get_type() method for L2 cache allocation." l2ca = CPqosCapabilityL2(mem_size=ctypes.sizeof(CPqosCapabilityL2), num_classes=4, num_ways=16, way_size=2*1024*1024, way_contention=0, cdp=1, cdp_on=0) l2ca_u = CPqosCapabilityUnion(l2ca=ctypes.pointer(l2ca)) l2ca_cap = CPqosCapability(type=CPqosCapability.PQOS_CAP_TYPE_L2CA, u=l2ca_u) _prepare_get_type(lib, l2ca_cap) pqos_cap = PqosCap() l2ca_capability = pqos_cap.get_type('l2ca') self.assertEqual(l2ca_capability.num_classes, 4) self.assertEqual(l2ca_capability.num_ways, 16) self.assertEqual(l2ca_capability.way_size, 2*1024*1024) self.assertEqual(l2ca_capability.way_contention, 0) self.assertEqual(l2ca_capability.cdp, True) self.assertEqual(l2ca_capability.cdp_on, False)
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
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ################################################################################ from pqos import Pqos from pqos.capability import PqosCap from pqos.l3ca import PqosCatL3 # Initialize PQoS library pqos = Pqos() pqos.init('MSR') # Check if L3 CAT is supported cap = PqosCap() l3ca_supported = False try: cap.get_type('l3ca') l3ca_supported = True except: pass print('Is L3 CAT supported? %s' % ('Yes' if l3ca_supported else 'No')) if l3ca_supported: l3ca = PqosCatL3() # Read L3 CAT configuration for socket 0 coses = l3ca.get(0) for cos in coses: print(cos) # Configure L3 CAT
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ################################################################################ from pqos import Pqos from pqos.capability import PqosCap # Initialize PQoS library pqos = Pqos() pqos.init('OS') cap = PqosCap() # Check if MBA is supported mba_supported = False try: cap.get_type('mba') mba_supported = True except: pass print('Is MBA supported? %s' % ('Yes' if mba_supported else 'No')) if mba_supported: # Get number of MBA classes of service mba_cos_num = cap.get_mba_cos_num() print('MBA: available %d classes of service' % mba_cos_num) # Check if L3 CAT is supported l3ca_cap = None try: l3ca_cap = cap.get_type('l3ca')
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
################################################################################ from pqos import Pqos from pqos.capability import PqosCap from pqos.mba import PqosMba # Initialize PQoS library pqos = Pqos() pqos.init('OS') # Check if MBA is supported cap = PqosCap() mba_supported = False try: cap.get_type('mba') mba_supported = True except: pass print('Is MBA supported? %s' % ('Yes' if mba_supported else 'No')) if mba_supported: mba = PqosMba() # Get MBA configuration for socket 0 coses = mba.get(0) print('MBA configuration for socket 0:') for cos in coses: print('COS: %d' % cos.class_id)
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ################################################################################ from pqos import Pqos from pqos.capability import PqosCap from pqos.mba import PqosMba # Initialize PQoS library pqos = Pqos() pqos.init('OS') # Check if MBA is supported cap = PqosCap() mba_supported = False try: cap.get_type('mba') mba_supported = True except: pass print('Is MBA supported? %s' % ('Yes' if mba_supported else 'No')) if mba_supported: mba = PqosMba() # Get MBA configuration for socket 0 coses = mba.get(0) print('MBA configuration for socket 0:') for cos in coses: print('COS: %d' % cos.class_id)
################################################################################ from pqos import Pqos from pqos.capability import PqosCap # Initialize PQoS library pqos = Pqos() pqos.init('OS') cap = PqosCap() # Check if MBA is supported mba_supported = False try: cap.get_type('mba') mba_supported = True except: pass print('Is MBA supported? %s' % ('Yes' if mba_supported else 'No')) if mba_supported: # Get number of MBA classes of service mba_cos_num = cap.get_mba_cos_num() print('MBA: available %d classes of service' % mba_cos_num) # Check if L3 CAT is supported l3ca_cap = None try: l3ca_cap = cap.get_type('l3ca')