Example #1
0
    def _getCpuCoresStats(self):
        """
        :returns: a dict that with the following formats:

            {'<cpuId>': {'numaNodeIndex': int, 'cpuSys': 'str',
             'cpuIdle': 'str', 'cpuUser': '******'}, ...}
        """
        cpuCoreStats = {}
        for nodeIndex, numaNode in caps.getNumaTopology().iteritems():
            cpuCores = numaNode['cpus']
            for cpuCore in cpuCores:
                coreStat = {}
                coreStat['nodeIndex'] = int(nodeIndex)
                hs0, hs1, _ = self._samples.stats()
                interval = hs1.timestamp - hs0.timestamp
                jiffies = (hs1.cpuCores.getCoreSample(cpuCore)['user'] -
                           hs0.cpuCores.getCoreSample(cpuCore)['user']) % \
                    JIFFIES_BOUND
                coreStat['cpuUser'] = ("%.2f" % (jiffies / interval))
                jiffies = (hs1.cpuCores.getCoreSample(cpuCore)['sys'] -
                           hs0.cpuCores.getCoreSample(cpuCore)['sys']) % \
                    JIFFIES_BOUND
                coreStat['cpuSys'] = ("%.2f" % (jiffies / interval))
                coreStat['cpuIdle'] = ("%.2f" % max(
                    0.0, 100.0 - float(coreStat['cpuUser']) -
                    float(coreStat['cpuSys'])))
                cpuCoreStats[str(cpuCore)] = coreStat
        return cpuCoreStats
Example #2
0
    def _getCpuCoresStats(self):
        """
        :returns: a dict that with the following formats:

            {'<cpuId>': {'numaNodeIndex': int, 'cpuSys': 'str',
             'cpuIdle': 'str', 'cpuUser': '******'}, ...}
        """
        cpuCoreStats = {}
        for nodeIndex, numaNode in caps.getNumaTopology().iteritems():
            cpuCores = numaNode['cpus']
            for cpuCore in cpuCores:
                coreStat = {}
                coreStat['nodeIndex'] = int(nodeIndex)
                hs0, hs1 = self._samples[0], self._samples[-1]
                interval = hs1.timestamp - hs0.timestamp
                jiffies = (hs1.cpuCores.getCoreSample(cpuCore)['user'] -
                           hs0.cpuCores.getCoreSample(cpuCore)['user']) % \
                    (2 ** 32)
                coreStat['cpuUser'] = ("%.2f" % (jiffies / interval))
                jiffies = (hs1.cpuCores.getCoreSample(cpuCore)['sys'] -
                           hs0.cpuCores.getCoreSample(cpuCore)['sys']) % \
                    (2 ** 32)
                coreStat['cpuSys'] = ("%.2f" % (jiffies / interval))
                coreStat['cpuIdle'] = ("%.2f" %
                                       max(0.0, 100.0 -
                                           float(coreStat['cpuUser']) -
                                           float(coreStat['cpuSys'])))
                cpuCoreStats[str(cpuCore)] = coreStat
        return cpuCoreStats
Example #3
0
def _get_cpu_core_stats(first_sample, last_sample):
    interval = last_sample.timestamp - first_sample.timestamp

    def compute_cpu_usage(cpu_core, mode):
        jiffies = (
            last_sample.cpuCores.getCoreSample(cpu_core)[mode] -
            first_sample.cpuCores.getCoreSample(cpu_core)[mode]
        ) % JIFFIES_BOUND
        return ("%.2f" % (jiffies / interval))

    cpu_core_stats = {}
    for node_index, numa_node in six.iteritems(caps.getNumaTopology()):
        cpu_cores = numa_node['cpus']
        for cpu_core in cpu_cores:
            core_stat = {
                'nodeIndex': int(node_index),
                'cpuUser': compute_cpu_usage(cpu_core, 'user'),
                'cpuSys': compute_cpu_usage(cpu_core, 'sys'),
            }
            core_stat['cpuIdle'] = (
                "%.2f" % max(0.0,
                             100.0 -
                             float(core_stat['cpuUser']) -
                             float(core_stat['cpuSys'])))
            cpu_core_stats[str(cpu_core)] = core_stat
    return cpu_core_stats
