Author: gnichols Date: 2011-08-31 14:37:12 +0000 (Wed, 31 Aug 2011) New Revision: 1056

Modified: trunk/tests/cpuscaling/cpuscaling.py Log: 732113 - cpuscaling rewrite

Modified: trunk/tests/cpuscaling/cpuscaling.py =================================================================== --- trunk/tests/cpuscaling/cpuscaling.py 2011-08-31 14:36:52 UTC (rev 1055) +++ trunk/tests/cpuscaling/cpuscaling.py 2011-08-31 14:37:12 UTC (rev 1056) @@ -29,18 +29,34 @@ from v7.device import Device from v7.command import Command, V7CommandException

+""" + Tolerance Calculation, workload time checks: + + p = predicted speedup = (max freq / min freq) + s = measured speedup = (workload time, min freq / workload time, max freq) + t = tolerance + + p - (p - 1.0)*t < s < p + (p - 1.0) + + example: p = 2.0, s = 1.9, t = 0.5 + 2.0 - (2.0 - 1.0)*0.5 < 1.9 < 2.0 + (2.0-1.0)*.5 + evaluates to: + 1.5 < 1.9 < 2.5 = True (PASS) +"""

+ class CPUScalingTest(Test):

def __init__(self): Test.__init__(self, name="cpuscaling") - self.speedUpTolerance = 10.0 # percent + self.speedUpTolerance = 50.0 # percent + self.frequencyTolerance = 50 # MHz, +/- self.retryLimit = 5 self.retryTolerance = 5.0 # percent self.sysCPUDirectory = "/sys/devices/system/cpu" self.idaFlag = "ida" + self.aperfmperfFlag = "aperfmperf" self.idaSpeedupFactor = 8.0 # percent - self.turboSpeedupTolerance = 5.0 # percent - test expects turbo/ida to increase performance by more than this self.selfTestData = [10.0, 10.0, 10.0, 10.0] # min, max, ondemand, performance self.selfTestStep = 0 self.deviceClass = DeviceClass.processor @@ -48,7 +64,11 @@ self.cpuToPackage = None self.packageToCpus = None self.workloads = ["minimum", "maximum", "ondemand", "performance"] + self.workloadNames = {"minimum": "User Space (min)", "maximum": "User Space (max)", "ondemand": "On Demand", "performance": "Performance"} self.workloadTime = dict() # workload run time list indexed by [workload][cpu] + self.workloadFreq = dict() # measured cpu freq indexed by [workload][cpu] + self.workloadErrors = dict() # error log indexed by [workload] + self.currentWorkload = "minimum"

def setWorkloadTime(self, workload, cpu, time): if not workload in self.workloadTime: @@ -56,6 +76,20 @@ if not cpu in self.workloadTime[workload]: self.workloadTime[workload][cpu] = list() self.workloadTime[workload][cpu].append(time) + + def setWorkloadFreq(self, workload, cpu, freq): + if not workload in self.workloadFreq: + self.workloadFreq[workload] = dict() + if not cpu in self.workloadFreq[workload]: + self.workloadFreq[workload][cpu] = list() + mhz = int(freq)/1000 + self.workloadFreq[workload][cpu].append(mhz) + + def logWorkloadError(self, errorMessage): + print errorMessage + if not self.currentWorkload in self.workloadErrors: + self.workloadErrors[self.currentWorkload] = list() + self.workloadErrors[self.currentWorkload].append(errorMessage)

def getWorkloadTime(self, workload, cpu): try: @@ -63,6 +97,12 @@ except KeyError: return None

+ def getWorkloadFreq(self, workload, cpu): + try: + return self.workloadFreq[workload][cpu][-1] # get the last time + except KeyError: + return None + def getWorkloadTimes(self, workload, cpu): try: return self.workloadTime[workload][cpu] # get the whole list of times @@ -76,15 +116,34 @@ max = len(self.workloadTime[workload][cpu]) return max

- def speedup(self, cpu): - return self.getWorkloadTime("minimum", cpu)/self.getWorkloadTime("maximum", cpu) + def speedup(self, cpu, workload="maximum"): + try: + return self.getWorkloadTime("minimum", cpu)/self.getWorkloadTime(workload, cpu) + except Exception, e: + print "Error: could not determine speedup for workload %s" % workload + print e + return None

