From ceabd2d712016be19986273f652c5eec636f9948 Mon Sep 17 00:00:00 2001 From: Sean Callanan Date: Fri, 6 Apr 2012 20:53:23 +0000 Subject: [PATCH] Updated the disassembler stress tester with two new features: (1) it outputs the instruction currently being tested to a log file, if a path is provided (2) if instructed, it prints the time remaining in the exhaustive test llvm-svn: 154205 --- lldb/examples/python/disasm-stress-test.py | 74 ++++++++++++++++------ 1 file changed, 54 insertions(+), 20 deletions(-) diff --git a/lldb/examples/python/disasm-stress-test.py b/lldb/examples/python/disasm-stress-test.py index 004c656fbbd4..78317933da3b 100755 --- a/lldb/examples/python/disasm-stress-test.py +++ b/lldb/examples/python/disasm-stress-test.py @@ -1,8 +1,6 @@ #!/usr/bin/python -import argparse, re, subprocess, sys - -#-- This code fragment loads LLDB -- +import argparse, datetime, re, subprocess, sys, time def AddLLDBToSysPathOnMacOSX(): def GetLLDBFrameworkPath(): @@ -25,8 +23,6 @@ AddLLDBToSysPathOnMacOSX() import lldb -#-- End of code fragment that loads LLDB -- - parser = argparse.ArgumentParser(description="Run an exhaustive test of the LLDB disassembler for a specific architecture.") parser.add_argument('--arch', required=True, action='store', help='The architecture whose disassembler is to be tested') @@ -34,6 +30,8 @@ parser.add_argument('--bytes', required=True, action='store', type=int, help='Th parser.add_argument('--random', required=False, action='store_true', help='Enables non-sequential testing') parser.add_argument('--start', required=False, action='store', type=int, help='The first instruction value to test') parser.add_argument('--skip', required=False, action='store', type=int, help='The interval between instructions to test') +parser.add_argument('--log', required=False, action='store', help='A log file to write the most recent instruction being tested') +parser.add_argument('--time', required=False, action='store_true', help='Every 100,000 instructions, print an ETA to standard out') arguments = sys.argv[1:] @@ -51,24 +49,39 @@ if target.IsValid() == False: print "Couldn't create an SBTarget for architecture " + arg_ns.arch sys.exit(-1) +def ResetLogFile(log_file): + if log_file != sys.stdout: + log_file.seek(0) + log_file.truncate(0) + +def PrintByteArray(log_file, byte_array): + for byte in byte_array: + print >>log_file, hex(byte) + " ", + print >>log_file + class SequentialInstructionProvider: - def __init__(self, byte_width, start=0, skip=1): + def __init__(self, byte_width, log_file, start=0, skip=1): self.m_byte_width = byte_width + self.m_log_file = log_file self.m_start = start self.m_skip = skip self.m_value = start self.m_last = (1 << (byte_width * 8)) - 1 + def PrintCurrentState(self, ret): + ResetLogFile(self.m_log_file) + print >>self.m_log_file, self.m_value + PrintByteArray(self.m_log_file, ret) def GetNextInstruction(self): - # Print current state - print self.m_value - # Done printing current state if self.m_value > self.m_last: return None ret = bytearray(self.m_byte_width) for i in range(self.m_byte_width): ret[self.m_byte_width - (i + 1)] = (self.m_value >> (i * 8)) & 255 + self.PrintCurrentState(ret) self.m_value += self.m_skip return ret + def GetNumInstructions(self): + return self.m_last / self.m_skip def __iter__(self): return self def next(self): @@ -78,18 +91,18 @@ class SequentialInstructionProvider: return ret class RandomInstructionProvider: - def __init__(self, byte_width): + def __init__(self, byte_width, log_file): self.m_byte_width = byte_width + self.m_log_file = log_file self.m_random_file = open("/dev/random", 'r') + def PrintCurrentState(self, ret): + ResetLogFile(self.m_log_file) + PrintByteArray(self.m_log_file, ret) def GetNextInstruction(self): ret = bytearray(self.m_byte_width) for i in range(self.m_byte_width): ret[i] = self.m_random_file.read(1) - # Print current state - for ret_byte in ret: - print hex(ret_byte) + " ", - print - # Done printing current state + self.PrintCurrentState(ret) return ret def __iter__(self): return self @@ -99,10 +112,17 @@ class RandomInstructionProvider: raise StopIteration return ret +log_file = None + def GetProviderWithArguments(args): + global log_file + if args.log != None: + log_file = open(args.log, 'w') + else: + log_file = sys.stdout instruction_provider = None if args.random == True: - instruction_provider = RandomInstructionProvider(args.bytes) + instruction_provider = RandomInstructionProvider(args.bytes, log_file) else: start = 0 skip = 1 @@ -110,22 +130,36 @@ def GetProviderWithArguments(args): start = args.start if args.skip != None: skip = args.skip - instruction_provider = SequentialInstructionProvider(args.bytes, start, skip) + instruction_provider = SequentialInstructionProvider(args.bytes, log_file, start, skip) return instruction_provider instruction_provider = GetProviderWithArguments(arg_ns) fake_address = lldb.SBAddress() +actually_time = arg_ns.time and not arg_ns.random + +if actually_time: + num_instructions_logged = 0 + total_num_instructions = instruction_provider.GetNumInstructions() + start_time = time.time() + for inst_bytes in instruction_provider: + if actually_time: + if (num_instructions_logged != 0) and (num_instructions_logged % 100000 == 0): + curr_time = time.time() + elapsed_time = curr_time - start_time + remaining_time = float(total_num_instructions - num_instructions_logged) * (float(elapsed_time) / float(num_instructions_logged)) + print str(datetime.timedelta(seconds=remaining_time)) + num_instructions_logged = num_instructions_logged + 1 inst_list = target.GetInstructions(fake_address, inst_bytes) if not inst_list.IsValid(): - print "Invalid instruction list" + print >>log_file, "Invalid instruction list" continue inst = inst_list.GetInstructionAtIndex(0) if not inst.IsValid(): - print "Invalid instruction" + print >>log_file, "Invalid instruction" continue instr_output_stream = lldb.SBStream() inst.GetDescription(instr_output_stream) - print instr_output_stream.GetData() + print >>log_file, instr_output_stream.GetData()