Attachment 859272 Details for Bug 1057159 – cpuscaling patch fixing max frequency expectations to assume no boost

[patch] cpuscaling patch fixing max frequency expectations to assume no boost

0001-1057159-cpuscaling-fails-max-frequency-measured-is-l.patch (text/plain), 25.19 KB, created by Greg Nichols on 2014-02-04 18:05:47 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Greg Nichols

Created: 2014-02-04 18:05:47 UTC

Size: 25.19 KB

patch

obsolete

>From 4558f21a8e4dfe69492bef86108d8433fe75422b Mon Sep 17 00:00:00 2001
>From: Greg Nichols <gnichols@redhat.com>
>Date: Tue, 4 Feb 2014 13:04:20 -0500
>Subject: [PATCH] 1057159 - cpuscaling fails: max frequency measured is lower
> than indicated by cpupower.
>
>---
> tests/cpuscaling/cpupower.py   | 284 ++++++++++++++++++++++++++++-------------
> tests/cpuscaling/cpuscaling.py |  22 ++--
> tests/cpuscaling/syscpufreq.py |  12 +-
> 3 files changed, 210 insertions(+), 108 deletions(-)
>
>diff --git a/tests/cpuscaling/cpupower.py b/tests/cpuscaling/cpupower.py
>index 35d6129..3e59576 100644
>--- a/tests/cpuscaling/cpupower.py
>+++ b/tests/cpuscaling/cpupower.py
>@@ -16,7 +16,26 @@
> 
> """ CPUPower: a python interface to the cpupower command from kernel-tools 
> 
>-   Note: all frequency parameters in and out are integer KHz"""
>+   Note: all frequency parameters in and out are integer KHz
>+
>+    Definitions:
>+        Maximum Frequency: The maximum frequency supported (ignoring boost state or "turbo")
>+        Minimum Frequency: The minimum frequency supported unloaded
>+        Maximum Model Frequency: The frequency stated in for the cpu 
>+
>+        Minimum Boost Frequency: The minimum boost frequency for a partially or singly loaded core
>+        Maximum Boost Frequency: The maximum boost frequency for a partially or singly loaded core
>+
>+        SupportedGovernors: the list of supported governors
>+
>+        Current Policy: a governor combined with min/max frequency settings
>+
>+        Current Frequency: Current reported clock frequency
>+
>+        Driver: The cpufrequency driver reported by cpupower
>+
>+        Vendor: The processor vendor
>+"""
> 
> import re
> 
>@@ -26,15 +45,22 @@ from hwcert.command import Command, HwCertCommandException
> from hwcert.procDeviceDetector import ProcDeviceDetector
> 
> class CPUPower():
>-    def __init__(self):
>+    def __init__(self, debug=False):
>+        self.debug = debug
>         self.cpuNumbers = None
>         self.minimumFrequency = dict()
>         self.maximumFrequency = dict()
>-        self.maximumHardwareFrequency = dict()
>+        self.minimumBoostFrequency = dict()
>+        self.maximumBoostFrequency = dict()
>+        self.maximumModelFrequency = None
>         self.supportedGovernors = dict() 
>         self.procCPUinfoCPUs = None
>-        self.usingCPUInfoForMaxFreq = False
>         self.possibleGovernors = ["performance", "powersave", "userspace", "conservative", "ondemand"]
>+        self.vendor = None
>+        self.vendors = ["Intel", "AMD", "IBM"]
>+        self.model = None
>+        self.driver = None
>+        self.driverPattern = re.compile("driver:\s+(?P<driver>.+)")
> 
>         self.__getSupportInformation()
> 
>@@ -62,41 +88,83 @@ class CPUPower():
>             self.cpuNumbers = None
>             return
> 
>-        # determine if it's the intel_pstate driver, call the right parser
>-        self.driver = "intel_pstate" # assume it is
>-        cpupower = Command("cpupower -c 0 frequency-info")
>-        try:
>-            cpupower.getString("intel_pstate", singleLine=False)
>-            if not self.__parseCPUPowerIntel():
>-                return False
>-        except HwCertCommandException, e:
>-            # it wasn't
>-            self.driver = "unknown"
>-            if not self.__parseCPUPowerUnkown():
>-                return False
>-
>-        # check /proc/cpuinfo
>+        # determine cpu vendor
>         proc = ProcDeviceDetector()
>         self.procCPUinfoCPUs = proc.getDevices(ProcDeviceDetector.procCPUInfo)
>         if self.procCPUinfoCPUs:
>-            model = self.procCPUinfoCPUs[0].getProperty("model name")
>-            if model:
>-                maxFreq = None
>-                pattern = re.compile("(?P<max>[0-9\.]+)(?P<units>(MHz|GHz))")
>-                match = pattern.search(model)
>-                if match:
>-                    maxFreq = int(Decimal(match.group("max"))*1000000) # to KHz
>-                    if match.group("units") == "MHz":
>-                        maxFreq = int(maxFreq/1000)
>-                if maxFreq and not self.maximumFrequency:
>-                    self.usingCPUInfoForMaxFreq = True
>-                    for cpu in self.cpuNumbers:
>-                        self.maximumFrequency[cpu] = maxFreq
>+            self.model = self.procCPUinfoCPUs[0].getProperty("model name")
>+            if self.model:
>+                for vendor in self.vendors:
>+                    if vendor in self.model:
>+                        self.vendor = vendor
>+                if "Intel" in self.vendor:
>+                    if not self.__parseCPUPowerIntel():
>+                        return False
>+        # else AMD or unknown
>+        if not self.__parseCPUPowerUnkown():
>+            return False
>+
>+        # check /proc/cpuinfo model string for maxFreq
>+        if self.model:
>+            maxFreq = None
>+            pattern = re.compile("(?P<max>[0-9\.]+)(?P<units>(MHz|GHz))")
>+            match = pattern.search(self.model)
>+            if match:
>+                maxFreq = int(Decimal(match.group("max"))*1000000) # to KHz
>+                if match.group("units") == "MHz":
>+                    maxFreq = int(maxFreq/1000)
>+            if maxFreq:
>+                self.maximumModelFrequency = maxFreq
> 
>         return True
> 
> 
>     def __parseCPUPowerIntel(self):
>+        """
>+        Example: intel_pstate:
>+
>+          analyzing CPU 0:
>+          driver: intel_pstate
>+          CPUs which run at the same hardware frequency: 0
>+          CPUs which need to have their frequency coordinated by software: 0
>+          maximum transition latency: 0.97 ms.
>+          hardware limits: 1.20 GHz - 3.60 GHz
>+          available cpufreq governors: performance, powersave
>+          current policy: frequency should be within 1.20 GHz and 3.60 GHz.
>+                          The governor "powersave" may decide which speed to use
>+                          within this range.
>+          current CPU frequency is 1.71 GHz (asserted by call to hardware).
>+          boost state support:
>+            Supported: yes
>+            Active: yes
>+            3400 MHz max turbo 4 active cores
>+            3400 MHz max turbo 3 active cores
>+            3400 MHz max turbo 2 active cores
>+            3600 MHz max turbo 1 active cores
>+
>+        Example: acpi_cpufreq (Intel)
>+
>+           analyzing CPU 0:
>+              driver: acpi-cpufreq
>+              CPUs which run at the same hardware frequency: 0
>+              CPUs which need to have their frequency coordinated by software: 0
>+              maximum transition latency: 10.0 us.
>+              hardware limits: 1.20 GHz - 2.60 GHz
>+              available frequency steps: 2.60 GHz, 2.60 GHz, 2.50 GHz, 2.40 GHz, 2.30 GHz, 2.20 GHz, 2.10 GHz, 2.00 GHz, 1.90 GHz, 1.80 GHz, 1.70 GHz, 1.60 GHz, 1.50 GHz, 1.40 GHz, 1.30 GHz, 1.20 GHz
>+              available cpufreq governors: conservative, userspace, powersave, ondemand, performance
>+              current policy: frequency should be within 1.20 GHz and 2.60 GHz.
>+                              The governor "ondemand" may decide which speed to use
>+                              within this range.
>+              current CPU frequency is 1.20 GHz (asserted by call to hardware).
>+              boost state support:
>+                Supported: yes
>+                Active: yes
>+                3400 MHz max turbo 4 active cores
>+                3400 MHz max turbo 3 active cores
>+                3500 MHz max turbo 2 active cores
>+                3600 MHz max turbo 1 active cores
>+        """
>+
>         # Get the min/max supported frequencies, governors
>         frequencyPattern = re.compile("hardware limits: (?P<min>[0-9\.]+) (?P<minunits>(MHz|GHz)) - (?P<max>[0-9\.]+) (?P<maxunits>(MHz|GHz))")
>         coreFrequencyPattern = re.compile("(?P<max>[0-9\.]+) (?P<activeunits>(MHz|GHz)) max (?P<boost>[a-zA-Z]+) (?P<active>[0-9\.]+) active cores")
>@@ -117,20 +185,23 @@ class CPUPower():
>                         if match.group("minunits") == "MHz":
>                             freq = freq/1000
>                         self.minimumFrequency[cpu] = freq
>-                        # grab the max hardware supported line - but we'll probably use max active cores instead
>                         freq = int(Decimal(match.group("max"))*1000000) # to KHz
>                         if match.group("maxunits") == "MHz":
>                             freq = freq/1000
>-                        self.maximumHardwareFrequency[cpu] = freq
>+                        self.maximumFrequency[cpu] = freq
>                         continue
>                     match = coreFrequencyPattern.search(line)
>                     if match:
>-                        if maxActiveCores < int(match.group("active")):
>-                            maxActiveCores = int(match.group("active"))
>-                            freq = int(Decimal(match.group("active"))*1000000) # to KHz
>-                            if match.group("activeunits") == "MHz":
>-                                freq = freq/1000
>-                            self.maximumFrequency[cpu] = int(match.group("max"))*1000 # KHz
>+                        freq = int(Decimal(match.group("max"))*1000000) # to KHz
>+                        if match.group("activeunits") == "MHz":
>+                            freq = freq/1000
>+                        cores = int(match.group("active"))
>+                        if not maxActiveCores:
>+                            self.minimumBoostFrequency[cpu] = freq
>+                            maxActiveCores = cores
>+                        elif cores < maxActiveCores:
>+                            self.maximumBoostFrequency[cpu] = freq
>+                            maxActiveCores = cores
>                         continue
>                     if governorPattern.search(line):
>                         for governor in self.possibleGovernors:
>@@ -138,6 +209,10 @@ class CPUPower():
>                                 if not cpu in self.supportedGovernors:
>                                     self.supportedGovernors[cpu] = list()
>                                 self.supportedGovernors[cpu].append(governor)
>+                    match = self.driverPattern.search(line)
>+                    if match:
>+                        self.driver = match.group("driver")
>+
>             except Exception, e:
>                 print "Error: could not determine intel cpu support"
>                 print e
>@@ -192,7 +267,8 @@ class CPUPower():
>             Pstate-P2:  2800MHz
>             Pstate-P3:  2100MHz
>             Pstate-P4:  1400MHz
>-        
>+
>+           
>         """
>         # Get the min/max supported frequencies, governors
>         frequencyPattern = re.compile("(?P<state>Pstate-P[b0-9]+):\s+(?P<freq>[0-9\.]+)(?P<units>(MHz|GHz))")
>@@ -217,23 +293,29 @@ class CPUPower():
>                             boostFrequencies.append(freq)
>                         else:
>                             frequencies.append(freq)
>-                    else:
>-                        match = governorPattern.search(line)
>-                        if match:
>-                            for governor in self.possibleGovernors:
>-                                if governor in line:
>-                                    if not cpu in self.supportedGovernors:
>-                                        self.supportedGovernors[cpu] = list()
>-                                    self.supportedGovernors[cpu].append(governor)
>+                        continue
>+                    match = governorPattern.search(line)
>+                    if match:
>+                        for governor in self.possibleGovernors:
>+                            if governor in line:
>+                                if not cpu in self.supportedGovernors:
>+                                    self.supportedGovernors[cpu] = list()
>+                                self.supportedGovernors[cpu].append(governor)
>+                        continue
>+
>+                    match = self.driverPattern.search(line)
>+                    if match:
>+                        self.driver = match.group("driver")
>+
>+                # got all the lines parsed - now sort the freqs
>                 if frequencies:
>                     frequencies.sort()
>                     self.minimumFrequency[cpu] = frequencies[0]
>                     self.maximumFrequency[cpu] = frequencies[-1]
>                 if boostFrequencies:
>                     boostFrequencies.sort()
>-                    self.maximumHardwareFrequency[cpu] = boostFrequencies[-1]
>-                else:
>-                    self.maximumHardwareFrequency[cpu] = self.maximumFrequency[cpu]
>+                    self.maximumBoostFrequency[cpu] = boostFrequencies[-1]
>+                    self.minimumBoostFrequency[cpu] = boostFrequencies[0]
> 
>                 # no supported governors???  guessing performance and powersave
>                 if cpu not in self.supportedGovernors:
>@@ -254,17 +336,20 @@ class CPUPower():
> 
>     def printInformation(self):
>         if self.procCPUinfoCPUs:
>-            print "\nProcessor Model: %s" % self.procCPUinfoCPUs[0].getProperty("model name")
>-            if self.usingCPUInfoForMaxFreq:
>-                print "   (using this frequency for maximum supported)"
>-            print ""
>+            print "\nProcessor Model: %s" % self.model
>+        if self.driver:
>+            print "cpufreq driver: %s" % self.driver
>+        else:
>+            print "cpufreq driver: unknown"
>         self.dumpOutput()
>         for cpu in self.cpuNumbers:
>             print "\nCPU: %s\n----------" % cpu
>-            print "     min:    %s MHz" % int(self.minimumFrequency[cpu]/1000)
>-            if self.maximumFrequency:
>-                print "     max:    %s MHz" % int(self.maximumFrequency[cpu]/1000)
>-            print "     max hw: %s MHz" % int(self.maximumHardwareFrequency[cpu]/1000)
>+            print "           min: %s MHz" % int(self.minimumFrequency[cpu]/1000)
>+            print "           max: %s MHz" % int(self.maximumFrequency[cpu]/1000)
>+            if self.minimumBoostFrequency:
>+                print "     min boost: %s MHz" % int(self.minimumBoostFrequency[cpu]/1000)
>+            if self.maximumBoostFrequency:
>+                print "     max boost: %s MHz" % int(self.maximumBoostFrequency[cpu]/1000)
>             print "     governors: " + ", ".join(self.supportedGovernors[cpu])
> 
>     def isSupported(self):
>@@ -273,6 +358,8 @@ class CPUPower():
>             for cpu in self.cpuNumbers:
>                 if cpu in self.supportedGovernors and self.supportedGovernors[cpu]:
>                     return True
>+        if self.debug:
>+            print "cpuscaling is NOT supported"
>         return False
> 
>     def isValid(self):
>@@ -282,7 +369,8 @@ class CPUPower():
>         # otherwise
>         min = None
>         max = None
>-        maxHW = None
>+        maxBoost = None
>+        minBoost = None
>         governors = list()
>         try:
>             for cpu in self.cpuNumbers:
>@@ -295,25 +383,26 @@ class CPUPower():
>                     print "Error: minimum frequency mismatch"
>                     return False
> 
>-                if cpu not in self.maximumHardwareFrequency:
>-                    print "Error: no hardware max frequency for cpu %s" % cpu
>+                if not maxBoost:
>+                    maxBoost = self.maximumBoostFrequency[cpu]
>+                elif maxBoost != self.maximumBoostFrequency[cpu]:
>+                    print "Error: maximum boost frequency mismatch"
>                     return False
>-                if not maxHW:
>-                    maxHW = self.maximumHardwareFrequency[cpu]
>-                elif maxHW != self.maximumHardwareFrequency[cpu]:
>-                    print "Error: maximum hardware frequency mismatch"
>+
>+                if not minBoost:
>+                    minBoost = self.minimumBoostFrequency[cpu]
>+                elif minBoost != self.minimumBoostFrequency[cpu]:
>+                    print "Error: minimum boost frequency mismatch"
>                     return False
> 
>-                # some systems do not have separate max frequencies for active cores
>-                if self.maximumFrequency:
>-                    if cpu not in self.maximumFrequency:
>-                        print "Error: no max frequency for cpu %s" % cpu
>-                        return False
>-                    if not max:
>-                        max = self.maximumFrequency[cpu]
>-                    elif max != self.maximumFrequency[cpu]:
>-                        print "Error: maximum (active cores) frequency mismatch"
>-                        return False
>+                if cpu not in self.maximumFrequency:
>+                    print "Error: no max frequency for cpu %s" % cpu
>+                    return False
>+                if not max:
>+                    max = self.maximumFrequency[cpu]
>+                elif max != self.maximumFrequency[cpu]:
>+                    print "Error: maximum (active cores) frequency mismatch"
>+                    return False
>                 if not governors:
>                     governors = self.supportedGovernors[cpu]
>                 else:
>@@ -340,14 +429,15 @@ class CPUPower():
> 
>     def getMaximumFrequency(self):
>         """ get the maximum supported frequency, all cores active in int(MHz)  """
>-        if self.maximumFrequency:
>-            return self.maximumFrequency[self.cpuNumbers[0]]
>-        # else, no active cores maximum, just return max hardware freq/
>-        return self.getMaximumHardwareFrequency()
>+        return self.maximumFrequency[self.cpuNumbers[0]]
>+
>+    def getMaximumBoostFrequency(self):
>+        """ get the maximum supported frequency, in int(MHz)  """
>+        return self.maximumBoostFrequency[self.cpuNumbers[0]]
> 
>-    def getMaximumHardwareFrequency(self):
>-        """ get the maximum supported frequency, single core, in int(MHz)  """
>-        return self.maximumHardwareFrequency[self.cpuNumbers[0]]
>+    def getMinimumBoostFrequency(self):
>+        """ get the minimum supported frequency, in int(MHz)  """
>+        return self.minimumBoostFrequency[self.cpuNumbers[0]]
> 
>     def getCurrentFrequency(self, cpu):
>         """ get the current frequency """
>@@ -399,8 +489,11 @@ class CPUPower():
> 
>     def getCurrentGovernor(self, cpu):
>         """ get the current governor """
>-        (min, max, governor) = self.getCurrentPolicy(cpu)
>-        return governor
>+        policy = self.getCurrentPolicy(cpu)
>+        if policy:
>+            (min, max, governor) = policy
>+            return governor
>+        return None
> 
>     def setGovernor(self, governor):
>         """ set the governor """
>@@ -433,16 +526,25 @@ if __name__ == "__main__":
>     if cpuPower.isValid():
>         print "IS valid"
>     print "Current Frequency: %s" % cpuPower.getCurrentFrequency(0)
>-    (min, max, gov) = cpuPower.getCurrentPolicy(0)
>-    print "policy: %s %s %s" % (min, max, gov)
>+    if cpuPower.getCurrentPolicy(0):
>+        (min, max, gov) = cpuPower.getCurrentPolicy(0)
>+        print "policy: %s %s %s" % (min, max, gov)
>     print "Current Governor; %s" % cpuPower.getCurrentGovernor(0)
>     if cpuPower.setGovernor("powersave"):
>         print "governor set to powersave"
>     if cpuPower.setPolicy(2000000, 2500000, "powersave"):
>         print "set policy"
>-    (min, max, gov) = cpuPower.getCurrentPolicy(0)
>-    print "policy: %s %s %s" % (min, max, gov)
>+    policy = cpuPower.getCurrentPolicy(0)
>+    if policy:
>+        (min, max, gov) = policy
>+        print "policy: %s %s %s" % (min, max, gov)
>+    else:
>+        print "could not get policy"
>     if cpuPower.setPolicy(1200000, 3600000, "powersave"):
>         print "set policy"
>-    (min, max, gov) = cpuPower.getCurrentPolicy(0)
>-    print "policy: %s %s %s" % (min, max, gov)
>\ No newline at end of file
>+    policy = cpuPower.getCurrentPolicy(0)
>+    if policy:
>+        (min, max, gov) = policy
>+        print "policy: %s %s %s" % (min, max, gov)
>+    else:
>+        print "could not get policy"
>diff --git a/tests/cpuscaling/cpuscaling.py b/tests/cpuscaling/cpuscaling.py
>index f2a0a23..f1798e4 100644
>--- a/tests/cpuscaling/cpuscaling.py
>+++ b/tests/cpuscaling/cpuscaling.py
>@@ -66,7 +66,7 @@ class CPUScalingTest(Test):
>         self.selfTestStep = 0
>         self.deviceClass = DeviceClass.processor
>         self.workloads = ["minimum", "maximum", "powersave", "performance"]
>-        self.workloadNames = {"minimum": "User Space (min)", "maximum": "User Space (max)", "ondemand": "On Demand", "performance": "Performance"}
>+        self.workloadNames = {"minimum": "User Space (min)", "maximum": "User Space (max)", "ondemand": "On Demand", "performance": "Performance", "powersave": "Power Save"}
>         self.workloadTime = dict() # workload run time list indexed by [workload][cpu]
>         self.workloadFreq = dict() # measured cpu freq indexed by [workload][cpu]
>         self.workloadEffectiveFreq = dict() # measured effective cpu freq indexed by [workload][cpu]
>@@ -311,11 +311,6 @@ class CPUScalingTest(Test):
>         return totalProcessTime/numberOfProcesses
> 
>     def __getCurrentFrequency(self, cpu):
>-        if self.sysCPUFreq.isValid():
>-            frequency = self.sysCPUFreq.getCurrentFrequency(cpu)
>-            if frequency:
>-                return frequency
>-        # otherwise
>         return self.cpuPower.getCurrentFrequency(cpu)
> 
>     def done(self, cpu):
>@@ -344,7 +339,7 @@ class CPUScalingTest(Test):
>             print "Error: could not control cpuscaling via cpupower (from kernel-tools)"
>             return False
>         if not self.sysCPUFreq.isValid():
>-            print "Error: could not determine cpuscaling capabilities via the % file system" % selfsysCPUFreq.sysCPUDirectory
>+            print "Error: could not determine cpuscaling capabilities via the % file system" % self.sysCPUFreq.sysCPUDirectory
>             return False
> 
>         print ""
>@@ -358,7 +353,6 @@ class CPUScalingTest(Test):
>         # 1.5 get core/package topology
>         self.sysCPUFreq.showCapabilities()
> 
>-
>         # 2. ensure that all cpu's scale the same amount; if not bail
>         # 3. verify all cpu's support the same control methods
>         if self.cpuPower.isValid():
>@@ -530,21 +524,21 @@ class CPUScalingTest(Test):
>             success = False
> 
>         # 11. Set the cpu speed to it's highest value as above.
>-        frequency = self.cpuPower.getMaximumFrequency()
>+        maximumFrequency = self.cpuPower.getMaximumFrequency()
>         currentFrequency = self.cpuPower.getCurrentFrequency(self.sysCPUFreq.getCPUs(self.currentPackage)[0])
>         if governor == "userspace":
>-            print "Changing cpu frequency from %u to %u MHz" % (int(currentFrequency/1000), int(frequency/1000))
>-            if not self.cpuPower.setFrequency(frequency):
>+            print "Changing cpu frequency from %u to %u MHz" % (int(currentFrequency/1000), int(maximumFrequency/1000))
>+            if not self.cpuPower.setFrequency(maximumFrequency):
>                 success = False
>         else: # powersave - set min and max to hardware max.
>-            print "Changing cpu frequency from %u to %u MHz (hardware maximum)" % (int(currentFrequency/1000), int(self.cpuPower.getMaximumHardwareFrequency()/1000))
>-            if not self.cpuPower.setPolicy(frequency, self.cpuPower.getMaximumHardwareFrequency(), "powersave"):
>+            print "Changing cpu frequency from %u to %u MHz, performance governor" % (int(currentFrequency/1000), int(maximumFrequency/1000))
>+            if not self.cpuPower.setPolicy(maximumFrequency, maximumFrequency, "performance"):
>                 success = False
>         self.currentWorkload = "maximum"
> 
>         currentFrequency = self.cpuPower.getCurrentFrequency(self.sysCPUFreq.getCPUs(self.currentPackage)[0])
>         if not maximumFrequency or not currentFrequency or not self.checkFrequency(maximumFrequency, currentFrequency):
>-            print "Warning: Could not verify that cpu frequency is set to the maximum value of %s MHz" % int(maximumFrequency/1000)
>+            print "Warning: Could not verify that cpu frequency %s MHzis set to the maximum value of %s MHz" % (int(currentFrequency/1000), int(maximumFrequency/1000))
> 
>         # 12. Repeat workload test, record timing
>         self.maximumFrequencyTestTime = self.runLoadTest()
>diff --git a/tests/cpuscaling/syscpufreq.py b/tests/cpuscaling/syscpufreq.py
>index 29985a3..0476e19 100644
>--- a/tests/cpuscaling/syscpufreq.py
>+++ b/tests/cpuscaling/syscpufreq.py
>@@ -27,7 +27,9 @@ class SysCPUFreq():
>         self.packageToCpus = None
>         self.frequencies = None
>         self.governors = None
>+        self.currentGovernors = None
>         self.debug = False
>+        self.cpufreqDirectories = None
>         self.__getSystemCapabilities()
> 
> 
>@@ -233,7 +235,7 @@ class SysCPUFreq():
>         else:
>             print "No supported frequency information"
> 
>-        if self.isValid():
>+        if self.isValid() and self.cpufreqDirectories:
>             print "\nCurrent Frequencies:"
>             for cpu in self.getCPUs():
>                 print "    cpu%s: %s" % (cpu, self.getCurrentFrequency(cpu))
>@@ -254,12 +256,16 @@ class SysCPUFreq():
> 
>     def getCPUs(self, package=None):
>         if package is not None:
>-            return self.packageToCpus[package]
>+            if self.packageToCpus:
>+                return self.packageToCpus[package]
>         # otherwise
>         return self.cpuNumbers
> 
>     def getPackages(self):
>-        return self.packageToCpus.keys()
>+        if self.packageToCpus:
>+            return self.packageToCpus.keys()
>+        # otherwise, a list of a single package
>+        return [0]
> 
>     def setFrequency(self, frequency):
>         if self.__setPackageParameter("f", "scaling_setspeed", "scaling_cur_freq", frequency, verify=False):
>-- 
>1.8.4.2
>

Actions: View | Diff

Attachments on bug 1057159: 859272 | 861506