This is an archive of the discontinued LLVM Phabricator instance.

Differential D55559

Remove the Disassembly benchmarks.
ClosedPublic

Authored by aprantl on Dec 11 2018, 8:43 AM.

Details

Reviewers
jingham
jasonmolenda
Commits
rG8f06d102915d: Remove the Disassembly benchmarks.
rL349194: Remove the Disassembly benchmarks.
rLLDB349194: Remove the Disassembly benchmarks.
Summary

While I was out hunting for remaining pexpect-based tests, I came across these tests that can't possibly work an any modern system, as they rely on having gdb available in /Developer.

This patch simply removes the test without replacement.

Diff Detail

Repository
rLLDB LLDB

Event Timeline

aprantl created this revision.Dec 11 2018, 8:43 AM
jingham accepted this revision.Dec 14 2018, 12:58 PM

LGTM

This revision is now accepted and ready to land.Dec 14 2018, 12:58 PM
Closed by commit rLLDB349194: Remove the Disassembly benchmarks. (authored by adrian). · Explain WhyDec 14 2018, 1:09 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
packages/
Python/
lldbsuite/
test/
benchmarks/
disassembly/
165 lines
70 lines
120 lines

Diff 178268

packages/Python/lldbsuite/test/benchmarks/disassembly/TestDisassembly.py

"""Disassemble lldb's Driver::MainLoop() functions comparing lldb against gdb."""
from __future__ import print_function
import os
import sys
import lldb
from lldbsuite.test.decorators import *
from lldbsuite.test.lldbbench import *
from lldbsuite.test.lldbtest import *
from lldbsuite.test import lldbutil
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
@expectedFailureAll(
oslist=["windows"],
bugnumber="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
@expectedFailureAll(
oslist=["windows"],
bugnumber="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

packages/Python/lldbsuite/test/benchmarks/disassembly/TestDoAttachThenDisassembly.py

"""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
import sys
import lldb
from lldbsuite.test.decorators import *
from lldbsuite.test.lldbbench import *
from lldbsuite.test.lldbtest import *
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")

packages/Python/lldbsuite/test/benchmarks/disassembly/TestXcode41Vs42GDBDisassembly.py

"""Disassemble lldb's Driver::MainLoop() functions comparing Xcode 4.1 vs. 4.2's gdb."""
from __future__ import print_function
import os
import sys
import lldb
from lldbsuite.test.decorators import *
from lldbsuite.test.lldbbench import *
from lldbsuite.test.lldbtest import *
from lldbsuite.test import configuration
from lldbsuite.test import lldbutil
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
@expectedFailureAll(
oslist=["windows"],
bugnumber="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
@expectedFailureAll(
oslist=["windows"],
bugnumber="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
packages/Python/lldbsuite/test/benchmarks/disassembly/TestDoAttachThenDisassembly.py