Merge lp:~cr3/checkbox/cpu_scaling_test into lp:checkbox

[Marc Tardif]

ubuntu@201002-5346:~$ sudo ./cpu_scaling_test

System Capabilites:
-------------------------------------------------
System has 4 cpus

Supported CPU Frequencies:
    2400 MHz
    2399 MHz
    2266 MHz
    2133 MHz
    1999 MHz
    1866 MHz
    1733 MHz
    1599 MHz
    1466 MHz
    1333 MHz
    1199 MHz

Supported Governors:
    conservative
    ondemand
    userspace
    powersave
    performance

Current governors:
    cpu0: userspace
    cpu1: userspace
    cpu2: userspace
    cpu3: userspace

Userspace Governor Test:
-------------------------------------------------
Setting governor to userspace
Setting CPU frequency to 1199 MHz
Running CPU load test...
pid 7018's current affinity list: 0-3
pid 7018's new affinity list: 0
Minimum frequency load test time: 6.47
Setting CPU frequency to 2400 MHz
Running CPU load test...
pid 7018's current affinity list: 0
pid 7018's new affinity list: 0
Maximum frequency load test time: 2.72
Note: found ida flag, increasing expected speedup by 8.0%

CPU Frequency Speed Up: 2.18
Measured Speed Up: 2.38
Percentage Difference 9.3%

On Demand Governor Test:
-------------------------------------------------
Setting governor to ondemand
Waiting 5 seconds... done.
Running CPU load test...
pid 7018's current affinity list: 0
pid 7018's new affinity list: 0
On Demand load test time: 2.73
Percentage Difference vs. maximum frequency: 0.4%
Waiting 5 seconds... done.

Performance Governor Test:
-------------------------------------------------
Setting governor to performance
Running CPU load test...
pid 7018's current affinity list: 0
pid 7018's new affinity list: 0
Performance load test time: 2.66
Percentage Difference vs. maximum frequency: 2.2%

Conservative Governor Test:
-------------------------------------------------
Setting governor to conservative
Waiting 10 seconds... done.
Running CPU load test...
pid 7018's current affinity list: 0
pid 7018's new affinity list: 0
Conservative load test time: 6.57
Percentage Difference vs. minimum frequency: 1.5%
Restoring original governor to userspace
ubuntu@201002-5346:~$ echo $?
0

... that is all

[lp:~cr3/checkbox/cpu_scaling_test]

1412. By Marc Tardif on 2012-06-14

Migrated from OptionParser to argparse.

[Brendan Donegan (brendan-donegan)]

Remarkably straightforward!

review: Approve

=== modified file 'debian/changelog'
--- debian/changelog	2012-06-13 20:09:23 +0000
+++ debian/changelog	2012-06-14 19:48:19 +0000
@@ -18,10 +18,15 @@
     a test for the Super key.
   * [FEATURE] Added new interactive and auto-verifying touchpad scrolling
     test.
+<<<<<<< TREE
   * [FEATURE] Python 2 to 3 conversion:
     * scripts/cking_suite
     * scripts/ansi_parser
     * scripts/network_bandwidth_test
+=======
+  * [FEATURE] Python 2 to 3 conversion:
+    * scripts/cpu_scaling_test
+>>>>>>> MERGE-SOURCE
   * Removed sleep_test script no longer used by any test definition.
 
   [Daniel Manrique]

=== modified file 'scripts/cpu_scaling_test'
--- scripts/cpu_scaling_test	2012-05-22 18:01:21 +0000
+++ scripts/cpu_scaling_test	2012-06-14 19:48:19 +0000
@@ -1,13 +1,12 @@
-#!/usr/bin/python
+#!/usr/bin/env python3
 
 import decimal
 import os
 import re
-import string
 import sys
 import time
+import argparse
 
-from optparse import OptionParser
 from subprocess import check_call, CalledProcessError
 
 
@@ -27,7 +26,7 @@
 
     def getCPUFreqDirectories(self):
         if not os.path.exists(self.sysCPUDirectory):
-            print "Error: no file %s" % self.sysCPUDirectory
+            print("Error: no file %s" % self.sysCPUDirectory)
             return None
         # look for cpu subdirectories
         pattern = re.compile("cpu(?P<cpuNumber>[0-9]+)")
@@ -38,8 +37,8 @@
                 cpufreqDirectory = os.path.join(self.sysCPUDirectory,
                     subdirectory, "cpufreq")
                 if not os.path.exists(cpufreqDirectory):
