def enablePMU(self, eventsDb, cpuSet, events):
"""
Enables user space pmc collection for the given cpuSet
:param eventsDb: A database of programmable performance counters
:type eventsDb: xpedite.pmu.eventsDb.EventsDb
:param cpuSet: A list of cpu cores to enable pmc collection
:param events: A user supplied list of pmc events to be programmed
"""
if not cpuSet or len(cpuSet) <= 0:
raise Exception(
'Invalid argument - cpu set missing. need explicit cpu set to enable pmu'
)
self.pmuCtrl = PMUCtrl(eventsDb)
self.pmuCtrl.__enter__()
return self.pmuCtrl.enable(cpuSet, events)
def resolveEvents(eventsDb, cpuSet, events):
"""
Resolves a list of given pmu events from events database
:param eventsDb: Handle to database of PMU events for the target cpu
:param events: List of PMU events to be enabled for the current profile session
:param cpuSet: List of cpu, where the userspace pmu collection will be enabled
"""
from xpedite.pmu.pmuctrl import PMUCtrl
return PMUCtrl.resolveEvents(eventsDb, cpuSet, events)
def test_request_sorter():
eventsFile = os.path.join(os.path.dirname(__file__), 'test_events.json')
eventsDb = EventsLoader().loadJson(eventsFile)
assert eventsDb
events = [
Event('EVENT_3', 'EVENT_3'),
Event('EVENT_2', 'EVENT_2'),
Event('EVENT_1', 'EVENT_1'),
Event('EVENT_0', 'EVENT_0'),
]
eventState = PMUCtrl.resolveEvents(eventsDb, [0], events)
assert len(eventState) == len(events)
assert len(eventState.genericRequests) == len(events)
for i, event in enumerate(events):
assert event.uarchName == eventState.genericRequests[i].uarchName
PMUCtrl.allocateEvents(eventState)
assert len(eventState.genericRequests) == len(events)
print(eventState.genericRequests)
for i, event in enumerate(events):
assert event.uarchName == eventState.genericRequests[len(events) - i -
1].uarchName
def enablePMU(self, eventsDb, cpuSet, events):
"""
Enables PMU counters for the given cpu set in target host
:param eventsDb: A database of programmable performance counters
:type eventsDb: xpedite.pmu.eventsDb.EventsDb
:param cpuSet: A list of cpu cores to enable pmc collection
:param events: A user supplied list of pmc events to be programmed
"""
if not self.isDriverLoaded():
(eventSet,
request) = PMUCtrl.buildPerfEventsRequest(eventsDb, events)
if eventSet and request:
LOGGER.warn(
'xpedite device driver not loaded - falling back to perf events api'
)
LOGGER.debug('sending request (%d bytes) to xpedite [%s]',
len(request), request)
rc = self.admin('ActivatePerfEvents --data {}'.format(request))
if rc:
raise Exception(rc)
return eventSet
return self.proxy.enablePMU(eventsDb, cpuSet, events)
class ProxyEnvironment(object):
"""
Collects and caches environment details for a profiling target.
This class is used to collect and store environment details like
cpu info, os version, kernel boot parameters etc ..
"""
def __init__(self):
"""Constructs an instance of ProxyEnvironment"""
self.fullCpuInfo = None
self.cpuId = None
self.osUname = None
self.bootParam = None
self.pmuCtrl = None
self.keepAliveCount = 0
@staticmethod
def gatherFiles(pattern):
"""
Method to build a list of files matching the given pattern
:param pattern: Wild card pattern for files to be collected
"""
import glob
return list(glob.iglob(pattern))
def getFullCpuInfo(self):
"""Builds and caches cpu info"""
if not self.fullCpuInfo:
from xpedite.util import getCpuInfo
self.fullCpuInfo = getCpuInfo()
return self.fullCpuInfo
def getCpuId(self):
"""Discovers and caches cpu model"""
if not self.cpuId:
from xpedite.util import getCpuId
self.cpuId = getCpuId()
return self.cpuId
def getOsUname(self):
"""Discovers and caches os build version"""
if not self.osUname:
self.osUname = os.uname()
return self.osUname
def getBootParam(self):
"""Reads and caches kernel boot parameters"""
if not self.bootParam:
with open('/proc/cmdline', 'r') as fileHandle:
self.bootParam = fileHandle.read()
return self.bootParam
def enablePMU(self, eventsDb, cpuSet, events):
"""
Enables user space pmc collection for the given cpuSet
:param eventsDb: A database of programmable performance counters
:type eventsDb: xpedite.pmu.eventsDb.EventsDb
:param cpuSet: A list of cpu cores to enable pmc collection
:param events: A user supplied list of pmc events to be programmed
"""
if not cpuSet or len(cpuSet) <= 0:
raise Exception(
'Invalid argument - cpu set missing. need explicit cpu set to enable pmu'
)
self.pmuCtrl = PMUCtrl(eventsDb)
self.pmuCtrl.__enter__()
return self.pmuCtrl.enable(cpuSet, events)
def disablePMU(self):
"""Disables user space pmc collection and restores cpu core to original state"""
if self.pmuCtrl:
self.pmuCtrl.__exit__()
@staticmethod
def getVmStats(pid):
"""
Collects virtual memory usage statistics for a target process
:param pid: pid of the target process
"""
result = {}
try:
lines = None
with open('/proc/{}/status'.format(pid), 'r') as fileHandle:
lines = [line.rstrip('\n') for line in fileHandle]
except IOError:
return result
for line in lines:
if not line.startswith('Vm'):
continue
parts = line.split()
result[parts[0]] = parts[len(parts) - 2]
return result
def keepAlive(self):
"""Initiates a method call to keep the rpyc connection alive for long profiling sessions"""
self.keepAliveCount += 1
