Lines Matching refs:self
54 self,
71 self.version = version
72 self.git_rev = git_rev
73 self.arch = arch
74 self.config = config
75 self.compiler = compiler
76 self.opt_level = opt_level
78 self.pre_make_cmd = [] #type: typing.List[str]
79 self.make_cmd = ''
81 def get_info_indication(self):
83 return '{git_rev}-{arch}-{config}-{compiler}'.format(**self.__dict__)
89 self,
97 self.host_arch = host_arch
98 self.measure_cmd = measure_cmd
100 def get_info_indication(self):
103 .format(measure_tool=self.measure_cmd.strip().split(' ')[0])
108 self,
124 self.record_dir = record_dir
125 self.comp_dir = comp_dir
126 self.with_markdown = with_markdown
127 self.stdout = stdout
128 self.show_all = show_all
170 self,
187 self.arch = size_dist_info.arch
188 self.config = size_dist_info.config
189 self.compiler = size_dist_info.compiler
190 self.opt_level = size_dist_info.opt_level
192 self.make_cmd = ['make', '-j', 'lib']
194 self.host_arch = host_arch
195 self.logger = logger
197 def check_correctness(self) -> bool:
202 if self.config == SupportedConfig.DEFAULT.value and \
203 self.arch == self.host_arch:
206 elif self.arch == SupportedArch.ARMV8_M.value and \
207 self.config == SupportedConfig.TFM_MEDIUM.value:
212 def infer_pre_make_command(self) -> typing.List[str]:
215 if self.config == SupportedConfig.TFM_MEDIUM.value:
224 def infer_make_cflags(self) -> str:
229 cflags.append(self.opt_level)
231 if self.config == SupportedConfig.TFM_MEDIUM.value:
232 self.compiler = 'armclang'
235 if self.compiler == 'armclang':
240 def infer_make_command(self) -> str:
243 if self.check_correctness():
245 self.make_cmd.append('CFLAGS=\'{}\''.format(self.infer_make_cflags()))
247 self.make_cmd.append('CC={}'.format(self.compiler))
248 return ' '.join(self.make_cmd)
250 self.logger.error("Unsupported combination of architecture: {} " \
252 .format(self.arch,
253 self.config))
254 self.logger.error("Please use supported combination of " \
257 self.logger.error(comb)
258 self.logger.error("")
259 self.logger.error("For your system, please use:")
261 if "default" in comb and self.host_arch not in comb:
263 self.logger.error(comb)
273 self,
287 self.repo_path = "."
288 self.git_command = "git"
289 self.make_clean = 'make clean'
291 self.git_rev = git_rev
292 self.pre_make_cmd = pre_make_cmd
293 self.make_cmd = make_cmd
294 self.measure_cmd = measure_cmd
295 self.logger = logger
304 def _create_git_worktree(self) -> str:
308 if self.git_rev == 'current':
309 self.logger.debug("Using current work directory.")
310 git_worktree_path = self.repo_path
312 self.logger.debug("Creating git worktree for {}."
313 .format(self.git_rev))
314 git_worktree_path = os.path.join(self.repo_path,
315 "temp-" + self.git_rev)
317 [self.git_command, "worktree", "add", "--detach",
318 git_worktree_path, self.git_rev], cwd=self.repo_path,
334 def _build_libraries(self, git_worktree_path: str) -> None:
337 self.logger.debug("Building library/*.o for {}."
338 .format(self.git_rev))
341 if self.git_rev == 'current':
342 self.backup_config_files(restore=False)
343 for pre_cmd in self.pre_make_cmd:
350 self.make_clean, env=my_environment, shell=True,
355 self.make_cmd, env=my_environment, shell=True,
359 if self.git_rev == 'current':
360 self.backup_config_files(restore=True)
362 self._handle_called_process_error(e, git_worktree_path)
364 def _gen_raw_code_size(self, git_worktree_path: str) -> typing.Dict[str, str]:
367 self.logger.debug("Measuring code size for {} by `{}`."
368 .format(self.git_rev,
369 self.measure_cmd.strip().split(' ')[0]))
375 [self.measure_cmd + ' ' + st_lib], cwd=git_worktree_path,
380 self._handle_called_process_error(e, git_worktree_path)
384 def _remove_worktree(self, git_worktree_path: str) -> None:
386 if git_worktree_path != self.repo_path:
387 self.logger.debug("Removing temporary worktree {}."
390 [self.git_command, "worktree", "remove", "--force",
391 git_worktree_path], cwd=self.repo_path,
395 def _handle_called_process_error(self, e: subprocess.CalledProcessError,
401 self.logger.error(e, exc_info=True)
402 self.logger.error("Process output:\n {}".format(e.output))
405 self._remove_worktree(git_worktree_path)
408 def cal_libraries_code_size(self) -> typing.Dict[str, str]:
416 git_worktree_path = self._create_git_worktree()
418 self._build_libraries(git_worktree_path)
419 res = self._gen_raw_code_size(git_worktree_path)
421 self._remove_worktree(git_worktree_path)
433 def __init__(self, logger: logging.Logger) -> None:
437 self.logger = logger
440 self,
457 self,
482 def __init__(self, text: int, data: int, bss: int, dec: int):
483 self.text = text
484 self.data = data
485 self.bss = bss
486 self.total = dec # total <=> dec
488 def __init__(self, logger: logging.Logger) -> None:
504 self.code_size = {} #type: typing.Dict[str, typing.Dict]
505 self.mod_total_suffix = '-' + 'TOTALS'
507 def _set_size_record(self, git_rev: str, mod: str, size_text: str) -> None:
516 data[5] = mod + self.mod_total_suffix
520 self.code_size.setdefault(git_rev, {}).update({mod: size_record})
522 def read_size_record(self, git_rev: str, fname: str) -> None:
543 m = re.match(r'\w+' + self.mod_total_suffix, line)
545 if git_rev in self.code_size:
546 self.code_size[git_rev].update({mod: size_record})
548 self.code_size[git_rev] = {mod: size_record}
553 self,
563 self._set_size_record(git_rev, mod, size_text)
569 for mod, f_size in self.code_size[git_rev].items():
578 self,
682 # convert self.code_size to:
691 for fname, size_entry in self.code_size[old_rev][mod].items():
693 for fname, size_entry in self.code_size[new_rev][mod].items():
696 mod_total_sz = f_rev_size.pop(mod + self.mod_total_suffix)
698 total_clm = get_results({mod + self.mod_total_suffix: mod_total_sz})
713 self,
733 self.logger = logger
735 self.old_size_dist_info = old_size_dist_info
736 self.new_size_dist_info = new_size_dist_info
737 self.size_common_info = size_common_info
739 self.old_size_dist_info.pre_make_cmd = CodeSizeBuildInfo(
740 self.old_size_dist_info, self.size_common_info.host_arch,
741 self.logger).infer_pre_make_command()
742 self.new_size_dist_info.pre_make_cmd = CodeSizeBuildInfo(
743 self.new_size_dist_info, self.size_common_info.host_arch,
744 self.logger).infer_pre_make_command()
746 self.old_size_dist_info.make_cmd = CodeSizeBuildInfo(
747 self.old_size_dist_info, self.size_common_info.host_arch,
748 self.logger).infer_make_command()
749 self.new_size_dist_info.make_cmd = CodeSizeBuildInfo(
750 self.new_size_dist_info, self.size_common_info.host_arch,
751 self.logger).infer_make_command()
753 self.code_size_generator = self.__generate_size_parser()
755 self.result_options = result_options
756 self.csv_dir = os.path.abspath(self.result_options.record_dir)
757 os.makedirs(self.csv_dir, exist_ok=True)
758 self.comp_dir = os.path.abspath(self.result_options.comp_dir)
759 os.makedirs(self.comp_dir, exist_ok=True)
761 def __generate_size_parser(self):
763 if re.match(r'size', self.size_common_info.measure_cmd.strip()):
764 return CodeSizeGeneratorWithSize(self.logger)
766 self.logger.error("Unsupported measurement tool: `{}`."
767 .format(self.size_common_info.measure_cmd
772 self,
780 self.size_common_info.measure_cmd,
781 self.logger).cal_libraries_code_size()
783 def gen_code_size_report(self, size_dist_info: CodeSizeDistinctInfo) -> None:
786 self.logger.info("Start to generate code size record for {}."
789 self.csv_dir,
792 self.size_common_info.get_info_indication()))
796 self.logger.debug("Code size csv file for {} already exists."
798 self.code_size_generator.read_size_record(
802 code_size_text = self.cal_code_size(size_dist_info)
804 self.logger.debug("Generating code size csv for {}."
807 self.code_size_generator.write_record(
810 def gen_code_size_comparison(self) -> None:
819 self.logger.info("Start to generate comparision result between "\
821 .format(self.old_size_dist_info.git_rev,
822 self.new_size_dist_info.git_rev))
823 if self.result_options.stdout:
827 self.comp_dir,
829 .format(self.old_size_dist_info.get_info_indication(),
830 self.new_size_dist_info.get_info_indication(),
831 self.size_common_info.get_info_indication(),
832 'md' if self.result_options.with_markdown else 'csv'))
835 self.logger.debug("Generating comparison results between {} and {}."
836 .format(self.old_size_dist_info.git_rev,
837 self.new_size_dist_info.git_rev))
838 if self.result_options.with_markdown or self.result_options.stdout:
840 .format(self.old_size_dist_info.get_info_indication(),
841 self.new_size_dist_info.get_info_indication(),
842 self.size_common_info.get_info_indication()),
844 self.code_size_generator.write_comparison(
845 self.old_size_dist_info.git_rev,
846 self.new_size_dist_info.git_rev,
847 output, self.result_options.with_markdown,
848 self.result_options.show_all)
850 def get_comparision_results(self) -> None:
851 """Compare size of library/*.o between self.old_size_dist_info and
852 self.old_size_dist_info and generate the result file."""
854 self.gen_code_size_report(self.old_size_dist_info)
855 self.gen_code_size_report(self.new_size_dist_info)
856 self.gen_code_size_comparison()