| #!/usr/bin/env python |
| # -*- coding: utf8 -*- |
| |
| from __future__ import print_function |
| |
| import math |
| import os.path |
| import re |
| import sys |
| import time |
| import unittest |
| |
| |
| def setupSysPath(): |
| testPath = sys.path[0] |
| rem = re.match("(^.*/)test$", testPath) |
| if not rem: |
| print("This script expects to reside in .../test.") |
| sys.exit(-1) |
| lldbBasePath = rem.group(1) |
| lldbDebugPythonPath = "build/Debug/LLDB.framework/Resources/Python" |
| lldbReleasePythonPath = "build/Release/LLDB.framework/Resources/Python" |
| lldbPythonPath = None |
| if os.path.isfile(lldbDebugPythonPath + "/lldb.py"): |
| lldbPythonPath = lldbDebugPythonPath |
| if os.path.isfile(lldbReleasePythonPath + "/lldb.py"): |
| lldbPythonPath = lldbReleasePythonPath |
| if not lldbPythonPath: |
| print( |
| "This script requires lldb.py to be in either " + |
| lldbDebugPythonPath, |
| end='') |
| print("or" + lldbReleasePythonPath) |
| sys.exit(-1) |
| sys.path.append(lldbPythonPath) |
| |
| |
| def prettyTime(t): |
| if t == 0.0: |
| return "0s" |
| if t < 0.000001: |
| return ("%.3f" % (t * 1000000000.0)) + "ns" |
| if t < 0.001: |
| return ("%.3f" % (t * 1000000.0)) + "µs" |
| if t < 1: |
| return ("%.3f" % (t * 1000.0)) + "ms" |
| return str(t) + "s" |
| |
| |
| class ExecutionTimes: |
| |
| @classmethod |
| def executionTimes(cls): |
| if cls.m_executionTimes is None: |
| cls.m_executionTimes = ExecutionTimes() |
| for i in range(100): |
| cls.m_executionTimes.start() |
| cls.m_executionTimes.end("null") |
| return cls.m_executionTimes |
| |
| def __init__(self): |
| self.m_times = dict() |
| |
| def start(self): |
| self.m_start = time.time() |
| |
| def end(self, component): |
| e = time.time() |
| if component not in self.m_times: |
| self.m_times[component] = list() |
| self.m_times[component].append(e - self.m_start) |
| |
| def dumpStats(self): |
| for key in list(self.m_times.keys()): |
| if len(self.m_times[key]): |
| sampleMin = float('inf') |
| sampleMax = float('-inf') |
| sampleSum = 0.0 |
| sampleCount = 0.0 |
| for time in self.m_times[key]: |
| if time > sampleMax: |
| sampleMax = time |
| if time < sampleMin: |
| sampleMin = time |
| sampleSum += time |
| sampleCount += 1.0 |
| sampleMean = sampleSum / sampleCount |
| sampleVariance = 0 |
| for time in self.m_times[key]: |
| sampleVariance += (time - sampleMean) ** 2 |
| sampleVariance /= sampleCount |
| sampleStandardDeviation = math.sqrt(sampleVariance) |
| print( |
| key + |
| ": [" + |
| prettyTime(sampleMin) + |
| ", " + |
| prettyTime(sampleMax) + |
| "] ", |
| end='') |
| print( |
| "µ " + |
| prettyTime(sampleMean) + |
| ", σ " + |
| prettyTime(sampleStandardDeviation)) |
| m_executionTimes = None |
| |
| setupSysPath() |
| |
| import lldb |
| |
| |
| class LLDBTestCase(unittest.TestCase): |
| |
| def setUp(self): |
| debugger = lldb.SBDebugger.Create() |
| debugger.SetAsync(True) |
| self.m_commandInterpreter = debugger.GetCommandInterpreter() |
| if not self.m_commandInterpreter: |
| print("Couldn't get the command interpreter") |
| sys.exit(-1) |
| |
| def runCommand(self, command, component): |
| res = lldb.SBCommandReturnObject() |
| ExecutionTimes.executionTimes().start() |
| self.m_commandInterpreter.HandleCommand(command, res, False) |
| ExecutionTimes.executionTimes().end(component) |
| if res.Succeeded(): |
| return res.GetOutput() |
| else: |
| self.fail("Command " + command + " returned an error") |
| return None |
| |
| def getCategories(self): |
| return [] |
| |
| |
| class SanityCheckTestCase(LLDBTestCase): |
| |
| def runTest(self): |
| ret = self.runCommand("show arch", "show-arch") |
| # print(ret) |
| |
| def getCategories(self): |
| return [] |
| |
| suite = unittest.TestLoader().loadTestsFromTestCase(SanityCheckTestCase) |
| unittest.TextTestRunner(verbosity=2).run(suite) |
| ExecutionTimes.executionTimes().dumpStats() |