-                    print "Error: cpu %s has no cpufreq directory %s" \
-                        % (match.group("cpuNumber"), cpufreqDirectory)
+                    print("Error: cpu %s has no cpufreq directory %s" \
+                        % (match.group("cpuNumber"), cpufreqDirectory))
                     return None
                 # otherwise
                 self.cpufreqDirectories.append(cpufreqDirectory)
@@ -53,8 +52,8 @@
         for cpufreqDirectory in self.cpufreqDirectories:
             parameters = self.getParameters(cpufreqDirectory, file)
             if not parameters:
-                print "Error: could not determine cpu parameters from %s" \
-                    % os.path.join(cpufreqDirectory, file)
+                print("Error: could not determine cpu parameters from %s" \
+                    % os.path.join(cpufreqDirectory, file))
                 return None
             if not current:
                 current = parameters
@@ -92,9 +91,9 @@
 
             try:
                 check_call("echo \"%s\" > %s" % (value, path), shell=True)
-            except CalledProcessError, exception:
-                print "Error: command failed:"
-                print exception
+            except CalledProcessError as exception:
+                print("Error: command failed:")
+                print(exception)
                 return False
 
         # verify it has changed
@@ -106,12 +105,12 @@
         parameterFile = open(path)
         line = parameterFile.readline()
         if not line or line.strip() != str(value):