Example #4
0
def _get_cpu_core_stats(first_sample, last_sample):
    interval = last_sample.timestamp - first_sample.timestamp

    def compute_cpu_usage(cpu_core, mode):
        first_core_sample = first_sample.cpuCores.getCoreSample(cpu_core)
        last_core_sample = last_sample.cpuCores.getCoreSample(cpu_core)
        if not first_core_sample or not last_core_sample:
            raise MissingSample()
        jiffies = (
            last_core_sample[mode] - first_core_sample[mode]
        ) % JIFFIES_BOUND
        return ("%.2f" % (jiffies / interval))

    cpu_core_stats = {}
    for node_index, numa_node in six.iteritems(caps.getNumaTopology()):
        cpu_cores = numa_node['cpus']
        for cpu_core in cpu_cores:
            try:
                user_cpu_usage = compute_cpu_usage(cpu_core, 'user')
                system_cpu_usage = compute_cpu_usage(cpu_core, 'sys')
            except MissingSample:
                # Only collect data when all required samples already present
                continue
            core_stat = {
                'nodeIndex': int(node_index),
                'cpuUser': user_cpu_usage,
                'cpuSys': system_cpu_usage,
            }
            core_stat['cpuIdle'] = (
                "%.2f" % max(0.0,
                             100.0 -
                             float(core_stat['cpuUser']) -
                             float(core_stat['cpuSys'])))
            cpu_core_stats[str(cpu_core)] = core_stat
    return cpu_core_stats
Example #5
0
 def testNumaTopology(self):
     # 2 x AMD 6272 (with Modules)
     t = caps.getNumaTopology()
     expectedNumaInfo = {
         '0': {'cpus': [0, 1, 2, 3, 4, 5, 6, 7], 'totalMemory': '49141'},
         '1': {'cpus': [8, 9, 10, 11, 12, 13, 14, 15],
               'totalMemory': '49141'},
         '2': {'cpus': [16, 17, 18, 19, 20, 21, 22, 23],
               'totalMemory': '49141'},
         '3': {'cpus': [24, 25, 26, 27, 28, 29, 30, 31],
               'totalMemory': '49141'}}
     self.assertEqual(t, expectedNumaInfo)
Example #6
0
 def __init__(self):
     self.nodesMemSample = {}
     numaTopology = caps.getNumaTopology()
     for nodeIndex in numaTopology:
         nodeMemSample = {}
         if len(numaTopology) < 2:
             memInfo = caps.getUMAHostMemoryStats()
         else:
             memInfo = caps.getMemoryStatsByNumaCell(int(nodeIndex))
         nodeMemSample['memFree'] = memInfo['free']
         nodeMemSample['memPercent'] = 100 - \
             int(100.0 * int(memInfo['free']) / int(memInfo['total']))
         self.nodesMemSample[nodeIndex] = nodeMemSample
Example #7
0
 def __init__(self):
     self.nodesMemSample = {}
     numaTopology = caps.getNumaTopology()
     for nodeIndex in numaTopology:
         nodeMemSample = {}
         memInfo = caps.getMemoryStatsByNumaCell(int(nodeIndex))
         nodeMemSample['memFree'] = memInfo['free']
         # in case the numa node has zero memory assigned, report the whole
         # memory as used
         nodeMemSample['memPercent'] = 100
         if int(memInfo['total']) != 0:
             nodeMemSample['memPercent'] = 100 - \
                 int(100.0 * int(memInfo['free']) / int(memInfo['total']))
         self.nodesMemSample[nodeIndex] = nodeMemSample
Example #8
0
 def __init__(self):
     self.nodesMemSample = {}
     numaTopology = caps.getNumaTopology()
     for nodeIndex in numaTopology:
         nodeMemSample = {}
         if len(numaTopology) < 2:
             memInfo = caps.getUMAHostMemoryStats()
         else:
             memInfo = caps.getMemoryStatsByNumaCell(int(nodeIndex))
         nodeMemSample["memFree"] = memInfo["free"]
         # in case the numa node has zero memory assigned, report the whole
         # memory as used
         nodeMemSample["memPercent"] = 100
         if int(memInfo["total"]) != 0:
             nodeMemSample["memPercent"] = 100 - int(100.0 * int(memInfo["free"]) / int(memInfo["total"]))
         self.nodesMemSample[nodeIndex] = nodeMemSample
