#!/usr/bin/env python3 """ This script is for comparing the size of the library files from two different Git revisions within an Mbed TLS repository. The results of the comparison is formatted as csv and stored at a configurable location. Note: must be run from Mbed TLS root. """ # Copyright The Mbed TLS Contributors # SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later import argparse import logging import os import re import shutil import subprocess import sys import typing from enum import Enum import framework_scripts_path # pylint: disable=unused-import from mbedtls_framework import build_tree from mbedtls_framework import logging_util from mbedtls_framework import typing_util class SupportedArch(Enum): """Supported architecture for code size measurement.""" AARCH64 = 'aarch64' AARCH32 = 'aarch32' ARMV8_M = 'armv8-m' X86_64 = 'x86_64' X86 = 'x86' class SupportedConfig(Enum): """Supported configuration for code size measurement.""" DEFAULT = 'default' TFM_MEDIUM = 'tfm-medium' # Static library MBEDTLS_STATIC_LIB = { 'CRYPTO': 'library/libmbedcrypto.a', 'X509': 'library/libmbedx509.a', 'TLS': 'library/libmbedtls.a', } class CodeSizeDistinctInfo: # pylint: disable=too-few-public-methods """Data structure to store possibly distinct information for code size comparison.""" def __init__( #pylint: disable=too-many-arguments self, version: str, git_rev: str, arch: str, config: str, compiler: str, opt_level: str, ) -> None: """ :param: version: which version to compare with for code size. :param: git_rev: Git revision to calculate code size. :param: arch: architecture to measure code size on. :param: config: Configuration type to calculate code size. (See SupportedConfig) :param: compiler: compiler used to build library/*.o. :param: opt_level: Options that control optimization. (E.g. -Os) """ self.version = version self.git_rev = git_rev self.arch = arch self.config = config self.compiler = compiler self.opt_level = opt_level # Note: Variables below are not initialized by class instantiation. self.pre_make_cmd = [] #type: typing.List[str] self.make_cmd = '' def get_info_indication(self): """Return a unique string to indicate Code Size Distinct Information.""" return '{git_rev}-{arch}-{config}-{compiler}'.format(**self.__dict__) class CodeSizeCommonInfo: # pylint: disable=too-few-public-methods """Data structure to store common information for code size comparison.""" def __init__( self, host_arch: str, measure_cmd: str, ) -> None: """ :param host_arch: host architecture. :param measure_cmd: command to measure code size for library/*.o. """ self.host_arch = host_arch self.measure_cmd = measure_cmd def get_info_indication(self): """Return a unique string to indicate Code Size Common Information.""" return '{measure_tool}'\ .format(measure_tool=self.measure_cmd.strip().split(' ')[0]) class CodeSizeResultInfo: # pylint: disable=too-few-public-methods """Data structure to store result options for code size comparison.""" def __init__( #pylint: disable=too-many-arguments self, record_dir: str, comp_dir: str, with_markdown=False, stdout=False, show_all=False, ) -> None: """ :param record_dir: directory to store code size record. :param comp_dir: directory to store results of code size comparision. :param with_markdown: write comparision result into a markdown table. (Default: False) :param stdout: direct comparison result into sys.stdout. (Default False) :param show_all: show all objects in comparison result. (Default False) """ self.record_dir = record_dir self.comp_dir = comp_dir self.with_markdown = with_markdown self.stdout = stdout self.show_all = show_all DETECT_ARCH_CMD = "cc -dM -E - < /dev/null" def detect_arch() -> str: """Auto-detect host architecture.""" cc_output = subprocess.check_output(DETECT_ARCH_CMD, shell=True).decode() if '__aarch64__' in cc_output: return SupportedArch.AARCH64.value if '__arm__' in cc_output: return SupportedArch.AARCH32.value if '__x86_64__' in cc_output: return SupportedArch.X86_64.value if '__i386__' in cc_output: return SupportedArch.X86.value else: print("Unknown host architecture, cannot auto-detect arch.") sys.exit(1) TFM_MEDIUM_CONFIG_H = 'configs/ext/tfm_mbedcrypto_config_profile_medium.h' TFM_MEDIUM_CRYPTO_CONFIG_H = 'configs/ext/crypto_config_profile_medium.h' CONFIG_H = 'include/mbedtls/mbedtls_config.h' CRYPTO_CONFIG_H = 'tf-psa-crypto/include/psa/crypto_config.h' BACKUP_SUFFIX = '.code_size.bak' class CodeSizeBuildInfo: # pylint: disable=too-few-public-methods """Gather information used to measure code size. It collects information about architecture, configuration in order to infer build command for code size measurement. """ SupportedArchConfig = [ '-a ' + SupportedArch.AARCH64.value + ' -c ' + SupportedConfig.DEFAULT.value, '-a ' + SupportedArch.AARCH32.value + ' -c ' + SupportedConfig.DEFAULT.value, '-a ' + SupportedArch.X86_64.value + ' -c ' + SupportedConfig.DEFAULT.value, '-a ' + SupportedArch.X86.value + ' -c ' + SupportedConfig.DEFAULT.value, '-a ' + SupportedArch.ARMV8_M.value + ' -c ' + SupportedConfig.TFM_MEDIUM.value, ] def __init__( self, size_dist_info: CodeSizeDistinctInfo, host_arch: str, logger: logging.Logger, ) -> None: """ :param size_dist_info: CodeSizeDistinctInfo containing info for code size measurement. - size_dist_info.arch: architecture to measure code size on. - size_dist_info.config: configuration type to measure code size with. - size_dist_info.compiler: compiler used to build library/*.o. - size_dist_info.opt_level: Options that control optimization. (E.g. -Os) :param host_arch: host architecture. :param logger: logging module """ self.arch = size_dist_info.arch self.config = size_dist_info.config self.compiler = size_dist_info.compiler self.opt_level = size_dist_info.opt_level self.make_cmd = ['make', '-j', 'lib'] self.host_arch = host_arch self.logger = logger def check_correctness(self) -> bool: """Check whether we are using proper / supported combination of information to build library/*.o.""" # default config if self.config == SupportedConfig.DEFAULT.value and \ self.arch == self.host_arch: return True # TF-M elif self.arch == SupportedArch.ARMV8_M.value and \ self.config == SupportedConfig.TFM_MEDIUM.value: return True return False def infer_pre_make_command(self) -> typing.List[str]: """Infer command to set up proper configuration before running make.""" pre_make_cmd = [] #type: typing.List[str] if self.config == SupportedConfig.TFM_MEDIUM.value: pre_make_cmd.append('cp {src} {dest}' .format(src=TFM_MEDIUM_CONFIG_H, dest=CONFIG_H)) pre_make_cmd.append('cp {src} {dest}' .format(src=TFM_MEDIUM_CRYPTO_CONFIG_H, dest=CRYPTO_CONFIG_H)) return pre_make_cmd def infer_make_cflags(self) -> str: """Infer CFLAGS by instance attributes in CodeSizeDistinctInfo.""" cflags = [] #type: typing.List[str] # set optimization level cflags.append(self.opt_level) # set compiler by config if self.config == SupportedConfig.TFM_MEDIUM.value: self.compiler = 'armclang' cflags.append('-mcpu=cortex-m33') # set target if self.compiler == 'armclang': cflags.append('--target=arm-arm-none-eabi') return ' '.join(cflags) def infer_make_command(self) -> str: """Infer make command by CFLAGS and CC.""" if self.check_correctness(): # set CFLAGS= self.make_cmd.append('CFLAGS=\'{}\''.format(self.infer_make_cflags())) # set CC= self.make_cmd.append('CC={}'.format(self.compiler)) return ' '.join(self.make_cmd) else: self.logger.error("Unsupported combination of architecture: {} " \ "and configuration: {}.\n" .format(self.arch, self.config)) self.logger.error("Please use supported combination of " \ "architecture and configuration:") for comb in CodeSizeBuildInfo.SupportedArchConfig: self.logger.error(comb) self.logger.error("") self.logger.error("For your system, please use:") for comb in CodeSizeBuildInfo.SupportedArchConfig: if "default" in comb and self.host_arch not in comb: continue self.logger.error(comb) sys.exit(1) class CodeSizeCalculator: """ A calculator to calculate code size of library/*.o based on Git revision and code size measurement tool. """ def __init__( #pylint: disable=too-many-arguments self, git_rev: str, pre_make_cmd: typing.List[str], make_cmd: str, measure_cmd: str, logger: logging.Logger, ) -> None: """ :param git_rev: Git revision. (E.g: commit) :param pre_make_cmd: command to set up proper config before running make. :param make_cmd: command to build library/*.o. :param measure_cmd: command to measure code size for library/*.o. :param logger: logging module """ self.repo_path = "." self.git_command = "git" self.make_clean = 'make clean' self.git_rev = git_rev self.pre_make_cmd = pre_make_cmd self.make_cmd = make_cmd self.measure_cmd = measure_cmd self.logger = logger @staticmethod def validate_git_revision(git_rev: str) -> str: result = subprocess.check_output(["git", "rev-parse", "--verify", git_rev + "^{commit}"], shell=False, universal_newlines=True) return result[:7] def _create_git_worktree(self) -> str: """Create a separate worktree for Git revision. If Git revision is current, use current worktree instead.""" if self.git_rev == 'current': self.logger.debug("Using current work directory.") git_worktree_path = self.repo_path else: self.logger.debug("Creating git worktree for {}." .format(self.git_rev)) git_worktree_path = os.path.join(self.repo_path, "temp-" + self.git_rev) subprocess.check_output( [self.git_command, "worktree", "add", "--detach", git_worktree_path, self.git_rev], cwd=self.repo_path, stderr=subprocess.STDOUT ) return git_worktree_path @staticmethod def backup_config_files(restore: bool) -> None: """Backup / Restore config files.""" if restore: shutil.move(CONFIG_H + BACKUP_SUFFIX, CONFIG_H) shutil.move(CRYPTO_CONFIG_H + BACKUP_SUFFIX, CRYPTO_CONFIG_H) else: shutil.copy(CONFIG_H, CONFIG_H + BACKUP_SUFFIX) shutil.copy(CRYPTO_CONFIG_H, CRYPTO_CONFIG_H + BACKUP_SUFFIX) def _build_libraries(self, git_worktree_path: str) -> None: """Build library/*.o in the specified worktree.""" self.logger.debug("Building library/*.o for {}." .format(self.git_rev)) my_environment = os.environ.copy() try: if self.git_rev == 'current': self.backup_config_files(restore=False) for pre_cmd in self.pre_make_cmd: subprocess.check_output( pre_cmd, env=my_environment, shell=True, cwd=git_worktree_path, stderr=subprocess.STDOUT, universal_newlines=True ) subprocess.check_output( self.make_clean, env=my_environment, shell=True, cwd=git_worktree_path, stderr=subprocess.STDOUT, universal_newlines=True ) subprocess.check_output( self.make_cmd, env=my_environment, shell=True, cwd=git_worktree_path, stderr=subprocess.STDOUT, universal_newlines=True ) if self.git_rev == 'current': self.backup_config_files(restore=True) except subprocess.CalledProcessError as e: self._handle_called_process_error(e, git_worktree_path) def _gen_raw_code_size(self, git_worktree_path: str) -> typing.Dict[str, str]: """Measure code size by a tool and return in UTF-8 encoding.""" self.logger.debug("Measuring code size for {} by `{}`." .format(self.git_rev, self.measure_cmd.strip().split(' ')[0])) res = {} for mod, st_lib in MBEDTLS_STATIC_LIB.items(): try: result = subprocess.check_output( [self.measure_cmd + ' ' + st_lib], cwd=git_worktree_path, shell=True, universal_newlines=True ) res[mod] = result except subprocess.CalledProcessError as e: self._handle_called_process_error(e, git_worktree_path) return res def _remove_worktree(self, git_worktree_path: str) -> None: """Remove temporary worktree.""" if git_worktree_path != self.repo_path: self.logger.debug("Removing temporary worktree {}." .format(git_worktree_path)) subprocess.check_output( [self.git_command, "worktree", "remove", "--force", git_worktree_path], cwd=self.repo_path, stderr=subprocess.STDOUT ) def _handle_called_process_error(self, e: subprocess.CalledProcessError, git_worktree_path: str) -> None: """Handle a CalledProcessError and quit the program gracefully. Remove any extra worktrees so that the script may be called again.""" # Tell the user what went wrong self.logger.error(e, exc_info=True) self.logger.error("Process output:\n {}".format(e.output)) # Quit gracefully by removing the existing worktree self._remove_worktree(git_worktree_path) sys.exit(-1) def cal_libraries_code_size(self) -> typing.Dict[str, str]: """Do a complete round to calculate code size of library/*.o by measurement tool. :return A dictionary of measured code size - typing.Dict[mod: str] """ git_worktree_path = self._create_git_worktree() try: self._build_libraries(git_worktree_path) res = self._gen_raw_code_size(git_worktree_path) finally: self._remove_worktree(git_worktree_path) return res class CodeSizeGenerator: """ A generator based on size measurement tool for library/*.o. This is an abstract class. To use it, derive a class that implements write_record and write_comparison methods, then call both of them with proper arguments. """ def __init__(self, logger: logging.Logger) -> None: """ :param logger: logging module """ self.logger = logger def write_record( self, git_rev: str, code_size_text: typing.Dict[str, str], output: typing_util.Writable ) -> None: """Write size record into a file. :param git_rev: Git revision. (E.g: commit) :param code_size_text: string output (utf-8) from measurement tool of code size. - typing.Dict[mod: str] :param output: output stream which the code size record is written to. (Note: Normally write code size record into File) """ raise NotImplementedError def write_comparison( #pylint: disable=too-many-arguments self, old_rev: str, new_rev: str, output: typing_util.Writable, with_markdown=False, show_all=False ) -> None: """Write a comparision result into a stream between two Git revisions. :param old_rev: old Git revision to compared with. :param new_rev: new Git revision to compared with. :param output: output stream which the code size record is written to. (File / sys.stdout) :param with_markdown: write comparision result in a markdown table. (Default: False) :param show_all: show all objects in comparison result. (Default False) """ raise NotImplementedError class CodeSizeGeneratorWithSize(CodeSizeGenerator): """Code Size Base Class for size record saving and writing.""" class SizeEntry: # pylint: disable=too-few-public-methods """Data Structure to only store information of code size.""" def __init__(self, text: int, data: int, bss: int, dec: int): self.text = text self.data = data self.bss = bss self.total = dec # total <=> dec def __init__(self, logger: logging.Logger) -> None: """ Variable code_size is used to store size info for any Git revisions. :param code_size: Data Format as following: code_size = { git_rev: { module: { file_name: SizeEntry, ... }, ... }, ... } """ super().__init__(logger) self.code_size = {} #type: typing.Dict[str, typing.Dict] self.mod_total_suffix = '-' + 'TOTALS' def _set_size_record(self, git_rev: str, mod: str, size_text: str) -> None: """Store size information for target Git revision and high-level module. size_text Format: text data bss dec hex filename """ size_record = {} for line in size_text.splitlines()[1:]: data = line.split() if re.match(r'\s*\(TOTALS\)', data[5]): data[5] = mod + self.mod_total_suffix # file_name: SizeEntry(text, data, bss, dec) size_record[data[5]] = CodeSizeGeneratorWithSize.SizeEntry( int(data[0]), int(data[1]), int(data[2]), int(data[3])) self.code_size.setdefault(git_rev, {}).update({mod: size_record}) def read_size_record(self, git_rev: str, fname: str) -> None: """Read size information from csv file and write it into code_size. fname Format: filename text data bss dec """ mod = "" size_record = {} with open(fname, 'r') as csv_file: for line in csv_file: data = line.strip().split() # check if we find the beginning of a module if data and data[0] in MBEDTLS_STATIC_LIB: mod = data[0] continue if mod: # file_name: SizeEntry(text, data, bss, dec) size_record[data[0]] = CodeSizeGeneratorWithSize.SizeEntry( int(data[1]), int(data[2]), int(data[3]), int(data[4])) # check if we hit record for the end of a module m = re.match(r'\w+' + self.mod_total_suffix, line) if m: if git_rev in self.code_size: self.code_size[git_rev].update({mod: size_record}) else: self.code_size[git_rev] = {mod: size_record} mod = "" size_record = {} def write_record( self, git_rev: str, code_size_text: typing.Dict[str, str], output: typing_util.Writable ) -> None: """Write size information to a file. Writing Format: filename text data bss total(dec) """ for mod, size_text in code_size_text.items(): self._set_size_record(git_rev, mod, size_text) format_string = "{:<30} {:>7} {:>7} {:>7} {:>7}\n" output.write(format_string.format("filename", "text", "data", "bss", "total")) for mod, f_size in self.code_size[git_rev].items(): output.write("\n" + mod + "\n") for fname, size_entry in f_size.items(): output.write(format_string .format(fname, size_entry.text, size_entry.data, size_entry.bss, size_entry.total)) def write_comparison( #pylint: disable=too-many-arguments self, old_rev: str, new_rev: str, output: typing_util.Writable, with_markdown=False, show_all=False ) -> None: # pylint: disable=too-many-locals """Write comparison result into a file. Writing Format: Markdown Output: filename new(text) new(data) change(text) change(data) CSV Output: filename new(text) new(data) old(text) old(data) change(text) change(data) """ header_line = ["filename", "new(text)", "old(text)", "change(text)", "new(data)", "old(data)", "change(data)"] if with_markdown: dash_line = [":----", "----:", "----:", "----:", "----:", "----:", "----:"] # | filename | new(text) | new(data) | change(text) | change(data) | line_format = "| {0:<30} | {1:>9} | {4:>9} | {3:>12} | {6:>12} |\n" bold_text = lambda x: '**' + str(x) + '**' else: # filename new(text) new(data) old(text) old(data) change(text) change(data) line_format = "{0:<30} {1:>9} {4:>9} {2:>10} {5:>10} {3:>12} {6:>12}\n" def cal_sect_change( old_size: typing.Optional[CodeSizeGeneratorWithSize.SizeEntry], new_size: typing.Optional[CodeSizeGeneratorWithSize.SizeEntry], sect: str ) -> typing.List: """Inner helper function to calculate size change for a section. Convention for special cases: - If the object has been removed in new Git revision, the size is minus code size of old Git revision; the size change is marked as `Removed`, - If the object only exists in new Git revision, the size is code size of new Git revision; the size change is marked as `None`, :param: old_size: code size for objects in old Git revision. :param: new_size: code size for objects in new Git revision. :param: sect: section to calculate from `size` tool. This could be any instance variable in SizeEntry. :return: List of [section size of objects for new Git revision, section size of objects for old Git revision, section size change of objects between two Git revisions] """ if old_size and new_size: new_attr = new_size.__dict__[sect] old_attr = old_size.__dict__[sect] delta = new_attr - old_attr change_attr = '{0:{1}}'.format(delta, '+' if delta else '') elif old_size: new_attr = 'Removed' old_attr = old_size.__dict__[sect] delta = - old_attr change_attr = '{0:{1}}'.format(delta, '+' if delta else '') elif new_size: new_attr = new_size.__dict__[sect] old_attr = 'NotCreated' delta = new_attr change_attr = '{0:{1}}'.format(delta, '+' if delta else '') else: # Should never happen new_attr = 'Error' old_attr = 'Error' change_attr = 'Error' return [new_attr, old_attr, change_attr] # sort dictionary by key sort_by_k = lambda item: item[0].lower() def get_results( f_rev_size: typing.Dict[str, typing.Dict[str, CodeSizeGeneratorWithSize.SizeEntry]] ) -> typing.List: """Return List of results in the format of: [filename, new(text), old(text), change(text), new(data), old(data), change(data)] """ res = [] for fname, revs_size in sorted(f_rev_size.items(), key=sort_by_k): old_size = revs_size.get(old_rev) new_size = revs_size.get(new_rev) text_sect = cal_sect_change(old_size, new_size, 'text') data_sect = cal_sect_change(old_size, new_size, 'data') # skip the files that haven't changed in code size if not show_all and text_sect[-1] == '0' and data_sect[-1] == '0': continue res.append([fname, *text_sect, *data_sect]) return res # write header output.write(line_format.format(*header_line)) if with_markdown: output.write(line_format.format(*dash_line)) for mod in MBEDTLS_STATIC_LIB: # convert self.code_size to: # { # file_name: { # old_rev: SizeEntry, # new_rev: SizeEntry # }, # ... # } f_rev_size = {} #type: typing.Dict[str, typing.Dict] for fname, size_entry in self.code_size[old_rev][mod].items(): f_rev_size.setdefault(fname, {}).update({old_rev: size_entry}) for fname, size_entry in self.code_size[new_rev][mod].items(): f_rev_size.setdefault(fname, {}).update({new_rev: size_entry}) mod_total_sz = f_rev_size.pop(mod + self.mod_total_suffix) res = get_results(f_rev_size) total_clm = get_results({mod + self.mod_total_suffix: mod_total_sz}) if with_markdown: # bold row of mod-TOTALS in markdown table total_clm = [[bold_text(j) for j in i] for i in total_clm] res += total_clm # write comparison result for line in res: output.write(line_format.format(*line)) class CodeSizeComparison: """Compare code size between two Git revisions.""" def __init__( #pylint: disable=too-many-arguments self, old_size_dist_info: CodeSizeDistinctInfo, new_size_dist_info: CodeSizeDistinctInfo, size_common_info: CodeSizeCommonInfo, result_options: CodeSizeResultInfo, logger: logging.Logger, ) -> None: """ :param old_size_dist_info: CodeSizeDistinctInfo containing old distinct info to compare code size with. :param new_size_dist_info: CodeSizeDistinctInfo containing new distinct info to take as comparision base. :param size_common_info: CodeSizeCommonInfo containing common info for both old and new size distinct info and measurement tool. :param result_options: CodeSizeResultInfo containing results options for code size record and comparision. :param logger: logging module """ self.logger = logger self.old_size_dist_info = old_size_dist_info self.new_size_dist_info = new_size_dist_info self.size_common_info = size_common_info # infer pre make command self.old_size_dist_info.pre_make_cmd = CodeSizeBuildInfo( self.old_size_dist_info, self.size_common_info.host_arch, self.logger).infer_pre_make_command() self.new_size_dist_info.pre_make_cmd = CodeSizeBuildInfo( self.new_size_dist_info, self.size_common_info.host_arch, self.logger).infer_pre_make_command() # infer make command self.old_size_dist_info.make_cmd = CodeSizeBuildInfo( self.old_size_dist_info, self.size_common_info.host_arch, self.logger).infer_make_command() self.new_size_dist_info.make_cmd = CodeSizeBuildInfo( self.new_size_dist_info, self.size_common_info.host_arch, self.logger).infer_make_command() # initialize size parser with corresponding measurement tool self.code_size_generator = self.__generate_size_parser() self.result_options = result_options self.csv_dir = os.path.abspath(self.result_options.record_dir) os.makedirs(self.csv_dir, exist_ok=True) self.comp_dir = os.path.abspath(self.result_options.comp_dir) os.makedirs(self.comp_dir, exist_ok=True) def __generate_size_parser(self): """Generate a parser for the corresponding measurement tool.""" if re.match(r'size', self.size_common_info.measure_cmd.strip()): return CodeSizeGeneratorWithSize(self.logger) else: self.logger.error("Unsupported measurement tool: `{}`." .format(self.size_common_info.measure_cmd .strip().split(' ')[0])) sys.exit(1) def cal_code_size( self, size_dist_info: CodeSizeDistinctInfo ) -> typing.Dict[str, str]: """Calculate code size of library/*.o in a UTF-8 encoding""" return CodeSizeCalculator(size_dist_info.git_rev, size_dist_info.pre_make_cmd, size_dist_info.make_cmd, self.size_common_info.measure_cmd, self.logger).cal_libraries_code_size() def gen_code_size_report(self, size_dist_info: CodeSizeDistinctInfo) -> None: """Generate code size record and write it into a file.""" self.logger.info("Start to generate code size record for {}." .format(size_dist_info.git_rev)) output_file = os.path.join( self.csv_dir, '{}-{}.csv' .format(size_dist_info.get_info_indication(), self.size_common_info.get_info_indication())) # Check if the corresponding record exists if size_dist_info.git_rev != "current" and \ os.path.exists(output_file): self.logger.debug("Code size csv file for {} already exists." .format(size_dist_info.git_rev)) self.code_size_generator.read_size_record( size_dist_info.git_rev, output_file) else: # measure code size code_size_text = self.cal_code_size(size_dist_info) self.logger.debug("Generating code size csv for {}." .format(size_dist_info.git_rev)) output = open(output_file, "w") self.code_size_generator.write_record( size_dist_info.git_rev, code_size_text, output) def gen_code_size_comparison(self) -> None: """Generate results of code size changes between two Git revisions, old and new. - Measured code size result of these two Git revisions must be available. - The result is directed into either file / stdout depending on the option, size_common_info.result_options.stdout. (Default: file) """ self.logger.info("Start to generate comparision result between "\ "{} and {}." .format(self.old_size_dist_info.git_rev, self.new_size_dist_info.git_rev)) if self.result_options.stdout: output = sys.stdout else: output_file = os.path.join( self.comp_dir, '{}-{}-{}.{}' .format(self.old_size_dist_info.get_info_indication(), self.new_size_dist_info.get_info_indication(), self.size_common_info.get_info_indication(), 'md' if self.result_options.with_markdown else 'csv')) output = open(output_file, "w") self.logger.debug("Generating comparison results between {} and {}." .format(self.old_size_dist_info.git_rev, self.new_size_dist_info.git_rev)) if self.result_options.with_markdown or self.result_options.stdout: print("Measure code size between {} and {} by `{}`." .format(self.old_size_dist_info.get_info_indication(), self.new_size_dist_info.get_info_indication(), self.size_common_info.get_info_indication()), file=output) self.code_size_generator.write_comparison( self.old_size_dist_info.git_rev, self.new_size_dist_info.git_rev, output, self.result_options.with_markdown, self.result_options.show_all) def get_comparision_results(self) -> None: """Compare size of library/*.o between self.old_size_dist_info and self.old_size_dist_info and generate the result file.""" build_tree.check_repo_path() self.gen_code_size_report(self.old_size_dist_info) self.gen_code_size_report(self.new_size_dist_info) self.gen_code_size_comparison() def main(): parser = argparse.ArgumentParser(description=(__doc__)) group_required = parser.add_argument_group( 'required arguments', 'required arguments to parse for running ' + os.path.basename(__file__)) group_required.add_argument( '-o', '--old-rev', type=str, required=True, help='old Git revision for comparison.') group_optional = parser.add_argument_group( 'optional arguments', 'optional arguments to parse for running ' + os.path.basename(__file__)) group_optional.add_argument( '--record-dir', type=str, default='code_size_records', help='directory where code size record is stored. ' '(Default: code_size_records)') group_optional.add_argument( '--comp-dir', type=str, default='comparison', help='directory where comparison result is stored. ' '(Default: comparison)') group_optional.add_argument( '-n', '--new-rev', type=str, default='current', help='new Git revision as comparison base. ' '(Default is the current work directory, including uncommitted ' 'changes.)') group_optional.add_argument( '-a', '--arch', type=str, default=detect_arch(), choices=list(map(lambda s: s.value, SupportedArch)), help='Specify architecture for code size comparison. ' '(Default is the host architecture.)') group_optional.add_argument( '-c', '--config', type=str, default=SupportedConfig.DEFAULT.value, choices=list(map(lambda s: s.value, SupportedConfig)), help='Specify configuration type for code size comparison. ' '(Default is the current Mbed TLS configuration.)') group_optional.add_argument( '--markdown', action='store_true', dest='markdown', help='Show comparision of code size in a markdown table. ' '(Only show the files that have changed).') group_optional.add_argument( '--stdout', action='store_true', dest='stdout', help='Set this option to direct comparison result into sys.stdout. ' '(Default: file)') group_optional.add_argument( '--show-all', action='store_true', dest='show_all', help='Show all the objects in comparison result, including the ones ' 'that haven\'t changed in code size. (Default: False)') group_optional.add_argument( '--verbose', action='store_true', dest='verbose', help='Show logs in detail for code size measurement. ' '(Default: False)') comp_args = parser.parse_args() logger = logging.getLogger() logging_util.configure_logger(logger, split_level=logging.NOTSET) logger.setLevel(logging.DEBUG if comp_args.verbose else logging.INFO) if os.path.isfile(comp_args.record_dir): logger.error("record directory: {} is not a directory" .format(comp_args.record_dir)) sys.exit(1) if os.path.isfile(comp_args.comp_dir): logger.error("comparison directory: {} is not a directory" .format(comp_args.comp_dir)) sys.exit(1) comp_args.old_rev = CodeSizeCalculator.validate_git_revision( comp_args.old_rev) if comp_args.new_rev != 'current': comp_args.new_rev = CodeSizeCalculator.validate_git_revision( comp_args.new_rev) # version, git_rev, arch, config, compiler, opt_level old_size_dist_info = CodeSizeDistinctInfo( 'old', comp_args.old_rev, comp_args.arch, comp_args.config, 'cc', '-Os') new_size_dist_info = CodeSizeDistinctInfo( 'new', comp_args.new_rev, comp_args.arch, comp_args.config, 'cc', '-Os') # host_arch, measure_cmd size_common_info = CodeSizeCommonInfo( detect_arch(), 'size -t') # record_dir, comp_dir, with_markdown, stdout, show_all result_options = CodeSizeResultInfo( comp_args.record_dir, comp_args.comp_dir, comp_args.markdown, comp_args.stdout, comp_args.show_all) logger.info("Measure code size between {} and {} by `{}`." .format(old_size_dist_info.get_info_indication(), new_size_dist_info.get_info_indication(), size_common_info.get_info_indication())) CodeSizeComparison(old_size_dist_info, new_size_dist_info, size_common_info, result_options, logger).get_comparision_results() if __name__ == "__main__": main()