8405ce13a1
At least one Linux distribution (Arch) has made python 3 the default interpreter, and Debian and Ubuntu have expressed a desire to eventually make this the case. As such, invoking 'python' or '/usr/bin/python' will possibly run python 3 instead of version 2. Distributions have included a 'python2' link for quite some time now, and given that we have some scripts that require python 3, we should be explicit about those that require python 2. In addition, be more consistent about how python is invoked, preferring the: #!/usr/bin/env python2 construct rather than a hardcoded path to python. This allows the user to have an alternative python in their path that will be used in preference to the system provided version. Jira: ZEP-1548 Change-Id: I125c2af808dc268f74277bc97a092df3acad23c0 Signed-off-by: David Brown <david.brown@linaro.org>
299 lines
10 KiB
Python
Executable file
299 lines
10 KiB
Python
Executable file
#!/usr/bin/env python2
|
|
|
|
"""
|
|
This script help you to compare footprint results with previous commits in git.
|
|
If you don't have a git repository, it will compare your current tree
|
|
against the last release results.
|
|
To run it you need to set up the same environment as sanity check.
|
|
The scripts take 2 optional args COMMIT and BASE_COMMIT, which tell the scripts
|
|
which commit to use as current commit and as base for comparing, respectively.
|
|
The script can take any SHA commit recognized for git.
|
|
|
|
COMMIT is the commit to compare against BASE_COMMIT.
|
|
Default
|
|
current working directory if we have changes in git tree or we don't have git.
|
|
HEAD in any other case.
|
|
BASE_COMMIT is the commit used as base to compare results.
|
|
Default:
|
|
sanity_last_release.csv if we don't have git tree.
|
|
HEAD is we have changes in the working tree.
|
|
HEAD~1 if we don't have changes and we have default COMMIT.
|
|
COMMIT~1 if we have a valid COMMIT.
|
|
|
|
"""
|
|
|
|
import argparse
|
|
import os
|
|
import sys
|
|
import csv
|
|
import subprocess
|
|
import logging
|
|
import tempfile
|
|
import shutil
|
|
|
|
if "ZEPHYR_BASE" not in os.environ:
|
|
logging.error("$ZEPHYR_BASE environment variable undefined.\n")
|
|
exit(1)
|
|
|
|
logger = None
|
|
GIT_ENABLED = False
|
|
RELEASE_DATA = 'sanity_last_release.csv'
|
|
|
|
def is_git_enabled():
|
|
global GIT_ENABLED
|
|
proc = subprocess.Popen('git rev-parse --is-inside-work-tree',
|
|
stdout=subprocess.PIPE,
|
|
cwd=os.environ.get('ZEPHYR_BASE'), shell=True)
|
|
if proc.wait() != 0:
|
|
GIT_ENABLED = False
|
|
|
|
GIT_ENABLED = True
|
|
|
|
def init_logs():
|
|
global logger
|
|
log_lev = os.environ.get('LOG_LEVEL', None)
|
|
level = logging.INFO
|
|
if log_lev == "DEBUG":
|
|
level = logging.DEBUG
|
|
elif log_lev == "ERROR":
|
|
level = logging.ERROR
|
|
|
|
console = logging.StreamHandler()
|
|
format = logging.Formatter('%(levelname)-8s: %(message)s')
|
|
console.setFormatter(format)
|
|
logger = logging.getLogger('')
|
|
logger.addHandler(console)
|
|
logger.setLevel(level)
|
|
|
|
logging.debug("Log init completed")
|
|
|
|
def parse_args():
|
|
parser = argparse.ArgumentParser(
|
|
description="Compare footprint apps RAM and ROM sizes. Note: "
|
|
"To run it you need to set up the same environment as sanitycheck.")
|
|
parser.add_argument('-b', '--base-commit', default=None,
|
|
help="Commit ID to use as base for footprint "
|
|
"compare. Default is parent current commit."
|
|
" or sanity_last_release.csv if we don't have git.")
|
|
parser.add_argument('-c', '--commit', default=None,
|
|
help="Commit ID to use compare footprint against base. "
|
|
"Default is HEAD or working tree.")
|
|
return parser.parse_args()
|
|
|
|
def get_git_commit(commit):
|
|
commit_id = None
|
|
proc = subprocess.Popen('git rev-parse %s' % commit, stdout=subprocess.PIPE,
|
|
cwd=os.environ.get('ZEPHYR_BASE'), shell=True)
|
|
if proc.wait() == 0:
|
|
commit_id = proc.stdout.read().decode("utf-8").strip()
|
|
return commit_id
|
|
|
|
def sanity_results_filename(commit=None, cwd=os.environ.get('ZEPHYR_BASE')):
|
|
if not commit:
|
|
file_name = "tmp.csv"
|
|
else:
|
|
if commit == RELEASE_DATA:
|
|
file_name = RELEASE_DATA
|
|
else:
|
|
file_name = "%s.csv" % commit
|
|
|
|
return os.path.join(cwd,'scripts', 'sanity_chk', file_name)
|
|
|
|
def git_checkout(commit, cwd=os.environ.get('ZEPHYR_BASE')):
|
|
proc = subprocess.Popen('git diff --quiet', stdout=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT, cwd=cwd, shell=True)
|
|
if proc.wait() != 0:
|
|
raise Exception("Cannot continue, you have unstaged changes in your working tree")
|
|
|
|
proc = subprocess.Popen('git reset %s --hard' % commit,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT,
|
|
cwd=cwd, shell=True)
|
|
if proc.wait() == 0:
|
|
return True
|
|
else:
|
|
logger.error(proc.stdout.read())
|
|
return False
|
|
|
|
def run_sanity_footprint(commit=None, cwd=os.environ.get('ZEPHYR_BASE'),
|
|
output_file=None):
|
|
if not output_file:
|
|
output_file = sanity_results_filename(commit)
|
|
cmd = '/bin/bash -c "source ./zephyr-env.sh && sanitycheck'
|
|
cmd += ' +scripts/sanity_chk/sanity_compare.args -o %s"' % output_file
|
|
logger.debug('Sanity (%s) %s' %(commit, cmd))
|
|
|
|
proc = subprocess.Popen(cmd, stdout=subprocess.PIPE,
|
|
cwd=cwd, shell=True)
|
|
output,error=proc.communicate()
|
|
if proc.wait() == 0:
|
|
logger.debug(output)
|
|
return True
|
|
|
|
logger.error("Couldn't build footprint apps in commit %s" % commit)
|
|
logger.error(output)
|
|
raise Exception("Couldn't build footprint apps in commit %s" % commit)
|
|
|
|
def run_footprint_build(commit=None):
|
|
logging.debug("footprint build for %s" % commit)
|
|
if not commit:
|
|
run_sanity_footprint()
|
|
else:
|
|
cmd = "git clone --no-hardlinks %s" % os.environ.get('ZEPHYR_BASE')
|
|
tmp_location = os.path.join(tempfile.gettempdir(),
|
|
os.path.basename(os.environ.get('ZEPHYR_BASE')))
|
|
if os.path.exists(tmp_location):
|
|
shutil.rmtree(tmp_location)
|
|
logging.debug("clonning into %s" % tmp_location)
|
|
proc = subprocess.Popen(cmd, stdout=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT,
|
|
cwd=tempfile.gettempdir(), shell=True)
|
|
if proc.wait() == 0:
|
|
if git_checkout(commit, tmp_location):
|
|
run_sanity_footprint(commit, tmp_location)
|
|
else:
|
|
logger.error(proc.stdout.read())
|
|
shutil.rmtree(tmp_location, ignore_errors=True)
|
|
return True
|
|
|
|
def read_sanity_report(filename):
|
|
data = []
|
|
with open(filename) as fp:
|
|
tmp = csv.DictReader(fp)
|
|
for row in tmp:
|
|
data.append(row)
|
|
return data
|
|
|
|
def get_footprint_results(commit=None):
|
|
results = {}
|
|
|
|
sanity_file = sanity_results_filename(commit)
|
|
if (not os.path.exists(sanity_file) or not commit) and commit != RELEASE_DATA:
|
|
run_footprint_build(commit)
|
|
|
|
return read_sanity_report(sanity_file)
|
|
|
|
def tree_changes():
|
|
proc = subprocess.Popen('git diff --quiet', stdout=subprocess.PIPE,
|
|
cwd=os.environ.get('ZEPHYR_BASE'), shell=True)
|
|
if proc.wait() != 0:
|
|
return True
|
|
return False
|
|
|
|
def get_default_current_commit():
|
|
if tree_changes():
|
|
return None
|
|
else:
|
|
return get_git_commit('HEAD')
|
|
|
|
def get_default_base_commit(current_commit):
|
|
if not current_commit:
|
|
if tree_changes():
|
|
return get_git_commit('HEAD')
|
|
else:
|
|
return get_git_commit('HEAD~1')
|
|
else:
|
|
return get_git_commit('%s~1'%current_commit)
|
|
|
|
def build_history(b_commit=None, c_commit=None):
|
|
if not GIT_ENABLED:
|
|
logger.info('Working on current tree, not git enabled.')
|
|
current_commit = None
|
|
base_commit = RELEASE_DATA
|
|
else:
|
|
if not c_commit:
|
|
current_commit = get_default_current_commit()
|
|
else:
|
|
current_commit = get_git_commit(c_commit)
|
|
|
|
if not b_commit:
|
|
base_commit = get_default_base_commit(current_commit)
|
|
else:
|
|
base_commit = get_git_commit(b_commit)
|
|
|
|
if not base_commit:
|
|
logger.error("Cannot resolve base commit")
|
|
return
|
|
|
|
logger.info("Base: %s" % base_commit)
|
|
logger.info("Current: %s" % (current_commit if current_commit else
|
|
'working space'))
|
|
|
|
current_results = get_footprint_results(current_commit)
|
|
base_results = get_footprint_results(base_commit)
|
|
deltas = compare_results(base_results, current_results)
|
|
print_deltas(deltas)
|
|
|
|
def compare_results(base_results, current_results):
|
|
interesting_metrics = [("ram_size", int),
|
|
("rom_size", int)]
|
|
results = {}
|
|
metrics = {}
|
|
|
|
for type, data in {'base': base_results, 'current': current_results}.items():
|
|
metrics[type] = {}
|
|
for row in data:
|
|
d = {}
|
|
for m, mtype in interesting_metrics:
|
|
if row[m]:
|
|
d[m] = mtype(row[m])
|
|
if not row["test"] in metrics[type]:
|
|
metrics[type][row["test"]] = {}
|
|
metrics[type][row["test"]][row["platform"]] = d
|
|
|
|
for test, platforms in metrics['current'].items():
|
|
if not test in metrics['base']:
|
|
continue
|
|
tests = {}
|
|
|
|
for platform, test_data in platforms.items():
|
|
if not platform in metrics['base'][test]:
|
|
continue
|
|
golden_metric = metrics['base'][test][platform]
|
|
tmp = {}
|
|
for metric, _ in interesting_metrics:
|
|
if metric not in golden_metric or metric not in test_data:
|
|
continue
|
|
if test_data[metric] == "":
|
|
continue
|
|
delta = test_data[metric] - golden_metric[metric]
|
|
if delta == 0:
|
|
continue
|
|
tmp[metric] = {
|
|
'delta': delta,
|
|
'current': test_data[metric],
|
|
}
|
|
|
|
if len(tmp) != 0:
|
|
tests[platform] = tmp
|
|
if len(tests) != 0:
|
|
results[test] = tests
|
|
|
|
return results
|
|
|
|
def print_deltas(deltas):
|
|
error_count = 0
|
|
for test in sorted(deltas):
|
|
print("\n{:<25}".format(test))
|
|
for platform, data in deltas[test].items():
|
|
print(" {:<25}".format(platform))
|
|
for metric, value in data.items():
|
|
percentage = (float(value['delta']) / float(value['current'] -
|
|
value['delta']))
|
|
print(" {} ({:+.2%}) {:+6} current size {:>7} bytes".format(
|
|
"RAM" if metric == "ram_size" else "ROM", percentage,
|
|
value['delta'], value['current']))
|
|
error_count = error_count + 1
|
|
if error_count == 0:
|
|
print("There are no changes in RAM neither in ROM of footprint apps.")
|
|
return error_count
|
|
|
|
def main():
|
|
args = parse_args()
|
|
build_history(args.base_commit, args.commit)
|
|
|
|
if __name__ == "__main__":
|
|
init_logs()
|
|
is_git_enabled()
|
|
main()
|