- def speedupMargin(self, cpu): - return (abs(self.speedup(cpu)-self.predictedSpeedup)/self.predictedSpeedup)*100 - - def margin(self, cpu, workload): - return (abs(self.getWorkloadTime(workload,cpu)-self.getWorkloadTime("maximum",cpu))/self.getWorkloadTime("maximum",cpu))*100 + def checkFrequency(self, freq1, freq2): + # freq1 and freq2 is strings, in KHz + return abs(int(freq1)-int(freq2)) < self.frequencyTolerance*1000 # MHz->KHz

+ def checkSpeedup(self, speedup): + success = True + if speedup < self.minimumRequiredSpeedup(): + self.logWorkloadError("Error: measured speedup %.2f less that the required minimum speedup of %.2f. " % (speedup, self.minimumRequiredSpeedup())) + success = False + if speedup > self.maximumRequiredSpeedup(): + self.logWorkloadError("Error: measured speedup %.2f greater than the maximum speedup of %.2f" % (speedup, self.maximumRequiredSpeedup())) + success = False + return success + + def minimumRequiredSpeedup(self): + return self.predictedSpeedup - ((self.predictedSpeedup - 1.00)*self.speedUpTolerance/100.0) + + def maximumRequiredSpeedup(self): + return self.predictedSpeedup + ((self.predictedSpeedup - 1.00)*self.speedUpTolerance/100.0) + def tags(self): return [TestTag.noninteractive, TestTag.certification]

@@ -165,15 +224,15 @@ return line.strip().split() return None

- def setPackageParameter(self, switch, setFile, readFile, value): + def setPackageParameter(self, switch, setFile, readFile, value, verify=True): # try the command for all cpus in the package result = True for cpu in self.packageToCpus[self.currentPackage]: - if not self.setParameter(cpu, switch, setFile, readFile, value): + if not self.setParameter(cpu, switch, setFile, readFile, value, verify): result = False return result

- def setParameter(self, cpu, switch, setFile, readFile, value): + def setParameter(self, cpu, switch, setFile, readFile, value, verify=True): result = True try: command = Command("cpufreq-selector -c %s -%s %s" % (cpu, switch, value)) @@ -194,32 +253,70 @@ return False

# verify it has changed - parameterFile = open("%s/%s" % (self.cpufreqDirectories[cpu], readFile)) - line = parameterFile.readline() - if not line or line.strip() != value: - print "Error: could not verify that %s/%s was set to %s" % (self.cpufreqDirectories[cpu], readFile, value) - if line: - print "Actual Value: %s" % line - else: - print "parameter file was empty" - return False + if verify: + parameterFile = open("%s/%s" % (self.cpufreqDirectories[cpu], readFile)) + line = parameterFile.readline() + if not line or line.strip() != value: + self.logWorkloadError("Error: could not verify that %s/%s was set to %s" % (self.cpufreqDirectories[cpu], readFile, value)) + if line: + print "Actual Value: %s" % line + else: + print "parameter file was empty" + return False

return True

def setFrequency(self, frequency): - return self.setPackageParameter("f", "scaling_setspeed", "scaling_cur_freq", frequency) + if self.setPackageParameter("f", "scaling_setspeed", "scaling_cur_freq", frequency, verify=False): + return self.getFrequency() + + # otherwise, set command has failed + return None

