| Configuration | " >> results.txt - for r in Code Stack Structs Coverage - do - echo "$r | " >> results.txt - done - echo "|
|---|---|---|
| ${c_or_default^} | " >> results.txt - for r in code stack structs + c_camel=${c_or_default^} + table[$i,$j]=$c_camel + ((j+=1)) + + for s in code stack struct do - # per-config results - echo "" >> results.txt
- [ -e results/thumb${c:+-$c}.csv ] && ( \
+ f=sizes/thumb${c:+-$c}.$s.csv
+ [ -e $f ] && table[$i,$j]=$( \
export PREV="$(jq -re '
- select(.context == "'"results (thumb${c:+, $c}) / $r"'").description
- | capture("(? | " >> results.txt
+ select(.context == "'"sizes (thumb${c:+, $c}) / $s"'").description
+ | capture("(?" >> results.txt
- [ -e results/coverage.csv ] && ( \
- export PREV="$(jq -re '
- select(.context == "results / coverage").description
- | capture("(? | " >> results.txt
- fi
- echo "
code\s*=)',
+ line)
+ if match and match.group('case'):
+ case_linenos.append((i+1, match.group('name')))
+ elif match and match.group('code'):
+ code_linenos.append(i+2)
+
+ # sort in case toml parsing did not retain order
+ case_linenos.sort()
+
+ cases = config.pop('cases')
+ for (lineno, name), (nlineno, _) in it.zip_longest(
+ case_linenos, case_linenos[1:],
+ fillvalue=(float('inf'), None)):
+ code_lineno = min(
+ (l for l in code_linenos if l >= lineno and l < nlineno),
+ default=None)
+ cases[name]['lineno'] = lineno
+ cases[name]['code_lineno'] = code_lineno
+
+ self.if_ = config.pop('if', None)
+ if isinstance(self.if_, bool):
+ self.if_ = 'true' if self.if_ else 'false'
+
+ self.code = config.pop('code', None)
+ self.code_lineno = min(
+ (l for l in code_linenos
+ if not case_linenos or l < case_linenos[0][0]),
+ default=None)
+
+ # a couple of these we just forward to all cases
+ defines = config.pop('defines', {})
+ in_ = config.pop('in', None)
+
+ self.cases = []
+ for name, case in sorted(cases.items(),
+ key=lambda c: c[1].get('lineno')):
+ self.cases.append(BenchCase(config={
+ 'name': name,
+ 'path': path + (':%d' % case['lineno']
+ if 'lineno' in case else ''),
+ 'suite': self.name,
+ 'suite_defines': defines,
+ 'suite_in': in_,
+ **case},
+ args=args))
+
+ # combine per-case defines
+ self.defines = set.union(*(
+ set(case.defines) for case in self.cases))
+
+ for k in config.keys():
+ print('%swarning:%s in %s, found unused key %r' % (
+ '\x1b[01;33m' if args['color'] else '',
+ '\x1b[m' if args['color'] else '',
+ self.name,
+ k),
+ file=sys.stderr)
+
+
+
+def compile(bench_paths, **args):
+ # find .toml files
+ paths = []
+ for path in bench_paths:
+ if os.path.isdir(path):
+ path = path + '/*.toml'
+
+ for path in glob.glob(path):
+ paths.append(path)
+
+ if not paths:
+ print('no bench suites found in %r?' % bench_paths)
+ sys.exit(-1)
+
+ # load the suites
+ suites = [BenchSuite(path, args) for path in paths]
+ suites.sort(key=lambda s: s.name)
+
+ # check for name conflicts, these will cause ambiguity problems later
+ # when running benches
+ seen = {}
+ for suite in suites:
+ if suite.name in seen:
+ print('%swarning:%s conflicting suite %r, %s and %s' % (
+ '\x1b[01;33m' if args['color'] else '',
+ '\x1b[m' if args['color'] else '',
+ suite.name,
+ suite.path,
+ seen[suite.name].path),
+ file=sys.stderr)
+ seen[suite.name] = suite
+
+ for case in suite.cases:
+ # only allow conflicts if a case and its suite share a name
+ if case.name in seen and not (
+ isinstance(seen[case.name], BenchSuite)
+ and seen[case.name].cases == [case]):
+ print('%swarning:%s conflicting case %r, %s and %s' % (
+ '\x1b[01;33m' if args['color'] else '',
+ '\x1b[m' if args['color'] else '',
+ case.name,
+ case.path,
+ seen[case.name].path),
+ file=sys.stderr)
+ seen[case.name] = case
+
+ # we can only compile one bench suite at a time
+ if not args.get('source'):
+ if len(suites) > 1:
+ print('more than one bench suite for compilation? (%r)' % bench_paths)
+ sys.exit(-1)
+
+ suite = suites[0]
+
+ # write generated bench source
+ if 'output' in args:
+ with openio(args['output'], 'w') as f:
+ _write = f.write
+ def write(s):
+ f.lineno += s.count('\n')
+ _write(s)
+ def writeln(s=''):
+ f.lineno += s.count('\n') + 1
+ _write(s)
+ _write('\n')
+ f.lineno = 1
+ f.write = write
+ f.writeln = writeln
+
+ f.writeln("// Generated by %s:" % sys.argv[0])
+ f.writeln("//")
+ f.writeln("// %s" % ' '.join(sys.argv))
+ f.writeln("//")
+ f.writeln()
+
+ # include bench_runner.h in every generated file
+ f.writeln("#include \"%s\"" % args['include'])
+ f.writeln()
+
+ # write out generated functions, this can end up in different
+ # files depending on the "in" attribute
+ #
+ # note it's up to the specific generated file to declare
+ # the bench defines
+ def write_case_functions(f, suite, case):
+ # create case define functions
+ if case.defines:
+ # deduplicate defines by value to try to reduce the
+ # number of functions we generate
+ define_cbs = {}
+ for i, defines in enumerate(case.permutations):
+ for k, v in sorted(defines.items()):
+ if v not in define_cbs:
+ name = ('__bench__%s__%s__%d'
+ % (case.name, k, i))
+ define_cbs[v] = name
+ f.writeln('intmax_t %s('
+ '__attribute__((unused)) '
+ 'void *data) {' % name)
+ f.writeln(4*' '+'return %s;' % v)
+ f.writeln('}')
+ f.writeln()
+ f.writeln('const bench_define_t '
+ '__bench__%s__defines[]['
+ 'BENCH_IMPLICIT_DEFINE_COUNT+%d] = {'
+ % (case.name, len(suite.defines)))
+ for defines in case.permutations:
+ f.writeln(4*' '+'{')
+ for k, v in sorted(defines.items()):
+ f.writeln(8*' '+'[%-24s] = {%s, NULL},' % (
+ k+'_i', define_cbs[v]))
+ f.writeln(4*' '+'},')
+ f.writeln('};')
+ f.writeln()
+
+ # create case filter function
+ if suite.if_ is not None or case.if_ is not None:
+ f.writeln('bool __bench__%s__filter(void) {'
+ % (case.name))
+ f.writeln(4*' '+'return %s;'
+ % ' && '.join('(%s)' % if_
+ for if_ in [suite.if_, case.if_]
+ if if_ is not None))
+ f.writeln('}')
+ f.writeln()
+
+ # create case run function
+ f.writeln('void __bench__%s__run('
+ '__attribute__((unused)) struct lfs_config *cfg) {'
+ % (case.name))
+ f.writeln(4*' '+'// bench case %s' % case.name)
+ if case.code_lineno is not None:
+ f.writeln(4*' '+'#line %d "%s"'
+ % (case.code_lineno, suite.path))
+ f.write(case.code)
+ if case.code_lineno is not None:
+ f.writeln(4*' '+'#line %d "%s"'
+ % (f.lineno+1, args['output']))
+ f.writeln('}')
+ f.writeln()
+
+ if not args.get('source'):
+ if suite.code is not None:
+ if suite.code_lineno is not None:
+ f.writeln('#line %d "%s"'
+ % (suite.code_lineno, suite.path))
+ f.write(suite.code)
+ if suite.code_lineno is not None:
+ f.writeln('#line %d "%s"'
+ % (f.lineno+1, args['output']))
+ f.writeln()
+
+ if suite.defines:
+ for i, define in enumerate(sorted(suite.defines)):
+ f.writeln('#ifndef %s' % define)
+ f.writeln('#define %-24s '
+ 'BENCH_IMPLICIT_DEFINE_COUNT+%d' % (define+'_i', i))
+ f.writeln('#define %-24s '
+ 'BENCH_DEFINE(%s)' % (define, define+'_i'))
+ f.writeln('#endif')
+ f.writeln()
+
+ # create case functions
+ for case in suite.cases:
+ if case.in_ is None:
+ write_case_functions(f, suite, case)
+ else:
+ if case.defines:
+ f.writeln('extern const bench_define_t '
+ '__bench__%s__defines[]['
+ 'BENCH_IMPLICIT_DEFINE_COUNT+%d];'
+ % (case.name, len(suite.defines)))
+ if suite.if_ is not None or case.if_ is not None:
+ f.writeln('extern bool __bench__%s__filter('
+ 'void);'
+ % (case.name))
+ f.writeln('extern void __bench__%s__run('
+ 'struct lfs_config *cfg);'
+ % (case.name))
+ f.writeln()
+
+ # create suite struct
+ #
+ # note we place this in the custom bench_suites section with
+ # minimum alignment, otherwise GCC ups the alignment to
+ # 32-bytes for some reason
+ f.writeln('__attribute__((section("_bench_suites"), '
+ 'aligned(1)))')
+ f.writeln('const struct bench_suite __bench__%s__suite = {'
+ % suite.name)
+ f.writeln(4*' '+'.name = "%s",' % suite.name)
+ f.writeln(4*' '+'.path = "%s",' % suite.path)
+ f.writeln(4*' '+'.flags = 0,')
+ if suite.defines:
+ # create suite define names
+ f.writeln(4*' '+'.define_names = (const char *const['
+ 'BENCH_IMPLICIT_DEFINE_COUNT+%d]){' % (
+ len(suite.defines)))
+ for k in sorted(suite.defines):
+ f.writeln(8*' '+'[%-24s] = "%s",' % (k+'_i', k))
+ f.writeln(4*' '+'},')
+ f.writeln(4*' '+'.define_count = '
+ 'BENCH_IMPLICIT_DEFINE_COUNT+%d,' % len(suite.defines))
+ f.writeln(4*' '+'.cases = (const struct bench_case[]){')
+ for case in suite.cases:
+ # create case structs
+ f.writeln(8*' '+'{')
+ f.writeln(12*' '+'.name = "%s",' % case.name)
+ f.writeln(12*' '+'.path = "%s",' % case.path)
+ f.writeln(12*' '+'.flags = 0,')
+ f.writeln(12*' '+'.permutations = %d,'
+ % len(case.permutations))
+ if case.defines:
+ f.writeln(12*' '+'.defines '
+ '= (const bench_define_t*)__bench__%s__defines,'
+ % (case.name))
+ if suite.if_ is not None or case.if_ is not None:
+ f.writeln(12*' '+'.filter = __bench__%s__filter,'
+ % (case.name))
+ f.writeln(12*' '+'.run = __bench__%s__run,'
+ % (case.name))
+ f.writeln(8*' '+'},')
+ f.writeln(4*' '+'},')
+ f.writeln(4*' '+'.case_count = %d,' % len(suite.cases))
+ f.writeln('};')
+ f.writeln()
+
+ else:
+ # copy source
+ f.writeln('#line 1 "%s"' % args['source'])
+ with open(args['source']) as sf:
+ shutil.copyfileobj(sf, f)
+ f.writeln()
+
+ # write any internal benches
+ for suite in suites:
+ for case in suite.cases:
+ if (case.in_ is not None
+ and os.path.normpath(case.in_)
+ == os.path.normpath(args['source'])):
+ # write defines, but note we need to undef any
+ # new defines since we're in someone else's file
+ if suite.defines:
+ for i, define in enumerate(
+ sorted(suite.defines)):
+ f.writeln('#ifndef %s' % define)
+ f.writeln('#define %-24s '
+ 'BENCH_IMPLICIT_DEFINE_COUNT+%d' % (
+ define+'_i', i))
+ f.writeln('#define %-24s '
+ 'BENCH_DEFINE(%s)' % (
+ define, define+'_i'))
+ f.writeln('#define '
+ '__BENCH__%s__NEEDS_UNDEF' % (
+ define))
+ f.writeln('#endif')
+ f.writeln()
+
+ write_case_functions(f, suite, case)
+
+ if suite.defines:
+ for define in sorted(suite.defines):
+ f.writeln('#ifdef __BENCH__%s__NEEDS_UNDEF'
+ % define)
+ f.writeln('#undef __BENCH__%s__NEEDS_UNDEF'
+ % define)
+ f.writeln('#undef %s' % define)
+ f.writeln('#undef %s' % (define+'_i'))
+ f.writeln('#endif')
+ f.writeln()
+
+def find_runner(runner, **args):
+ cmd = runner.copy()
+
+ # run under some external command?
+ if args.get('exec'):
+ cmd[:0] = args['exec']
+
+ # run under valgrind?
+ if args.get('valgrind'):
+ cmd[:0] = args['valgrind_path'] + [
+ '--leak-check=full',
+ '--track-origins=yes',
+ '--error-exitcode=4',
+ '-q']
+
+ # run under perf?
+ if args.get('perf'):
+ cmd[:0] = args['perf_script'] + list(filter(None, [
+ '-R',
+ '--perf-freq=%s' % args['perf_freq']
+ if args.get('perf_freq') else None,
+ '--perf-period=%s' % args['perf_period']
+ if args.get('perf_period') else None,
+ '--perf-events=%s' % args['perf_events']
+ if args.get('perf_events') else None,
+ '--perf-path=%s' % args['perf_path']
+ if args.get('perf_path') else None,
+ '-o%s' % args['perf']]))
+
+ # other context
+ if args.get('geometry'):
+ cmd.append('-G%s' % args['geometry'])
+ if args.get('disk'):
+ cmd.append('-d%s' % args['disk'])
+ if args.get('trace'):
+ cmd.append('-t%s' % args['trace'])
+ if args.get('trace_backtrace'):
+ cmd.append('--trace-backtrace')
+ if args.get('trace_period'):
+ cmd.append('--trace-period=%s' % args['trace_period'])
+ if args.get('trace_freq'):
+ cmd.append('--trace-freq=%s' % args['trace_freq'])
+ if args.get('read_sleep'):
+ cmd.append('--read-sleep=%s' % args['read_sleep'])
+ if args.get('prog_sleep'):
+ cmd.append('--prog-sleep=%s' % args['prog_sleep'])
+ if args.get('erase_sleep'):
+ cmd.append('--erase-sleep=%s' % args['erase_sleep'])
+
+ # defines?
+ if args.get('define'):
+ for define in args.get('define'):
+ cmd.append('-D%s' % define)
+
+ return cmd
+
+def list_(runner, bench_ids=[], **args):
+ cmd = find_runner(runner, **args) + bench_ids
+ if args.get('summary'): cmd.append('--summary')
+ if args.get('list_suites'): cmd.append('--list-suites')
+ if args.get('list_cases'): cmd.append('--list-cases')
+ if args.get('list_suite_paths'): cmd.append('--list-suite-paths')
+ if args.get('list_case_paths'): cmd.append('--list-case-paths')
+ if args.get('list_defines'): cmd.append('--list-defines')
+ if args.get('list_permutation_defines'):
+ cmd.append('--list-permutation-defines')
+ if args.get('list_implicit_defines'):
+ cmd.append('--list-implicit-defines')
+ if args.get('list_geometries'): cmd.append('--list-geometries')
+
+ if args.get('verbose'):
+ print(' '.join(shlex.quote(c) for c in cmd))
+ return sp.call(cmd)
+
+
+def find_perms(runner_, ids=[], **args):
+ case_suites = {}
+ expected_case_perms = co.defaultdict(lambda: 0)
+ expected_perms = 0
+ total_perms = 0
+
+ # query cases from the runner
+ cmd = runner_ + ['--list-cases'] + ids
+ if args.get('verbose'):
+ print(' '.join(shlex.quote(c) for c in cmd))
+ proc = sp.Popen(cmd,
+ stdout=sp.PIPE,
+ stderr=sp.PIPE if not args.get('verbose') else None,
+ universal_newlines=True,
+ errors='replace',
+ close_fds=False)
+ pattern = re.compile(
+ '^(?P[^\s]+)'
+ '\s+(?P[^\s]+)'
+ '\s+(?P\d+)/(?P\d+)')
+ # skip the first line
+ for line in it.islice(proc.stdout, 1, None):
+ m = pattern.match(line)
+ if m:
+ filtered = int(m.group('filtered'))
+ perms = int(m.group('perms'))
+ expected_case_perms[m.group('case')] += filtered
+ expected_perms += filtered
+ total_perms += perms
+ proc.wait()
+ if proc.returncode != 0:
+ if not args.get('verbose'):
+ for line in proc.stderr:
+ sys.stdout.write(line)
+ sys.exit(-1)
+
+ # get which suite each case belongs to via paths
+ cmd = runner_ + ['--list-case-paths'] + ids
+ if args.get('verbose'):
+ print(' '.join(shlex.quote(c) for c in cmd))
+ proc = sp.Popen(cmd,
+ stdout=sp.PIPE,
+ stderr=sp.PIPE if not args.get('verbose') else None,
+ universal_newlines=True,
+ errors='replace',
+ close_fds=False)
+ pattern = re.compile(
+ '^(?P[^\s]+)'
+ '\s+(?P[^:]+):(?P\d+)')
+ # skip the first line
+ for line in it.islice(proc.stdout, 1, None):
+ m = pattern.match(line)
+ if m:
+ path = m.group('path')
+ # strip path/suffix here
+ suite = os.path.basename(path)
+ if suite.endswith('.toml'):
+ suite = suite[:-len('.toml')]
+ case_suites[m.group('case')] = suite
+ proc.wait()
+ if proc.returncode != 0:
+ if not args.get('verbose'):
+ for line in proc.stderr:
+ sys.stdout.write(line)
+ sys.exit(-1)
+
+ # figure out expected suite perms
+ expected_suite_perms = co.defaultdict(lambda: 0)
+ for case, suite in case_suites.items():
+ expected_suite_perms[suite] += expected_case_perms[case]
+
+ return (
+ case_suites,
+ expected_suite_perms,
+ expected_case_perms,
+ expected_perms,
+ total_perms)
+
+def find_path(runner_, id, **args):
+ path = None
+ # query from runner
+ cmd = runner_ + ['--list-case-paths', id]
+ if args.get('verbose'):
+ print(' '.join(shlex.quote(c) for c in cmd))
+ proc = sp.Popen(cmd,
+ stdout=sp.PIPE,
+ stderr=sp.PIPE if not args.get('verbose') else None,
+ universal_newlines=True,
+ errors='replace',
+ close_fds=False)
+ pattern = re.compile(
+ '^(?P[^\s]+)'
+ '\s+(?P[^:]+):(?P\d+)')
+ # skip the first line
+ for line in it.islice(proc.stdout, 1, None):
+ m = pattern.match(line)
+ if m and path is None:
+ path_ = m.group('path')
+ lineno = int(m.group('lineno'))
+ path = (path_, lineno)
+ proc.wait()
+ if proc.returncode != 0:
+ if not args.get('verbose'):
+ for line in proc.stderr:
+ sys.stdout.write(line)
+ sys.exit(-1)
+
+ return path
+
+def find_defines(runner_, id, **args):
+ # query permutation defines from runner
+ cmd = runner_ + ['--list-permutation-defines', id]
+ if args.get('verbose'):
+ print(' '.join(shlex.quote(c) for c in cmd))
+ proc = sp.Popen(cmd,
+ stdout=sp.PIPE,
+ stderr=sp.PIPE if not args.get('verbose') else None,
+ universal_newlines=True,
+ errors='replace',
+ close_fds=False)
+ defines = co.OrderedDict()
+ pattern = re.compile('^(?P\w+)=(?P.+)')
+ for line in proc.stdout:
+ m = pattern.match(line)
+ if m:
+ define = m.group('define')
+ value = m.group('value')
+ defines[define] = value
+ proc.wait()
+ if proc.returncode != 0:
+ if not args.get('verbose'):
+ for line in proc.stderr:
+ sys.stdout.write(line)
+ sys.exit(-1)
+
+ return defines
+
+
+# Thread-safe CSV writer
+class BenchOutput:
+ def __init__(self, path, head=None, tail=None):
+ self.f = openio(path, 'w+', 1)
+ self.lock = th.Lock()
+ self.head = head or []
+ self.tail = tail or []
+ self.writer = csv.DictWriter(self.f, self.head + self.tail)
+ self.rows = []
+
+ def close(self):
+ self.f.close()
+
+ def __enter__(self):
+ return self
+
+ def __exit__(self, *_):
+ self.f.close()
+
+ def writerow(self, row):
+ with self.lock:
+ self.rows.append(row)
+ if all(k in self.head or k in self.tail for k in row.keys()):
+ # can simply append
+ self.writer.writerow(row)
+ else:
+ # need to rewrite the file
+ self.head.extend(row.keys() - (self.head + self.tail))
+ self.f.seek(0)
+ self.f.truncate()
+ self.writer = csv.DictWriter(self.f, self.head + self.tail)
+ self.writer.writeheader()
+ for row in self.rows:
+ self.writer.writerow(row)
+
+# A bench failure
+class BenchFailure(Exception):
+ def __init__(self, id, returncode, stdout, assert_=None):
+ self.id = id
+ self.returncode = returncode
+ self.stdout = stdout
+ self.assert_ = assert_
+
+def run_stage(name, runner_, ids, stdout_, trace_, output_, **args):
+ # get expected suite/case/perm counts
+ (case_suites,
+ expected_suite_perms,
+ expected_case_perms,
+ expected_perms,
+ total_perms) = find_perms(runner_, ids, **args)
+
+ passed_suite_perms = co.defaultdict(lambda: 0)
+ passed_case_perms = co.defaultdict(lambda: 0)
+ passed_perms = 0
+ readed = 0
+ proged = 0
+ erased = 0
+ failures = []
+ killed = False
+
+ pattern = re.compile('^(?:'
+ '(?Prunning|finished|skipped|powerloss)'
+ ' (?P(?P[^:]+)[^\s]*)'
+ '(?: (?P\d+))?'
+ '(?: (?P\d+))?'
+ '(?: (?P\d+))?'
+ '|' '(?P[^:]+):(?P\d+):(?Passert):'
+ ' *(?P.*)'
+ ')$')
+ locals = th.local()
+ children = set()
+
+ def run_runner(runner_, ids=[]):
+ nonlocal passed_suite_perms
+ nonlocal passed_case_perms
+ nonlocal passed_perms
+ nonlocal readed
+ nonlocal proged
+ nonlocal erased
+ nonlocal locals
+
+ # run the benches!
+ cmd = runner_ + ids
+ if args.get('verbose'):
+ print(' '.join(shlex.quote(c) for c in cmd))
+
+ mpty, spty = pty.openpty()
+ proc = sp.Popen(cmd, stdout=spty, stderr=spty, close_fds=False)
+ os.close(spty)
+ children.add(proc)
+ mpty = os.fdopen(mpty, 'r', 1)
+
+ last_id = None
+ last_stdout = co.deque(maxlen=args.get('context', 5) + 1)
+ last_assert = None
+ try:
+ while True:
+ # parse a line for state changes
+ try:
+ line = mpty.readline()
+ except OSError as e:
+ if e.errno != errno.EIO:
+ raise
+ break
+ if not line:
+ break
+ last_stdout.append(line)
+ if stdout_:
+ try:
+ stdout_.write(line)
+ stdout_.flush()
+ except BrokenPipeError:
+ pass
+
+ m = pattern.match(line)
+ if m:
+ op = m.group('op') or m.group('op_')
+ if op == 'running':
+ locals.seen_perms += 1
+ last_id = m.group('id')
+ last_stdout.clear()
+ last_assert = None
+ elif op == 'finished':
+ case = m.group('case')
+ suite = case_suites[case]
+ readed_ = int(m.group('readed'))
+ proged_ = int(m.group('proged'))
+ erased_ = int(m.group('erased'))
+ passed_suite_perms[suite] += 1
+ passed_case_perms[case] += 1
+ passed_perms += 1
+ readed += readed_
+ proged += proged_
+ erased += erased_
+ if output_:
+ # get defines and write to csv
+ defines = find_defines(
+ runner_, m.group('id'), **args)
+ output_.writerow({
+ 'suite': suite,
+ 'case': case,
+ 'bench_readed': readed_,
+ 'bench_proged': proged_,
+ 'bench_erased': erased_,
+ **defines})
+ elif op == 'skipped':
+ locals.seen_perms += 1
+ elif op == 'assert':
+ last_assert = (
+ m.group('path'),
+ int(m.group('lineno')),
+ m.group('message'))
+ # go ahead and kill the process, aborting takes a while
+ if args.get('keep_going'):
+ proc.kill()
+ except KeyboardInterrupt:
+ raise BenchFailure(last_id, 1, list(last_stdout))
+ finally:
+ children.remove(proc)
+ mpty.close()
+
+ proc.wait()
+ if proc.returncode != 0:
+ raise BenchFailure(
+ last_id,
+ proc.returncode,
+ list(last_stdout),
+ last_assert)
+
+ def run_job(runner_, ids=[], start=None, step=None):
+ nonlocal failures
+ nonlocal killed
+ nonlocal locals
+
+ start = start or 0
+ step = step or 1
+ while start < total_perms:
+ job_runner = runner_.copy()
+ if args.get('isolate') or args.get('valgrind'):
+ job_runner.append('-s%s,%s,%s' % (start, start+step, step))
+ else:
+ job_runner.append('-s%s,,%s' % (start, step))
+
+ try:
+ # run the benches
+ locals.seen_perms = 0
+ run_runner(job_runner, ids)
+ assert locals.seen_perms > 0
+ start += locals.seen_perms*step
+
+ except BenchFailure as failure:
+ # keep track of failures
+ if output_:
+ case, _ = failure.id.split(':', 1)
+ suite = case_suites[case]
+ # get defines and write to csv
+ defines = find_defines(runner_, failure.id, **args)
+ output_.writerow({
+ 'suite': suite,
+ 'case': case,
+ **defines})
+
+ # race condition for multiple failures?
+ if failures and not args.get('keep_going'):
+ break
+
+ failures.append(failure)
+
+ if args.get('keep_going') and not killed:
+ # resume after failed bench
+ assert locals.seen_perms > 0
+ start += locals.seen_perms*step
+ continue
+ else:
+ # stop other benches
+ killed = True
+ for child in children.copy():
+ child.kill()
+ break
+
+
+ # parallel jobs?
+ runners = []
+ if 'jobs' in args:
+ for job in range(args['jobs']):
+ runners.append(th.Thread(
+ target=run_job, args=(runner_, ids, job, args['jobs']),
+ daemon=True))
+ else:
+ runners.append(th.Thread(
+ target=run_job, args=(runner_, ids, None, None),
+ daemon=True))
+
+ def print_update(done):
+ if not args.get('verbose') and (args['color'] or done):
+ sys.stdout.write('%s%srunning %s%s:%s %s%s' % (
+ '\r\x1b[K' if args['color'] else '',
+ '\x1b[?7l' if not done else '',
+ ('\x1b[34m' if not failures else '\x1b[31m')
+ if args['color'] else '',
+ name,
+ '\x1b[m' if args['color'] else '',
+ ', '.join(filter(None, [
+ '%d/%d suites' % (
+ sum(passed_suite_perms[k] == v
+ for k, v in expected_suite_perms.items()),
+ len(expected_suite_perms))
+ if (not args.get('by_suites')
+ and not args.get('by_cases')) else None,
+ '%d/%d cases' % (
+ sum(passed_case_perms[k] == v
+ for k, v in expected_case_perms.items()),
+ len(expected_case_perms))
+ if not args.get('by_cases') else None,
+ '%d/%d perms' % (passed_perms, expected_perms),
+ '%s%d/%d failures%s' % (
+ '\x1b[31m' if args['color'] else '',
+ len(failures),
+ expected_perms,
+ '\x1b[m' if args['color'] else '')
+ if failures else None])),
+ '\x1b[?7h' if not done else '\n'))
+ sys.stdout.flush()
+
+ for r in runners:
+ r.start()
+
+ try:
+ while any(r.is_alive() for r in runners):
+ time.sleep(0.01)
+ print_update(False)
+ except KeyboardInterrupt:
+ # this is handled by the runner threads, we just
+ # need to not abort here
+ killed = True
+ finally:
+ print_update(True)
+
+ for r in runners:
+ r.join()
+
+ return (
+ expected_perms,
+ passed_perms,
+ readed,
+ proged,
+ erased,
+ failures,
+ killed)
+
+
+def run(runner, bench_ids=[], **args):
+ # query runner for benches
+ runner_ = find_runner(runner, **args)
+ print('using runner: %s' % ' '.join(shlex.quote(c) for c in runner_))
+ (_,
+ expected_suite_perms,
+ expected_case_perms,
+ expected_perms,
+ total_perms) = find_perms(runner_, bench_ids, **args)
+ print('found %d suites, %d cases, %d/%d permutations' % (
+ len(expected_suite_perms),
+ len(expected_case_perms),
+ expected_perms,
+ total_perms))
+ print()
+
+ # automatic job detection?
+ if args.get('jobs') == 0:
+ args['jobs'] = len(os.sched_getaffinity(0))
+
+ # truncate and open logs here so they aren't disconnected between benches
+ stdout = None
+ if args.get('stdout'):
+ stdout = openio(args['stdout'], 'w', 1)
+ trace = None
+ if args.get('trace'):
+ trace = openio(args['trace'], 'w', 1)
+ output = None
+ if args.get('output'):
+ output = BenchOutput(args['output'],
+ ['suite', 'case'],
+ ['bench_readed', 'bench_proged', 'bench_erased'])
+
+ # measure runtime
+ start = time.time()
+
+ # spawn runners
+ expected = 0
+ passed = 0
+ readed = 0
+ proged = 0
+ erased = 0
+ failures = []
+ for by in (bench_ids if bench_ids
+ else expected_case_perms.keys() if args.get('by_cases')
+ else expected_suite_perms.keys() if args.get('by_suites')
+ else [None]):
+ # spawn jobs for stage
+ (expected_,
+ passed_,
+ readed_,
+ proged_,
+ erased_,
+ failures_,
+ killed) = run_stage(
+ by or 'benches',
+ runner_,
+ [by] if by is not None else [],
+ stdout,
+ trace,
+ output,
+ **args)
+ # collect passes/failures
+ expected += expected_
+ passed += passed_
+ readed += readed_
+ proged += proged_
+ erased += erased_
+ failures.extend(failures_)
+ if (failures and not args.get('keep_going')) or killed:
+ break
+
+ stop = time.time()
+
+ if stdout:
+ try:
+ stdout.close()
+ except BrokenPipeError:
+ pass
+ if trace:
+ try:
+ trace.close()
+ except BrokenPipeError:
+ pass
+ if output:
+ output.close()
+
+ # show summary
+ print()
+ print('%sdone:%s %s' % (
+ ('\x1b[34m' if not failures else '\x1b[31m')
+ if args['color'] else '',
+ '\x1b[m' if args['color'] else '',
+ ', '.join(filter(None, [
+ '%d readed' % readed,
+ '%d proged' % proged,
+ '%d erased' % erased,
+ 'in %.2fs' % (stop-start)]))))
+ print()
+
+ # print each failure
+ for failure in failures:
+ assert failure.id is not None, '%s broken? %r' % (
+ ' '.join(shlex.quote(c) for c in runner_),
+ failure)
+
+ # get some extra info from runner
+ path, lineno = find_path(runner_, failure.id, **args)
+ defines = find_defines(runner_, failure.id, **args)
+
+ # show summary of failure
+ print('%s%s:%d:%sfailure:%s %s%s failed' % (
+ '\x1b[01m' if args['color'] else '',
+ path, lineno,
+ '\x1b[01;31m' if args['color'] else '',
+ '\x1b[m' if args['color'] else '',
+ failure.id,
+ ' (%s)' % ', '.join('%s=%s' % (k,v) for k,v in defines.items())
+ if defines else ''))
+
+ if failure.stdout:
+ stdout = failure.stdout
+ if failure.assert_ is not None:
+ stdout = stdout[:-1]
+ for line in stdout[-args.get('context', 5):]:
+ sys.stdout.write(line)
+
+ if failure.assert_ is not None:
+ path, lineno, message = failure.assert_
+ print('%s%s:%d:%sassert:%s %s' % (
+ '\x1b[01m' if args['color'] else '',
+ path, lineno,
+ '\x1b[01;31m' if args['color'] else '',
+ '\x1b[m' if args['color'] else '',
+ message))
+ with open(path) as f:
+ line = next(it.islice(f, lineno-1, None)).strip('\n')
+ print(line)
+ print()
+
+ # drop into gdb?
+ if failures and (args.get('gdb')
+ or args.get('gdb_case')
+ or args.get('gdb_main')):
+ failure = failures[0]
+ cmd = runner_ + [failure.id]
+
+ if args.get('gdb_main'):
+ # we don't really need the case breakpoint here, but it
+ # can be helpful
+ path, lineno = find_path(runner_, failure.id, **args)
+ cmd[:0] = args['gdb_path'] + [
+ '-ex', 'break main',
+ '-ex', 'break %s:%d' % (path, lineno),
+ '-ex', 'run',
+ '--args']
+ elif args.get('gdb_case'):
+ path, lineno = find_path(runner_, failure.id, **args)
+ cmd[:0] = args['gdb_path'] + [
+ '-ex', 'break %s:%d' % (path, lineno),
+ '-ex', 'run',
+ '--args']
+ elif failure.assert_ is not None:
+ cmd[:0] = args['gdb_path'] + [
+ '-ex', 'run',
+ '-ex', 'frame function raise',
+ '-ex', 'up 2',
+ '--args']
+ else:
+ cmd[:0] = args['gdb_path'] + [
+ '-ex', 'run',
+ '--args']
+
+ # exec gdb interactively
+ if args.get('verbose'):
+ print(' '.join(shlex.quote(c) for c in cmd))
+ os.execvp(cmd[0], cmd)
+
+ return 1 if failures else 0
+
+
+def main(**args):
+ # figure out what color should be
+ if args.get('color') == 'auto':
+ args['color'] = sys.stdout.isatty()
+ elif args.get('color') == 'always':
+ args['color'] = True
+ else:
+ args['color'] = False
+
+ if args.get('compile'):
+ return compile(**args)
+ elif (args.get('summary')
+ or args.get('list_suites')
+ or args.get('list_cases')
+ or args.get('list_suite_paths')
+ or args.get('list_case_paths')
+ or args.get('list_defines')
+ or args.get('list_permutation_defines')
+ or args.get('list_implicit_defines')
+ or args.get('list_geometries')):
+ return list_(**args)
+ else:
+ return run(**args)
+
+
+if __name__ == "__main__":
+ import argparse
+ import sys
+ argparse.ArgumentParser._handle_conflict_ignore = lambda *_: None
+ argparse._ArgumentGroup._handle_conflict_ignore = lambda *_: None
+ parser = argparse.ArgumentParser(
+ description="Build and run benches.",
+ allow_abbrev=False,
+ conflict_handler='ignore')
+ parser.add_argument(
+ '-v', '--verbose',
+ action='store_true',
+ help="Output commands that run behind the scenes.")
+ parser.add_argument(
+ '--color',
+ choices=['never', 'always', 'auto'],
+ default='auto',
+ help="When to use terminal colors. Defaults to 'auto'.")
+
+ # bench flags
+ bench_parser = parser.add_argument_group('bench options')
+ bench_parser.add_argument(
+ 'runner',
+ nargs='?',
+ type=lambda x: x.split(),
+ help="Bench runner to use for benching. Defaults to %r." % RUNNER_PATH)
+ bench_parser.add_argument(
+ 'bench_ids',
+ nargs='*',
+ help="Description of benches to run.")
+ bench_parser.add_argument(
+ '-Y', '--summary',
+ action='store_true',
+ help="Show quick summary.")
+ bench_parser.add_argument(
+ '-l', '--list-suites',
+ action='store_true',
+ help="List bench suites.")
+ bench_parser.add_argument(
+ '-L', '--list-cases',
+ action='store_true',
+ help="List bench cases.")
+ bench_parser.add_argument(
+ '--list-suite-paths',
+ action='store_true',
+ help="List the path for each bench suite.")
+ bench_parser.add_argument(
+ '--list-case-paths',
+ action='store_true',
+ help="List the path and line number for each bench case.")
+ bench_parser.add_argument(
+ '--list-defines',
+ action='store_true',
+ help="List all defines in this bench-runner.")
+ bench_parser.add_argument(
+ '--list-permutation-defines',
+ action='store_true',
+ help="List explicit defines in this bench-runner.")
+ bench_parser.add_argument(
+ '--list-implicit-defines',
+ action='store_true',
+ help="List implicit defines in this bench-runner.")
+ bench_parser.add_argument(
+ '--list-geometries',
+ action='store_true',
+ help="List the available disk geometries.")
+ bench_parser.add_argument(
+ '-D', '--define',
+ action='append',
+ help="Override a bench define.")
+ bench_parser.add_argument(
+ '-G', '--geometry',
+ help="Comma-separated list of disk geometries to bench.")
+ bench_parser.add_argument(
+ '-d', '--disk',
+ help="Direct block device operations to this file.")
+ bench_parser.add_argument(
+ '-t', '--trace',
+ help="Direct trace output to this file.")
+ bench_parser.add_argument(
+ '--trace-backtrace',
+ action='store_true',
+ help="Include a backtrace with every trace statement.")
+ bench_parser.add_argument(
+ '--trace-period',
+ help="Sample trace output at this period in cycles.")
+ bench_parser.add_argument(
+ '--trace-freq',
+ help="Sample trace output at this frequency in hz.")
+ bench_parser.add_argument(
+ '-O', '--stdout',
+ help="Direct stdout to this file. Note stderr is already merged here.")
+ bench_parser.add_argument(
+ '-o', '--output',
+ help="CSV file to store results.")
+ bench_parser.add_argument(
+ '--read-sleep',
+ help="Artificial read delay in seconds.")
+ bench_parser.add_argument(
+ '--prog-sleep',
+ help="Artificial prog delay in seconds.")
+ bench_parser.add_argument(
+ '--erase-sleep',
+ help="Artificial erase delay in seconds.")
+ bench_parser.add_argument(
+ '-j', '--jobs',
+ nargs='?',
+ type=lambda x: int(x, 0),
+ const=0,
+ help="Number of parallel runners to run. 0 runs one runner per core.")
+ bench_parser.add_argument(
+ '-k', '--keep-going',
+ action='store_true',
+ help="Don't stop on first error.")
+ bench_parser.add_argument(
+ '-i', '--isolate',
+ action='store_true',
+ help="Run each bench permutation in a separate process.")
+ bench_parser.add_argument(
+ '-b', '--by-suites',
+ action='store_true',
+ help="Step through benches by suite.")
+ bench_parser.add_argument(
+ '-B', '--by-cases',
+ action='store_true',
+ help="Step through benches by case.")
+ bench_parser.add_argument(
+ '--context',
+ type=lambda x: int(x, 0),
+ default=5,
+ help="Show this many lines of stdout on bench failure. "
+ "Defaults to 5.")
+ bench_parser.add_argument(
+ '--gdb',
+ action='store_true',
+ help="Drop into gdb on bench failure.")
+ bench_parser.add_argument(
+ '--gdb-case',
+ action='store_true',
+ help="Drop into gdb on bench failure but stop at the beginning "
+ "of the failing bench case.")
+ bench_parser.add_argument(
+ '--gdb-main',
+ action='store_true',
+ help="Drop into gdb on bench failure but stop at the beginning "
+ "of main.")
+ bench_parser.add_argument(
+ '--gdb-path',
+ type=lambda x: x.split(),
+ default=GDB_PATH,
+ help="Path to the gdb executable, may include flags. "
+ "Defaults to %r." % GDB_PATH)
+ bench_parser.add_argument(
+ '--exec',
+ type=lambda e: e.split(),
+ help="Run under another executable.")
+ bench_parser.add_argument(
+ '--valgrind',
+ action='store_true',
+ help="Run under Valgrind to find memory errors. Implicitly sets "
+ "--isolate.")
+ bench_parser.add_argument(
+ '--valgrind-path',
+ type=lambda x: x.split(),
+ default=VALGRIND_PATH,
+ help="Path to the Valgrind executable, may include flags. "
+ "Defaults to %r." % VALGRIND_PATH)
+ bench_parser.add_argument(
+ '-p', '--perf',
+ help="Run under Linux's perf to sample performance counters, writing "
+ "samples to this file.")
+ bench_parser.add_argument(
+ '--perf-freq',
+ help="perf sampling frequency. This is passed directly to the perf "
+ "script.")
+ bench_parser.add_argument(
+ '--perf-period',
+ help="perf sampling period. This is passed directly to the perf "
+ "script.")
+ bench_parser.add_argument(
+ '--perf-events',
+ help="perf events to record. This is passed directly to the perf "
+ "script.")
+ bench_parser.add_argument(
+ '--perf-script',
+ type=lambda x: x.split(),
+ default=PERF_SCRIPT,
+ help="Path to the perf script to use. Defaults to %r." % PERF_SCRIPT)
+ bench_parser.add_argument(
+ '--perf-path',
+ type=lambda x: x.split(),
+ help="Path to the perf executable, may include flags. This is passed "
+ "directly to the perf script")
+
+ # compilation flags
+ comp_parser = parser.add_argument_group('compilation options')
+ comp_parser.add_argument(
+ 'bench_paths',
+ nargs='*',
+ help="Description of *.toml files to compile. May be a directory "
+ "or a list of paths.")
+ comp_parser.add_argument(
+ '-c', '--compile',
+ action='store_true',
+ help="Compile a bench suite or source file.")
+ comp_parser.add_argument(
+ '-s', '--source',
+ help="Source file to compile, possibly injecting internal benches.")
+ comp_parser.add_argument(
+ '--include',
+ default=HEADER_PATH,
+ help="Inject this header file into every compiled bench file. "
+ "Defaults to %r." % HEADER_PATH)
+ comp_parser.add_argument(
+ '-o', '--output',
+ help="Output file.")
+
+ # runner/bench_paths overlap, so need to do some munging here
+ args = parser.parse_intermixed_args()
+ args.bench_paths = [' '.join(args.runner or [])] + args.bench_ids
+ args.runner = args.runner or [RUNNER_PATH]
+
+ sys.exit(main(**{k: v
+ for k, v in vars(args).items()
+ if v is not None}))
diff --git a/scripts/changeprefix.py b/scripts/changeprefix.py
new file mode 100755
index 00000000..381a4568
--- /dev/null
+++ b/scripts/changeprefix.py
@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+#
+# Change prefixes in files/filenames. Useful for creating different versions
+# of a codebase that don't conflict at compile time.
+#
+# Example:
+# $ ./scripts/changeprefix.py lfs lfs3
+#
+# Copyright (c) 2022, The littlefs authors.
+# Copyright (c) 2019, Arm Limited. All rights reserved.
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+import glob
+import itertools
+import os
+import os.path
+import re
+import shlex
+import shutil
+import subprocess
+import tempfile
+
+GIT_PATH = ['git']
+
+
+def openio(path, mode='r', buffering=-1):
+ # allow '-' for stdin/stdout
+ if path == '-':
+ if mode == 'r':
+ return os.fdopen(os.dup(sys.stdin.fileno()), mode, buffering)
+ else:
+ return os.fdopen(os.dup(sys.stdout.fileno()), mode, buffering)
+ else:
+ return open(path, mode, buffering)
+
+def changeprefix(from_prefix, to_prefix, line):
+ line, count1 = re.subn(
+ '\\b'+from_prefix,
+ to_prefix,
+ line)
+ line, count2 = re.subn(
+ '\\b'+from_prefix.upper(),
+ to_prefix.upper(),
+ line)
+ line, count3 = re.subn(
+ '\\B-D'+from_prefix.upper(),
+ '-D'+to_prefix.upper(),
+ line)
+ return line, count1+count2+count3
+
+def changefile(from_prefix, to_prefix, from_path, to_path, *,
+ no_replacements=False):
+ # rename any prefixes in file
+ count = 0
+
+ # create a temporary file to avoid overwriting ourself
+ if from_path == to_path and to_path != '-':
+ to_path_temp = tempfile.NamedTemporaryFile('w', delete=False)
+ to_path = to_path_temp.name
+ else:
+ to_path_temp = None
+
+ with openio(from_path) as from_f:
+ with openio(to_path, 'w') as to_f:
+ for line in from_f:
+ if not no_replacements:
+ line, n = changeprefix(from_prefix, to_prefix, line)
+ count += n
+ to_f.write(line)
+
+ if from_path != '-' and to_path != '-':
+ shutil.copystat(from_path, to_path)
+
+ if to_path_temp:
+ os.rename(to_path, from_path)
+ elif from_path != '-':
+ os.remove(from_path)
+
+ # Summary
+ print('%s: %d replacements' % (
+ '%s -> %s' % (from_path, to_path) if not to_path_temp else from_path,
+ count))
+
+def main(from_prefix, to_prefix, paths=[], *,
+ verbose=False,
+ output=None,
+ no_replacements=False,
+ no_renames=False,
+ git=False,
+ no_stage=False,
+ git_path=GIT_PATH):
+ if not paths:
+ if git:
+ cmd = git_path + ['ls-tree', '-r', '--name-only', 'HEAD']
+ if verbose:
+ print(' '.join(shlex.quote(c) for c in cmd))
+ paths = subprocess.check_output(cmd, encoding='utf8').split()
+ else:
+ print('no paths?', file=sys.stderr)
+ sys.exit(1)
+
+ for from_path in paths:
+ # rename filename?
+ if output:
+ to_path = output
+ elif no_renames:
+ to_path = from_path
+ else:
+ to_path = os.path.join(
+ os.path.dirname(from_path),
+ changeprefix(from_prefix, to_prefix,
+ os.path.basename(from_path))[0])
+
+ # rename contents
+ changefile(from_prefix, to_prefix, from_path, to_path,
+ no_replacements=no_replacements)
+
+ # stage?
+ if git and not no_stage:
+ if from_path != to_path:
+ cmd = git_path + ['rm', '-q', from_path]
+ if verbose:
+ print(' '.join(shlex.quote(c) for c in cmd))
+ subprocess.check_call(cmd)
+ cmd = git_path + ['add', to_path]
+ if verbose:
+ print(' '.join(shlex.quote(c) for c in cmd))
+ subprocess.check_call(cmd)
+
+
+if __name__ == "__main__":
+ import argparse
+ import sys
+ parser = argparse.ArgumentParser(
+ description="Change prefixes in files/filenames. Useful for creating "
+ "different versions of a codebase that don't conflict at compile "
+ "time.",
+ allow_abbrev=False)
+ parser.add_argument(
+ 'from_prefix',
+ help="Prefix to replace.")
+ parser.add_argument(
+ 'to_prefix',
+ help="Prefix to replace with.")
+ parser.add_argument(
+ 'paths',
+ nargs='*',
+ help="Files to operate on.")
+ parser.add_argument(
+ '-v', '--verbose',
+ action='store_true',
+ help="Output commands that run behind the scenes.")
+ parser.add_argument(
+ '-o', '--output',
+ help="Output file.")
+ parser.add_argument(
+ '-N', '--no-replacements',
+ action='store_true',
+ help="Don't change prefixes in files")
+ parser.add_argument(
+ '-R', '--no-renames',
+ action='store_true',
+ help="Don't rename files")
+ parser.add_argument(
+ '--git',
+ action='store_true',
+ help="Use git to find/update files.")
+ parser.add_argument(
+ '--no-stage',
+ action='store_true',
+ help="Don't stage changes with git.")
+ parser.add_argument(
+ '--git-path',
+ type=lambda x: x.split(),
+ default=GIT_PATH,
+ help="Path to git executable, may include flags. "
+ "Defaults to %r." % GIT_PATH)
+ sys.exit(main(**{k: v
+ for k, v in vars(parser.parse_intermixed_args()).items()
+ if v is not None}))
diff --git a/scripts/code.py b/scripts/code.py
index b394e9cd..ba8bd1e0 100755
--- a/scripts/code.py
+++ b/scripts/code.py
@@ -1,42 +1,188 @@
#!/usr/bin/env python3
#
-# Script to find code size at the function level. Basically just a bit wrapper
+# Script to find code size at the function level. Basically just a big wrapper
# around nm with some extra conveniences for comparing builds. Heavily inspired
# by Linux's Bloat-O-Meter.
#
+# Example:
+# ./scripts/code.py lfs.o lfs_util.o -Ssize
+#
+# Copyright (c) 2022, The littlefs authors.
+# Copyright (c) 2020, Arm Limited. All rights reserved.
+# SPDX-License-Identifier: BSD-3-Clause
+#
-import os
-import glob
+import collections as co
+import csv
+import difflib
import itertools as it
-import subprocess as sp
-import shlex
+import math as m
+import os
import re
-import csv
-import collections as co
+import shlex
+import subprocess as sp
+
+
+NM_PATH = ['nm']
+NM_TYPES = 'tTrRdD'
+OBJDUMP_PATH = ['objdump']
+
+
+# integer fields
+class Int(co.namedtuple('Int', 'x')):
+ __slots__ = ()
+ def __new__(cls, x=0):
+ if isinstance(x, Int):
+ return x
+ if isinstance(x, str):
+ try:
+ x = int(x, 0)
+ except ValueError:
+ # also accept +-∞ and +-inf
+ if re.match('^\s*\+?\s*(?:∞|inf)\s*$', x):
+ x = m.inf
+ elif re.match('^\s*-\s*(?:∞|inf)\s*$', x):
+ x = -m.inf
+ else:
+ raise
+ assert isinstance(x, int) or m.isinf(x), x
+ return super().__new__(cls, x)
+
+ def __str__(self):
+ if self.x == m.inf:
+ return '∞'
+ elif self.x == -m.inf:
+ return '-∞'
+ else:
+ return str(self.x)
+
+ def __int__(self):
+ assert not m.isinf(self.x)
+ return self.x
+
+ def __float__(self):
+ return float(self.x)
+
+ none = '%7s' % '-'
+ def table(self):
+ return '%7s' % (self,)
+
+ diff_none = '%7s' % '-'
+ diff_table = table
+
+ def diff_diff(self, other):
+ new = self.x if self else 0
+ old = other.x if other else 0
+ diff = new - old
+ if diff == +m.inf:
+ return '%7s' % '+∞'
+ elif diff == -m.inf:
+ return '%7s' % '-∞'
+ else:
+ return '%+7d' % diff
+
+ def ratio(self, other):
+ new = self.x if self else 0
+ old = other.x if other else 0
+ if m.isinf(new) and m.isinf(old):
+ return 0.0
+ elif m.isinf(new):
+ return +m.inf
+ elif m.isinf(old):
+ return -m.inf
+ elif not old and not new:
+ return 0.0
+ elif not old:
+ return 1.0
+ else:
+ return (new-old) / old
+
+ def __add__(self, other):
+ return self.__class__(self.x + other.x)
+
+ def __sub__(self, other):
+ return self.__class__(self.x - other.x)
+
+ def __mul__(self, other):
+ return self.__class__(self.x * other.x)
+# code size results
+class CodeResult(co.namedtuple('CodeResult', [
+ 'file', 'function',
+ 'size'])):
+ _by = ['file', 'function']
+ _fields = ['size']
+ _sort = ['size']
+ _types = {'size': Int}
-OBJ_PATHS = ['*.o']
+ __slots__ = ()
+ def __new__(cls, file='', function='', size=0):
+ return super().__new__(cls, file, function,
+ Int(size))
-def collect(paths, **args):
- results = co.defaultdict(lambda: 0)
- pattern = re.compile(
+ def __add__(self, other):
+ return CodeResult(self.file, self.function,
+ self.size + other.size)
+
+
+def openio(path, mode='r', buffering=-1):
+ # allow '-' for stdin/stdout
+ if path == '-':
+ if mode == 'r':
+ return os.fdopen(os.dup(sys.stdin.fileno()), mode, buffering)
+ else:
+ return os.fdopen(os.dup(sys.stdout.fileno()), mode, buffering)
+ else:
+ return open(path, mode, buffering)
+
+def collect(obj_paths, *,
+ nm_path=NM_PATH,
+ nm_types=NM_TYPES,
+ objdump_path=OBJDUMP_PATH,
+ sources=None,
+ everything=False,
+ **args):
+ size_pattern = re.compile(
'^(?P[0-9a-fA-F]+)' +
- ' (?P[%s])' % re.escape(args['type']) +
+ ' (?P[%s])' % re.escape(nm_types) +
' (?P.+?)$')
- for path in paths:
- # note nm-tool may contain extra args
- cmd = args['nm_tool'] + ['--size-sort', path]
+ line_pattern = re.compile(
+ '^\s+(?P[0-9]+)'
+ '(?:\s+(?P[0-9]+))?'
+ '\s+.*'
+ '\s+(?P[^\s]+)$')
+ info_pattern = re.compile(
+ '^(?:.*(?PDW_TAG_[a-z_]+).*'
+ '|.*DW_AT_name.*:\s*(?P[^:\s]+)\s*'
+ '|.*DW_AT_decl_file.*:\s*(?P[0-9]+)\s*)$')
+
+ results = []
+ for path in obj_paths:
+ # guess the source, if we have debug-info we'll replace this later
+ file = re.sub('(\.o)?$', '.c', path, 1)
+
+ # find symbol sizes
+ results_ = []
+ # note nm-path may contain extra args
+ cmd = nm_path + ['--size-sort', path]
if args.get('verbose'):
print(' '.join(shlex.quote(c) for c in cmd))
proc = sp.Popen(cmd,
stdout=sp.PIPE,
stderr=sp.PIPE if not args.get('verbose') else None,
universal_newlines=True,
- errors='replace')
+ errors='replace',
+ close_fds=False)
for line in proc.stdout:
- m = pattern.match(line)
+ m = size_pattern.match(line)
if m:
- results[(path, m.group('func'))] += int(m.group('size'), 16)
+ func = m.group('func')
+ # discard internal functions
+ if not everything and func.startswith('__'):
+ continue
+ results_.append(CodeResult(
+ file, func,
+ int(m.group('size'), 16)))
proc.wait()
if proc.returncode != 0:
if not args.get('verbose'):
@@ -44,241 +190,518 @@ def collect(paths, **args):
sys.stdout.write(line)
sys.exit(-1)
- flat_results = []
- for (file, func), size in results.items():
- # map to source files
- if args.get('build_dir'):
- file = re.sub('%s/*' % re.escape(args['build_dir']), '', file)
- # replace .o with .c, different scripts report .o/.c, we need to
- # choose one if we want to deduplicate csv files
- file = re.sub('\.o$', '.c', file)
- # discard internal functions
- if not args.get('everything'):
- if func.startswith('__'):
- continue
- # discard .8449 suffixes created by optimizer
- func = re.sub('\.[0-9]+', '', func)
-
- flat_results.append((file, func, size))
-
- return flat_results
-
-def main(**args):
- def openio(path, mode='r'):
- if path == '-':
- if 'r' in mode:
- return os.fdopen(os.dup(sys.stdin.fileno()), 'r')
+
+ # try to figure out the source file if we have debug-info
+ dirs = {}
+ files = {}
+ # note objdump-path may contain extra args
+ cmd = objdump_path + ['--dwarf=rawline', path]
+ if args.get('verbose'):
+ print(' '.join(shlex.quote(c) for c in cmd))
+ proc = sp.Popen(cmd,
+ stdout=sp.PIPE,
+ stderr=sp.PIPE if not args.get('verbose') else None,
+ universal_newlines=True,
+ errors='replace',
+ close_fds=False)
+ for line in proc.stdout:
+ # note that files contain references to dirs, which we
+ # dereference as soon as we see them as each file table follows a
+ # dir table
+ m = line_pattern.match(line)
+ if m:
+ if not m.group('dir'):
+ # found a directory entry
+ dirs[int(m.group('no'))] = m.group('path')
+ else:
+ # found a file entry
+ dir = int(m.group('dir'))
+ if dir in dirs:
+ files[int(m.group('no'))] = os.path.join(
+ dirs[dir],
+ m.group('path'))
+ else:
+ files[int(m.group('no'))] = m.group('path')
+ proc.wait()
+ if proc.returncode != 0:
+ if not args.get('verbose'):
+ for line in proc.stderr:
+ sys.stdout.write(line)
+ # do nothing on error, we don't need objdump to work, source files
+ # may just be inaccurate
+ pass
+
+ defs = {}
+ is_func = False
+ f_name = None
+ f_file = None
+ # note objdump-path may contain extra args
+ cmd = objdump_path + ['--dwarf=info', path]
+ if args.get('verbose'):
+ print(' '.join(shlex.quote(c) for c in cmd))
+ proc = sp.Popen(cmd,
+ stdout=sp.PIPE,
+ stderr=sp.PIPE if not args.get('verbose') else None,
+ universal_newlines=True,
+ errors='replace',
+ close_fds=False)
+ for line in proc.stdout:
+ # state machine here to find definitions
+ m = info_pattern.match(line)
+ if m:
+ if m.group('tag'):
+ if is_func:
+ defs[f_name] = files.get(f_file, '?')
+ is_func = (m.group('tag') == 'DW_TAG_subprogram')
+ elif m.group('name'):
+ f_name = m.group('name')
+ elif m.group('file'):
+ f_file = int(m.group('file'))
+ if is_func:
+ defs[f_name] = files.get(f_file, '?')
+ proc.wait()
+ if proc.returncode != 0:
+ if not args.get('verbose'):
+ for line in proc.stderr:
+ sys.stdout.write(line)
+ # do nothing on error, we don't need objdump to work, source files
+ # may just be inaccurate
+ pass
+
+ for r in results_:
+ # find best matching debug symbol, this may be slightly different
+ # due to optimizations
+ if defs:
+ # exact match? avoid difflib if we can for speed
+ if r.function in defs:
+ file = defs[r.function]
+ else:
+ _, file = max(
+ defs.items(),
+ key=lambda d: difflib.SequenceMatcher(None,
+ d[0],
+ r.function, False).ratio())
else:
- return os.fdopen(os.dup(sys.stdout.fileno()), 'w')
- else:
- return open(path, mode)
+ file = r.file
- # find sizes
- if not args.get('use', None):
- # find .o files
- paths = []
- for path in args['obj_paths']:
- if os.path.isdir(path):
- path = path + '/*.o'
+ # ignore filtered sources
+ if sources is not None:
+ if not any(
+ os.path.abspath(file) == os.path.abspath(s)
+ for s in sources):
+ continue
+ else:
+ # default to only cwd
+ if not everything and not os.path.commonpath([
+ os.getcwd(),
+ os.path.abspath(file)]) == os.getcwd():
+ continue
+
+ # simplify path
+ if os.path.commonpath([
+ os.getcwd(),
+ os.path.abspath(file)]) == os.getcwd():
+ file = os.path.relpath(file)
+ else:
+ file = os.path.abspath(file)
+
+ results.append(r._replace(file=file))
+
+ return results
- for path in glob.glob(path):
- paths.append(path)
- if not paths:
- print('no .obj files found in %r?' % args['obj_paths'])
+def fold(Result, results, *,
+ by=None,
+ defines=None,
+ **_):
+ if by is None:
+ by = Result._by
+
+ for k in it.chain(by or [], (k for k, _ in defines or [])):
+ if k not in Result._by and k not in Result._fields:
+ print("error: could not find field %r?" % k)
sys.exit(-1)
- results = collect(paths, **args)
- else:
- with openio(args['use']) as f:
- r = csv.DictReader(f)
- results = [
- ( result['file'],
- result['name'],
- int(result['code_size']))
- for result in r
- if result.get('code_size') not in {None, ''}]
-
- total = 0
- for _, _, size in results:
- total += size
+ # filter by matching defines
+ if defines is not None:
+ results_ = []
+ for r in results:
+ if all(getattr(r, k) in vs for k, vs in defines):
+ results_.append(r)
+ results = results_
- # find previous results?
- if args.get('diff'):
- try:
- with openio(args['diff']) as f:
- r = csv.DictReader(f)
- prev_results = [
- ( result['file'],
- result['name'],
- int(result['code_size']))
- for result in r
- if result.get('code_size') not in {None, ''}]
- except FileNotFoundError:
- prev_results = []
+ # organize results into conflicts
+ folding = co.OrderedDict()
+ for r in results:
+ name = tuple(getattr(r, k) for k in by)
+ if name not in folding:
+ folding[name] = []
+ folding[name].append(r)
- prev_total = 0
- for _, _, size in prev_results:
- prev_total += size
+ # merge conflicts
+ folded = []
+ for name, rs in folding.items():
+ folded.append(sum(rs[1:], start=rs[0]))
- # write results to CSV
- if args.get('output'):
- merged_results = co.defaultdict(lambda: {})
- other_fields = []
+ return folded
- # merge?
- if args.get('merge'):
- try:
- with openio(args['merge']) as f:
- r = csv.DictReader(f)
- for result in r:
- file = result.pop('file', '')
- func = result.pop('name', '')
- result.pop('code_size', None)
- merged_results[(file, func)] = result
- other_fields = result.keys()
- except FileNotFoundError:
- pass
-
- for file, func, size in results:
- merged_results[(file, func)]['code_size'] = size
+def table(Result, results, diff_results=None, *,
+ by=None,
+ fields=None,
+ sort=None,
+ summary=False,
+ all=False,
+ percent=False,
+ **_):
+ all_, all = all, __builtins__.all
- with openio(args['output'], 'w') as f:
- w = csv.DictWriter(f, ['file', 'name', *other_fields, 'code_size'])
- w.writeheader()
- for (file, func), result in sorted(merged_results.items()):
- w.writerow({'file': file, 'name': func, **result})
-
- # print results
- def dedup_entries(results, by='name'):
- entries = co.defaultdict(lambda: 0)
- for file, func, size in results:
- entry = (file if by == 'file' else func)
- entries[entry] += size
- return entries
-
- def diff_entries(olds, news):
- diff = co.defaultdict(lambda: (0, 0, 0, 0))
- for name, new in news.items():
- diff[name] = (0, new, new, 1.0)
- for name, old in olds.items():
- _, new, _, _ = diff[name]
- diff[name] = (old, new, new-old, (new-old)/old if old else 1.0)
- return diff
-
- def sorted_entries(entries):
- if args.get('size_sort'):
- return sorted(entries, key=lambda x: (-x[1], x))
- elif args.get('reverse_size_sort'):
- return sorted(entries, key=lambda x: (+x[1], x))
- else:
- return sorted(entries)
+ if by is None:
+ by = Result._by
+ if fields is None:
+ fields = Result._fields
+ types = Result._types
- def sorted_diff_entries(entries):
- if args.get('size_sort'):
- return sorted(entries, key=lambda x: (-x[1][1], x))
- elif args.get('reverse_size_sort'):
- return sorted(entries, key=lambda x: (+x[1][1], x))
- else:
- return sorted(entries, key=lambda x: (-x[1][3], x))
+ # fold again
+ results = fold(Result, results, by=by)
+ if diff_results is not None:
+ diff_results = fold(Result, diff_results, by=by)
- def print_header(by=''):
- if not args.get('diff'):
- print('%-36s %7s' % (by, 'size'))
- else:
- print('%-36s %7s %7s %7s' % (by, 'old', 'new', 'diff'))
+ # organize by name
+ table = {
+ ','.join(str(getattr(r, k) or '') for k in by): r
+ for r in results}
+ diff_table = {
+ ','.join(str(getattr(r, k) or '') for k in by): r
+ for r in diff_results or []}
+ names = list(table.keys() | diff_table.keys())
+
+ # sort again, now with diff info, note that python's sort is stable
+ names.sort()
+ if diff_results is not None:
+ names.sort(key=lambda n: tuple(
+ types[k].ratio(
+ getattr(table.get(n), k, None),
+ getattr(diff_table.get(n), k, None))
+ for k in fields),
+ reverse=True)
+ if sort:
+ for k, reverse in reversed(sort):
+ names.sort(
+ key=lambda n: tuple(
+ (getattr(table[n], k),)
+ if getattr(table.get(n), k, None) is not None else ()
+ for k in ([k] if k else [
+ k for k in Result._sort if k in fields])),
+ reverse=reverse ^ (not k or k in Result._fields))
- def print_entry(name, size):
- print("%-36s %7d" % (name, size))
- def print_diff_entry(name, old, new, diff, ratio):
- print("%-36s %7s %7s %+7d%s" % (name,
- old or "-",
- new or "-",
- diff,
- ' (%+.1f%%)' % (100*ratio) if ratio else ''))
+ # build up our lines
+ lines = []
- def print_entries(by='name'):
- entries = dedup_entries(results, by=by)
+ # header
+ header = []
+ header.append('%s%s' % (
+ ','.join(by),
+ ' (%d added, %d removed)' % (
+ sum(1 for n in table if n not in diff_table),
+ sum(1 for n in diff_table if n not in table))
+ if diff_results is not None and not percent else '')
+ if not summary else '')
+ if diff_results is None:
+ for k in fields:
+ header.append(k)
+ elif percent:
+ for k in fields:
+ header.append(k)
+ else:
+ for k in fields:
+ header.append('o'+k)
+ for k in fields:
+ header.append('n'+k)
+ for k in fields:
+ header.append('d'+k)
+ header.append('')
+ lines.append(header)
- if not args.get('diff'):
- print_header(by=by)
- for name, size in sorted_entries(entries.items()):
- print_entry(name, size)
+ def table_entry(name, r, diff_r=None, ratios=[]):
+ entry = []
+ entry.append(name)
+ if diff_results is None:
+ for k in fields:
+ entry.append(getattr(r, k).table()
+ if getattr(r, k, None) is not None
+ else types[k].none)
+ elif percent:
+ for k in fields:
+ entry.append(getattr(r, k).diff_table()
+ if getattr(r, k, None) is not None
+ else types[k].diff_none)
else:
- prev_entries = dedup_entries(prev_results, by=by)
- diff = diff_entries(prev_entries, entries)
- print_header(by='%s (%d added, %d removed)' % (by,
- sum(1 for old, _, _, _ in diff.values() if not old),
- sum(1 for _, new, _, _ in diff.values() if not new)))
- for name, (old, new, diff, ratio) in sorted_diff_entries(
- diff.items()):
- if ratio or args.get('all'):
- print_diff_entry(name, old, new, diff, ratio)
-
- def print_totals():
- if not args.get('diff'):
- print_entry('TOTAL', total)
+ for k in fields:
+ entry.append(getattr(diff_r, k).diff_table()
+ if getattr(diff_r, k, None) is not None
+ else types[k].diff_none)
+ for k in fields:
+ entry.append(getattr(r, k).diff_table()
+ if getattr(r, k, None) is not None
+ else types[k].diff_none)
+ for k in fields:
+ entry.append(types[k].diff_diff(
+ getattr(r, k, None),
+ getattr(diff_r, k, None)))
+ if diff_results is None:
+ entry.append('')
+ elif percent:
+ entry.append(' (%s)' % ', '.join(
+ '+∞%' if t == +m.inf
+ else '-∞%' if t == -m.inf
+ else '%+.1f%%' % (100*t)
+ for t in ratios))
else:
- ratio = (0.0 if not prev_total and not total
- else 1.0 if not prev_total
- else (total-prev_total)/prev_total)
- print_diff_entry('TOTAL',
- prev_total, total,
- total-prev_total,
- ratio)
-
- if args.get('quiet'):
- pass
- elif args.get('summary'):
- print_header()
- print_totals()
- elif args.get('files'):
- print_entries(by='file')
- print_totals()
+ entry.append(' (%s)' % ', '.join(
+ '+∞%' if t == +m.inf
+ else '-∞%' if t == -m.inf
+ else '%+.1f%%' % (100*t)
+ for t in ratios
+ if t)
+ if any(ratios) else '')
+ return entry
+
+ # entries
+ if not summary:
+ for name in names:
+ r = table.get(name)
+ if diff_results is None:
+ diff_r = None
+ ratios = None
+ else:
+ diff_r = diff_table.get(name)
+ ratios = [
+ types[k].ratio(
+ getattr(r, k, None),
+ getattr(diff_r, k, None))
+ for k in fields]
+ if not all_ and not any(ratios):
+ continue
+ lines.append(table_entry(name, r, diff_r, ratios))
+
+ # total
+ r = next(iter(fold(Result, results, by=[])), None)
+ if diff_results is None:
+ diff_r = None
+ ratios = None
else:
- print_entries(by='name')
- print_totals()
+ diff_r = next(iter(fold(Result, diff_results, by=[])), None)
+ ratios = [
+ types[k].ratio(
+ getattr(r, k, None),
+ getattr(diff_r, k, None))
+ for k in fields]
+ lines.append(table_entry('TOTAL', r, diff_r, ratios))
+
+ # find the best widths, note that column 0 contains the names and column -1
+ # the ratios, so those are handled a bit differently
+ widths = [
+ ((max(it.chain([w], (len(l[i]) for l in lines)))+1+4-1)//4)*4-1
+ for w, i in zip(
+ it.chain([23], it.repeat(7)),
+ range(len(lines[0])-1))]
+
+ # print our table
+ for line in lines:
+ print('%-*s %s%s' % (
+ widths[0], line[0],
+ ' '.join('%*s' % (w, x)
+ for w, x in zip(widths[1:], line[1:-1])),
+ line[-1]))
+
+
+def main(obj_paths, *,
+ by=None,
+ fields=None,
+ defines=None,
+ sort=None,
+ **args):
+ # find sizes
+ if not args.get('use', None):
+ results = collect(obj_paths, **args)
+ else:
+ results = []
+ with openio(args['use']) as f:
+ reader = csv.DictReader(f, restval='')
+ for r in reader:
+ if not any('code_'+k in r and r['code_'+k].strip()
+ for k in CodeResult._fields):
+ continue
+ try:
+ results.append(CodeResult(
+ **{k: r[k] for k in CodeResult._by
+ if k in r and r[k].strip()},
+ **{k: r['code_'+k] for k in CodeResult._fields
+ if 'code_'+k in r and r['code_'+k].strip()}))
+ except TypeError:
+ pass
+
+ # fold
+ results = fold(CodeResult, results, by=by, defines=defines)
+
+ # sort, note that python's sort is stable
+ results.sort()
+ if sort:
+ for k, reverse in reversed(sort):
+ results.sort(
+ key=lambda r: tuple(
+ (getattr(r, k),) if getattr(r, k) is not None else ()
+ for k in ([k] if k else CodeResult._sort)),
+ reverse=reverse ^ (not k or k in CodeResult._fields))
+
+ # write results to CSV
+ if args.get('output'):
+ with openio(args['output'], 'w') as f:
+ writer = csv.DictWriter(f,
+ (by if by is not None else CodeResult._by)
+ + ['code_'+k for k in (
+ fields if fields is not None else CodeResult._fields)])
+ writer.writeheader()
+ for r in results:
+ writer.writerow(
+ {k: getattr(r, k) for k in (
+ by if by is not None else CodeResult._by)}
+ | {'code_'+k: getattr(r, k) for k in (
+ fields if fields is not None else CodeResult._fields)})
+
+ # find previous results?
+ if args.get('diff'):
+ diff_results = []
+ try:
+ with openio(args['diff']) as f:
+ reader = csv.DictReader(f, restval='')
+ for r in reader:
+ if not any('code_'+k in r and r['code_'+k].strip()
+ for k in CodeResult._fields):
+ continue
+ try:
+ diff_results.append(CodeResult(
+ **{k: r[k] for k in CodeResult._by
+ if k in r and r[k].strip()},
+ **{k: r['code_'+k] for k in CodeResult._fields
+ if 'code_'+k in r and r['code_'+k].strip()}))
+ except TypeError:
+ pass
+ except FileNotFoundError:
+ pass
+
+ # fold
+ diff_results = fold(CodeResult, diff_results, by=by, defines=defines)
+
+ # print table
+ if not args.get('quiet'):
+ table(CodeResult, results,
+ diff_results if args.get('diff') else None,
+ by=by if by is not None else ['function'],
+ fields=fields,
+ sort=sort,
+ **args)
+
if __name__ == "__main__":
import argparse
import sys
parser = argparse.ArgumentParser(
- description="Find code size at the function level.")
- parser.add_argument('obj_paths', nargs='*', default=OBJ_PATHS,
- help="Description of where to find *.o files. May be a directory \
- or a list of paths. Defaults to %r." % OBJ_PATHS)
- parser.add_argument('-v', '--verbose', action='store_true',
+ description="Find code size at the function level.",
+ allow_abbrev=False)
+ parser.add_argument(
+ 'obj_paths',
+ nargs='*',
+ help="Input *.o files.")
+ parser.add_argument(
+ '-v', '--verbose',
+ action='store_true',
help="Output commands that run behind the scenes.")
- parser.add_argument('-q', '--quiet', action='store_true',
+ parser.add_argument(
+ '-q', '--quiet',
+ action='store_true',
help="Don't show anything, useful with -o.")
- parser.add_argument('-o', '--output',
+ parser.add_argument(
+ '-o', '--output',
help="Specify CSV file to store results.")
- parser.add_argument('-u', '--use',
- help="Don't compile and find code sizes, instead use this CSV file.")
- parser.add_argument('-d', '--diff',
- help="Specify CSV file to diff code size against.")
- parser.add_argument('-m', '--merge',
- help="Merge with an existing CSV file when writing to output.")
- parser.add_argument('-a', '--all', action='store_true',
- help="Show all functions, not just the ones that changed.")
- parser.add_argument('-A', '--everything', action='store_true',
+ parser.add_argument(
+ '-u', '--use',
+ help="Don't parse anything, use this CSV file.")
+ parser.add_argument(
+ '-d', '--diff',
+ help="Specify CSV file to diff against.")
+ parser.add_argument(
+ '-a', '--all',
+ action='store_true',
+ help="Show all, not just the ones that changed.")
+ parser.add_argument(
+ '-p', '--percent',
+ action='store_true',
+ help="Only show percentage change, not a full diff.")
+ parser.add_argument(
+ '-b', '--by',
+ action='append',
+ choices=CodeResult._by,
+ help="Group by this field.")
+ parser.add_argument(
+ '-f', '--field',
+ dest='fields',
+ action='append',
+ choices=CodeResult._fields,
+ help="Show this field.")
+ parser.add_argument(
+ '-D', '--define',
+ dest='defines',
+ action='append',
+ type=lambda x: (lambda k,v: (k, set(v.split(','))))(*x.split('=', 1)),
+ help="Only include results where this field is this value.")
+ class AppendSort(argparse.Action):
+ def __call__(self, parser, namespace, value, option):
+ if namespace.sort is None:
+ namespace.sort = []
+ namespace.sort.append((value, True if option == '-S' else False))
+ parser.add_argument(
+ '-s', '--sort',
+ nargs='?',
+ action=AppendSort,
+ help="Sort by this field.")
+ parser.add_argument(
+ '-S', '--reverse-sort',
+ nargs='?',
+ action=AppendSort,
+ help="Sort by this field, but backwards.")
+ parser.add_argument(
+ '-Y', '--summary',
+ action='store_true',
+ help="Only show the total.")
+ parser.add_argument(
+ '-F', '--source',
+ dest='sources',
+ action='append',
+ help="Only consider definitions in this file. Defaults to anything "
+ "in the current directory.")
+ parser.add_argument(
+ '--everything',
+ action='store_true',
help="Include builtin and libc specific symbols.")
- parser.add_argument('-s', '--size-sort', action='store_true',
- help="Sort by size.")
- parser.add_argument('-S', '--reverse-size-sort', action='store_true',
- help="Sort by size, but backwards.")
- parser.add_argument('-F', '--files', action='store_true',
- help="Show file-level code sizes. Note this does not include padding! "
- "So sizes may differ from other tools.")
- parser.add_argument('-Y', '--summary', action='store_true',
- help="Only show the total code size.")
- parser.add_argument('--type', default='tTrRdD',
+ parser.add_argument(
+ '--nm-types',
+ default=NM_TYPES,
help="Type of symbols to report, this uses the same single-character "
- "type-names emitted by nm. Defaults to %(default)r.")
- parser.add_argument('--nm-tool', default=['nm'], type=lambda x: x.split(),
- help="Path to the nm tool to use.")
- parser.add_argument('--build-dir',
- help="Specify the relative build directory. Used to map object files \
- to the correct source files.")
- sys.exit(main(**vars(parser.parse_args())))
+ "type-names emitted by nm. Defaults to %r." % NM_TYPES)
+ parser.add_argument(
+ '--nm-path',
+ type=lambda x: x.split(),
+ default=NM_PATH,
+ help="Path to the nm executable, may include flags. "
+ "Defaults to %r." % NM_PATH)
+ parser.add_argument(
+ '--objdump-path',
+ type=lambda x: x.split(),
+ default=OBJDUMP_PATH,
+ help="Path to the objdump executable, may include flags. "
+ "Defaults to %r." % OBJDUMP_PATH)
+ sys.exit(main(**{k: v
+ for k, v in vars(parser.parse_intermixed_args()).items()
+ if v is not None}))
diff --git a/scripts/cov.py b/scripts/cov.py
new file mode 100755
index 00000000..b61b2e52
--- /dev/null
+++ b/scripts/cov.py
@@ -0,0 +1,828 @@
+#!/usr/bin/env python3
+#
+# Script to find coverage info after running tests.
+#
+# Example:
+# ./scripts/cov.py \
+# lfs.t.a.gcda lfs_util.t.a.gcda \
+# -Flfs.c -Flfs_util.c -slines
+#
+# Copyright (c) 2022, The littlefs authors.
+# Copyright (c) 2020, Arm Limited. All rights reserved.
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+import collections as co
+import csv
+import itertools as it
+import json
+import math as m
+import os
+import re
+import shlex
+import subprocess as sp
+
+# TODO use explode_asserts to avoid counting assert branches?
+# TODO use dwarf=info to find functions for inline functions?
+
+GCOV_PATH = ['gcov']
+
+
+# integer fields
+class Int(co.namedtuple('Int', 'x')):
+ __slots__ = ()
+ def __new__(cls, x=0):
+ if isinstance(x, Int):
+ return x
+ if isinstance(x, str):
+ try:
+ x = int(x, 0)
+ except ValueError:
+ # also accept +-∞ and +-inf
+ if re.match('^\s*\+?\s*(?:∞|inf)\s*$', x):
+ x = m.inf
+ elif re.match('^\s*-\s*(?:∞|inf)\s*$', x):
+ x = -m.inf
+ else:
+ raise
+ assert isinstance(x, int) or m.isinf(x), x
+ return super().__new__(cls, x)
+
+ def __str__(self):
+ if self.x == m.inf:
+ return '∞'
+ elif self.x == -m.inf:
+ return '-∞'
+ else:
+ return str(self.x)
+
+ def __int__(self):
+ assert not m.isinf(self.x)
+ return self.x
+
+ def __float__(self):
+ return float(self.x)
+
+ none = '%7s' % '-'
+ def table(self):
+ return '%7s' % (self,)
+
+ diff_none = '%7s' % '-'
+ diff_table = table
+
+ def diff_diff(self, other):
+ new = self.x if self else 0
+ old = other.x if other else 0
+ diff = new - old
+ if diff == +m.inf:
+ return '%7s' % '+∞'
+ elif diff == -m.inf:
+ return '%7s' % '-∞'
+ else:
+ return '%+7d' % diff
+
+ def ratio(self, other):
+ new = self.x if self else 0
+ old = other.x if other else 0
+ if m.isinf(new) and m.isinf(old):
+ return 0.0
+ elif m.isinf(new):
+ return +m.inf
+ elif m.isinf(old):
+ return -m.inf
+ elif not old and not new:
+ return 0.0
+ elif not old:
+ return 1.0
+ else:
+ return (new-old) / old
+
+ def __add__(self, other):
+ return self.__class__(self.x + other.x)
+
+ def __sub__(self, other):
+ return self.__class__(self.x - other.x)
+
+ def __mul__(self, other):
+ return self.__class__(self.x * other.x)
+
+# fractional fields, a/b
+class Frac(co.namedtuple('Frac', 'a,b')):
+ __slots__ = ()
+ def __new__(cls, a=0, b=None):
+ if isinstance(a, Frac) and b is None:
+ return a
+ if isinstance(a, str) and b is None:
+ a, b = a.split('/', 1)
+ if b is None:
+ b = a
+ return super().__new__(cls, Int(a), Int(b))
+
+ def __str__(self):
+ return '%s/%s' % (self.a, self.b)
+
+ def __float__(self):
+ return float(self.a)
+
+ none = '%11s %7s' % ('-', '-')
+ def table(self):
+ t = self.a.x/self.b.x if self.b.x else 1.0
+ return '%11s %7s' % (
+ self,
+ '∞%' if t == +m.inf
+ else '-∞%' if t == -m.inf
+ else '%.1f%%' % (100*t))
+
+ diff_none = '%11s' % '-'
+ def diff_table(self):
+ return '%11s' % (self,)
+
+ def diff_diff(self, other):
+ new_a, new_b = self if self else (Int(0), Int(0))
+ old_a, old_b = other if other else (Int(0), Int(0))
+ return '%11s' % ('%s/%s' % (
+ new_a.diff_diff(old_a).strip(),
+ new_b.diff_diff(old_b).strip()))
+
+ def ratio(self, other):
+ new_a, new_b = self if self else (Int(0), Int(0))
+ old_a, old_b = other if other else (Int(0), Int(0))
+ new = new_a.x/new_b.x if new_b.x else 1.0
+ old = old_a.x/old_b.x if old_b.x else 1.0
+ return new - old
+
+ def __add__(self, other):
+ return self.__class__(self.a + other.a, self.b + other.b)
+
+ def __sub__(self, other):
+ return self.__class__(self.a - other.a, self.b - other.b)
+
+ def __mul__(self, other):
+ return self.__class__(self.a * other.a, self.b + other.b)
+
+ def __lt__(self, other):
+ self_t = self.a.x/self.b.x if self.b.x else 1.0
+ other_t = other.a.x/other.b.x if other.b.x else 1.0
+ return (self_t, self.a.x) < (other_t, other.a.x)
+
+ def __gt__(self, other):
+ return self.__class__.__lt__(other, self)
+
+ def __le__(self, other):
+ return not self.__gt__(other)
+
+ def __ge__(self, other):
+ return not self.__lt__(other)
+
+# coverage results
+class CovResult(co.namedtuple('CovResult', [
+ 'file', 'function', 'line',
+ 'calls', 'hits', 'funcs', 'lines', 'branches'])):
+ _by = ['file', 'function', 'line']
+ _fields = ['calls', 'hits', 'funcs', 'lines', 'branches']
+ _sort = ['funcs', 'lines', 'branches', 'hits', 'calls']
+ _types = {
+ 'calls': Int, 'hits': Int,
+ 'funcs': Frac, 'lines': Frac, 'branches': Frac}
+
+ __slots__ = ()
+ def __new__(cls, file='', function='', line=0,
+ calls=0, hits=0, funcs=0, lines=0, branches=0):
+ return super().__new__(cls, file, function, int(Int(line)),
+ Int(calls), Int(hits), Frac(funcs), Frac(lines), Frac(branches))
+
+ def __add__(self, other):
+ return CovResult(self.file, self.function, self.line,
+ max(self.calls, other.calls),
+ max(self.hits, other.hits),
+ self.funcs + other.funcs,
+ self.lines + other.lines,
+ self.branches + other.branches)
+
+
+def openio(path, mode='r', buffering=-1):
+ # allow '-' for stdin/stdout
+ if path == '-':
+ if mode == 'r':
+ return os.fdopen(os.dup(sys.stdin.fileno()), mode, buffering)
+ else:
+ return os.fdopen(os.dup(sys.stdout.fileno()), mode, buffering)
+ else:
+ return open(path, mode, buffering)
+
+def collect(gcda_paths, *,
+ gcov_path=GCOV_PATH,
+ sources=None,
+ everything=False,
+ **args):
+ results = []
+ for path in gcda_paths:
+ # get coverage info through gcov's json output
+ # note, gcov-path may contain extra args
+ cmd = GCOV_PATH + ['-b', '-t', '--json-format', path]
+ if args.get('verbose'):
+ print(' '.join(shlex.quote(c) for c in cmd))
+ proc = sp.Popen(cmd,
+ stdout=sp.PIPE,
+ stderr=sp.PIPE if not args.get('verbose') else None,
+ universal_newlines=True,
+ errors='replace',
+ close_fds=False)
+ data = json.load(proc.stdout)
+ proc.wait()
+ if proc.returncode != 0:
+ if not args.get('verbose'):
+ for line in proc.stderr:
+ sys.stdout.write(line)
+ sys.exit(-1)
+
+ # collect line/branch coverage
+ for file in data['files']:
+ # ignore filtered sources
+ if sources is not None:
+ if not any(
+ os.path.abspath(file['file']) == os.path.abspath(s)
+ for s in sources):
+ continue
+ else:
+ # default to only cwd
+ if not everything and not os.path.commonpath([
+ os.getcwd(),
+ os.path.abspath(file['file'])]) == os.getcwd():
+ continue
+
+ # simplify path
+ if os.path.commonpath([
+ os.getcwd(),
+ os.path.abspath(file['file'])]) == os.getcwd():
+ file_name = os.path.relpath(file['file'])
+ else:
+ file_name = os.path.abspath(file['file'])
+
+ for func in file['functions']:
+ func_name = func.get('name', '(inlined)')
+ # discard internal functions (this includes injected test cases)
+ if not everything:
+ if func_name.startswith('__'):
+ continue
+
+ # go ahead and add functions, later folding will merge this if
+ # there are other hits on this line
+ results.append(CovResult(
+ file_name, func_name, func['start_line'],
+ func['execution_count'], 0,
+ Frac(1 if func['execution_count'] > 0 else 0, 1),
+ 0,
+ 0))
+
+ for line in file['lines']:
+ func_name = line.get('function_name', '(inlined)')
+ # discard internal function (this includes injected test cases)
+ if not everything:
+ if func_name.startswith('__'):
+ continue
+
+ # go ahead and add lines, later folding will merge this if
+ # there are other hits on this line
+ results.append(CovResult(
+ file_name, func_name, line['line_number'],
+ 0, line['count'],
+ 0,
+ Frac(1 if line['count'] > 0 else 0, 1),
+ Frac(
+ sum(1 if branch['count'] > 0 else 0
+ for branch in line['branches']),
+ len(line['branches']))))
+
+ return results
+
+
+def fold(Result, results, *,
+ by=None,
+ defines=None,
+ **_):
+ if by is None:
+ by = Result._by
+
+ for k in it.chain(by or [], (k for k, _ in defines or [])):
+ if k not in Result._by and k not in Result._fields:
+ print("error: could not find field %r?" % k)
+ sys.exit(-1)
+
+ # filter by matching defines
+ if defines is not None:
+ results_ = []
+ for r in results:
+ if all(getattr(r, k) in vs for k, vs in defines):
+ results_.append(r)
+ results = results_
+
+ # organize results into conflicts
+ folding = co.OrderedDict()
+ for r in results:
+ name = tuple(getattr(r, k) for k in by)
+ if name not in folding:
+ folding[name] = []
+ folding[name].append(r)
+
+ # merge conflicts
+ folded = []
+ for name, rs in folding.items():
+ folded.append(sum(rs[1:], start=rs[0]))
+
+ return folded
+
+def table(Result, results, diff_results=None, *,
+ by=None,
+ fields=None,
+ sort=None,
+ summary=False,
+ all=False,
+ percent=False,
+ **_):
+ all_, all = all, __builtins__.all
+
+ if by is None:
+ by = Result._by
+ if fields is None:
+ fields = Result._fields
+ types = Result._types
+
+ # fold again
+ results = fold(Result, results, by=by)
+ if diff_results is not None:
+ diff_results = fold(Result, diff_results, by=by)
+
+ # organize by name
+ table = {
+ ','.join(str(getattr(r, k) or '') for k in by): r
+ for r in results}
+ diff_table = {
+ ','.join(str(getattr(r, k) or '') for k in by): r
+ for r in diff_results or []}
+ names = list(table.keys() | diff_table.keys())
+
+ # sort again, now with diff info, note that python's sort is stable
+ names.sort()
+ if diff_results is not None:
+ names.sort(key=lambda n: tuple(
+ types[k].ratio(
+ getattr(table.get(n), k, None),
+ getattr(diff_table.get(n), k, None))
+ for k in fields),
+ reverse=True)
+ if sort:
+ for k, reverse in reversed(sort):
+ names.sort(
+ key=lambda n: tuple(
+ (getattr(table[n], k),)
+ if getattr(table.get(n), k, None) is not None else ()
+ for k in ([k] if k else [
+ k for k in Result._sort if k in fields])),
+ reverse=reverse ^ (not k or k in Result._fields))
+
+
+ # build up our lines
+ lines = []
+
+ # header
+ header = []
+ header.append('%s%s' % (
+ ','.join(by),
+ ' (%d added, %d removed)' % (
+ sum(1 for n in table if n not in diff_table),
+ sum(1 for n in diff_table if n not in table))
+ if diff_results is not None and not percent else '')
+ if not summary else '')
+ if diff_results is None:
+ for k in fields:
+ header.append(k)
+ elif percent:
+ for k in fields:
+ header.append(k)
+ else:
+ for k in fields:
+ header.append('o'+k)
+ for k in fields:
+ header.append('n'+k)
+ for k in fields:
+ header.append('d'+k)
+ header.append('')
+ lines.append(header)
+
+ def table_entry(name, r, diff_r=None, ratios=[]):
+ entry = []
+ entry.append(name)
+ if diff_results is None:
+ for k in fields:
+ entry.append(getattr(r, k).table()
+ if getattr(r, k, None) is not None
+ else types[k].none)
+ elif percent:
+ for k in fields:
+ entry.append(getattr(r, k).diff_table()
+ if getattr(r, k, None) is not None
+ else types[k].diff_none)
+ else:
+ for k in fields:
+ entry.append(getattr(diff_r, k).diff_table()
+ if getattr(diff_r, k, None) is not None
+ else types[k].diff_none)
+ for k in fields:
+ entry.append(getattr(r, k).diff_table()
+ if getattr(r, k, None) is not None
+ else types[k].diff_none)
+ for k in fields:
+ entry.append(types[k].diff_diff(
+ getattr(r, k, None),
+ getattr(diff_r, k, None)))
+ if diff_results is None:
+ entry.append('')
+ elif percent:
+ entry.append(' (%s)' % ', '.join(
+ '+∞%' if t == +m.inf
+ else '-∞%' if t == -m.inf
+ else '%+.1f%%' % (100*t)
+ for t in ratios))
+ else:
+ entry.append(' (%s)' % ', '.join(
+ '+∞%' if t == +m.inf
+ else '-∞%' if t == -m.inf
+ else '%+.1f%%' % (100*t)
+ for t in ratios
+ if t)
+ if any(ratios) else '')
+ return entry
+
+ # entries
+ if not summary:
+ for name in names:
+ r = table.get(name)
+ if diff_results is None:
+ diff_r = None
+ ratios = None
+ else:
+ diff_r = diff_table.get(name)
+ ratios = [
+ types[k].ratio(
+ getattr(r, k, None),
+ getattr(diff_r, k, None))
+ for k in fields]
+ if not all_ and not any(ratios):
+ continue
+ lines.append(table_entry(name, r, diff_r, ratios))
+
+ # total
+ r = next(iter(fold(Result, results, by=[])), None)
+ if diff_results is None:
+ diff_r = None
+ ratios = None
+ else:
+ diff_r = next(iter(fold(Result, diff_results, by=[])), None)
+ ratios = [
+ types[k].ratio(
+ getattr(r, k, None),
+ getattr(diff_r, k, None))
+ for k in fields]
+ lines.append(table_entry('TOTAL', r, diff_r, ratios))
+
+ # find the best widths, note that column 0 contains the names and column -1
+ # the ratios, so those are handled a bit differently
+ widths = [
+ ((max(it.chain([w], (len(l[i]) for l in lines)))+1+4-1)//4)*4-1
+ for w, i in zip(
+ it.chain([23], it.repeat(7)),
+ range(len(lines[0])-1))]
+
+ # print our table
+ for line in lines:
+ print('%-*s %s%s' % (
+ widths[0], line[0],
+ ' '.join('%*s' % (w, x)
+ for w, x in zip(widths[1:], line[1:-1])),
+ line[-1]))
+
+
+def annotate(Result, results, *,
+ annotate=False,
+ lines=False,
+ branches=False,
+ **args):
+ # if neither branches/lines specified, color both
+ if annotate and not lines and not branches:
+ lines, branches = True, True
+
+ for path in co.OrderedDict.fromkeys(r.file for r in results).keys():
+ # flatten to line info
+ results = fold(Result, results, by=['file', 'line'])
+ table = {r.line: r for r in results if r.file == path}
+
+ # calculate spans to show
+ if not annotate:
+ spans = []
+ last = None
+ func = None
+ for line, r in sorted(table.items()):
+ if ((lines and int(r.hits) == 0)
+ or (branches and r.branches.a < r.branches.b)):
+ if last is not None and line - last.stop <= args['context']:
+ last = range(
+ last.start,
+ line+1+args['context'])
+ else:
+ if last is not None:
+ spans.append((last, func))
+ last = range(
+ line-args['context'],
+ line+1+args['context'])
+ func = r.function
+ if last is not None:
+ spans.append((last, func))
+
+ with open(path) as f:
+ skipped = False
+ for i, line in enumerate(f):
+ # skip lines not in spans?
+ if not annotate and not any(i+1 in s for s, _ in spans):
+ skipped = True
+ continue
+
+ if skipped:
+ skipped = False
+ print('%s@@ %s:%d: %s @@%s' % (
+ '\x1b[36m' if args['color'] else '',
+ path,
+ i+1,
+ next(iter(f for _, f in spans)),
+ '\x1b[m' if args['color'] else ''))
+
+ # build line
+ if line.endswith('\n'):
+ line = line[:-1]
+
+ if i+1 in table:
+ r = table[i+1]
+ line = '%-*s // %s hits%s' % (
+ args['width'],
+ line,
+ r.hits,
+ ', %s branches' % (r.branches,)
+ if int(r.branches.b) else '')
+
+ if args['color']:
+ if lines and int(r.hits) == 0:
+ line = '\x1b[1;31m%s\x1b[m' % line
+ elif branches and r.branches.a < r.branches.b:
+ line = '\x1b[35m%s\x1b[m' % line
+
+ print(line)
+
+
+def main(gcda_paths, *,
+ by=None,
+ fields=None,
+ defines=None,
+ sort=None,
+ hits=False,
+ **args):
+ # figure out what color should be
+ if args.get('color') == 'auto':
+ args['color'] = sys.stdout.isatty()
+ elif args.get('color') == 'always':
+ args['color'] = True
+ else:
+ args['color'] = False
+
+ # find sizes
+ if not args.get('use', None):
+ results = collect(gcda_paths, **args)
+ else:
+ results = []
+ with openio(args['use']) as f:
+ reader = csv.DictReader(f, restval='')
+ for r in reader:
+ if not any('cov_'+k in r and r['cov_'+k].strip()
+ for k in CovResult._fields):
+ continue
+ try:
+ results.append(CovResult(
+ **{k: r[k] for k in CovResult._by
+ if k in r and r[k].strip()},
+ **{k: r['cov_'+k]
+ for k in CovResult._fields
+ if 'cov_'+k in r
+ and r['cov_'+k].strip()}))
+ except TypeError:
+ pass
+
+ # fold
+ results = fold(CovResult, results, by=by, defines=defines)
+
+ # sort, note that python's sort is stable
+ results.sort()
+ if sort:
+ for k, reverse in reversed(sort):
+ results.sort(
+ key=lambda r: tuple(
+ (getattr(r, k),) if getattr(r, k) is not None else ()
+ for k in ([k] if k else CovResult._sort)),
+ reverse=reverse ^ (not k or k in CovResult._fields))
+
+ # write results to CSV
+ if args.get('output'):
+ with openio(args['output'], 'w') as f:
+ writer = csv.DictWriter(f,
+ (by if by is not None else CovResult._by)
+ + ['cov_'+k for k in (
+ fields if fields is not None else CovResult._fields)])
+ writer.writeheader()
+ for r in results:
+ writer.writerow(
+ {k: getattr(r, k) for k in (
+ by if by is not None else CovResult._by)}
+ | {'cov_'+k: getattr(r, k) for k in (
+ fields if fields is not None else CovResult._fields)})
+
+ # find previous results?
+ if args.get('diff'):
+ diff_results = []
+ try:
+ with openio(args['diff']) as f:
+ reader = csv.DictReader(f, restval='')
+ for r in reader:
+ if not any('cov_'+k in r and r['cov_'+k].strip()
+ for k in CovResult._fields):
+ continue
+ try:
+ diff_results.append(CovResult(
+ **{k: r[k] for k in CovResult._by
+ if k in r and r[k].strip()},
+ **{k: r['cov_'+k]
+ for k in CovResult._fields
+ if 'cov_'+k in r
+ and r['cov_'+k].strip()}))
+ except TypeError:
+ pass
+ except FileNotFoundError:
+ pass
+
+ # fold
+ diff_results = fold(CovResult, diff_results,
+ by=by, defines=defines)
+
+ # print table
+ if not args.get('quiet'):
+ if (args.get('annotate')
+ or args.get('lines')
+ or args.get('branches')):
+ # annotate sources
+ annotate(CovResult, results, **args)
+ else:
+ # print table
+ table(CovResult, results,
+ diff_results if args.get('diff') else None,
+ by=by if by is not None else ['function'],
+ fields=fields if fields is not None
+ else ['lines', 'branches'] if not hits
+ else ['calls', 'hits'],
+ sort=sort,
+ **args)
+
+ # catch lack of coverage
+ if args.get('error_on_lines') and any(
+ r.lines.a < r.lines.b for r in results):
+ sys.exit(2)
+ elif args.get('error_on_branches') and any(
+ r.branches.a < r.branches.b for r in results):
+ sys.exit(3)
+
+
+if __name__ == "__main__":
+ import argparse
+ import sys
+ parser = argparse.ArgumentParser(
+ description="Find coverage info after running tests.",
+ allow_abbrev=False)
+ parser.add_argument(
+ 'gcda_paths',
+ nargs='*',
+ help="Input *.gcda files.")
+ parser.add_argument(
+ '-v', '--verbose',
+ action='store_true',
+ help="Output commands that run behind the scenes.")
+ parser.add_argument(
+ '-q', '--quiet',
+ action='store_true',
+ help="Don't show anything, useful with -o.")
+ parser.add_argument(
+ '-o', '--output',
+ help="Specify CSV file to store results.")
+ parser.add_argument(
+ '-u', '--use',
+ help="Don't parse anything, use this CSV file.")
+ parser.add_argument(
+ '-d', '--diff',
+ help="Specify CSV file to diff against.")
+ parser.add_argument(
+ '-a', '--all',
+ action='store_true',
+ help="Show all, not just the ones that changed.")
+ parser.add_argument(
+ '-p', '--percent',
+ action='store_true',
+ help="Only show percentage change, not a full diff.")
+ parser.add_argument(
+ '-b', '--by',
+ action='append',
+ choices=CovResult._by,
+ help="Group by this field.")
+ parser.add_argument(
+ '-f', '--field',
+ dest='fields',
+ action='append',
+ choices=CovResult._fields,
+ help="Show this field.")
+ parser.add_argument(
+ '-D', '--define',
+ dest='defines',
+ action='append',
+ type=lambda x: (lambda k,v: (k, set(v.split(','))))(*x.split('=', 1)),
+ help="Only include results where this field is this value.")
+ class AppendSort(argparse.Action):
+ def __call__(self, parser, namespace, value, option):
+ if namespace.sort is None:
+ namespace.sort = []
+ namespace.sort.append((value, True if option == '-S' else False))
+ parser.add_argument(
+ '-s', '--sort',
+ nargs='?',
+ action=AppendSort,
+ help="Sort by this field.")
+ parser.add_argument(
+ '-S', '--reverse-sort',
+ nargs='?',
+ action=AppendSort,
+ help="Sort by this field, but backwards.")
+ parser.add_argument(
+ '-Y', '--summary',
+ action='store_true',
+ help="Only show the total.")
+ parser.add_argument(
+ '-F', '--source',
+ dest='sources',
+ action='append',
+ help="Only consider definitions in this file. Defaults to anything "
+ "in the current directory.")
+ parser.add_argument(
+ '--everything',
+ action='store_true',
+ help="Include builtin and libc specific symbols.")
+ parser.add_argument(
+ '--hits',
+ action='store_true',
+ help="Show total hits instead of coverage.")
+ parser.add_argument(
+ '-A', '--annotate',
+ action='store_true',
+ help="Show source files annotated with coverage info.")
+ parser.add_argument(
+ '-L', '--lines',
+ action='store_true',
+ help="Show uncovered lines.")
+ parser.add_argument(
+ '-B', '--branches',
+ action='store_true',
+ help="Show uncovered branches.")
+ parser.add_argument(
+ '-c', '--context',
+ type=lambda x: int(x, 0),
+ default=3,
+ help="Show n additional lines of context. Defaults to 3.")
+ parser.add_argument(
+ '-W', '--width',
+ type=lambda x: int(x, 0),
+ default=80,
+ help="Assume source is styled with this many columns. Defaults to 80.")
+ parser.add_argument(
+ '--color',
+ choices=['never', 'always', 'auto'],
+ default='auto',
+ help="When to use terminal colors. Defaults to 'auto'.")
+ parser.add_argument(
+ '-e', '--error-on-lines',
+ action='store_true',
+ help="Error if any lines are not covered.")
+ parser.add_argument(
+ '-E', '--error-on-branches',
+ action='store_true',
+ help="Error if any branches are not covered.")
+ parser.add_argument(
+ '--gcov-path',
+ default=GCOV_PATH,
+ type=lambda x: x.split(),
+ help="Path to the gcov executable, may include paths. "
+ "Defaults to %r." % GCOV_PATH)
+ sys.exit(main(**{k: v
+ for k, v in vars(parser.parse_intermixed_args()).items()
+ if v is not None}))
diff --git a/scripts/coverage.py b/scripts/coverage.py
deleted file mode 100755
index b3a90ed2..00000000
--- a/scripts/coverage.py
+++ /dev/null
@@ -1,323 +0,0 @@
-#!/usr/bin/env python3
-#
-# Parse and report coverage info from .info files generated by lcov
-#
-import os
-import glob
-import csv
-import re
-import collections as co
-import bisect as b
-
-
-INFO_PATHS = ['tests/*.toml.info']
-
-def collect(paths, **args):
- file = None
- funcs = []
- lines = co.defaultdict(lambda: 0)
- pattern = re.compile(
- '^(?PSF:/?(?P.*))$'
- '|^(?PFN:(?P[0-9]*),(?P.*))$'
- '|^(?PDA:(?P[0-9]*),(?P[0-9]*))$')
- for path in paths:
- with open(path) as f:
- for line in f:
- m = pattern.match(line)
- if m and m.group('file'):
- file = m.group('file_name')
- elif m and file and m.group('func'):
- funcs.append((file, int(m.group('func_lineno')),
- m.group('func_name')))
- elif m and file and m.group('line'):
- lines[(file, int(m.group('line_lineno')))] += (
- int(m.group('line_hits')))
-
- # map line numbers to functions
- funcs.sort()
- def func_from_lineno(file, lineno):
- i = b.bisect(funcs, (file, lineno))
- if i and funcs[i-1][0] == file:
- return funcs[i-1][2]
- else:
- return None
-
- # reduce to function info
- reduced_funcs = co.defaultdict(lambda: (0, 0))
- for (file, line_lineno), line_hits in lines.items():
- func = func_from_lineno(file, line_lineno)
- if not func:
- continue
- hits, count = reduced_funcs[(file, func)]
- reduced_funcs[(file, func)] = (hits + (line_hits > 0), count + 1)
-
- results = []
- for (file, func), (hits, count) in reduced_funcs.items():
- # discard internal/testing functions (test_* injected with
- # internal testing)
- if not args.get('everything'):
- if func.startswith('__') or func.startswith('test_'):
- continue
- # discard .8449 suffixes created by optimizer
- func = re.sub('\.[0-9]+', '', func)
- results.append((file, func, hits, count))
-
- return results
-
-
-def main(**args):
- def openio(path, mode='r'):
- if path == '-':
- if 'r' in mode:
- return os.fdopen(os.dup(sys.stdin.fileno()), 'r')
- else:
- return os.fdopen(os.dup(sys.stdout.fileno()), 'w')
- else:
- return open(path, mode)
-
- # find coverage
- if not args.get('use'):
- # find *.info files
- paths = []
- for path in args['info_paths']:
- if os.path.isdir(path):
- path = path + '/*.gcov'
-
- for path in glob.glob(path):
- paths.append(path)
-
- if not paths:
- print('no .info files found in %r?' % args['info_paths'])
- sys.exit(-1)
-
- results = collect(paths, **args)
- else:
- with openio(args['use']) as f:
- r = csv.DictReader(f)
- results = [
- ( result['file'],
- result['name'],
- int(result['coverage_hits']),
- int(result['coverage_count']))
- for result in r
- if result.get('coverage_hits') not in {None, ''}
- if result.get('coverage_count') not in {None, ''}]
-
- total_hits, total_count = 0, 0
- for _, _, hits, count in results:
- total_hits += hits
- total_count += count
-
- # find previous results?
- if args.get('diff'):
- try:
- with openio(args['diff']) as f:
- r = csv.DictReader(f)
- prev_results = [
- ( result['file'],
- result['name'],
- int(result['coverage_hits']),
- int(result['coverage_count']))
- for result in r
- if result.get('coverage_hits') not in {None, ''}
- if result.get('coverage_count') not in {None, ''}]
- except FileNotFoundError:
- prev_results = []
-
- prev_total_hits, prev_total_count = 0, 0
- for _, _, hits, count in prev_results:
- prev_total_hits += hits
- prev_total_count += count
-
- # write results to CSV
- if args.get('output'):
- merged_results = co.defaultdict(lambda: {})
- other_fields = []
-
- # merge?
- if args.get('merge'):
- try:
- with openio(args['merge']) as f:
- r = csv.DictReader(f)
- for result in r:
- file = result.pop('file', '')
- func = result.pop('name', '')
- result.pop('coverage_hits', None)
- result.pop('coverage_count', None)
- merged_results[(file, func)] = result
- other_fields = result.keys()
- except FileNotFoundError:
- pass
-
- for file, func, hits, count in results:
- merged_results[(file, func)]['coverage_hits'] = hits
- merged_results[(file, func)]['coverage_count'] = count
-
- with openio(args['output'], 'w') as f:
- w = csv.DictWriter(f, ['file', 'name', *other_fields, 'coverage_hits', 'coverage_count'])
- w.writeheader()
- for (file, func), result in sorted(merged_results.items()):
- w.writerow({'file': file, 'name': func, **result})
-
- # print results
- def dedup_entries(results, by='name'):
- entries = co.defaultdict(lambda: (0, 0))
- for file, func, hits, count in results:
- entry = (file if by == 'file' else func)
- entry_hits, entry_count = entries[entry]
- entries[entry] = (entry_hits + hits, entry_count + count)
- return entries
-
- def diff_entries(olds, news):
- diff = co.defaultdict(lambda: (0, 0, 0, 0, 0, 0, 0))
- for name, (new_hits, new_count) in news.items():
- diff[name] = (
- 0, 0,
- new_hits, new_count,
- new_hits, new_count,
- (new_hits/new_count if new_count else 1.0) - 1.0)
- for name, (old_hits, old_count) in olds.items():
- _, _, new_hits, new_count, _, _, _ = diff[name]
- diff[name] = (
- old_hits, old_count,
- new_hits, new_count,
- new_hits-old_hits, new_count-old_count,
- ((new_hits/new_count if new_count else 1.0)
- - (old_hits/old_count if old_count else 1.0)))
- return diff
-
- def sorted_entries(entries):
- if args.get('coverage_sort'):
- return sorted(entries, key=lambda x: (-(x[1][0]/x[1][1] if x[1][1] else -1), x))
- elif args.get('reverse_coverage_sort'):
- return sorted(entries, key=lambda x: (+(x[1][0]/x[1][1] if x[1][1] else -1), x))
- else:
- return sorted(entries)
-
- def sorted_diff_entries(entries):
- if args.get('coverage_sort'):
- return sorted(entries, key=lambda x: (-(x[1][2]/x[1][3] if x[1][3] else -1), x))
- elif args.get('reverse_coverage_sort'):
- return sorted(entries, key=lambda x: (+(x[1][2]/x[1][3] if x[1][3] else -1), x))
- else:
- return sorted(entries, key=lambda x: (-x[1][6], x))
-
- def print_header(by=''):
- if not args.get('diff'):
- print('%-36s %19s' % (by, 'hits/line'))
- else:
- print('%-36s %19s %19s %11s' % (by, 'old', 'new', 'diff'))
-
- def print_entry(name, hits, count):
- print("%-36s %11s %7s" % (name,
- '%d/%d' % (hits, count)
- if count else '-',
- '%.1f%%' % (100*hits/count)
- if count else '-'))
-
- def print_diff_entry(name,
- old_hits, old_count,
- new_hits, new_count,
- diff_hits, diff_count,
- ratio):
- print("%-36s %11s %7s %11s %7s %11s%s" % (name,
- '%d/%d' % (old_hits, old_count)
- if old_count else '-',
- '%.1f%%' % (100*old_hits/old_count)
- if old_count else '-',
- '%d/%d' % (new_hits, new_count)
- if new_count else '-',
- '%.1f%%' % (100*new_hits/new_count)
- if new_count else '-',
- '%+d/%+d' % (diff_hits, diff_count),
- ' (%+.1f%%)' % (100*ratio) if ratio else ''))
-
- def print_entries(by='name'):
- entries = dedup_entries(results, by=by)
-
- if not args.get('diff'):
- print_header(by=by)
- for name, (hits, count) in sorted_entries(entries.items()):
- print_entry(name, hits, count)
- else:
- prev_entries = dedup_entries(prev_results, by=by)
- diff = diff_entries(prev_entries, entries)
- print_header(by='%s (%d added, %d removed)' % (by,
- sum(1 for _, old, _, _, _, _, _ in diff.values() if not old),
- sum(1 for _, _, _, new, _, _, _ in diff.values() if not new)))
- for name, (
- old_hits, old_count,
- new_hits, new_count,
- diff_hits, diff_count, ratio) in sorted_diff_entries(
- diff.items()):
- if ratio or args.get('all'):
- print_diff_entry(name,
- old_hits, old_count,
- new_hits, new_count,
- diff_hits, diff_count,
- ratio)
-
- def print_totals():
- if not args.get('diff'):
- print_entry('TOTAL', total_hits, total_count)
- else:
- ratio = ((total_hits/total_count
- if total_count else 1.0)
- - (prev_total_hits/prev_total_count
- if prev_total_count else 1.0))
- print_diff_entry('TOTAL',
- prev_total_hits, prev_total_count,
- total_hits, total_count,
- total_hits-prev_total_hits, total_count-prev_total_count,
- ratio)
-
- if args.get('quiet'):
- pass
- elif args.get('summary'):
- print_header()
- print_totals()
- elif args.get('files'):
- print_entries(by='file')
- print_totals()
- else:
- print_entries(by='name')
- print_totals()
-
-if __name__ == "__main__":
- import argparse
- import sys
- parser = argparse.ArgumentParser(
- description="Parse and report coverage info from .info files \
- generated by lcov")
- parser.add_argument('info_paths', nargs='*', default=INFO_PATHS,
- help="Description of where to find *.info files. May be a directory \
- or list of paths. *.info files will be merged to show the total \
- coverage. Defaults to %r." % INFO_PATHS)
- parser.add_argument('-v', '--verbose', action='store_true',
- help="Output commands that run behind the scenes.")
- parser.add_argument('-o', '--output',
- help="Specify CSV file to store results.")
- parser.add_argument('-u', '--use',
- help="Don't do any work, instead use this CSV file.")
- parser.add_argument('-d', '--diff',
- help="Specify CSV file to diff code size against.")
- parser.add_argument('-m', '--merge',
- help="Merge with an existing CSV file when writing to output.")
- parser.add_argument('-a', '--all', action='store_true',
- help="Show all functions, not just the ones that changed.")
- parser.add_argument('-A', '--everything', action='store_true',
- help="Include builtin and libc specific symbols.")
- parser.add_argument('-s', '--coverage-sort', action='store_true',
- help="Sort by coverage.")
- parser.add_argument('-S', '--reverse-coverage-sort', action='store_true',
- help="Sort by coverage, but backwards.")
- parser.add_argument('-F', '--files', action='store_true',
- help="Show file-level coverage.")
- parser.add_argument('-Y', '--summary', action='store_true',
- help="Only show the total coverage.")
- parser.add_argument('-q', '--quiet', action='store_true',
- help="Don't show anything, useful with -o.")
- parser.add_argument('--build-dir',
- help="Specify the relative build directory. Used to map object files \
- to the correct source files.")
- sys.exit(main(**vars(parser.parse_args())))
diff --git a/scripts/data.py b/scripts/data.py
index 4b8e00da..e9770aa1 100755
--- a/scripts/data.py
+++ b/scripts/data.py
@@ -1,42 +1,188 @@
#!/usr/bin/env python3
#
-# Script to find data size at the function level. Basically just a bit wrapper
+# Script to find data size at the function level. Basically just a big wrapper
# around nm with some extra conveniences for comparing builds. Heavily inspired
# by Linux's Bloat-O-Meter.
#
+# Example:
+# ./scripts/data.py lfs.o lfs_util.o -Ssize
+#
+# Copyright (c) 2022, The littlefs authors.
+# Copyright (c) 2020, Arm Limited. All rights reserved.
+# SPDX-License-Identifier: BSD-3-Clause
+#
-import os
-import glob
+import collections as co
+import csv
+import difflib
import itertools as it
-import subprocess as sp
-import shlex
+import math as m
+import os
import re
-import csv
-import collections as co
+import shlex
+import subprocess as sp
+
+
+NM_PATH = ['nm']
+NM_TYPES = 'dDbB'
+OBJDUMP_PATH = ['objdump']
+
+
+# integer fields
+class Int(co.namedtuple('Int', 'x')):
+ __slots__ = ()
+ def __new__(cls, x=0):
+ if isinstance(x, Int):
+ return x
+ if isinstance(x, str):
+ try:
+ x = int(x, 0)
+ except ValueError:
+ # also accept +-∞ and +-inf
+ if re.match('^\s*\+?\s*(?:∞|inf)\s*$', x):
+ x = m.inf
+ elif re.match('^\s*-\s*(?:∞|inf)\s*$', x):
+ x = -m.inf
+ else:
+ raise
+ assert isinstance(x, int) or m.isinf(x), x
+ return super().__new__(cls, x)
+
+ def __str__(self):
+ if self.x == m.inf:
+ return '∞'
+ elif self.x == -m.inf:
+ return '-∞'
+ else:
+ return str(self.x)
+
+ def __int__(self):
+ assert not m.isinf(self.x)
+ return self.x
+
+ def __float__(self):
+ return float(self.x)
+
+ none = '%7s' % '-'
+ def table(self):
+ return '%7s' % (self,)
+
+ diff_none = '%7s' % '-'
+ diff_table = table
+
+ def diff_diff(self, other):
+ new = self.x if self else 0
+ old = other.x if other else 0
+ diff = new - old
+ if diff == +m.inf:
+ return '%7s' % '+∞'
+ elif diff == -m.inf:
+ return '%7s' % '-∞'
+ else:
+ return '%+7d' % diff
+
+ def ratio(self, other):
+ new = self.x if self else 0
+ old = other.x if other else 0
+ if m.isinf(new) and m.isinf(old):
+ return 0.0
+ elif m.isinf(new):
+ return +m.inf
+ elif m.isinf(old):
+ return -m.inf
+ elif not old and not new:
+ return 0.0
+ elif not old:
+ return 1.0
+ else:
+ return (new-old) / old
+
+ def __add__(self, other):
+ return self.__class__(self.x + other.x)
+
+ def __sub__(self, other):
+ return self.__class__(self.x - other.x)
+
+ def __mul__(self, other):
+ return self.__class__(self.x * other.x)
+# data size results
+class DataResult(co.namedtuple('DataResult', [
+ 'file', 'function',
+ 'size'])):
+ _by = ['file', 'function']
+ _fields = ['size']
+ _sort = ['size']
+ _types = {'size': Int}
-OBJ_PATHS = ['*.o']
+ __slots__ = ()
+ def __new__(cls, file='', function='', size=0):
+ return super().__new__(cls, file, function,
+ Int(size))
-def collect(paths, **args):
- results = co.defaultdict(lambda: 0)
- pattern = re.compile(
+ def __add__(self, other):
+ return DataResult(self.file, self.function,
+ self.size + other.size)
+
+
+def openio(path, mode='r', buffering=-1):
+ # allow '-' for stdin/stdout
+ if path == '-':
+ if mode == 'r':
+ return os.fdopen(os.dup(sys.stdin.fileno()), mode, buffering)
+ else:
+ return os.fdopen(os.dup(sys.stdout.fileno()), mode, buffering)
+ else:
+ return open(path, mode, buffering)
+
+def collect(obj_paths, *,
+ nm_path=NM_PATH,
+ nm_types=NM_TYPES,
+ objdump_path=OBJDUMP_PATH,
+ sources=None,
+ everything=False,
+ **args):
+ size_pattern = re.compile(
'^(?P[0-9a-fA-F]+)' +
- ' (?P[%s])' % re.escape(args['type']) +
+ ' (?P[%s])' % re.escape(nm_types) +
' (?P.+?)$')
- for path in paths:
- # note nm-tool may contain extra args
- cmd = args['nm_tool'] + ['--size-sort', path]
+ line_pattern = re.compile(
+ '^\s+(?P[0-9]+)'
+ '(?:\s+(?P[0-9]+))?'
+ '\s+.*'
+ '\s+(?P[^\s]+)$')
+ info_pattern = re.compile(
+ '^(?:.*(?PDW_TAG_[a-z_]+).*'
+ '|.*DW_AT_name.*:\s*(?P[^:\s]+)\s*'
+ '|.*DW_AT_decl_file.*:\s*(?P[0-9]+)\s*)$')
+
+ results = []
+ for path in obj_paths:
+ # guess the source, if we have debug-info we'll replace this later
+ file = re.sub('(\.o)?$', '.c', path, 1)
+
+ # find symbol sizes
+ results_ = []
+ # note nm-path may contain extra args
+ cmd = nm_path + ['--size-sort', path]
if args.get('verbose'):
print(' '.join(shlex.quote(c) for c in cmd))
proc = sp.Popen(cmd,
stdout=sp.PIPE,
stderr=sp.PIPE if not args.get('verbose') else None,
universal_newlines=True,
- errors='replace')
+ errors='replace',
+ close_fds=False)
for line in proc.stdout:
- m = pattern.match(line)
+ m = size_pattern.match(line)
if m:
- results[(path, m.group('func'))] += int(m.group('size'), 16)
+ func = m.group('func')
+ # discard internal functions
+ if not everything and func.startswith('__'):
+ continue
+ results_.append(DataResult(
+ file, func,
+ int(m.group('size'), 16)))
proc.wait()
if proc.returncode != 0:
if not args.get('verbose'):
@@ -44,240 +190,515 @@ def collect(paths, **args):
sys.stdout.write(line)
sys.exit(-1)
- flat_results = []
- for (file, func), size in results.items():
- # map to source files
- if args.get('build_dir'):
- file = re.sub('%s/*' % re.escape(args['build_dir']), '', file)
- # replace .o with .c, different scripts report .o/.c, we need to
- # choose one if we want to deduplicate csv files
- file = re.sub('\.o$', '.c', file)
- # discard internal functions
- if not args.get('everything'):
- if func.startswith('__'):
- continue
- # discard .8449 suffixes created by optimizer
- func = re.sub('\.[0-9]+', '', func)
- flat_results.append((file, func, size))
-
- return flat_results
-
-def main(**args):
- def openio(path, mode='r'):
- if path == '-':
- if 'r' in mode:
- return os.fdopen(os.dup(sys.stdin.fileno()), 'r')
+
+ # try to figure out the source file if we have debug-info
+ dirs = {}
+ files = {}
+ # note objdump-path may contain extra args
+ cmd = objdump_path + ['--dwarf=rawline', path]
+ if args.get('verbose'):
+ print(' '.join(shlex.quote(c) for c in cmd))
+ proc = sp.Popen(cmd,
+ stdout=sp.PIPE,
+ stderr=sp.PIPE if not args.get('verbose') else None,
+ universal_newlines=True,
+ errors='replace',
+ close_fds=False)
+ for line in proc.stdout:
+ # note that files contain references to dirs, which we
+ # dereference as soon as we see them as each file table follows a
+ # dir table
+ m = line_pattern.match(line)
+ if m:
+ if not m.group('dir'):
+ # found a directory entry
+ dirs[int(m.group('no'))] = m.group('path')
+ else:
+ # found a file entry
+ dir = int(m.group('dir'))
+ if dir in dirs:
+ files[int(m.group('no'))] = os.path.join(
+ dirs[dir],
+ m.group('path'))
+ else:
+ files[int(m.group('no'))] = m.group('path')
+ proc.wait()
+ if proc.returncode != 0:
+ if not args.get('verbose'):
+ for line in proc.stderr:
+ sys.stdout.write(line)
+ # do nothing on error, we don't need objdump to work, source files
+ # may just be inaccurate
+ pass
+
+ defs = {}
+ is_func = False
+ f_name = None
+ f_file = None
+ # note objdump-path may contain extra args
+ cmd = objdump_path + ['--dwarf=info', path]
+ if args.get('verbose'):
+ print(' '.join(shlex.quote(c) for c in cmd))
+ proc = sp.Popen(cmd,
+ stdout=sp.PIPE,
+ stderr=sp.PIPE if not args.get('verbose') else None,
+ universal_newlines=True,
+ errors='replace',
+ close_fds=False)
+ for line in proc.stdout:
+ # state machine here to find definitions
+ m = info_pattern.match(line)
+ if m:
+ if m.group('tag'):
+ if is_func:
+ defs[f_name] = files.get(f_file, '?')
+ is_func = (m.group('tag') == 'DW_TAG_subprogram')
+ elif m.group('name'):
+ f_name = m.group('name')
+ elif m.group('file'):
+ f_file = int(m.group('file'))
+ if is_func:
+ defs[f_name] = files.get(f_file, '?')
+ proc.wait()
+ if proc.returncode != 0:
+ if not args.get('verbose'):
+ for line in proc.stderr:
+ sys.stdout.write(line)
+ # do nothing on error, we don't need objdump to work, source files
+ # may just be inaccurate
+ pass
+
+ for r in results_:
+ # find best matching debug symbol, this may be slightly different
+ # due to optimizations
+ if defs:
+ # exact match? avoid difflib if we can for speed
+ if r.function in defs:
+ file = defs[r.function]
+ else:
+ _, file = max(
+ defs.items(),
+ key=lambda d: difflib.SequenceMatcher(None,
+ d[0],
+ r.function, False).ratio())
else:
- return os.fdopen(os.dup(sys.stdout.fileno()), 'w')
- else:
- return open(path, mode)
+ file = r.file
- # find sizes
- if not args.get('use', None):
- # find .o files
- paths = []
- for path in args['obj_paths']:
- if os.path.isdir(path):
- path = path + '/*.o'
+ # ignore filtered sources
+ if sources is not None:
+ if not any(
+ os.path.abspath(file) == os.path.abspath(s)
+ for s in sources):
+ continue
+ else:
+ # default to only cwd
+ if not everything and not os.path.commonpath([
+ os.getcwd(),
+ os.path.abspath(file)]) == os.getcwd():
+ continue
+
+ # simplify path
+ if os.path.commonpath([
+ os.getcwd(),
+ os.path.abspath(file)]) == os.getcwd():
+ file = os.path.relpath(file)
+ else:
+ file = os.path.abspath(file)
+
+ results.append(r._replace(file=file))
+
+ return results
- for path in glob.glob(path):
- paths.append(path)
- if not paths:
- print('no .obj files found in %r?' % args['obj_paths'])
+def fold(Result, results, *,
+ by=None,
+ defines=None,
+ **_):
+ if by is None:
+ by = Result._by
+
+ for k in it.chain(by or [], (k for k, _ in defines or [])):
+ if k not in Result._by and k not in Result._fields:
+ print("error: could not find field %r?" % k)
sys.exit(-1)
- results = collect(paths, **args)
- else:
- with openio(args['use']) as f:
- r = csv.DictReader(f)
- results = [
- ( result['file'],
- result['name'],
- int(result['data_size']))
- for result in r
- if result.get('data_size') not in {None, ''}]
-
- total = 0
- for _, _, size in results:
- total += size
+ # filter by matching defines
+ if defines is not None:
+ results_ = []
+ for r in results:
+ if all(getattr(r, k) in vs for k, vs in defines):
+ results_.append(r)
+ results = results_
- # find previous results?
- if args.get('diff'):
- try:
- with openio(args['diff']) as f:
- r = csv.DictReader(f)
- prev_results = [
- ( result['file'],
- result['name'],
- int(result['data_size']))
- for result in r
- if result.get('data_size') not in {None, ''}]
- except FileNotFoundError:
- prev_results = []
+ # organize results into conflicts
+ folding = co.OrderedDict()
+ for r in results:
+ name = tuple(getattr(r, k) for k in by)
+ if name not in folding:
+ folding[name] = []
+ folding[name].append(r)
- prev_total = 0
- for _, _, size in prev_results:
- prev_total += size
+ # merge conflicts
+ folded = []
+ for name, rs in folding.items():
+ folded.append(sum(rs[1:], start=rs[0]))
- # write results to CSV
- if args.get('output'):
- merged_results = co.defaultdict(lambda: {})
- other_fields = []
+ return folded
- # merge?
- if args.get('merge'):
- try:
- with openio(args['merge']) as f:
- r = csv.DictReader(f)
- for result in r:
- file = result.pop('file', '')
- func = result.pop('name', '')
- result.pop('data_size', None)
- merged_results[(file, func)] = result
- other_fields = result.keys()
- except FileNotFoundError:
- pass
-
- for file, func, size in results:
- merged_results[(file, func)]['data_size'] = size
+def table(Result, results, diff_results=None, *,
+ by=None,
+ fields=None,
+ sort=None,
+ summary=False,
+ all=False,
+ percent=False,
+ **_):
+ all_, all = all, __builtins__.all
- with openio(args['output'], 'w') as f:
- w = csv.DictWriter(f, ['file', 'name', *other_fields, 'data_size'])
- w.writeheader()
- for (file, func), result in sorted(merged_results.items()):
- w.writerow({'file': file, 'name': func, **result})
-
- # print results
- def dedup_entries(results, by='name'):
- entries = co.defaultdict(lambda: 0)
- for file, func, size in results:
- entry = (file if by == 'file' else func)
- entries[entry] += size
- return entries
-
- def diff_entries(olds, news):
- diff = co.defaultdict(lambda: (0, 0, 0, 0))
- for name, new in news.items():
- diff[name] = (0, new, new, 1.0)
- for name, old in olds.items():
- _, new, _, _ = diff[name]
- diff[name] = (old, new, new-old, (new-old)/old if old else 1.0)
- return diff
-
- def sorted_entries(entries):
- if args.get('size_sort'):
- return sorted(entries, key=lambda x: (-x[1], x))
- elif args.get('reverse_size_sort'):
- return sorted(entries, key=lambda x: (+x[1], x))
- else:
- return sorted(entries)
+ if by is None:
+ by = Result._by
+ if fields is None:
+ fields = Result._fields
+ types = Result._types
- def sorted_diff_entries(entries):
- if args.get('size_sort'):
- return sorted(entries, key=lambda x: (-x[1][1], x))
- elif args.get('reverse_size_sort'):
- return sorted(entries, key=lambda x: (+x[1][1], x))
- else:
- return sorted(entries, key=lambda x: (-x[1][3], x))
+ # fold again
+ results = fold(Result, results, by=by)
+ if diff_results is not None:
+ diff_results = fold(Result, diff_results, by=by)
- def print_header(by=''):
- if not args.get('diff'):
- print('%-36s %7s' % (by, 'size'))
- else:
- print('%-36s %7s %7s %7s' % (by, 'old', 'new', 'diff'))
+ # organize by name
+ table = {
+ ','.join(str(getattr(r, k) or '') for k in by): r
+ for r in results}
+ diff_table = {
+ ','.join(str(getattr(r, k) or '') for k in by): r
+ for r in diff_results or []}
+ names = list(table.keys() | diff_table.keys())
+
+ # sort again, now with diff info, note that python's sort is stable
+ names.sort()
+ if diff_results is not None:
+ names.sort(key=lambda n: tuple(
+ types[k].ratio(
+ getattr(table.get(n), k, None),
+ getattr(diff_table.get(n), k, None))
+ for k in fields),
+ reverse=True)
+ if sort:
+ for k, reverse in reversed(sort):
+ names.sort(
+ key=lambda n: tuple(
+ (getattr(table[n], k),)
+ if getattr(table.get(n), k, None) is not None else ()
+ for k in ([k] if k else [
+ k for k in Result._sort if k in fields])),
+ reverse=reverse ^ (not k or k in Result._fields))
- def print_entry(name, size):
- print("%-36s %7d" % (name, size))
- def print_diff_entry(name, old, new, diff, ratio):
- print("%-36s %7s %7s %+7d%s" % (name,
- old or "-",
- new or "-",
- diff,
- ' (%+.1f%%)' % (100*ratio) if ratio else ''))
+ # build up our lines
+ lines = []
- def print_entries(by='name'):
- entries = dedup_entries(results, by=by)
+ # header
+ header = []
+ header.append('%s%s' % (
+ ','.join(by),
+ ' (%d added, %d removed)' % (
+ sum(1 for n in table if n not in diff_table),
+ sum(1 for n in diff_table if n not in table))
+ if diff_results is not None and not percent else '')
+ if not summary else '')
+ if diff_results is None:
+ for k in fields:
+ header.append(k)
+ elif percent:
+ for k in fields:
+ header.append(k)
+ else:
+ for k in fields:
+ header.append('o'+k)
+ for k in fields:
+ header.append('n'+k)
+ for k in fields:
+ header.append('d'+k)
+ header.append('')
+ lines.append(header)
- if not args.get('diff'):
- print_header(by=by)
- for name, size in sorted_entries(entries.items()):
- print_entry(name, size)
+ def table_entry(name, r, diff_r=None, ratios=[]):
+ entry = []
+ entry.append(name)
+ if diff_results is None:
+ for k in fields:
+ entry.append(getattr(r, k).table()
+ if getattr(r, k, None) is not None
+ else types[k].none)
+ elif percent:
+ for k in fields:
+ entry.append(getattr(r, k).diff_table()
+ if getattr(r, k, None) is not None
+ else types[k].diff_none)
else:
- prev_entries = dedup_entries(prev_results, by=by)
- diff = diff_entries(prev_entries, entries)
- print_header(by='%s (%d added, %d removed)' % (by,
- sum(1 for old, _, _, _ in diff.values() if not old),
- sum(1 for _, new, _, _ in diff.values() if not new)))
- for name, (old, new, diff, ratio) in sorted_diff_entries(
- diff.items()):
- if ratio or args.get('all'):
- print_diff_entry(name, old, new, diff, ratio)
-
- def print_totals():
- if not args.get('diff'):
- print_entry('TOTAL', total)
+ for k in fields:
+ entry.append(getattr(diff_r, k).diff_table()
+ if getattr(diff_r, k, None) is not None
+ else types[k].diff_none)
+ for k in fields:
+ entry.append(getattr(r, k).diff_table()
+ if getattr(r, k, None) is not None
+ else types[k].diff_none)
+ for k in fields:
+ entry.append(types[k].diff_diff(
+ getattr(r, k, None),
+ getattr(diff_r, k, None)))
+ if diff_results is None:
+ entry.append('')
+ elif percent:
+ entry.append(' (%s)' % ', '.join(
+ '+∞%' if t == +m.inf
+ else '-∞%' if t == -m.inf
+ else '%+.1f%%' % (100*t)
+ for t in ratios))
else:
- ratio = (0.0 if not prev_total and not total
- else 1.0 if not prev_total
- else (total-prev_total)/prev_total)
- print_diff_entry('TOTAL',
- prev_total, total,
- total-prev_total,
- ratio)
-
- if args.get('quiet'):
- pass
- elif args.get('summary'):
- print_header()
- print_totals()
- elif args.get('files'):
- print_entries(by='file')
- print_totals()
+ entry.append(' (%s)' % ', '.join(
+ '+∞%' if t == +m.inf
+ else '-∞%' if t == -m.inf
+ else '%+.1f%%' % (100*t)
+ for t in ratios
+ if t)
+ if any(ratios) else '')
+ return entry
+
+ # entries
+ if not summary:
+ for name in names:
+ r = table.get(name)
+ if diff_results is None:
+ diff_r = None
+ ratios = None
+ else:
+ diff_r = diff_table.get(name)
+ ratios = [
+ types[k].ratio(
+ getattr(r, k, None),
+ getattr(diff_r, k, None))
+ for k in fields]
+ if not all_ and not any(ratios):
+ continue
+ lines.append(table_entry(name, r, diff_r, ratios))
+
+ # total
+ r = next(iter(fold(Result, results, by=[])), None)
+ if diff_results is None:
+ diff_r = None
+ ratios = None
else:
- print_entries(by='name')
- print_totals()
+ diff_r = next(iter(fold(Result, diff_results, by=[])), None)
+ ratios = [
+ types[k].ratio(
+ getattr(r, k, None),
+ getattr(diff_r, k, None))
+ for k in fields]
+ lines.append(table_entry('TOTAL', r, diff_r, ratios))
+
+ # find the best widths, note that column 0 contains the names and column -1
+ # the ratios, so those are handled a bit differently
+ widths = [
+ ((max(it.chain([w], (len(l[i]) for l in lines)))+1+4-1)//4)*4-1
+ for w, i in zip(
+ it.chain([23], it.repeat(7)),
+ range(len(lines[0])-1))]
+
+ # print our table
+ for line in lines:
+ print('%-*s %s%s' % (
+ widths[0], line[0],
+ ' '.join('%*s' % (w, x)
+ for w, x in zip(widths[1:], line[1:-1])),
+ line[-1]))
+
+
+def main(obj_paths, *,
+ by=None,
+ fields=None,
+ defines=None,
+ sort=None,
+ **args):
+ # find sizes
+ if not args.get('use', None):
+ results = collect(obj_paths, **args)
+ else:
+ results = []
+ with openio(args['use']) as f:
+ reader = csv.DictReader(f, restval='')
+ for r in reader:
+ try:
+ results.append(DataResult(
+ **{k: r[k] for k in DataResult._by
+ if k in r and r[k].strip()},
+ **{k: r['data_'+k] for k in DataResult._fields
+ if 'data_'+k in r and r['data_'+k].strip()}))
+ except TypeError:
+ pass
+
+ # fold
+ results = fold(DataResult, results, by=by, defines=defines)
+
+ # sort, note that python's sort is stable
+ results.sort()
+ if sort:
+ for k, reverse in reversed(sort):
+ results.sort(
+ key=lambda r: tuple(
+ (getattr(r, k),) if getattr(r, k) is not None else ()
+ for k in ([k] if k else DataResult._sort)),
+ reverse=reverse ^ (not k or k in DataResult._fields))
+
+ # write results to CSV
+ if args.get('output'):
+ with openio(args['output'], 'w') as f:
+ writer = csv.DictWriter(f,
+ (by if by is not None else DataResult._by)
+ + ['data_'+k for k in (
+ fields if fields is not None else DataResult._fields)])
+ writer.writeheader()
+ for r in results:
+ writer.writerow(
+ {k: getattr(r, k) for k in (
+ by if by is not None else DataResult._by)}
+ | {'data_'+k: getattr(r, k) for k in (
+ fields if fields is not None else DataResult._fields)})
+
+ # find previous results?
+ if args.get('diff'):
+ diff_results = []
+ try:
+ with openio(args['diff']) as f:
+ reader = csv.DictReader(f, restval='')
+ for r in reader:
+ if not any('data_'+k in r and r['data_'+k].strip()
+ for k in DataResult._fields):
+ continue
+ try:
+ diff_results.append(DataResult(
+ **{k: r[k] for k in DataResult._by
+ if k in r and r[k].strip()},
+ **{k: r['data_'+k] for k in DataResult._fields
+ if 'data_'+k in r and r['data_'+k].strip()}))
+ except TypeError:
+ pass
+ except FileNotFoundError:
+ pass
+
+ # fold
+ diff_results = fold(DataResult, diff_results, by=by, defines=defines)
+
+ # print table
+ if not args.get('quiet'):
+ table(DataResult, results,
+ diff_results if args.get('diff') else None,
+ by=by if by is not None else ['function'],
+ fields=fields,
+ sort=sort,
+ **args)
+
if __name__ == "__main__":
import argparse
import sys
parser = argparse.ArgumentParser(
- description="Find data size at the function level.")
- parser.add_argument('obj_paths', nargs='*', default=OBJ_PATHS,
- help="Description of where to find *.o files. May be a directory \
- or a list of paths. Defaults to %r." % OBJ_PATHS)
- parser.add_argument('-v', '--verbose', action='store_true',
+ description="Find data size at the function level.",
+ allow_abbrev=False)
+ parser.add_argument(
+ 'obj_paths',
+ nargs='*',
+ help="Input *.o files.")
+ parser.add_argument(
+ '-v', '--verbose',
+ action='store_true',
help="Output commands that run behind the scenes.")
- parser.add_argument('-q', '--quiet', action='store_true',
+ parser.add_argument(
+ '-q', '--quiet',
+ action='store_true',
help="Don't show anything, useful with -o.")
- parser.add_argument('-o', '--output',
+ parser.add_argument(
+ '-o', '--output',
help="Specify CSV file to store results.")
- parser.add_argument('-u', '--use',
- help="Don't compile and find data sizes, instead use this CSV file.")
- parser.add_argument('-d', '--diff',
- help="Specify CSV file to diff data size against.")
- parser.add_argument('-m', '--merge',
- help="Merge with an existing CSV file when writing to output.")
- parser.add_argument('-a', '--all', action='store_true',
- help="Show all functions, not just the ones that changed.")
- parser.add_argument('-A', '--everything', action='store_true',
+ parser.add_argument(
+ '-u', '--use',
+ help="Don't parse anything, use this CSV file.")
+ parser.add_argument(
+ '-d', '--diff',
+ help="Specify CSV file to diff against.")
+ parser.add_argument(
+ '-a', '--all',
+ action='store_true',
+ help="Show all, not just the ones that changed.")
+ parser.add_argument(
+ '-p', '--percent',
+ action='store_true',
+ help="Only show percentage change, not a full diff.")
+ parser.add_argument(
+ '-b', '--by',
+ action='append',
+ choices=DataResult._by,
+ help="Group by this field.")
+ parser.add_argument(
+ '-f', '--field',
+ dest='fields',
+ action='append',
+ choices=DataResult._fields,
+ help="Show this field.")
+ parser.add_argument(
+ '-D', '--define',
+ dest='defines',
+ action='append',
+ type=lambda x: (lambda k,v: (k, set(v.split(','))))(*x.split('=', 1)),
+ help="Only include results where this field is this value.")
+ class AppendSort(argparse.Action):
+ def __call__(self, parser, namespace, value, option):
+ if namespace.sort is None:
+ namespace.sort = []
+ namespace.sort.append((value, True if option == '-S' else False))
+ parser.add_argument(
+ '-s', '--sort',
+ nargs='?',
+ action=AppendSort,
+ help="Sort by this field.")
+ parser.add_argument(
+ '-S', '--reverse-sort',
+ nargs='?',
+ action=AppendSort,
+ help="Sort by this field, but backwards.")
+ parser.add_argument(
+ '-Y', '--summary',
+ action='store_true',
+ help="Only show the total.")
+ parser.add_argument(
+ '-F', '--source',
+ dest='sources',
+ action='append',
+ help="Only consider definitions in this file. Defaults to anything "
+ "in the current directory.")
+ parser.add_argument(
+ '--everything',
+ action='store_true',
help="Include builtin and libc specific symbols.")
- parser.add_argument('-s', '--size-sort', action='store_true',
- help="Sort by size.")
- parser.add_argument('-S', '--reverse-size-sort', action='store_true',
- help="Sort by size, but backwards.")
- parser.add_argument('-F', '--files', action='store_true',
- help="Show file-level data sizes. Note this does not include padding! "
- "So sizes may differ from other tools.")
- parser.add_argument('-Y', '--summary', action='store_true',
- help="Only show the total data size.")
- parser.add_argument('--type', default='dDbB',
+ parser.add_argument(
+ '--nm-types',
+ default=NM_TYPES,
help="Type of symbols to report, this uses the same single-character "
- "type-names emitted by nm. Defaults to %(default)r.")
- parser.add_argument('--nm-tool', default=['nm'], type=lambda x: x.split(),
- help="Path to the nm tool to use.")
- parser.add_argument('--build-dir',
- help="Specify the relative build directory. Used to map object files \
- to the correct source files.")
- sys.exit(main(**vars(parser.parse_args())))
+ "type-names emitted by nm. Defaults to %r." % NM_TYPES)
+ parser.add_argument(
+ '--nm-path',
+ type=lambda x: x.split(),
+ default=NM_PATH,
+ help="Path to the nm executable, may include flags. "
+ "Defaults to %r." % NM_PATH)
+ parser.add_argument(
+ '--objdump-path',
+ type=lambda x: x.split(),
+ default=OBJDUMP_PATH,
+ help="Path to the objdump executable, may include flags. "
+ "Defaults to %r." % OBJDUMP_PATH)
+ sys.exit(main(**{k: v
+ for k, v in vars(parser.parse_intermixed_args()).items()
+ if v is not None}))
diff --git a/scripts/explode_asserts.py b/scripts/explode_asserts.py
deleted file mode 100755
index 8a8e5b1c..00000000
--- a/scripts/explode_asserts.py
+++ /dev/null
@@ -1,383 +0,0 @@
-#!/usr/bin/env python3
-
-import re
-import sys
-
-PATTERN = ['LFS_ASSERT', 'assert']
-PREFIX = 'LFS'
-MAXWIDTH = 16
-
-ASSERT = "__{PREFIX}_ASSERT_{TYPE}_{COMP}"
-FAIL = """
-__attribute__((unused))
-static void __{prefix}_assert_fail_{type}(
- const char *file, int line, const char *comp,
- {ctype} lh, size_t lsize,
- {ctype} rh, size_t rsize) {{
- printf("%s:%d:assert: assert failed with ", file, line);
- __{prefix}_assert_print_{type}(lh, lsize);
- printf(", expected %s ", comp);
- __{prefix}_assert_print_{type}(rh, rsize);
- printf("\\n");
- fflush(NULL);
- raise(SIGABRT);
-}}
-"""
-
-COMP = {
- '==': 'eq',
- '!=': 'ne',
- '<=': 'le',
- '>=': 'ge',
- '<': 'lt',
- '>': 'gt',
-}
-
-TYPE = {
- 'int': {
- 'ctype': 'intmax_t',
- 'fail': FAIL,
- 'print': """
- __attribute__((unused))
- static void __{prefix}_assert_print_{type}({ctype} v, size_t size) {{
- (void)size;
- printf("%"PRIiMAX, v);
- }}
- """,
- 'assert': """
- #define __{PREFIX}_ASSERT_{TYPE}_{COMP}(file, line, lh, rh)
- do {{
- __typeof__(lh) _lh = lh;
- __typeof__(lh) _rh = (__typeof__(lh))rh;
- if (!(_lh {op} _rh)) {{
- __{prefix}_assert_fail_{type}(file, line, "{comp}",
- (intmax_t)_lh, 0, (intmax_t)_rh, 0);
- }}
- }} while (0)
- """
- },
- 'bool': {
- 'ctype': 'bool',
- 'fail': FAIL,
- 'print': """
- __attribute__((unused))
- static void __{prefix}_assert_print_{type}({ctype} v, size_t size) {{
- (void)size;
- printf("%s", v ? "true" : "false");
- }}
- """,
- 'assert': """
- #define __{PREFIX}_ASSERT_{TYPE}_{COMP}(file, line, lh, rh)
- do {{
- bool _lh = !!(lh);
- bool _rh = !!(rh);
- if (!(_lh {op} _rh)) {{
- __{prefix}_assert_fail_{type}(file, line, "{comp}",
- _lh, 0, _rh, 0);
- }}
- }} while (0)
- """
- },
- 'mem': {
- 'ctype': 'const void *',
- 'fail': FAIL,
- 'print': """
- __attribute__((unused))
- static void __{prefix}_assert_print_{type}({ctype} v, size_t size) {{
- const uint8_t *s = v;
- printf("\\\"");
- for (size_t i = 0; i < size && i < {maxwidth}; i++) {{
- if (s[i] >= ' ' && s[i] <= '~') {{
- printf("%c", s[i]);
- }} else {{
- printf("\\\\x%02x", s[i]);
- }}
- }}
- if (size > {maxwidth}) {{
- printf("...");
- }}
- printf("\\\"");
- }}
- """,
- 'assert': """
- #define __{PREFIX}_ASSERT_{TYPE}_{COMP}(file, line, lh, rh, size)
- do {{
- const void *_lh = lh;
- const void *_rh = rh;
- if (!(memcmp(_lh, _rh, size) {op} 0)) {{
- __{prefix}_assert_fail_{type}(file, line, "{comp}",
- _lh, size, _rh, size);
- }}
- }} while (0)
- """
- },
- 'str': {
- 'ctype': 'const char *',
- 'fail': FAIL,
- 'print': """
- __attribute__((unused))
- static void __{prefix}_assert_print_{type}({ctype} v, size_t size) {{
- __{prefix}_assert_print_mem(v, size);
- }}
- """,
- 'assert': """
- #define __{PREFIX}_ASSERT_{TYPE}_{COMP}(file, line, lh, rh)
- do {{
- const char *_lh = lh;
- const char *_rh = rh;
- if (!(strcmp(_lh, _rh) {op} 0)) {{
- __{prefix}_assert_fail_{type}(file, line, "{comp}",
- _lh, strlen(_lh), _rh, strlen(_rh));
- }}
- }} while (0)
- """
- }
-}
-
-def mkdecls(outf, maxwidth=16):
- outf.write("#include \n")
- outf.write("#include \n")
- outf.write("#include \n")
- outf.write("#include \n")
- outf.write("#include \n")
-
- for type, desc in sorted(TYPE.items()):
- format = {
- 'type': type.lower(), 'TYPE': type.upper(),
- 'ctype': desc['ctype'],
- 'prefix': PREFIX.lower(), 'PREFIX': PREFIX.upper(),
- 'maxwidth': maxwidth,
- }
- outf.write(re.sub('\s+', ' ',
- desc['print'].strip().format(**format))+'\n')
- outf.write(re.sub('\s+', ' ',
- desc['fail'].strip().format(**format))+'\n')
-
- for op, comp in sorted(COMP.items()):
- format.update({
- 'comp': comp.lower(), 'COMP': comp.upper(),
- 'op': op,
- })
- outf.write(re.sub('\s+', ' ',
- desc['assert'].strip().format(**format))+'\n')
-
-def mkassert(type, comp, lh, rh, size=None):
- format = {
- 'type': type.lower(), 'TYPE': type.upper(),
- 'comp': comp.lower(), 'COMP': comp.upper(),
- 'prefix': PREFIX.lower(), 'PREFIX': PREFIX.upper(),
- 'lh': lh.strip(' '),
- 'rh': rh.strip(' '),
- 'size': size,
- }
- if size:
- return ((ASSERT + '(__FILE__, __LINE__, {lh}, {rh}, {size})')
- .format(**format))
- else:
- return ((ASSERT + '(__FILE__, __LINE__, {lh}, {rh})')
- .format(**format))
-
-
-# simple recursive descent parser
-LEX = {
- 'ws': [r'(?:\s|\n|#.*?\n|//.*?\n|/\*.*?\*/)+'],
- 'assert': PATTERN,
- 'string': [r'"(?:\\.|[^"])*"', r"'(?:\\.|[^'])\'"],
- 'arrow': ['=>'],
- 'paren': ['\(', '\)'],
- 'op': ['strcmp', 'memcmp', '->'],
- 'comp': ['==', '!=', '<=', '>=', '<', '>'],
- 'logic': ['\&\&', '\|\|'],
- 'sep': [':', ';', '\{', '\}', ','],
-}
-
-class ParseFailure(Exception):
- def __init__(self, expected, found):
- self.expected = expected
- self.found = found
-
- def __str__(self):
- return "expected %r, found %s..." % (
- self.expected, repr(self.found)[:70])
-
-class Parse:
- def __init__(self, inf, lexemes):
- p = '|'.join('(?P<%s>%s)' % (n, '|'.join(l))
- for n, l in lexemes.items())
- p = re.compile(p, re.DOTALL)
- data = inf.read()
- tokens = []
- while True:
- m = p.search(data)
- if m:
- if m.start() > 0:
- tokens.append((None, data[:m.start()]))
- tokens.append((m.lastgroup, m.group()))
- data = data[m.end():]
- else:
- tokens.append((None, data))
- break
- self.tokens = tokens
- self.off = 0
-
- def lookahead(self, *pattern):
- if self.off < len(self.tokens):
- token = self.tokens[self.off]
- if token[0] in pattern or token[1] in pattern:
- self.m = token[1]
- return self.m
- self.m = None
- return self.m
-
- def accept(self, *patterns):
- m = self.lookahead(*patterns)
- if m is not None:
- self.off += 1
- return m
-
- def expect(self, *patterns):
- m = self.accept(*patterns)
- if not m:
- raise ParseFailure(patterns, self.tokens[self.off:])
- return m
-
- def push(self):
- return self.off
-
- def pop(self, state):
- self.off = state
-
-def passert(p):
- def pastr(p):
- p.expect('assert') ; p.accept('ws') ; p.expect('(') ; p.accept('ws')
- p.expect('strcmp') ; p.accept('ws') ; p.expect('(') ; p.accept('ws')
- lh = pexpr(p) ; p.accept('ws')
- p.expect(',') ; p.accept('ws')
- rh = pexpr(p) ; p.accept('ws')
- p.expect(')') ; p.accept('ws')
- comp = p.expect('comp') ; p.accept('ws')
- p.expect('0') ; p.accept('ws')
- p.expect(')')
- return mkassert('str', COMP[comp], lh, rh)
-
- def pamem(p):
- p.expect('assert') ; p.accept('ws') ; p.expect('(') ; p.accept('ws')
- p.expect('memcmp') ; p.accept('ws') ; p.expect('(') ; p.accept('ws')
- lh = pexpr(p) ; p.accept('ws')
- p.expect(',') ; p.accept('ws')
- rh = pexpr(p) ; p.accept('ws')
- p.expect(',') ; p.accept('ws')
- size = pexpr(p) ; p.accept('ws')
- p.expect(')') ; p.accept('ws')
- comp = p.expect('comp') ; p.accept('ws')
- p.expect('0') ; p.accept('ws')
- p.expect(')')
- return mkassert('mem', COMP[comp], lh, rh, size)
-
- def paint(p):
- p.expect('assert') ; p.accept('ws') ; p.expect('(') ; p.accept('ws')
- lh = pexpr(p) ; p.accept('ws')
- comp = p.expect('comp') ; p.accept('ws')
- rh = pexpr(p) ; p.accept('ws')
- p.expect(')')
- return mkassert('int', COMP[comp], lh, rh)
-
- def pabool(p):
- p.expect('assert') ; p.accept('ws') ; p.expect('(') ; p.accept('ws')
- lh = pexprs(p) ; p.accept('ws')
- p.expect(')')
- return mkassert('bool', 'eq', lh, 'true')
-
- def pa(p):
- return p.expect('assert')
-
- state = p.push()
- lastf = None
- for pa in [pastr, pamem, paint, pabool, pa]:
- try:
- return pa(p)
- except ParseFailure as f:
- p.pop(state)
- lastf = f
- else:
- raise lastf
-
-def pexpr(p):
- res = []
- while True:
- if p.accept('('):
- res.append(p.m)
- while True:
- res.append(pexprs(p))
- if p.accept('sep'):
- res.append(p.m)
- else:
- break
- res.append(p.expect(')'))
- elif p.lookahead('assert'):
- res.append(passert(p))
- elif p.accept('assert', 'ws', 'string', 'op', None):
- res.append(p.m)
- else:
- return ''.join(res)
-
-def pexprs(p):
- res = []
- while True:
- res.append(pexpr(p))
- if p.accept('comp', 'logic', ','):
- res.append(p.m)
- else:
- return ''.join(res)
-
-def pstmt(p):
- ws = p.accept('ws') or ''
- lh = pexprs(p)
- if p.accept('=>'):
- rh = pexprs(p)
- return ws + mkassert('int', 'eq', lh, rh)
- else:
- return ws + lh
-
-
-def main(args):
- inf = open(args.input, 'r') if args.input else sys.stdin
- outf = open(args.output, 'w') if args.output else sys.stdout
-
- lexemes = LEX.copy()
- if args.pattern:
- lexemes['assert'] = args.pattern
- p = Parse(inf, lexemes)
-
- # write extra verbose asserts
- mkdecls(outf, maxwidth=args.maxwidth)
- if args.input:
- outf.write("#line %d \"%s\"\n" % (1, args.input))
-
- # parse and write out stmt at a time
- try:
- while True:
- outf.write(pstmt(p))
- if p.accept('sep'):
- outf.write(p.m)
- else:
- break
- except ParseFailure as f:
- pass
-
- for i in range(p.off, len(p.tokens)):
- outf.write(p.tokens[i][1])
-
-if __name__ == "__main__":
- import argparse
- parser = argparse.ArgumentParser(
- description="Cpp step that increases assert verbosity")
- parser.add_argument('input', nargs='?',
- help="Input C file after cpp.")
- parser.add_argument('-o', '--output', required=True,
- help="Output C file.")
- parser.add_argument('-p', '--pattern', action='append',
- help="Patterns to search for starting an assert statement.")
- parser.add_argument('--maxwidth', default=MAXWIDTH, type=int,
- help="Maximum number of characters to display for strcmp and memcmp.")
- main(parser.parse_args())
diff --git a/scripts/perf.py b/scripts/perf.py
new file mode 100755
index 00000000..2ee006c0
--- /dev/null
+++ b/scripts/perf.py
@@ -0,0 +1,1344 @@
+#!/usr/bin/env python3
+#
+# Script to aggregate and report Linux perf results.
+#
+# Example:
+# ./scripts/perf.py -R -obench.perf ./runners/bench_runner
+# ./scripts/perf.py bench.perf -j -Flfs.c -Flfs_util.c -Scycles
+#
+# Copyright (c) 2022, The littlefs authors.
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+import bisect
+import collections as co
+import csv
+import errno
+import fcntl
+import functools as ft
+import itertools as it
+import math as m
+import multiprocessing as mp
+import os
+import re
+import shlex
+import shutil
+import subprocess as sp
+import tempfile
+import zipfile
+
+# TODO support non-zip perf results?
+
+
+PERF_PATH = ['perf']
+PERF_EVENTS = 'cycles,branch-misses,branches,cache-misses,cache-references'
+PERF_FREQ = 100
+OBJDUMP_PATH = ['objdump']
+THRESHOLD = (0.5, 0.85)
+
+
+# integer fields
+class Int(co.namedtuple('Int', 'x')):
+ __slots__ = ()
+ def __new__(cls, x=0):
+ if isinstance(x, Int):
+ return x
+ if isinstance(x, str):
+ try:
+ x = int(x, 0)
+ except ValueError:
+ # also accept +-∞ and +-inf
+ if re.match('^\s*\+?\s*(?:∞|inf)\s*$', x):
+ x = m.inf
+ elif re.match('^\s*-\s*(?:∞|inf)\s*$', x):
+ x = -m.inf
+ else:
+ raise
+ assert isinstance(x, int) or m.isinf(x), x
+ return super().__new__(cls, x)
+
+ def __str__(self):
+ if self.x == m.inf:
+ return '∞'
+ elif self.x == -m.inf:
+ return '-∞'
+ else:
+ return str(self.x)
+
+ def __int__(self):
+ assert not m.isinf(self.x)
+ return self.x
+
+ def __float__(self):
+ return float(self.x)
+
+ none = '%7s' % '-'
+ def table(self):
+ return '%7s' % (self,)
+
+ diff_none = '%7s' % '-'
+ diff_table = table
+
+ def diff_diff(self, other):
+ new = self.x if self else 0
+ old = other.x if other else 0
+ diff = new - old
+ if diff == +m.inf:
+ return '%7s' % '+∞'
+ elif diff == -m.inf:
+ return '%7s' % '-∞'
+ else:
+ return '%+7d' % diff
+
+ def ratio(self, other):
+ new = self.x if self else 0
+ old = other.x if other else 0
+ if m.isinf(new) and m.isinf(old):
+ return 0.0
+ elif m.isinf(new):
+ return +m.inf
+ elif m.isinf(old):
+ return -m.inf
+ elif not old and not new:
+ return 0.0
+ elif not old:
+ return 1.0
+ else:
+ return (new-old) / old
+
+ def __add__(self, other):
+ return self.__class__(self.x + other.x)
+
+ def __sub__(self, other):
+ return self.__class__(self.x - other.x)
+
+ def __mul__(self, other):
+ return self.__class__(self.x * other.x)
+
+# perf results
+class PerfResult(co.namedtuple('PerfResult', [
+ 'file', 'function', 'line',
+ 'cycles', 'bmisses', 'branches', 'cmisses', 'caches',
+ 'children'])):
+ _by = ['file', 'function', 'line']
+ _fields = ['cycles', 'bmisses', 'branches', 'cmisses', 'caches']
+ _sort = ['cycles', 'bmisses', 'cmisses', 'branches', 'caches']
+ _types = {
+ 'cycles': Int,
+ 'bmisses': Int, 'branches': Int,
+ 'cmisses': Int, 'caches': Int}
+
+ __slots__ = ()
+ def __new__(cls, file='', function='', line=0,
+ cycles=0, bmisses=0, branches=0, cmisses=0, caches=0,
+ children=[]):
+ return super().__new__(cls, file, function, int(Int(line)),
+ Int(cycles), Int(bmisses), Int(branches), Int(cmisses), Int(caches),
+ children)
+
+ def __add__(self, other):
+ return PerfResult(self.file, self.function, self.line,
+ self.cycles + other.cycles,
+ self.bmisses + other.bmisses,
+ self.branches + other.branches,
+ self.cmisses + other.cmisses,
+ self.caches + other.caches,
+ self.children + other.children)
+
+
+def openio(path, mode='r', buffering=-1):
+ # allow '-' for stdin/stdout
+ if path == '-':
+ if mode == 'r':
+ return os.fdopen(os.dup(sys.stdin.fileno()), mode, buffering)
+ else:
+ return os.fdopen(os.dup(sys.stdout.fileno()), mode, buffering)
+ else:
+ return open(path, mode, buffering)
+
+# run perf as a subprocess, storing measurements into a zip file
+def record(command, *,
+ output=None,
+ perf_freq=PERF_FREQ,
+ perf_period=None,
+ perf_events=PERF_EVENTS,
+ perf_path=PERF_PATH,
+ **args):
+ # create a temporary file for perf to write to, as far as I can tell
+ # this is strictly needed because perf's pipe-mode only works with stdout
+ with tempfile.NamedTemporaryFile('rb') as f:
+ # figure out our perf invocation
+ perf = perf_path + list(filter(None, [
+ 'record',
+ '-F%s' % perf_freq
+ if perf_freq is not None
+ and perf_period is None else None,
+ '-c%s' % perf_period
+ if perf_period is not None else None,
+ '-B',
+ '-g',
+ '--all-user',
+ '-e%s' % perf_events,
+ '-o%s' % f.name]))
+
+ # run our command
+ try:
+ if args.get('verbose'):
+ print(' '.join(shlex.quote(c) for c in perf + command))
+ err = sp.call(perf + command, close_fds=False)
+
+ except KeyboardInterrupt:
+ err = errno.EOWNERDEAD
+
+ # synchronize access
+ z = os.open(output, os.O_RDWR | os.O_CREAT)
+ fcntl.flock(z, fcntl.LOCK_EX)
+
+ # copy measurements into our zip file
+ with os.fdopen(z, 'r+b') as z:
+ with zipfile.ZipFile(z, 'a',
+ compression=zipfile.ZIP_DEFLATED,
+ compresslevel=1) as z:
+ with z.open('perf.%d' % os.getpid(), 'w') as g:
+ shutil.copyfileobj(f, g)
+
+ # forward the return code
+ return err
+
+
+# try to only process each dso onceS
+#
+# note this only caches with the non-keyword arguments
+def multiprocessing_cache(f):
+ local_cache = {}
+ manager = mp.Manager()
+ global_cache = manager.dict()
+ lock = mp.Lock()
+
+ def multiprocessing_cache(*args, **kwargs):
+ # check local cache?
+ if args in local_cache:
+ return local_cache[args]
+ # check global cache?
+ with lock:
+ if args in global_cache:
+ v = global_cache[args]
+ local_cache[args] = v
+ return v
+ # fall back to calling the function
+ v = f(*args, **kwargs)
+ global_cache[args] = v
+ local_cache[args] = v
+ return v
+
+ return multiprocessing_cache
+
+@multiprocessing_cache
+def collect_syms_and_lines(obj_path, *,
+ objdump_path=None,
+ **args):
+ symbol_pattern = re.compile(
+ '^(?P[0-9a-fA-F]+)'
+ '\s+.*'
+ '\s+(?P[0-9a-fA-F]+)'
+ '\s+(?P[^\s]+)\s*$')
+ line_pattern = re.compile(
+ '^\s+(?:'
+ # matches dir/file table
+ '(?P[0-9]+)'
+ '(?:\s+(?P[0-9]+))?'
+ '\s+.*'
+ '\s+(?P[^\s]+)'
+ # matches line opcodes
+ '|' '\[[^\]]*\]\s+'
+ '(?:'
+ '(?PSpecial)'
+ '|' '(?PCopy)'
+ '|' '(?PEnd of Sequence)'
+ '|' 'File .*?to (?:entry )?(?P\d+)'
+ '|' 'Line .*?to (?P[0-9]+)'
+ '|' '(?:Address|PC) .*?to (?P[0x0-9a-fA-F]+)'
+ '|' '.' ')*'
+ ')$', re.IGNORECASE)
+
+ # figure out symbol addresses and file+line ranges
+ syms = {}
+ sym_at = []
+ cmd = objdump_path + ['-t', obj_path]
+ if args.get('verbose'):
+ print(' '.join(shlex.quote(c) for c in cmd))
+ proc = sp.Popen(cmd,
+ stdout=sp.PIPE,
+ stderr=sp.PIPE if not args.get('verbose') else None,
+ universal_newlines=True,
+ errors='replace',
+ close_fds=False)
+ for line in proc.stdout:
+ m = symbol_pattern.match(line)
+ if m:
+ name = m.group('name')
+ addr = int(m.group('addr'), 16)
+ size = int(m.group('size'), 16)
+ # ignore zero-sized symbols
+ if not size:
+ continue
+ # note multiple symbols can share a name
+ if name not in syms:
+ syms[name] = set()
+ syms[name].add((addr, size))
+ sym_at.append((addr, name, size))
+ proc.wait()
+ if proc.returncode != 0:
+ if not args.get('verbose'):
+ for line in proc.stderr:
+ sys.stdout.write(line)
+ # assume no debug-info on failure
+ pass
+
+ # sort and keep largest/first when duplicates
+ sym_at.sort(key=lambda x: (x[0], -x[2], x[1]))
+ sym_at_ = []
+ for addr, name, size in sym_at:
+ if len(sym_at_) == 0 or sym_at_[-1][0] != addr:
+ sym_at_.append((addr, name, size))
+ sym_at = sym_at_
+
+ # state machine for dwarf line numbers, note that objdump's
+ # decodedline seems to have issues with multiple dir/file
+ # tables, which is why we need this
+ lines = []
+ line_at = []
+ dirs = {}
+ files = {}
+ op_file = 1
+ op_line = 1
+ op_addr = 0
+ cmd = objdump_path + ['--dwarf=rawline', obj_path]
+ if args.get('verbose'):
+ print(' '.join(shlex.quote(c) for c in cmd))
+ proc = sp.Popen(cmd,
+ stdout=sp.PIPE,
+ stderr=sp.PIPE if not args.get('verbose') else None,
+ universal_newlines=True,
+ errors='replace',
+ close_fds=False)
+ for line in proc.stdout:
+ m = line_pattern.match(line)
+ if m:
+ if m.group('no') and not m.group('dir'):
+ # found a directory entry
+ dirs[int(m.group('no'))] = m.group('path')
+ elif m.group('no'):
+ # found a file entry
+ dir = int(m.group('dir'))
+ if dir in dirs:
+ files[int(m.group('no'))] = os.path.join(
+ dirs[dir],
+ m.group('path'))
+ else:
+ files[int(m.group('no'))] = m.group('path')
+ else:
+ # found a state machine update
+ if m.group('op_file'):
+ op_file = int(m.group('op_file'), 0)
+ if m.group('op_line'):
+ op_line = int(m.group('op_line'), 0)
+ if m.group('op_addr'):
+ op_addr = int(m.group('op_addr'), 0)
+
+ if (m.group('op_special')
+ or m.group('op_copy')
+ or m.group('op_end')):
+ file = os.path.abspath(files.get(op_file, '?'))
+ lines.append((file, op_line, op_addr))
+ line_at.append((op_addr, file, op_line))
+
+ if m.group('op_end'):
+ op_file = 1
+ op_line = 1
+ op_addr = 0
+ proc.wait()
+ if proc.returncode != 0:
+ if not args.get('verbose'):
+ for line in proc.stderr:
+ sys.stdout.write(line)
+ # assume no debug-info on failure
+ pass
+
+ # sort and keep first when duplicates
+ lines.sort()
+ lines_ = []
+ for file, line, addr in lines:
+ if len(lines_) == 0 or lines_[-1][0] != file or lines[-1][1] != line:
+ lines_.append((file, line, addr))
+ lines = lines_
+
+ # sort and keep first when duplicates
+ line_at.sort()
+ line_at_ = []
+ for addr, file, line in line_at:
+ if len(line_at_) == 0 or line_at_[-1][0] != addr:
+ line_at_.append((addr, file, line))
+ line_at = line_at_
+
+ return syms, sym_at, lines, line_at
+
+
+def collect_decompressed(path, *,
+ perf_path=PERF_PATH,
+ sources=None,
+ everything=False,
+ propagate=0,
+ depth=1,
+ **args):
+ sample_pattern = re.compile(
+ '(?P\w+)'
+ '\s+(?P\w+)'
+ '\s+(?P