diff options
Diffstat (limited to 'packages/Python/lldbsuite/test/benchmarks/disassembly')
3 files changed, 316 insertions, 0 deletions
diff --git a/packages/Python/lldbsuite/test/benchmarks/disassembly/TestDisassembly.py b/packages/Python/lldbsuite/test/benchmarks/disassembly/TestDisassembly.py new file mode 100644 index 0000000000000..a18cb2a64c767 --- /dev/null +++ b/packages/Python/lldbsuite/test/benchmarks/disassembly/TestDisassembly.py @@ -0,0 +1,155 @@ +"""Disassemble lldb's Driver::MainLoop() functions comparing lldb against gdb.""" + +from __future__ import print_function + + + +import os, sys +import lldb +from lldbsuite.test import configuration +from lldbsuite.test.lldbbench import * + +def is_exe(fpath): + """Returns true if fpath is an executable.""" + return os.path.isfile(fpath) and os.access(fpath, os.X_OK) + +class DisassembleDriverMainLoop(BenchBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + """ + Note that lldbtest_config.lldbExec can be specified with the LLDB_EXEC env variable (see + dotest.py), and gdbExec can be specified with the GDB_EXEC env variable. + This provides a flexibility in specifying different versions of gdb for + comparison purposes. + """ + BenchBase.setUp(self) + # If env var GDB_EXEC is specified, use it; otherwise, use gdb in your + # PATH env var. + if "GDB_EXEC" in os.environ and is_exe(os.environ["GDB_EXEC"]): + self.gdbExec = os.environ["GDB_EXEC"] + else: + self.gdbExec = "gdb" + + self.exe = lldbtest_config.lldbExec + self.function = 'Driver::MainLoop()' + self.lldb_avg = None + self.gdb_avg = None + self.count = 5 + + @benchmarks_test + @no_debug_info_test + @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows") + def test_run_lldb_then_gdb(self): + """Test disassembly on a large function with lldb vs. gdb.""" + print() + print("lldb path: %s" % lldbtest_config.lldbExec) + print("gdb path: %s" % self.gdbExec) + + print() + self.run_lldb_disassembly(self.exe, self.function, self.count) + print("lldb benchmark:", self.stopwatch) + self.run_gdb_disassembly(self.exe, self.function, self.count) + print("gdb benchmark:", self.stopwatch) + print("lldb_avg/gdb_avg: %f" % (self.lldb_avg/self.gdb_avg)) + + @benchmarks_test + @no_debug_info_test + @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows") + def test_run_gdb_then_lldb(self): + """Test disassembly on a large function with lldb vs. gdb.""" + print() + print("lldb path: %s" % lldbtest_config.lldbExec) + print("gdb path: %s" % self.gdbExec) + + print() + self.run_gdb_disassembly(self.exe, self.function, self.count) + print("gdb benchmark:", self.stopwatch) + self.run_lldb_disassembly(self.exe, self.function, self.count) + print("lldb benchmark:", self.stopwatch) + print("lldb_avg/gdb_avg: %f" % (self.lldb_avg/self.gdb_avg)) + + def run_lldb_disassembly(self, exe, function, count): + import pexpect + # Set self.child_prompt, which is "(lldb) ". + self.child_prompt = '(lldb) ' + prompt = self.child_prompt + + # So that the child gets torn down after the test. + self.child = pexpect.spawn('%s %s %s' % (lldbtest_config.lldbExec, self.lldbOption, exe)) + child = self.child + + # Turn on logging for what the child sends back. + if self.TraceOn(): + child.logfile_read = sys.stdout + + child.expect_exact(prompt) + child.sendline('breakpoint set -F %s' % function) + child.expect_exact(prompt) + child.sendline('run') + child.expect_exact(prompt) + + # Reset the stopwatch now. + self.stopwatch.reset() + for i in range(count): + with self.stopwatch: + # Disassemble the function. + child.sendline('disassemble -f') + child.expect_exact(prompt) + child.sendline('next') + child.expect_exact(prompt) + + child.sendline('quit') + try: + self.child.expect(pexpect.EOF) + except: + pass + + self.lldb_avg = self.stopwatch.avg() + if self.TraceOn(): + print("lldb disassembly benchmark:", str(self.stopwatch)) + self.child = None + + def run_gdb_disassembly(self, exe, function, count): + import pexpect + # Set self.child_prompt, which is "(gdb) ". + self.child_prompt = '(gdb) ' + prompt = self.child_prompt + + # So that the child gets torn down after the test. + self.child = pexpect.spawn('%s --nx %s' % (self.gdbExec, exe)) + child = self.child + + # Turn on logging for what the child sends back. + if self.TraceOn(): + child.logfile_read = sys.stdout + + child.expect_exact(prompt) + child.sendline('break %s' % function) + child.expect_exact(prompt) + child.sendline('run') + child.expect_exact(prompt) + + # Reset the stopwatch now. + self.stopwatch.reset() + for i in range(count): + with self.stopwatch: + # Disassemble the function. + child.sendline('disassemble') + child.expect_exact(prompt) + child.sendline('next') + child.expect_exact(prompt) + + child.sendline('quit') + child.expect_exact('The program is running. Exit anyway?') + child.sendline('y') + try: + self.child.expect(pexpect.EOF) + except: + pass + + self.gdb_avg = self.stopwatch.avg() + if self.TraceOn(): + print("gdb disassembly benchmark:", str(self.stopwatch)) + self.child = None diff --git a/packages/Python/lldbsuite/test/benchmarks/disassembly/TestDoAttachThenDisassembly.py b/packages/Python/lldbsuite/test/benchmarks/disassembly/TestDoAttachThenDisassembly.py new file mode 100644 index 0000000000000..b7b07090959ef --- /dev/null +++ b/packages/Python/lldbsuite/test/benchmarks/disassembly/TestDoAttachThenDisassembly.py @@ -0,0 +1,67 @@ +"""Test lldb's disassemblt speed. This bench deliberately attaches to an lldb +inferior and traverses the stack for thread0 to arrive at frame with function +'MainLoop'. It is important to specify an lldb executable as the inferior.""" + +from __future__ import print_function + + + +import os, sys +import lldb +from lldbsuite.test.lldbbench import * +from lldbsuite.test import configuration + +class AttachThenDisassemblyBench(BenchBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + BenchBase.setUp(self) + self.exe = lldbtest_config.lldbExec + self.count = 10 + + @benchmarks_test + @no_debug_info_test + def test_attach_then_disassembly(self): + """Attach to a spawned lldb process then run disassembly benchmarks.""" + print() + self.run_lldb_attach_then_disassembly(self.exe, self.count) + print("lldb disassembly benchmark:", self.stopwatch) + + def run_lldb_attach_then_disassembly(self, exe, count): + target = self.dbg.CreateTarget(exe) + + # Spawn a new process and don't display the stdout if not in TraceOn() mode. + import subprocess + popen = subprocess.Popen([exe, self.lldbOption], + stdout = open(os.devnull, 'w') if not self.TraceOn() else None) + if self.TraceOn(): + print("pid of spawned process: %d" % popen.pid) + + # Attach to the launched lldb process. + listener = lldb.SBListener("my.attach.listener") + error = lldb.SBError() + process = target.AttachToProcessWithID(listener, popen.pid, error) + + # Set thread0 as the selected thread, followed by the 'MainLoop' frame + # as the selected frame. Then do disassembly on the function. + thread0 = process.GetThreadAtIndex(0) + process.SetSelectedThread(thread0) + i = 0 + found = False + for f in thread0: + #print("frame#%d %s" % (i, f.GetFunctionName())) + if "MainLoop" in f.GetFunctionName(): + found = True + thread0.SetSelectedFrame(i) + if self.TraceOn(): + print("Found frame#%d for function 'MainLoop'" % i) + break + i += 1 + + # Reset the stopwatch now. + self.stopwatch.reset() + for i in range(count): + with self.stopwatch: + # Disassemble the function. + self.runCmd("disassemble -f") diff --git a/packages/Python/lldbsuite/test/benchmarks/disassembly/TestXcode41Vs42GDBDisassembly.py b/packages/Python/lldbsuite/test/benchmarks/disassembly/TestXcode41Vs42GDBDisassembly.py new file mode 100644 index 0000000000000..745e7b6a8c3b9 --- /dev/null +++ b/packages/Python/lldbsuite/test/benchmarks/disassembly/TestXcode41Vs42GDBDisassembly.py @@ -0,0 +1,94 @@ +"""Disassemble lldb's Driver::MainLoop() functions comparing Xcode 4.1 vs. 4.2's gdb.""" + +from __future__ import print_function + + + +import os, sys +import lldb +from lldbsuite.test import configuration +from lldbsuite.test.lldbbench import * + +class XCode41Vs42GDBDisassembly(BenchBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + BenchBase.setUp(self) + self.gdb_41_exe = '/Xcode41/usr/bin/gdb' + self.gdb_42_exe = '/Developer/usr/bin/gdb' + self.exe = lldbtest_config.lldbExec + self.function = 'Driver::MainLoop()' + self.gdb_41_avg = None + self.gdb_42_avg = None + self.count = 5 + + @benchmarks_test + @no_debug_info_test + @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows") + def test_run_41_then_42(self): + """Test disassembly on a large function with 4.1 vs. 4.2's gdb.""" + print() + self.run_gdb_disassembly(self.gdb_41_exe, self.exe, self.function, self.count) + print("4.1 gdb benchmark:", self.stopwatch) + self.gdb_41_avg = self.stopwatch.avg() + self.run_gdb_disassembly(self.gdb_42_exe, self.exe, self.function, self.count) + print("4.2 gdb benchmark:", self.stopwatch) + self.gdb_42_avg = self.stopwatch.avg() + print("gdb_42_avg/gdb_41_avg: %f" % (self.gdb_42_avg/self.gdb_41_avg)) + + @benchmarks_test + @no_debug_info_test + @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows") + def test_run_42_then_41(self): + """Test disassembly on a large function with 4.1 vs. 4.2's gdb.""" + print() + self.run_gdb_disassembly(self.gdb_42_exe, self.exe, self.function, self.count) + print("4.2 gdb benchmark:", self.stopwatch) + self.gdb_42_avg = self.stopwatch.avg() + self.run_gdb_disassembly(self.gdb_41_exe, self.exe, self.function, self.count) + print("4.1 gdb benchmark:", self.stopwatch) + self.gdb_41_avg = self.stopwatch.avg() + print("gdb_42_avg/gdb_41_avg: %f" % (self.gdb_42_avg/self.gdb_41_avg)) + + def run_gdb_disassembly(self, gdb_exe_path, exe, function, count): + import pexpect + # Set self.child_prompt, which is "(gdb) ". + self.child_prompt = '(gdb) ' + prompt = self.child_prompt + + # So that the child gets torn down after the test. + self.child = pexpect.spawn('%s --nx %s' % (gdb_exe_path, exe)) + child = self.child + + # Turn on logging for what the child sends back. + if self.TraceOn(): + child.logfile_read = sys.stdout + + child.expect_exact(prompt) + child.sendline('break %s' % function) + child.expect_exact(prompt) + child.sendline('run') + child.expect_exact(prompt) + + # Reset the stopwatch now. + self.stopwatch.reset() + for i in range(count): + with self.stopwatch: + # Disassemble the function. + child.sendline('disassemble') + child.expect_exact(prompt) + child.sendline('next') + child.expect_exact(prompt) + + child.sendline('quit') + child.expect_exact('The program is running. Exit anyway?') + child.sendline('y') + try: + self.child.expect(pexpect.EOF) + except: + pass + + if self.TraceOn(): + print("gdb disassembly benchmark:", str(self.stopwatch)) + self.child = None |