+ def getFrequency(self, cpu=None): + if not cpu: + cpuInfoCurrentFreq = self.getPackageParameter("cpuinfo_cur_freq", logging=True) + # scalingCurrentFreq = self.getPackageParameter("scaling_cur_freq", logging=True) + # if cpuInfoCurrentFreq != scalingCurrentFreq: + # print "Warning: scaling_cur_freq is %s while cpuinfo_cur_freq is %s" % ( scalingCurrentFreq, cpuInfoCurrentFreq) + if cpuInfoCurrentFreq: + # print "Using cpuinfo_cur_freq" + return cpuInfoCurrentFreq + + # otherwise + # if scalingCurrentFreq: + # print "Using scaling_cur_freq" + # return scalingCurrentFreq + + self.logWorkloadError("Error: could not determine frequency") + return None + else: + cpuInfoCurrentFreq = self.getParameter(cpu, "cpuinfo_cur_freq") + # scalingCurrentFreq = self.getParameter(cpu, "scaling_cur_freq") + if cpuInfoCurrentFreq: + return cpuInfoCurrentFreq + + # otherwise + # if scalingCurrentFreq: + # return scalingCurrentFreq + + self.logWorkloadError("Error: could not determine frequency") + return None + + def setGovernor(self, governor): return self.setPackageParameter("g", "scaling_governor", "scaling_governor", governor)

- def getPackageParameter(self, parameter): + def getPackageParameter(self, parameter, logging=False): packageParameterValue = None for cpu in self.packageToCpus[self.currentPackage]: value = self.getParameter(cpu, parameter) + if logging: + print "cpu%s %s = %s" % (cpu, parameter, value) if value and not packageParameterValue: packageParameterValue = value elif value != packageParameterValue: - print "Error: cpu%s in package %s has the value %s which differs from other cpus in the package" % (cpu, self.currentPackage, value) + self.logWorkloadError("Error: cpu%s in package %s has the value %s which differs from other cpus in the package" % (cpu, self.currentPackage, value)) return None return packageParameterValue

@@ -230,12 +327,12 @@ parameterFile = open(parameterFilePath) line = parameterFile.readline() if not line: - print "Error: failed to get %s for %s" % (parameter, self.cpufreqDirectories[cpu]) + self.logWorkloadError("Error: failed to get %s for %s" % (parameter, self.cpufreqDirectories[cpu])) return None value = line.strip() return value except IOError, exception: - print "Error: could not open %s" % parameterFilePath + self.logWorkloadError("Error: could not open %s" % parameterFilePath) print exception

return None @@ -246,7 +343,7 @@ parameterFile = open("%s/%s" % (cpufreqDirectory, parameter)) line = parameterFile.readline() if not line: - print "Error: failed to get %s for %s" % (parameter, cpufreqDirectory) + self.logWorkloadError("Error: failed to get %s for %s" % (parameter, cpufreqDirectory)) return None values.append(line.strip())

@@ -261,20 +358,21 @@ while tries < self.retryLimit: sys.stdout.flush() averageProcessTime = self.__runSubprocessLoadTest(cpu) - print "average worker process time: %.2f seconds" % averageProcessTime - if not runTime: - runTime = averageProcessTime - else: - thisTime = averageProcessTime - # print "comparing %.2f" % (abs(thisTime-runTime)/runTime) - if (abs(thisTime-runTime)/runTime)*100 < self.retryTolerance: - return thisTime + if averageProcessTime: + print "average worker process time: %.2f seconds" % averageProcessTime + if not runTime: + runTime = averageProcessTime else: - runTime = thisTime + thisTime = averageProcessTime + # print "comparing %.2f" % (abs(thisTime-runTime)/runTime) + if (abs(thisTime-runTime)/runTime)*100 < self.retryTolerance: + return thisTime + else: + runTime = thisTime tries += 1 # print "try %u - %.2f sec" % (tries, runTime)

- print "Error: could not repeat load test times within %.1f%%" % self.retryTolerance + self.logWorkloadError("Error: could not repeat load test times within %.1f%%" % self.retryTolerance) return None

def __runSubprocessLoadTest(self, cpu=None): @@ -299,15 +397,20 @@ for (cpu, process) in self.loadProcesses.items(): if process.isDone(): if process.returnCode is not 0: - print "Error: load process terminated with return code " + process.returnCode + self.logWorkloadError("Error: load process terminated with return code " + process.returnCode) return None runTime = process.getRunTime() + frequency = self.getFrequency(cpu) if not runTime: - print "Error: could not find process run time" + self.logWorkloadError("Error: could not find process run time") return None + if not frequency: + self.logWorkloadError("Error: could not determine cpu frequency") + return None # otherwise - collect info - print "process for cpu %s is done in %.2f seconds" % (cpu, runTime) + print "process for cpu %s is done in %.2f seconds, at %u MHz" % (cpu, runTime, int(int(frequency)/1000)) self.setWorkloadTime(self.currentWorkload, cpu, runTime) + self.setWorkloadFreq(self.currentWorkload, cpu, frequency) totalProcessTime += runTime del self.loadProcesses[cpu]

