From eb8dc40360f0cfef56fb6947cc817a547d6d9bc6 Mon Sep 17 00:00:00 2001 From: Dave Cobbley Date: Tue, 14 Aug 2018 10:05:37 -0700 Subject: [Subtree] Removing import-layers directory As part of the move to subtrees, need to bring all the import layers content to the top level. Change-Id: I4a163d10898cbc6e11c27f776f60e1a470049d8f Signed-off-by: Dave Cobbley Signed-off-by: Brad Bishop --- poky/scripts/tiny/dirsize.py | 89 ++++++++++++++++++++++ poky/scripts/tiny/ksize.py | 170 +++++++++++++++++++++++++++++++++++++++++++ poky/scripts/tiny/ksum.py | 168 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 427 insertions(+) create mode 100755 poky/scripts/tiny/dirsize.py create mode 100755 poky/scripts/tiny/ksize.py create mode 100755 poky/scripts/tiny/ksum.py (limited to 'poky/scripts/tiny') diff --git a/poky/scripts/tiny/dirsize.py b/poky/scripts/tiny/dirsize.py new file mode 100755 index 000000000..ddccc5a8c --- /dev/null +++ b/poky/scripts/tiny/dirsize.py @@ -0,0 +1,89 @@ +#!/usr/bin/env python3 +# +# Copyright (c) 2011, Intel Corporation. +# All rights reserved. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# +# Display details of the root filesystem size, broken up by directory. +# Allows for limiting by size to focus on the larger files. +# +# Author: Darren Hart +# + +import os +import sys +import stat + +class Record: + def create(path): + r = Record(path) + + s = os.lstat(path) + if stat.S_ISDIR(s.st_mode): + for p in os.listdir(path): + pathname = path + "/" + p + ss = os.lstat(pathname) + if not stat.S_ISLNK(ss.st_mode): + r.records.append(Record.create(pathname)) + r.size += r.records[-1].size + r.records.sort(reverse=True) + else: + r.size = os.lstat(path).st_size + + return r + create = staticmethod(create) + + def __init__(self, path): + self.path = path + self.size = 0 + self.records = [] + + def __lt__(this, that): + if that is None: + return False + if not isinstance(that, Record): + raise TypeError + if len(this.records) > 0 and len(that.records) == 0: + return False + if this.size > that.size: + return False + return True + + def show(self, minsize): + total = 0 + if self.size <= minsize: + return 0 + print("%10d %s" % (self.size, self.path)) + for r in self.records: + total += r.show(minsize) + if len(self.records) == 0: + total = self.size + return total + + +def main(): + minsize = 0 + if len(sys.argv) == 2: + minsize = int(sys.argv[1]) + rootfs = Record.create(".") + total = rootfs.show(minsize) + print("Displayed %d/%d bytes (%.2f%%)" % \ + (total, rootfs.size, 100 * float(total) / rootfs.size)) + + +if __name__ == "__main__": + main() diff --git a/poky/scripts/tiny/ksize.py b/poky/scripts/tiny/ksize.py new file mode 100755 index 000000000..ea1ca7ff2 --- /dev/null +++ b/poky/scripts/tiny/ksize.py @@ -0,0 +1,170 @@ +#!/usr/bin/env python3 +# +# Copyright (c) 2011, Intel Corporation. +# All rights reserved. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# +# Display details of the kernel build size, broken up by built-in.o. Sort +# the objects by size. Run from the top level kernel build directory. +# +# Author: Darren Hart +# + +import sys +import getopt +import os +from subprocess import * + +def usage(): + prog = os.path.basename(sys.argv[0]) + print('Usage: %s [OPTION]...' % prog) + print(' -d, display an additional level of drivers detail') + print(' -h, --help display this help and exit') + print('') + print('Run %s from the top-level Linux kernel build directory.' % prog) + + +class Sizes: + def __init__(self, glob): + self.title = glob + p = Popen("size -t " + str(glob), shell=True, stdout=PIPE, stderr=PIPE) + output = p.communicate()[0].splitlines() + if len(output) > 2: + sizes = output[-1].split()[0:4] + self.text = int(sizes[0]) + self.data = int(sizes[1]) + self.bss = int(sizes[2]) + self.total = int(sizes[3]) + else: + self.text = self.data = self.bss = self.total = 0 + + def show(self, indent=""): + print("%-32s %10d | %10d %10d %10d" % \ + (indent+self.title, self.total, self.text, self.data, self.bss)) + + +class Report: + def create(filename, title, subglob=None): + r = Report(filename, title) + path = os.path.dirname(filename) + + p = Popen("ls " + str(path) + "/*.o | grep -v built-in.o", + shell=True, stdout=PIPE, stderr=PIPE) + glob = ' '.join(p.communicate()[0].splitlines()) + oreport = Report(glob, str(path) + "/*.o") + oreport.sizes.title = str(path) + "/*.o" + r.parts.append(oreport) + + if subglob: + p = Popen("ls " + subglob, shell=True, stdout=PIPE, stderr=PIPE) + for f in p.communicate()[0].splitlines(): + path = os.path.dirname(f) + r.parts.append(Report.create(f, path, str(path) + "/*/built-in.o")) + r.parts.sort(reverse=True) + + for b in r.parts: + r.totals["total"] += b.sizes.total + r.totals["text"] += b.sizes.text + r.totals["data"] += b.sizes.data + r.totals["bss"] += b.sizes.bss + + r.deltas["total"] = r.sizes.total - r.totals["total"] + r.deltas["text"] = r.sizes.text - r.totals["text"] + r.deltas["data"] = r.sizes.data - r.totals["data"] + r.deltas["bss"] = r.sizes.bss - r.totals["bss"] + return r + create = staticmethod(create) + + def __init__(self, glob, title): + self.glob = glob + self.title = title + self.sizes = Sizes(glob) + self.parts = [] + self.totals = {"total":0, "text":0, "data":0, "bss":0} + self.deltas = {"total":0, "text":0, "data":0, "bss":0} + + def show(self, indent=""): + rule = str.ljust(indent, 80, '-') + print("%-32s %10s | %10s %10s %10s" % \ + (indent+self.title, "total", "text", "data", "bss")) + print(rule) + self.sizes.show(indent) + print(rule) + for p in self.parts: + if p.sizes.total > 0: + p.sizes.show(indent) + print(rule) + print("%-32s %10d | %10d %10d %10d" % \ + (indent+"sum", self.totals["total"], self.totals["text"], + self.totals["data"], self.totals["bss"])) + print("%-32s %10d | %10d %10d %10d" % \ + (indent+"delta", self.deltas["total"], self.deltas["text"], + self.deltas["data"], self.deltas["bss"])) + print("\n") + + def __lt__(this, that): + if that is None: + return 1 + if not isinstance(that, Report): + raise TypeError + return this.sizes.total < that.sizes.total + + def __cmp__(this, that): + if that is None: + return 1 + if not isinstance(that, Report): + raise TypeError + if this.sizes.total < that.sizes.total: + return -1 + if this.sizes.total > that.sizes.total: + return 1 + return 0 + + +def main(): + try: + opts, args = getopt.getopt(sys.argv[1:], "dh", ["help"]) + except getopt.GetoptError as err: + print('%s' % str(err)) + usage() + sys.exit(2) + + driver_detail = False + for o, a in opts: + if o == '-d': + driver_detail = True + elif o in ('-h', '--help'): + usage() + sys.exit(0) + else: + assert False, "unhandled option" + + glob = "arch/*/built-in.o */built-in.o" + vmlinux = Report.create("vmlinux", "Linux Kernel", glob) + + vmlinux.show() + for b in vmlinux.parts: + if b.totals["total"] > 0 and len(b.parts) > 1: + b.show() + if b.title == "drivers" and driver_detail: + for d in b.parts: + if d.totals["total"] > 0 and len(d.parts) > 1: + d.show(" ") + + +if __name__ == "__main__": + main() diff --git a/poky/scripts/tiny/ksum.py b/poky/scripts/tiny/ksum.py new file mode 100755 index 000000000..d4f389215 --- /dev/null +++ b/poky/scripts/tiny/ksum.py @@ -0,0 +1,168 @@ +#!/usr/bin/env python +# ex:ts=4:sw=4:sts=4:et +# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- +# +# Copyright (c) 2016, Intel Corporation. +# All rights reserved. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along +# with this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +# +# DESCRIPTION 'ksum.py' generates a combined summary of vmlinux and +# module sizes for a built kernel, as a quick tool for comparing the +# overall effects of systemic tinification changes. Execute from the +# base directory of the kernel build you want to summarize. Setting +# the 'verbose' flag will display the sizes for each file included in +# the summary. +# +# AUTHORS +# Tom Zanussi +# + +__version__ = "0.1.0" + +# Python Standard Library modules +import os +import sys +import getopt +from subprocess import * + +def usage(): + prog = os.path.basename(sys.argv[0]) + print('Usage: %s [OPTION]...' % prog) + print(' -v, display sizes for each file') + print(' -h, --help display this help and exit') + print('') + print('Run %s from the top-level Linux kernel build directory.' % prog) + +verbose = False + +n_ko_files = 0 +ko_file_list = [] + +ko_text = 0 +ko_data = 0 +ko_bss = 0 +ko_total = 0 + +vmlinux_file = "" +vmlinux_level = 0 + +vmlinux_text = 0 +vmlinux_data = 0 +vmlinux_bss = 0 +vmlinux_total = 0 + +def is_vmlinux_file(filename): + global vmlinux_level + if filename == ("vmlinux") and vmlinux_level == 0: + vmlinux_level += 1 + return True + return False + +def is_ko_file(filename): + if filename.endswith(".ko"): + return True + return False + +def collect_object_files(): + print "Collecting object files recursively from %s..." % os.getcwd() + for dirpath, dirs, files in os.walk(os.getcwd()): + for filename in files: + if is_ko_file(filename): + ko_file_list.append(os.path.join(dirpath, filename)) + elif is_vmlinux_file(filename): + global vmlinux_file + vmlinux_file = os.path.join(dirpath, filename) + print "Collecting object files [DONE]" + +def add_ko_file(filename): + p = Popen("size -t " + filename, shell=True, stdout=PIPE, stderr=PIPE) + output = p.communicate()[0].splitlines() + if len(output) > 2: + sizes = output[-1].split()[0:4] + if verbose: + print " %10d %10d %10d %10d\t" % \ + (int(sizes[0]), int(sizes[1]), int(sizes[2]), int(sizes[3])), + print "%s" % filename[len(os.getcwd()) + 1:] + global n_ko_files, ko_text, ko_data, ko_bss, ko_total + ko_text += int(sizes[0]) + ko_data += int(sizes[1]) + ko_bss += int(sizes[2]) + ko_total += int(sizes[3]) + n_ko_files += 1 + +def get_vmlinux_totals(): + p = Popen("size -t " + vmlinux_file, shell=True, stdout=PIPE, stderr=PIPE) + output = p.communicate()[0].splitlines() + if len(output) > 2: + sizes = output[-1].split()[0:4] + if verbose: + print " %10d %10d %10d %10d\t" % \ + (int(sizes[0]), int(sizes[1]), int(sizes[2]), int(sizes[3])), + print "%s" % vmlinux_file[len(os.getcwd()) + 1:] + global vmlinux_text, vmlinux_data, vmlinux_bss, vmlinux_total + vmlinux_text += int(sizes[0]) + vmlinux_data += int(sizes[1]) + vmlinux_bss += int(sizes[2]) + vmlinux_total += int(sizes[3]) + +def sum_ko_files(): + for ko_file in ko_file_list: + add_ko_file(ko_file) + +def main(): + try: + opts, args = getopt.getopt(sys.argv[1:], "vh", ["help"]) + except getopt.GetoptError as err: + print('%s' % str(err)) + usage() + sys.exit(2) + + for o, a in opts: + if o == '-v': + global verbose + verbose = True + elif o in ('-h', '--help'): + usage() + sys.exit(0) + else: + assert False, "unhandled option" + + collect_object_files() + sum_ko_files() + get_vmlinux_totals() + + print "\nTotals:" + print "\nvmlinux:" + print " text\tdata\t\tbss\t\ttotal" + print " %-10d\t%-10d\t%-10d\t%-10d" % \ + (vmlinux_text, vmlinux_data, vmlinux_bss, vmlinux_total) + print "\nmodules (%d):" % n_ko_files + print " text\tdata\t\tbss\t\ttotal" + print " %-10d\t%-10d\t%-10d\t%-10d" % \ + (ko_text, ko_data, ko_bss, ko_total) + print "\nvmlinux + modules:" + print " text\tdata\t\tbss\t\ttotal" + print " %-10d\t%-10d\t%-10d\t%-10d" % \ + (vmlinux_text + ko_text, vmlinux_data + ko_data, \ + vmlinux_bss + ko_bss, vmlinux_total + ko_total) + +if __name__ == "__main__": + try: + ret = main() + except Exception: + ret = 1 + import traceback + traceback.print_exc(5) + sys.exit(ret) -- cgit v1.2.3