#!/usr/bin/python # # Copyright (c) 2016, Intel Corporation # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Based on a script by: # Chereau, Fabien import os import re from optparse import OptionParser import sys import argparse import subprocess import json import operator class bcolors: HEADER = '\033[95m' OKBLUE = '\033[94m' OKGREEN = '\033[92m' WARNING = '\033[93m' FAIL = '\033[91m' ENDC = '\033[0m' BOLD = '\033[1m' UNDERLINE = '\033[4m' parser = OptionParser() parser.add_option("-d", "--depth", dest="depth", type="int", help="How deep should we go into the tree", metavar="DEPTH") parser.add_option("-o", "--outdir", dest="outdir", help="read files from directory OUT", metavar="OUT") parser.add_option("-k", "--kernel-name", dest="binary", default="zephyr", help="kernel binary name") parser.add_option("-r", "--ram", action="store_true", dest="ram", default=False, help="print RAM statistics") parser.add_option("-F", "--rom", action="store_true", dest="rom", default=False, help="print ROM statistics") (options, args) = parser.parse_args() # Return a dict containing symbol_name: path/to/file/where/it/originates # for all symbols from the .elf file. Optionnaly strips the path according # to the passed sub-path def load_symbols_and_paths(elf_file, path_to_strip = None): symbols_paths = {} nm_out = subprocess.check_output(["nm", elf_file, "-S", "-l", "--size-sort", "--radix=d"]) for line in nm_out.split('\n'): fields = line.replace('\t', ' ').split(' ') # Get rid of trailing empty field if len(fields) == 1 and fields[0] == '': continue assert len(fields)>=4 if len(fields)<5: path = ":/" + fields[3] else: path = fields[4].split(':')[0] if path_to_strip != None: if path_to_strip in path: path = path.replace(path_to_strip, "") + '/' + fields[3] else: path = ":/" + fields[3] symbols_paths[fields[3]] = path return symbols_paths def get_section_size(f, section_name): decimal_size = 0 re_res = re.search(r"(.*] "+section_name+".*)", f, re.MULTILINE) if re_res != None : # Replace multiple spaces with one space # Skip first characters to avoid having 1 extra random space res = ' '.join(re_res.group(1).split())[5:] decimal_size = int(res.split()[4], 16) return decimal_size def get_footprint_from_bin_and_statfile(bin_file, stat_file, total_flash, total_ram): """Compute flash and RAM memory footprint from a .bin and.stat file""" f = open(stat_file).read() # Get kctext + text + ctors + rodata + kcrodata segment size total_used_flash = os.path.getsize(bin_file) #getting used ram on target total_used_ram = (get_section_size(f, "noinit") + get_section_size(f, "bss") + get_section_size(f, "initlevel") + get_section_size(f, "datas") + get_section_size(f, ".data") + get_section_size(f, ".heap") + get_section_size(f, ".stack") + get_section_size(f, ".bss") + get_section_size(f, ".panic_section")) total_percent_ram = 0 total_percent_flash = 0 if total_ram > 0: total_percent_ram = float(total_used_ram) / total_ram * 100 if total_flash >0: total_percent_flash = float(total_used_flash) / total_flash * 100 res = { "total_flash": total_used_flash, "percent_flash": total_percent_flash, "total_ram": total_used_ram, "percent_ram": total_percent_ram} return res def generate_target_memory_section(out, kernel_name, source_dir, features_json): features_path_data = None try: features_path_data = json.loads(open(features_json, 'r').read()) except: pass bin_file_abs = os.path.join(out, kernel_name+'.bin') elf_file_abs = os.path.join(out, kernel_name+'.elf') # First deal with size on flash. These are the symbols flagged as LOAD in objdump output size_out = subprocess.check_output(["objdump", "-hw", elf_file_abs]) loaded_section_total = 0 loaded_section_names = [] loaded_section_names_sizes = {} ram_section_total = 0 ram_section_names = [] ram_section_names_sizes = {} for line in size_out.split('\n'): if "LOAD" in line: loaded_section_total = loaded_section_total + int(line.split()[2], 16) loaded_section_names.append(line.split()[1]) loaded_section_names_sizes[line.split()[1]] = int(line.split()[2], 16) if "ALLOC" in line and "READONLY" not in line and "rodata" not in line and "CODE" not in line: ram_section_total = ram_section_total + int(line.split()[2], 16) ram_section_names.append(line.split()[1]) ram_section_names_sizes[line.split()[1]] = int(line.split()[2], 16) # Actual .bin size, which doesn't not always match section sizes bin_size = os.stat(bin_file_abs).st_size # Get the path associated to each symbol symbols_paths = load_symbols_and_paths(elf_file_abs, source_dir) # A set of helper function for building a simple tree with a path-like # hierarchy. def _insert_one_elem(tree, path, size): splitted_path = path.split('/') cur = None for p in splitted_path: if cur == None: cur = p else: cur = cur + '/' + p if cur in tree: tree[cur] += size else: tree[cur] = size def _parent_for_node(e): parent = "root" if len(e.split('/')) == 1 else e.rsplit('/', 1)[0] if e == "root": parent = None return parent def _childs_for_node(tree, node): res = [] for e in tree: if _parent_for_node(e) == node: res += [e] return res def _siblings_for_node(tree, node): return _childs_for_node(tree, _parent_for_node(node)) def _max_sibling_size(tree, node): siblings = _siblings_for_node(tree, node) return max([tree[e] for e in siblings]) # Extract the list of symbols a second time but this time using the objdump tool # which provides more info as nm symbols_out = subprocess.check_output(["objdump", "-tw", elf_file_abs]) flash_symbols_total = 0 data_nodes = {} data_nodes['root'] = 0 ram_symbols_total = 0 ram_nodes = {} ram_nodes['root'] = 0 for l in symbols_out.split('\n'): line = l[0:9] + "......." + l[16:] fields = line.replace('\t', ' ').split(' ') # Get rid of trailing empty field if len(fields) != 5: continue size = int(fields[3], 16) if fields[2] in loaded_section_names and size != 0: flash_symbols_total += size _insert_one_elem(data_nodes, symbols_paths[fields[4]], size) if fields[2] in ram_section_names and size != 0: ram_symbols_total += size _insert_one_elem(ram_nodes, symbols_paths[fields[4]], size) def _init_features_list_results(features_list): for feature in features_list: _init_feature_results(feature) def _init_feature_results(feature): feature["size"] = 0 # recursive through children for child in feature["children"]: _init_feature_results(child) def _check_all_symbols(symbols_struct, features_list): out = "" sorted_nodes = sorted(symbols_struct.items(), key=operator.itemgetter(0)) named_symbol_filter = re.compile('.*\.[a-zA-Z]+/.*') out_symbols_filter = re.compile('^:/') for symbpath in sorted_nodes: matched = 0 # The files and folders (not matching regex) are discarded # like: folder folder/file.ext is_symbol=named_symbol_filter.match(symbpath[0]) is_generated=out_symbols_filter.match(symbpath[0]) if is_symbol == None and is_generated == None: continue # The symbols inside a file are kept: folder/file.ext/symbol # and unrecognized paths too (":/") for feature in features_list: matched = matched + _does_symbol_matches_feature(symbpath[0], symbpath[1], feature) if matched is 0: out += "UNCATEGORIZED: %s %d
" % (symbpath[0], symbpath[1]) return out def _does_symbol_matches_feature(symbol, size, feature): matched = 0 # check each include-filter in feature for inc_path in feature["folders"]: # filter out if the include-filter is not in the symbol string if inc_path not in symbol: continue # if the symbol match the include-filter, check against exclude-filter is_excluded = 0 for exc_path in feature["excludes"]: if exc_path in symbol: is_excluded = 1 break if is_excluded == 0: matched = 1 feature["size"] = feature["size"] + size # it can only be matched once per feature (add size once) break # check children independently of this feature's result for child in feature["children"]: child_matched = _does_symbol_matches_feature(symbol, size, child) matched = matched + child_matched return matched # Create a simplified tree keeping only the most important contributors # This is used for the pie diagram summary min_parent_size = bin_size/25 min_sibling_size = bin_size/35 tmp = {} for e in data_nodes: if _parent_for_node(e) == None: continue if data_nodes[_parent_for_node(e)] < min_parent_size: continue if _max_sibling_size(data_nodes, e) < min_sibling_size: continue tmp[e] = data_nodes[e] # Keep only final nodes tmp2 = {} for e in tmp: if len(_childs_for_node(tmp, e)) == 0: tmp2[e] = tmp[e] # Group nodes too small in an "other" section filtered_data_nodes = {} for e in tmp2: if tmp[e] < min_sibling_size: k = _parent_for_node(e) + "/(other)" if k in filtered_data_nodes: filtered_data_nodes[k] += tmp[e] else: filtered_data_nodes[k] = tmp[e] else: filtered_data_nodes[e] = tmp[e] def _parent_level_3_at_most(node): e = _parent_for_node(node) while e.count('/')>2: e = _parent_for_node(e) return e return ram_nodes, data_nodes def print_tree(data, total, depth): base = os.environ['ZEPHYR_BASE'] totp = 0 print '{:92s} {:10s} {:8s}'.format(bcolors.FAIL + "Path", "Size", "%" + bcolors.ENDC) print '='*110 for i in sorted(data): p = i.split("/") if depth and len(p) > depth: continue percent = 100 * float(data[i])/float(total) percent_c = percent if len(p) < 2: totp += percent if len(p) > 1: if not os.path.exists(os.path.join(base, i)): s = bcolors.WARNING + p[-1] + bcolors.ENDC else: s = bcolors.OKBLUE + p[-1] + bcolors.ENDC print '{:80s} {:20d} {:8.2f}%'.format(" "*(len(p)-1) + s, data[i], percent_c ) else: print '{:80s} {:20d} {:8.2f}%'.format(bcolors.OKBLUE + i + bcolors.ENDC, data[i], percent_c ) print '='*110 print '{:92d}'.format(total) return totp binary = os.path.join(options.outdir, options.binary + ".elf") if options.outdir and os.path.exists(binary): fp = get_footprint_from_bin_and_statfile("%s/%s.bin" %(options.outdir, options.binary), "%s/%s.stat" %(options.outdir,options.binary), 0, 0 ) base = os.environ['ZEPHYR_BASE'] ram, data = generate_target_memory_section(options.outdir, options.binary, base + '/', None) if options.rom: print_tree(data, fp['total_flash'], options.depth) if options.ram: print_tree(ram, fp['total_ram'], options.depth) else: print "%s does not exist." %(binary)