299 lines
10 KiB
Python
Executable File
299 lines
10 KiB
Python
Executable File
#!/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()
|