-            print ("Error: could not verify that %s was set to %s"
+            print("Error: could not verify that %s was set to %s"
                    % (path, value))
             if line:
-                print "Actual Value: %s" % line
+                print("Actual Value: %s" % line)
             else:
-                print "parameter file was empty"
+                print("parameter file was empty")
             return False
 
         return True
@@ -142,8 +141,8 @@
             try:
                 check_call("cpufreq-selector -%s %s"
                            % (switch, value), shell=True)
-            except CalledProcessError, exception:
-                print "Note: command failed: %s" % exception.cmd
+            except CalledProcessError as exception:
+                print("Note: command failed: %s" % exception.cmd)
                 skip = False
         else:
             skip = False
@@ -165,14 +164,14 @@
             parameterFile = open(parameterFilePath)
             line = parameterFile.readline()
             if not line:
-                print ("Error: failed to get %s for %s"
+                print("Error: failed to get %s for %s"
                        % (parameter, self.cpufreqDirectory))
                 return None
             value = line.strip()
             return value
-        except IOError, exception:
-            print "Error: could not open %s" % parameterFilePath
-            print exception
+        except IOError as exception:
+            print("Error: could not open %s" % parameterFilePath)
+            print(exception)
 
         return None
 
@@ -183,19 +182,19 @@
             parameterFile = open(path)
             line = parameterFile.readline()
             if not line:
-                print ("Error: failed to get %s for %s"
+                print("Error: failed to get %s for %s"
                        % (parameter, cpufreqDirectory))
                 return None
             values.append(line.strip())
         return values
 
     def runLoadTest(self):
-        print "Running CPU load test..."
+        print("Running CPU load test...")
         try:
             check_call("taskset -pc 0 %s" % os.getpid(), shell=True)
-        except CalledProcessError, exception:
-            print "Error: could not set task affinity"
-            print exception
+        except CalledProcessError as exception:
+            print("Error: could not set task affinity")
+            print(exception)
             return None
 
         runTime = None
@@ -218,7 +217,7 @@
                     runTime = thisTime
             tries += 1
 
-        print ("Error: could not repeat load test times within %.1f%%"
+        print("Error: could not repeat load test times within %.1f%%"
                % self.retryTolerance)
         return None
 
@@ -251,15 +250,15 @@
         return True
 
     def getSystemCapabilities(self):
-        print ""
-        print "System Capabilites:"
-        print "-------------------------------------------------"
+        print("")
+        print("System Capabilites:")
+        print("-------------------------------------------------")
 
         # Do the CPUs support scaling?
         if not self.getCPUFreqDirectories():
             return False
         if len(self.cpufreqDirectories) > 1:
-            print "System has %u cpus" % len(self.cpufreqDirectories)
+            print("System has %u cpus" % len(self.cpufreqDirectories))
 
         # Ensure all CPUs support the same frequencies
         freqFileName = "scaling_available_frequencies"
@@ -267,11 +266,11 @@
         if not self.frequencies:
             return False
 
-        print ""
-        print "Supported CPU Frequencies: "
+        print("")
+        print("Supported CPU Frequencies: ")
         for freq in self.frequencies:
-            f = string.atoi(freq) / 1000
-            print "    %u MHz" % f
+            f = int(freq) / 1000
+            print("    %u MHz" % f)
 
         # Check governors to verify all CPUs support the same control methods
         governorFileName = "scaling_available_governors"
@@ -279,21 +278,21 @@
         if not self.governors:
             return False
 
-        print ""
-        print "Supported Governors: "
+        print("")
+        print("Supported Governors: ")
         for governor in self.governors:
-            print "    %s" % governor
+            print("    %s" % governor)
 
         self.originalGovernors = self.getParameterList("scaling_governor")
         if self.originalGovernors:
-            print ""
-            print "Current governors:"
+            print("")
+            print("Current governors:")
             i = 0
             for g in self.originalGovernors:
-                print "    cpu%u: %s" % (i, g)
+                print("    cpu%u: %s" % (i, g))
                 i += 1
         else:
-            print "Error: could not determine current governor settings"
+            print("Error: could not determine current governor settings")
             return False
 
         self.getCPUFlags()
@@ -313,12 +312,12 @@
                     self.cpuFlags = post.strip().split()
                     break
         except:
-            print "Warning: could not read CPU flags"
+            print("Warning: could not read CPU flags")
 
     def runUserSpaceTests(self):
-        print ""
-        print "Userspace Governor Test:"
-        print "-------------------------------------------------"
+        print("")
+        print("Userspace Governor Test:")
+        print("-------------------------------------------------")
         self.minimumFrequencyTestTime = None
         self.maximumFrequencyTestTime = None
 
@@ -326,18 +325,17 @@
         differenceSpeedUp = None
         governor = "userspace"
         if governor not in self.governors:
-            print "Note: %s governor not supported" % governor
+            print("Note: %s governor not supported" % governor)
         else:
 
             # Set the governor to "userspace" and verify
-            print "Setting governor to %s" % governor
+            print("Setting governor to %s" % governor)
             if not self.setGovernor(governor):
                 success = False
 
             # Set the the CPU speed to it's lowest value
             frequency = self.frequencies[-1]
-            print ("Setting CPU frequency to %u MHz"
-                   % (string.atoi(frequency) / 1000))
+            print("Setting CPU frequency to %u MHz" % (int(frequency) / 1000))
             if not self.setFrequency(frequency):
                 success = False
 
@@ -347,7 +345,7 @@
             if (not minimumFrequency
                 or not currentFrequency
                 or (minimumFrequency != currentFrequency)):
-                print ("Error: Could not verify that cpu frequency "
+                print("Error: Could not verify that cpu frequency "
                        "is set to the minimum value of %s"
                        % minimumFrequency)
                 success = False
@@ -359,13 +357,12 @@
                        "test's execution time.")
                 success = False
             else:
-                print ("Minimum frequency load test time: %.2f"
+                print("Minimum frequency load test time: %.2f"
                        % self.minimumFrequencyTestTime)
 
             # Set the CPU speed to it's highest value as above.
             frequency = self.frequencies[0]
-            print ("Setting CPU frequency to %u MHz"
-                   % (string.atoi(frequency) / 1000))
+            print("Setting CPU frequency to %u MHz" % (int(frequency) / 1000))
             if not self.setFrequency(frequency):
                 success = False
 
@@ -374,7 +371,7 @@
             if (not maximumFrequency
                 or not currentFrequency
                 or (maximumFrequency != currentFrequency)):
-                print ("Error: Could not verify that cpu frequency is set "
+                print("Error: Could not verify that cpu frequency is set "
                        "to the maximum value of %s"
                        % maximumFrequency)
                 success = False
@@ -386,16 +383,16 @@
                        "test's execution time.")
                 success = False
             else:
-                print ("Maximum frequency load test time: %.2f"
+                print("Maximum frequency load test time: %.2f"
                        % self.maximumFrequencyTestTime)
 
             # Verify MHz increase is comparable to time % decrease
-            predictedSpeedup = (string.atof(maximumFrequency)
-                                / string.atof(minimumFrequency))
+            predictedSpeedup = (float(maximumFrequency)
+                                / float(minimumFrequency))
 
             # If "ida" turbo thing, increase the expectation by 8%
             if self.cpuFlags and self.idaFlag in self.cpuFlags:
-                print ("Note: found %s flag, increasing expected "
+                print("Note: found %s flag, increasing expected "
                        "speedup by %.1f%%"
                        % (self.idaFlag, self.idaSpeedupFactor))
                 predictedSpeedup = \
@@ -405,14 +402,14 @@
             if self.minimumFrequencyTestTime and self.maximumFrequencyTestTime:
                 measuredSpeedup = (self.minimumFrequencyTestTime
                                    / self.maximumFrequencyTestTime)
-                print ""
-                print "CPU Frequency Speed Up: %.2f" % predictedSpeedup
-                print "Measured Speed Up: %.2f" % measuredSpeedup
+                print("")
+                print("CPU Frequency Speed Up: %.2f" % predictedSpeedup)
+                print("Measured Speed Up: %.2f" % measuredSpeedup)
                 differenceSpeedUp = ((abs(measuredSpeedup - predictedSpeedup)
                                      / predictedSpeedup) * 100)
-                print "Percentage Difference %.1f%%" % differenceSpeedUp
+                print("Percentage Difference %.1f%%" % differenceSpeedUp)
                 if differenceSpeedUp > self.speedUpTolerance:
-                    print ("Error: measured speedup vs expected speedup "
+                    print("Error: measured speedup vs expected speedup "
                            "is %.1f%% and is not within %.1f%% margin. "
                            % (differenceSpeedUp, self.speedUpTolerance))
                     success = False
@@ -423,18 +420,18 @@
         return success
 
     def runOnDemandTests(self):
-        print ""
-        print "On Demand Governor Test:"
-        print "-------------------------------------------------"
+        print("")
+        print("On Demand Governor Test:")
+        print("-------------------------------------------------")
         differenceOnDemandVsMaximum = None
         onDemandTestTime = None
         governor = "ondemand"
         success = True
         if governor not in self.governors:
-            print "Note: %s governor not supported" % governor
+            print("Note: %s governor not supported" % governor)
         else:
             # Set the governor to "ondemand"
-            print "Setting governor to %s" % governor
+            print("Setting governor to %s" % governor)
             if not self.setGovernor(governor):
                 success = False
 
@@ -448,10 +445,10 @@
             # Repeat workload test
             onDemandTestTime = self.runLoadTest()
             if not onDemandTestTime:
-                print "Error: No On Demand load test time available."
+                print("Error: No On Demand load test time available.")
                 success = False
             else:
-                print "On Demand load test time: %.2f" % onDemandTestTime
+                print("On Demand load test time: %.2f" % onDemandTestTime)
 
             if onDemandTestTime and self.maximumFrequencyTestTime:
                 # Compare the timing to the max results from earlier,
@@ -459,10 +456,10 @@
                 differenceOnDemandVsMaximum = \
                     (abs(onDemandTestTime - self.maximumFrequencyTestTime)
                      / self.maximumFrequencyTestTime) * 100
-                print ("Percentage Difference vs. maximum frequency: %.1f%%"
+                print("Percentage Difference vs. maximum frequency: %.1f%%"
                        % differenceOnDemandVsMaximum)
                 if differenceOnDemandVsMaximum > self.speedUpTolerance:
-                    print ("Error: on demand performance vs maximum of %.1f%% "
+                    print("Error: on demand performance vs maximum of %.1f%% "
                            "is not within %.1f%% margin"
                            % (differenceOnDemandVsMaximum,
                               self.speedUpTolerance))
@@ -480,17 +477,17 @@
         return success
 
     def runPerformanceTests(self):
-        print ""
-        print "Performance Governor Test:"
-        print "-------------------------------------------------"
+        print("")
+        print("Performance Governor Test:")
+        print("-------------------------------------------------")
         differencePerformanceVsMaximum = None
         governor = "performance"
         success = True
         if governor not in self.governors:
-            print "Note: %s governor not supported" % governor
+            print("Note: %s governor not supported" % governor)
         else:
             # Set the governor to "performance"
-            print "Setting governor to %s" % governor
+            print("Setting governor to %s" % governor)
             if not self.setGovernor(governor):
                 success = False
 
@@ -500,7 +497,7 @@
             if (not maximumFrequency
                 or not currentFrequency
                 or (maximumFrequency != currentFrequency)):
-                print ("Error: Current cpu frequency of %s "
+                print("Error: Current cpu frequency of %s "
                        "is not set to the maximum value of %s"
                        % (currentFrequency, maximumFrequency))
                 success = False
@@ -508,20 +505,20 @@
             # Repeat work load test
             performanceTestTime = self.runLoadTest()
             if not performanceTestTime:
-                print "Error: No Performance load test time available."
+                print("Error: No Performance load test time available.")
                 success = False
             else:
-                print "Performance load test time: %.2f" % performanceTestTime
+                print("Performance load test time: %.2f" % performanceTestTime)
 
             if performanceTestTime and self.maximumFrequencyTestTime:
                 # Compare the timing to the max results
                 differencePerformanceVsMaximum = \
                     (abs(performanceTestTime - self.maximumFrequencyTestTime)
                      / self.maximumFrequencyTestTime) * 100
-                print ("Percentage Difference vs. maximum frequency: %.1f%%"
+                print("Percentage Difference vs. maximum frequency: %.1f%%"
                        % differencePerformanceVsMaximum)
                 if differencePerformanceVsMaximum > self.speedUpTolerance:
-                    print ("Error: performance setting vs maximum of %.1f%% "
+                    print("Error: performance setting vs maximum of %.1f%% "
                            "is not within %.1f%% margin"
                            % (differencePerformanceVsMaximum,
                               self.speedUpTolerance))
@@ -533,17 +530,17 @@
         return success
 
     def runConservativeTests(self):
-        print ""
-        print "Conservative Governor Test:"
-        print "-------------------------------------------------"
+        print("")
+        print("Conservative Governor Test:")
+        print("-------------------------------------------------")
         differenceConservativeVsMinimum = None
         governor = "conservative"
         success = True
         if governor not in self.governors:
-            print "Note: %s governor not supported" % governor
+            print("Note: %s governor not supported" % governor)
         else:
             # Set the governor to "conservative"
-            print "Setting governor to %s" % governor
+            print("Setting governor to %s" % governor)
             if not self.setGovernor(governor):
                 success = False
 
@@ -568,10 +565,10 @@
             # Repeat work load test
             conservativeTestTime = self.runLoadTest()
             if not conservativeTestTime:
-                print "Error: No Conservative load test time available."
+                print("Error: No Conservative load test time available.")
                 success = False
             else:
-                print ("Conservative load test time: %.2f"
+                print("Conservative load test time: %.2f"
                        % conservativeTestTime)
 
             if conservativeTestTime and self.minimumFrequencyTestTime:
@@ -579,10 +576,10 @@
                 differenceConservativeVsMinimum = \
                     (abs(conservativeTestTime - self.minimumFrequencyTestTime)
                      / self.minimumFrequencyTestTime) * 100
-                print ("Percentage Difference vs. minimum frequency: %.1f%%"
+                print("Percentage Difference vs. minimum frequency: %.1f%%"
                        % differenceConservativeVsMinimum)
                 if differenceConservativeVsMinimum > self.speedUpTolerance:
-                    print ("Error: performance setting vs minimum of %.1f%% "
+                    print("Error: performance setting vs minimum of %.1f%% "
                            "is not within %.1f%% margin"
                            % (differenceConservativeVsMinimum,
                               self.speedUpTolerance))
@@ -594,35 +591,32 @@
         return success
 
     def restoreGovernors(self):
-        print "Restoring original governor to %s" % (self.originalGovernors[0])
+        print("Restoring original governor to %s" % (self.originalGovernors[0]))
         self.setGovernor(self.originalGovernors[0])
 
 
 def main(args):
-    usage = "Usage: %prog [OPTIONS]"
-    parser = OptionParser(usage=usage)
-    parser.add_option("-q", "--quiet",
-                      action="store_true",
-                      help="Suppress output.")
-    parser.add_option("-c", "--capabilities",
-                      action="store_true",
-                      help="Only output CPU capabilities.")
-    (options, args) = parser.parse_args(args)
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-q", "--quiet", action="store_true",
+                        help="Suppress output.")
+    parser.add_argument("-c", "--capabilities", action="store_true",
+                        help="Only output CPU capabilities.")
+    args = parser.parse_args()
 
-    if options.quiet:
+    if args.quiet:
         sys.stdout = open(os.devnull, 'a')
         sys.stderr = open(os.devnull, 'a')
 
     test = CPUScalingTest()
     if not os.path.exists(test.cpufreqDirectory):
-        print "CPU Frequency Scaling not supported"
+        print("CPU Frequency Scaling not supported")
         return 0
 
     if not test.getSystemCapabilities():
         parser.error("Failed to get system capabilities")
 
     returnValues = []
-    if not options.capabilities:
+    if not args.capabilities:
         returnValues.append(test.runUserSpaceTests())
         returnValues.append(test.runOnDemandTests())
         returnValues.append(test.runPerformanceTests())