@@ -320,7 +423,7 @@ try: del self.loadProcesses[cpu] except KeyError: - print "Error: no cpu %s in load processes" % cpu + self.logWorkloadError("Error: no cpu %s in load processes" % cpu)

def verifyMinimumFrequency(self): waitTime = 5 @@ -329,8 +432,8 @@ time.sleep(waitTime) sys.stdout.write(" done.\n") minimumFrequency = self.getPackageParameter("scaling_min_freq") - currentFrequency = self.getPackageParameter("scaling_cur_freq") - if not minimumFrequency or not currentFrequency or (minimumFrequency != currentFrequency): + currentFrequency = self.getFrequency() + if not minimumFrequency or not currentFrequency or not self.checkFrequency(minimumFrequency, currentFrequency): return False

# otherwise @@ -413,12 +516,21 @@ sys.stdout.write(" cpu%u: %s\n" % (i, g)) i += 1 else: - print "Error: could not determine current governor settings" + self.logWorkloadError("Error: could not determine current governor settings") return False

+ print "\nCPU Flags:" self.getCPUFlags() + support = " NOT" + if self.idaFlag in self.cpuFlags: + support = "" + print " %s: Turbo Boost is%s supported" % (self.idaFlag, support) + support = " NOT" + if self.aperfmperfFlag in self.cpuFlags: + support = "" + print " %s: aperf/mperf is%s supported"% (self.aperfmperfFlag, support) sys.stdout.flush()

return True @@ -452,10 +564,6 @@ # 5. Set the govr.(*) to "userspace" for each cpu via a command similar to: # 6. Verify the govr. setting took by checking ~/scaling_governor self.differenceSpeedUp = None - # calculate predicted (theoretical) speed up based on scaling frequencies - maximumFrequency = self.getPackageParameter("scaling_max_freq") - minimumFrequency = self.getPackageParameter("scaling_min_freq") - self.predictedSpeedup = string.atof(maximumFrequency)/string.atof(minimumFrequency)

success = True governor = "userspace" @@ -466,7 +574,7 @@

# 7. Set the the cpu speed to it's lowest value frequency = self.frequencies[0] - currentFrequency = self.getPackageParameter("scaling_cur_freq") + currentFrequency = self.getFrequency() if currentFrequency: print "Changing cpu frequency from %u to %u MHz" % (int(currentFrequency)/1000, (frequency/1000)) else: @@ -477,9 +585,10 @@ sys.stdout.flush()

# 8. Verify the speed is set to the lowest value by comparing ~/scaling_min_freq to ~/scaling_cur_freq - currentFrequency = self.getPackageParameter("scaling_cur_freq") - if not minimumFrequency or not currentFrequency or (minimumFrequency != currentFrequency): - print "Error: Could not verify that cpu frequency is set to the minimum value of %s" % minimumFrequency + currentFrequency = self.getFrequency() + minimumFrequency = self.getPackageParameter("scaling_min_freq") + if not minimumFrequency or not currentFrequency or not self.checkFrequency(minimumFrequency, currentFrequency): + self.logWorkloadError("Error: Could not verify that cpu frequency is set to the minimum value of %s" % minimumFrequency) success = False

# 9. Run and time non-cacheable work(?) test for each CPU @@ -492,15 +601,23 @@

# 11. Set the cpu speed to it's highest value as above. frequency = self.frequencies[-1] - currentFrequency = self.getPackageParameter("scaling_cur_freq") + currentFrequency = self.getFrequency() print "Changing cpu frequency from %u to %u MHz" % (int(currentFrequency)/1000, (frequency/1000)) if not self.setFrequency("%u" % frequency): success = False self.currentWorkload = "maximum"