Example #9
0
 def __init__(self):
     self.nodesMemSample = {}
     numaTopology = caps.getNumaTopology()
     for nodeIndex in numaTopology:
         nodeMemSample = {}
         if len(numaTopology) < 2:
             memInfo = caps.getUMAHostMemoryStats()
         else:
             memInfo = caps.getMemoryStatsByNumaCell(int(nodeIndex))
         nodeMemSample['memFree'] = memInfo['free']
         # in case the numa node has zero memory assigned, report the whole
         # memory as used
         nodeMemSample['memPercent'] = 100
         if int(memInfo['total']) != 0:
             nodeMemSample['memPercent'] = 100 - \
                 int(100.0 * int(memInfo['free']) / int(memInfo['total']))
         self.nodesMemSample[nodeIndex] = nodeMemSample
Example #10
0
 def testNumaTopology(self):
     # 2 x AMD 6272 (with Modules)
     t = caps.getNumaTopology()
     expectedNumaInfo = {
         '0': {
             'cpus': [0, 1, 2, 3, 4, 5, 6, 7],
             'totalMemory': '49141'
         },
         '1': {
             'cpus': [8, 9, 10, 11, 12, 13, 14, 15],
             'totalMemory': '49141'
         },
         '2': {
             'cpus': [16, 17, 18, 19, 20, 21, 22, 23],
             'totalMemory': '49141'
         },
         '3': {
             'cpus': [24, 25, 26, 27, 28, 29, 30, 31],
             'totalMemory': '49141'
         }
     }
     self.assertEqual(t, expectedNumaInfo)
Example #11
0
def _get_cpu_core_stats(first_sample, last_sample):
    interval = last_sample.timestamp - first_sample.timestamp

    def compute_cpu_usage(cpu_core, mode):
        jiffies = (last_sample.cpuCores.getCoreSample(cpu_core)[mode] -
                   first_sample.cpuCores.getCoreSample(cpu_core)[mode]
                   ) % JIFFIES_BOUND
        return ("%.2f" % (jiffies / interval))

    cpu_core_stats = {}
    for node_index, numa_node in six.iteritems(caps.getNumaTopology()):
        cpu_cores = numa_node['cpus']
        for cpu_core in cpu_cores:
            core_stat = {
                'nodeIndex': int(node_index),
                'cpuUser': compute_cpu_usage(cpu_core, 'user'),
                'cpuSys': compute_cpu_usage(cpu_core, 'sys'),
            }
            core_stat['cpuIdle'] = ("%.2f" % max(
                0.0, 100.0 - float(core_stat['cpuUser']) -
                float(core_stat['cpuSys'])))
            cpu_core_stats[str(cpu_core)] = core_stat
    return cpu_core_stats
Example #12
0
def _get_mapping_pcpu_to_pnode():
    pcpu_to_pnode = {}
    for node_index, numa_node in caps.getNumaTopology().iteritems():
        for pcpu_id in numa_node['cpus']:
            pcpu_to_pnode[pcpu_id] = int(node_index)
    return pcpu_to_pnode
Example #13
0
 def test_getNumaTopology(self):
     capsData = self._readCaps("caps_libvirt_intel_i73770_nosnap.out")
     result = caps.getNumaTopology(capsData)
     # only check cpus, memory does not come from file
     expected = [0, 1, 2, 3, 4, 5, 6, 7]
     self.assertEqual(expected, result['0']['cpus'])
Example #14
0
def _getHostNumaNodesCpuMap():
    pNodesCpusMap = {}
    for nodeIndex, numaNode in caps.getNumaTopology().iteritems():
        for cpuId in numaNode['cpus']:
            pNodesCpusMap[cpuId] = int(nodeIndex)
    return pNodesCpusMap
Example #15
0
def _getHostNumaNodesCpuMap():
    pNodesCpusMap = {}
    for nodeIndex, numaNode in caps.getNumaTopology().iteritems():
        for cpuId in numaNode['cpus']:
            pNodesCpusMap[cpuId] = int(nodeIndex)
    return pNodesCpusMap
Example #16
0
 def test_getNumaTopology(self):
     capsData = self._readCaps("caps_libvirt_intel_i73770_nosnap.out")
     result = caps.getNumaTopology(capsData)
     # only check cpus, memory does not come from file
     expected = [0, 1, 2, 3, 4, 5, 6, 7]
     self.assertEqual(expected, result['0']['cpus'])