def run(self, tests):
targets = list([test.full_path() for test in tests])
+
+ parser = argparse.ArgumentParser()
+ parser.add_argument('-j', type=int, default=0)
+ args, leftovers = parser.parse_known_args(self.args)
+ if args.j == 0:
+ self.args = ('-j', str(self.main_args.j)) + self.args
+
scons_args = [ 'USE_SYSTEMC=1' ] + list(self.args) + targets
scons(*scons_args)
def run(self, tests):
parser = argparse.ArgumentParser()
parser.add_argument('--timeout', type=int, metavar='SECONDS',
- help='Time limit for each run in seconds.',
- default=0)
- parser.add_argument('-j', type=int, default=1,
+ help='Time limit for each run in seconds, '
+ '0 to disable.',
+ default=60)
+ parser.add_argument('-j', type=int, default=0,
help='How many tests to run in parallel.')
args = parser.parse_args(self.args)
cmd.extend(timeout_cmd)
cmd.extend([
test.full_path(),
- '-red', os.path.abspath(test.m5out_dir()),
+ '-rd', os.path.abspath(test.m5out_dir()),
'--listener-mode=off',
'--quiet',
config_path,
with open(test.returncode_file(), 'w') as rc:
rc.write('%d\n' % returncode)
+ j = self.main_args.j if args.j == 0 else args.j
+
runnable = filter(lambda t: not t.compile_only, tests)
- if args.j == 1:
+ if j == 1:
map(run_test, runnable)
else:
- tp = multiprocessing.pool.ThreadPool(args.j)
+ tp = multiprocessing.pool.ThreadPool(j)
map(lambda t: tp.apply_async(run_test, (t,)), runnable)
tp.close()
tp.join()
self.tag = tag
def check(self):
- with open(self.text) as test_f, open(self.ref) as ref_f:
+ with open(self.test) as test_f, open(self.ref) as ref_f:
return test_f.read() == ref_f.read()
def tagged_filt(tag, num):
- return (r'^\n{}: \({}{}\) .*\n(In file: .*\n)?'
+ return (r'\n{}: \({}{}\) .*\n(In file: .*\n)?'
r'(In process: [\w.]* @ .*\n)?').format(tag, tag[0], num)
def error_filt(num):
def info_filt(num):
return tagged_filt('Info', num)
-class LogChecker(Checker):
+class DiffingChecker(Checker):
+ def __init__(self, ref, test, tag, out_dir):
+ super(DiffingChecker, self).__init__(ref, test, tag)
+ self.out_dir = out_dir
+
+ def diffing_check(self, ref_lines, test_lines):
+ test_file = os.path.basename(self.test)
+ ref_file = os.path.basename(self.ref)
+
+ diff_file = '.'.join([ref_file, 'diff'])
+ diff_path = os.path.join(self.out_dir, diff_file)
+ if test_lines != ref_lines:
+ with open(diff_path, 'w') as diff_f:
+ for line in difflib.unified_diff(
+ ref_lines, test_lines,
+ fromfile=ref_file,
+ tofile=test_file):
+ diff_f.write(line)
+ return False
+ else:
+ if os.path.exists(diff_path):
+ os.unlink(diff_path)
+ return True
+
+class LogChecker(DiffingChecker):
def merge_filts(*filts):
filts = map(lambda f: '(' + f + ')', filts)
filts = '|'.join(filts)
return re.compile(filts, flags=re.MULTILINE)
+ # The reporting mechanism will print the actual filename when running in
+ # gem5, and the "golden" output will say "<removed by verify.py>". We want
+ # to strip out both versions to make comparing the output sensible.
+ in_file_filt = r'^In file: ((<removed by verify\.pl>)|([a-zA-Z0-9.:_/]*))$'
+
ref_filt = merge_filts(
r'^\nInfo: /OSCI/SystemC: Simulation stopped by user.\n',
r'^SystemC Simulation\n',
r'^\nInfo: \(I804\) /IEEE_Std_1666/deprecated: \n' +
r' sc_clock\(const char(.*\n){3}',
warning_filt(540),
- warning_filt(569),
warning_filt(571),
- error_filt(541),
- error_filt(542),
- error_filt(543),
info_filt(804),
+ in_file_filt,
)
test_filt = merge_filts(
r'^Global frequency set at \d* ticks per second\n',
+ r'^info: Entering event queue @ \d*\. Starting simulation\.\.\.\n',
+ r'warn: [^(]+\([^)]*\)( \[with [^]]*\])? not implemented\.\n',
+ r'warn: Ignoring request to set stack size\.\n',
info_filt(804),
+ in_file_filt,
)
- def __init__(self, ref, test, tag, out_dir):
- super(LogChecker, self).__init__(ref, test, tag)
- self.out_dir = out_dir
-
def apply_filters(self, data, filts):
re.sub(filt, '', data)
def check(self):
- test_file = os.path.basename(self.test)
- ref_file = os.path.basename(self.ref)
with open(self.test) as test_f, open(self.ref) as ref_f:
test = re.sub(self.test_filt, '', test_f.read())
ref = re.sub(self.ref_filt, '', ref_f.read())
- diff_file = '.'.join([ref_file, 'diff'])
- diff_path = os.path.join(self.out_dir, diff_file)
- if test != ref:
- with open(diff_path, 'w') as diff_f:
- for line in difflib.unified_diff(
- ref.splitlines(True), test.splitlines(True),
- fromfile=ref_file,
- tofile=test_file):
- diff_f.write(line)
- return False
- else:
- if os.path.exists(diff_path):
- os.unlink(diff_path)
- return True
+ return self.diffing_check(ref.splitlines(True),
+ test.splitlines(True))
+
+class VcdChecker(DiffingChecker):
+ def check(self):
+ with open (self.test) as test_f, open(self.ref) as ref_f:
+ ref = ref_f.read().splitlines(True)
+ test = test_f.read().splitlines(True)
+ # Strip off the first seven lines of the test output which are
+ # date and version information.
+ test = test[7:]
+
+ return self.diffing_check(ref, test)
class GoldenDir(object):
def __init__(self, path, platform):
help='Create a results.json file in the current directory.')
result_opts.add_argument('--result-file-at', metavar='PATH',
help='Create a results json file at the given path.')
- parser.add_argument('--print-results', action='store_true',
- help='Print a list of tests that passed or failed')
+ parser.add_argument('--no-print-results', action='store_true',
+ help='Don\'t print a list of tests that passed or failed')
args = parser.parse_args(self.args)
self.reset_status()
ref_path = gd.entry(name)
if not os.path.exists(test_path):
missing.append(name)
+ elif name.endswith('.vcd'):
+ diffs.append(VcdChecker(ref_path, test_path,
+ name, out_dir))
else:
diffs.append(Checker(ref_path, test_path, name))
self.passed(test)
- if args.print_results:
+ if not args.no_print_results:
self.print_results()
self.print_status()
parser.add_argument('--list', action='store_true',
help='List the available tests')
+parser.add_argument('-j', type=int, default=1,
+ help='Default level of parallelism, can be overriden '
+ 'for individual stages')
+
filter_opts = parser.add_mutually_exclusive_group()
filter_opts.add_argument('--filter', default='True',
help='Python expression which filters tests based '