- currentFrequency = self.getPackageParameter("scaling_cur_freq") - if not maximumFrequency or not currentFrequency or (maximumFrequency != currentFrequency): - print "Error: Could not verify that cpu frequency is set to the maximum value of %s" % maximumFrequency + currentFrequency = self.getFrequency() + maximumFrequency = self.getPackageParameter("scaling_max_freq") + try: + self.predictedSpeedup = float(maximumFrequency)/float(minimumFrequency) + except Exception, e: + print "Error: could not determine predicted speedup" + print e + return False + + if not maximumFrequency or not currentFrequency or not self.checkFrequency(maximumFrequency, currentFrequency): + self.logWorkloadError("Error: Could not verify that cpu frequency is set to the maximum value of %s" % maximumFrequency) success = False

# 12. Repeat workload test, record timing @@ -519,10 +636,7 @@ print "" print "CPU Frequency Speed Up: %.2f" % self.predictedSpeedup print "CPU %s Measured Speed Up: %.2f" % (cpu, measuredSpeedup) - self.differenceSpeedUp = self.speedupMargin(cpu) - print "Percentage Difference %.1f%%" % self.differenceSpeedUp - if self.differenceSpeedUp > self.speedUpTolerance: - print "Error: measured speedup vs expected speedup is %.1f%% and is not within %.1f%% margin. " % (self.differenceSpeedUp, self.speedUpTolerance) + if not self.checkSpeedup(measuredSpeedup): success = False else: print "Note: %s governor not supported" % governor @@ -547,7 +661,7 @@

# 16. Wait a fixed period of time, then verify current speed is the slowest in as before if not self.verifyMinimumFrequency(): - print "Error: Could not verify that cpu frequency has settled to the minimum value" + self.logWorkloadError("Error: Could not verify that cpu frequency has settled to the minimum value") success = False

# 17. Repeat workload test, record timing; also during testing verify the ~scaling_cur_freq reaches ~scaling_max_freq @@ -560,10 +674,9 @@ # for each cpu in the package for cpu in self.packageToCpus[self.currentPackage]: if self.getWorkloadTime("maximum", cpu): - self.differenceOnDemandVsMaximum = self.margin(cpu, "ondemand") - print "CPU %s Percentage Difference vs. maximum frequency: %.1f%%" % (cpu, self.differenceOnDemandVsMaximum) - if self.differenceOnDemandVsMaximum > self.speedUpTolerance: - print "Error: on demand performance vs maximum of %.1f%% is not within %.1f%% margin" % (self.differenceOnDemandVsMaximum, self.speedUpTolerance) + onDemandSpeedup = self.speedup(cpu, "ondemand") + print "CPU %s Speedup On Demand: %.2f%%" % (cpu, onDemandSpeedup) + if not self.checkSpeedup(onDemandSpeedup): success = False else: print "No maximum frequency test data to compare" @@ -571,7 +684,7 @@

# 19. Verify the current speed has returned to the lowest speed as before if not self.verifyMinimumFrequency(): - print "Error: Could not verify that cpu frequency has settled to the minimum value" + self.logWorkloadError("Error: Could not verify that cpu frequency has settled to the minimum value") success = False else: print "Note: %s governor not supported" % governor @@ -595,10 +708,13 @@

# 21. Verify the current speed is the same as scaling_max_freq maximumFrequency = self.getPackageParameter("scaling_max_freq") - currentFrequency = self.getPackageParameter("scaling_cur_freq") - if not maximumFrequency or not currentFrequency or (maximumFrequency != currentFrequency): - print "Error: Current cpu frequency of %.2f is not set to the maximum value of %.2f" % (currentFrequency, maximumFrequency) + currentFrequency = self.getFrequency() + if not maximumFrequency or not currentFrequency: + self.logWorkloadError("Error: could not determine current frequency") return False + elif not self.checkFrequency(maximumFrequency, currentFrequency): + self.logWorkloadError("Error: Current cpu frequency of %.2f is not set to the maximum value of %.2f" % (currentFrequency, maximumFrequency)) + return False

# 22. Repeat workload test, record timing, also verify frequency does not drop during run self.performanceTestTime = self.runLoadTest() @@ -609,11 +725,10 @@

