blob: 5f7a8fff44ba710a0b6762a094c7ba2429c84e97 [file] [log] [blame]
#!/usr/bin/env python3
"""
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()