# 23. Compare the timing to the max results for a self.speedUpTolerance delta for cpu in self.packageToCpus[self.currentPackage]: - self.differencePerformanceVsMaximum = self.margin(cpu, "performance") - print "CPU %s Percentage Difference vs. maximum frequency: %.1f%%" % (cpu, self.differencePerformanceVsMaximum) - if self.differencePerformanceVsMaximum > self.speedUpTolerance: - print "Error: performance setting vs maximum of %.1f%% is not within %.1f%% margin" % (self.differencePerformanceVsMaximum, self.speedUpTolerance) - success = False + performanceSpeedup = self.speedup(cpu, "performance") + print "CPU %s Performance Speedup: %.2f%%" % (cpu, performanceSpeedup) + if not self.checkSpeedup(performanceSpeedup): + success = False

else: print "Note: %s governor not supported" % governor @@ -649,14 +764,16 @@ print "Turbo/IDA load test time: %.2f" % self.turboTestTime

# 23. Compare the timing to the max results for a self.speedUpTolerance delta - self.differenceTurboVsMaximum = self.margin(turboCpu, "turbo") - print "Percentage Difference vs. maximum frequency: %.1f%%" % self.differenceTurboVsMaximum - if self.differenceTurboVsMaximum < self.turboSpeedupTolerance: - print "Error: turbo/IDA setting vs maximum of %.1f%% is not within %.1f%% margin" % (self.differenceTurboVsMaximum, self.turboSpeedupTolerance) - success = False + turboSpeedup = self.speedup(turboCpu, "turbo") + if not turboSpeedup: + return False + print "Turbo Speedup: %.1f%%" % turboSpeedup

+ if not self.checkSpeedup(turboSpeedup): + success = False + else: - print "Error: %s governor not supported" % governor + self.logWorkloadError("Error: %s governor not supported" % governor) success = False

return success @@ -676,64 +793,69 @@ for package in self.packageToCpus.keys(): self.printSummary(package)

- for package in self.packageToCpus.keys(): - self.printWorkloadTimeSummary(package) + if False: # disable for now: + for package in self.packageToCpus.keys(): + self.printWorkloadTimeSummary(package)

+ if self.workloadErrors: + print "\nError Summary:" + print "----------------" + for workload in self.workloads: + if workload in self.workloadErrors: + for error in self.workloadErrors[workload]: + print "%s: %s" % (self.workloadNames[workload], error) + return False + return True

def printSummary(self, package): - """ tables: row title is 13 characters, each cpu cell is 9 characters """ + print "" print "Summary for Package %s:" % package - self.__printBorder(package) - sys.stdout.write("Workload ") + print "\nCPU Frequency Test:\n" + print " User Min User Max Performance" + print "-------- -------------- -------------- --------------" + + # expected values + minimumFrequency = int(self.getPackageParameter("scaling_min_freq"))/1000 + maximumFrequency = int(self.getPackageParameter("scaling_max_freq"))/1000 + print "expected %5u MHz %5u MHz %5u MHz" % (minimumFrequency, maximumFrequency, maximumFrequency) + + #actual values, one row per cpu for cpu in self.packageToCpus[package]: - sys.stdout.write(" cpu %-3s " % cpu) + sys.stdout.write("cpu %-3s " % cpu) + for workload in self.workloads: + if workload in self.workloadTime and workload != "ondemand" and workload != "turbo": + sys.stdout.write(" %4u" % self.getWorkloadFreq(workload, cpu)) + sys.stdout.write((" (%.2fs) " % self.getWorkloadTime(workload, cpu))[:10]) + print "" + print "" - self.__printBorder(package) - for workload in self.workloads: - if workload in self.workloadTime: - sys.stdout.write("%-13s" % workload) - for cpu in self.packageToCpus[package]: - sys.stdout.write("%9.2f" % self.getWorkloadTime(workload, cpu)) - print "" - print "\n"

- sys.stdout.write("Speedup ") - for cpu in self.packageToCpus[package]: - sys.stdout.write(" cpu %-3s " % cpu) + + print "\nCPU Workload Test:\n" + print "Expected Speedup: %.2f" % self.predictedSpeedup + print "Allowable Speedup: %.2f to %.2f" % (self.minimumRequiredSpeedup(), self.maximumRequiredSpeedup()) print "" - self.__printBorder(package) - sys.stdout.write("expected ") + print " On Demand Single CPU " + print "-------- -------------- --------------" + + #actual values, one row per cpu for cpu in self.packageToCpus[package]: - sys.stdout.write("%9.2f" % self.predictedSpeedup) - print "" - sys.stdout.write("actual ") - for cpu in self.packageToCpus[package]: - sys.stdout.write("%9.2f" % self.speedup(cpu)) - print "" - sys.stdout.write("margin ") - for cpu in self.packageToCpus[package]: - sys.stdout.write("%8.2f%%" % self.speedupMargin(cpu)) - print "" - for workload in ["ondemand", "performance"]: - if workload in self.workloadTime.keys(): # iterate over logged workloads - sys.stdout.write("%-13s" % workload) - for cpu in self.packageToCpus[package]: - sys.stdout.write("%8.2f%%" % self.margin(cpu, workload)) - print "" - if "turbo" in self.workloadTime: - sys.stdout.write("%-13s" % "turbo") - turboCpu = self.getTurboCpu() - for cpu in self.packageToCpus[package]: - if cpu == turboCpu: - sys.stdout.write("%8.2f%%" % self.margin(cpu, "turbo")) - else: - sys.stdout.write(" - ") + sys.stdout.write("cpu %-3s " % cpu) + for workload in ["ondemand", "turbo"]: + if workload in self.workloadTime: + workloadTime = self.getWorkloadTime(workload, cpu) + if workloadTime: + sys.stdout.write(" %.2f" % self.speedup(cpu, workload)) + sys.stdout.write((" (%.2fs) " % workloadTime)[:10]) + else: + sys.stdout.write(" - ") print "" - print "\n"

+ print "" + def printWorkloadTimeSummary(self, package): sys.stdout.write("Workload run times for package %s:\n" % package) sys.stdout.write("-------------------\n") @@ -759,10 +881,13 @@ print "" print "\n"

- def __printBorder(self, package): + def __printBorder(self, package, cell): sys.stdout.write("-------------") # 13 for row title + cellBorder = " " + for i in range(cell): + cellBorder = cellBorder + "-" for cpu in self.packageToCpus[package]: - sys.stdout.write(" --------") # 9 for cpu cell ( 1 space, 8 -) + sys.stdout.write(cellBorder) # 15 for cpu cell ( 1 space, 14 -) sys.stdout.write("\n")

def run(self): @@ -784,17 +909,16 @@ if not self.runSubTest(self.runUserSpaceTests, "User Space, package %s" % package): result = FAILED

- if not self.runSubTest(self.runOnDemandTests, "On Demand, package %s" % package): result = FAILED - + if not self.runSubTest(self.runPerformanceTests, "Performance, package %s" % package): result = FAILED

if self.turboBoostSupported(): if not self.runSubTest(self.runTurboBoostTest, "Turbo Boost/IDA, package %s" % package): result = FAILED - +

self.restoreGovernors()

@@ -840,20 +964,21 @@ self.owner.done(self.cpu)

def isDone(self): - if self.workProcess and self.workProcess.poll() is not None: + if self.workProcess: self.returnCode = self.workProcess.poll() - while True: - line = self.workProcess.readline() - if line: - try: - self.runTime = float(line) - return True - except ValueError: - pass # keep trying - else: - print "Error: could not determine process run time" - break - return True + if self.returnCode is not None: + while True: + line = self.workProcess.readline() + if line: + try: + self.runTime = float(line) + return True + except ValueError, e: + pass # keep trying + else: + print "Error: could not determine process run time" + break + return True # otherwise return False

@@ -881,7 +1006,9 @@ pi() (stop_utime, stop_stime, stop_cutime, stop_cstime, stop_elapsed_time) = os.times() runTime = stop_elapsed_time - start_elapsed_time + print "" # make sure runTime is on its own line print runTime + sys.stdout.flush() sys.exit(0)

test = CPUScalingTest()