The poky repository master branch is no longer being updated.

You can either:

a) switch to individual clones of bitbake, openembedded-core, meta-yocto and yocto-docs

b) use the new bitbake-setup

You can find information about either approach in our documentation:
https://docs.yoctoproject.org/

Note that "poky" the distro setting is still available in meta-yocto as
before and we continue to use and maintain that.

Long live Poky!

Some further information on the background of this change can be found
in: https://lists.openembedded.org/g/openembedded-architecture/message/2179

Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>

1 files changed, 0 insertions, 324 deletions

diff --git a/scripts/buildstats-diff b/scripts/buildstats-diff
deleted file mode 100755
index df1df432f1..0000000000
--- a/scripts/buildstats-diff
+++ /dev/null
@@ -1,324 +0,0 @@
-#!/usr/bin/env python3
-#
-# Script for comparing buildstats from two different builds
-#
-# Copyright (c) 2016, Intel Corporation.
-#
-# SPDX-License-Identifier: GPL-2.0-only
-#
-
-import argparse
-import glob
-import logging
-import math
-import os
-import pathlib
-import sys
-from operator import attrgetter
-
-# Import oe libs
-scripts_path = os.path.dirname(os.path.realpath(__file__))
-sys.path.append(os.path.join(scripts_path, 'lib'))
-from buildstats import BuildStats, diff_buildstats, taskdiff_fields, BSVerDiff
-
-
-# Setup logging
-logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
-log = logging.getLogger()
-
-
-class ScriptError(Exception):
-    """Exception for internal error handling of this script"""
-    pass
-
-
-def read_buildstats(path, multi):
-    """Read buildstats"""
-    if not os.path.exists(path):
-        raise ScriptError("No such file or directory: {}".format(path))
-
-    if os.path.isfile(path):
-        return BuildStats.from_file_json(path)
-
-    if os.path.isfile(os.path.join(path, 'build_stats')):
-        return BuildStats.from_dir(path)
-
-    # Handle a non-buildstat directory
-    subpaths = sorted(glob.glob(path + '/*'))
-    if len(subpaths) > 1:
-        if multi:
-            log.info("Averaging over {} buildstats from {}".format(
-                     len(subpaths), path))
-        else:
-            raise ScriptError("Multiple buildstats found in '{}'. Please give "
-                              "a single buildstat directory of use the --multi "
-                              "option".format(path))
-    bs = None
-    for subpath in subpaths:
-        if os.path.isfile(subpath):
-            _bs = BuildStats.from_file_json(subpath)
-        else:
-            _bs = BuildStats.from_dir(subpath)
-        if bs is None:
-            bs = _bs
-        else:
-            bs.aggregate(_bs)
-    if not bs:
-        raise ScriptError("No buildstats found under {}".format(path))
-
-    return bs
-
-
-def print_ver_diff(bs1, bs2):
-    """Print package version differences"""
-
-    diff = BSVerDiff(bs1, bs2)
-
-    maxlen = max([len(r) for r in set(bs1.keys()).union(set(bs2.keys()))])
-    fmt_str = "  {:{maxlen}} ({})"
-
-    if diff.new:
-        print("\nNEW RECIPES:")
-        print("------------")
-        for name, val in sorted(diff.new.items()):
-            print(fmt_str.format(name, val.nevr, maxlen=maxlen))
-
-    if diff.dropped:
-        print("\nDROPPED RECIPES:")
-        print("----------------")
-        for name, val in sorted(diff.dropped.items()):
-            print(fmt_str.format(name, val.nevr, maxlen=maxlen))
-
-    fmt_str = "  {0:{maxlen}} {1:<20}    ({2})"
-    if diff.rchanged:
-        print("\nREVISION CHANGED:")
-        print("-----------------")
-        for name, val in sorted(diff.rchanged.items()):
-            field1 = "{} -> {}".format(val.left.revision, val.right.revision)
-            field2 = "{} -> {}".format(val.left.nevr, val.right.nevr)
-            print(fmt_str.format(name, field1, field2, maxlen=maxlen))
-
-    if diff.vchanged:
-        print("\nVERSION CHANGED:")
-        print("----------------")
-        for name, val in sorted(diff.vchanged.items()):
-            field1 = "{} -> {}".format(val.left.version, val.right.version)
-            field2 = "{} -> {}".format(val.left.nevr, val.right.nevr)
-            print(fmt_str.format(name, field1, field2, maxlen=maxlen))
-
-    if diff.echanged:
-        print("\nEPOCH CHANGED:")
-        print("--------------")
-        for name, val in sorted(diff.echanged.items()):
-            field1 = "{} -> {}".format(val.left.epoch, val.right.epoch)
-            field2 = "{} -> {}".format(val.left.nevr, val.right.nevr)
-            print(fmt_str.format(name, field1, field2, maxlen=maxlen))
-
-
-def print_task_diff(bs1, bs2, val_type, min_val=0, min_absdiff=0, sort_by=('absdiff',), only_tasks=[]):
-    """Diff task execution times"""
-    def val_to_str(val, human_readable=False):
-        """Convert raw value to printable string"""
-        def hms_time(secs):
-            """Get time in human-readable HH:MM:SS format"""
-            h = int(secs / 3600)
-            m = int((secs % 3600) / 60)
-            s = secs % 60
-            if h == 0:
-                return "{:02d}:{:04.1f}".format(m, s)
-            else:
-                return "{:d}:{:02d}:{:04.1f}".format(h, m, s)
-
-        if 'time' in val_type:
-            if human_readable:
-                return hms_time(val)
-            else:
-                return "{:.1f}s".format(val)
-        elif 'bytes' in val_type and human_readable:
-                prefix = ['', 'Ki', 'Mi', 'Gi', 'Ti', 'Pi']
-                dec = int(math.log(val, 2) / 10)
-                prec = 1 if dec > 0 else 0
-                return "{:.{prec}f}{}B".format(val / (2 ** (10 * dec)),
-                                               prefix[dec], prec=prec)
-        elif 'ops' in val_type and human_readable:
-                prefix = ['', 'k', 'M', 'G', 'T', 'P']
-                dec = int(math.log(val, 1000))
-                prec = 1 if dec > 0 else 0
-                return "{:.{prec}f}{}ops".format(val / (1000 ** dec),
-                                                 prefix[dec], prec=prec)
-        return str(int(val))
-
-    def sum_vals(buildstats):
-        """Get cumulative sum of all tasks"""
-        total = 0.0
-        for recipe_data in buildstats.values():
-            for name, bs_task in recipe_data.tasks.items():
-                if not only_tasks or name in only_tasks:
-                    total += getattr(bs_task, val_type)
-        return total
-
-    if min_val:
-        print("Ignoring tasks less than {} ({})".format(
-                val_to_str(min_val, True), val_to_str(min_val)))
-    if min_absdiff:
-        print("Ignoring differences less than {} ({})".format(
-                val_to_str(min_absdiff, True), val_to_str(min_absdiff)))
-
-    # Prepare the data
-    tasks_diff = diff_buildstats(bs1, bs2, val_type, min_val, min_absdiff, only_tasks)
-
-    # Sort our list
-    for field in reversed(sort_by):
-        if field.startswith('-'):
-            field = field[1:]
-            reverse = True
-        else:
-            reverse = False
-        tasks_diff = sorted(tasks_diff, key=attrgetter(field), reverse=reverse)
-
-    linedata = [('  ', 'PKG', '  ', 'TASK', 'ABSDIFF', 'RELDIFF',
-                val_type.upper() + '1', val_type.upper() + '2')]
-    field_lens = dict([('len_{}'.format(i), len(f)) for i, f in enumerate(linedata[0])])
-
-    # Prepare fields in string format and measure field lengths
-    for diff in tasks_diff:
-        task_prefix = diff.task_op if diff.pkg_op == '  ' else '  '
-        linedata.append((diff.pkg_op, diff.pkg, task_prefix, diff.task,
-                         val_to_str(diff.absdiff),
-                         '{:+.1f}%'.format(diff.reldiff),
-                         val_to_str(diff.value1),
-                         val_to_str(diff.value2)))
-        for i, field in enumerate(linedata[-1]):
-            key = 'len_{}'.format(i)
-            if len(field) > field_lens[key]:
-                field_lens[key] = len(field)
-
-    # Print data
-    print()
-    for fields in linedata:
-        print("{:{len_0}}{:{len_1}}  {:{len_2}}{:{len_3}}  {:>{len_4}}  {:>{len_5}}  {:>{len_6}} -> {:{len_7}}".format(
-                *fields, **field_lens))
-
-    # Print summary of the diffs
-    total1 = sum_vals(bs1)
-    total2 = sum_vals(bs2)
-    print("\nCumulative {}:".format(val_type))
-    print ("  {}    {:+.1f}%    {} ({}) -> {} ({})".format(
-                val_to_str(total2 - total1), 100 * (total2-total1) / total1,
-                val_to_str(total1, True), val_to_str(total1),
-                val_to_str(total2, True), val_to_str(total2)))
-
-
-def parse_args(argv):
-    """Parse cmdline arguments"""
-    description="""
-Script for comparing buildstats of two separate builds."""
-    parser = argparse.ArgumentParser(
-            formatter_class=argparse.ArgumentDefaultsHelpFormatter,
-            description=description)
-
-    min_val_defaults = {'cputime': 3.0,
-                        'read_bytes': 524288,
-                        'write_bytes': 524288,
-                        'read_ops': 500,
-                        'write_ops': 500,
-                        'walltime': 5}
-    min_absdiff_defaults = {'cputime': 1.0,
-                            'read_bytes': 131072,
-                            'write_bytes': 131072,
-                            'read_ops': 50,
-                            'write_ops': 50,
-                            'walltime': 2}
-
-    parser.add_argument('--debug', '-d', action='store_true',
-                        help="Verbose logging")
-    parser.add_argument('--ver-diff', action='store_true',
-                        help="Show package version differences and exit")
-    parser.add_argument('--diff-attr', default='cputime',
-                        choices=min_val_defaults.keys(),
-                        help="Buildstat attribute which to compare")
-    parser.add_argument('--min-val', default=min_val_defaults, type=float,
-                        help="Filter out tasks less than MIN_VAL. "
-                             "Default depends on --diff-attr.")
-    parser.add_argument('--min-absdiff', default=min_absdiff_defaults, type=float,
-                        help="Filter out tasks whose difference is less than "
-                             "MIN_ABSDIFF, Default depends on --diff-attr.")
-    parser.add_argument('--sort-by', default='absdiff',
-                        help="Comma-separated list of field sort order. "
-                             "Prepend the field name with '-' for reversed sort. "
-                             "Available fields are: {}".format(', '.join(taskdiff_fields)))
-    parser.add_argument('--multi', action='store_true',
-                        help="Read all buildstats from the given paths and "
-                             "average over them")
-    parser.add_argument('--only-task', dest='only_tasks', metavar='TASK', action='append', default=[],
-                        help="Only include TASK in report. May be specified multiple times")
-    parser.add_argument('buildstats1', metavar='BUILDSTATS1', nargs="?", help="'Left' buildstat")
-    parser.add_argument('buildstats2', metavar='BUILDSTATS2', nargs="?", help="'Right' buildstat")
-
-    args = parser.parse_args(argv)
-
-    if args.buildstats1 and args.buildstats2:
-        # Both paths specified
-        pass
-    elif args.buildstats1 or args.buildstats2:
-        # Just one path specified, this is an error
-        parser.print_usage(sys.stderr)
-        print("Either specify two buildstats paths, or none to use the last two paths.", file=sys.stderr)
-        sys.exit(1)
-    else:
-        # No paths specified, try to find the last two buildstats
-        try:
-            buildstats_dir = pathlib.Path(os.environ["BUILDDIR"]) / "tmp" / "buildstats"
-            paths = sorted(buildstats_dir.iterdir())
-            args.buildstats2 = paths.pop()
-            args.buildstats1 = paths.pop()
-            print(f"Comparing {args.buildstats1} -> {args.buildstats2}\n")
-        except KeyError:
-            parser.print_usage(sys.stderr)
-            print("Build environment has not been configured, cannot find buildstats", file=sys.stderr)
-            sys.exit(1)
-
-    # We do not nedd/want to read all buildstats if we just want to look at the
-    # package versions
-    if args.ver_diff:
-        args.multi = False
-
-    # Handle defaults for the filter arguments
-    if args.min_val is min_val_defaults:
-        args.min_val = min_val_defaults[args.diff_attr]
-    if args.min_absdiff is min_absdiff_defaults:
-        args.min_absdiff = min_absdiff_defaults[args.diff_attr]
-
-    return args
-
-def main(argv=None):
-    """Script entry point"""
-    args = parse_args(argv)
-    if args.debug:
-        log.setLevel(logging.DEBUG)
-
-    # Validate sort fields
-    sort_by = []
-    for field in args.sort_by.split(','):
-        if field.lstrip('-') not in taskdiff_fields:
-            log.error("Invalid sort field '%s' (must be one of: %s)" %
-                      (field, ', '.join(taskdiff_fields)))
-            sys.exit(1)
-        sort_by.append(field)
-
-    try:
-        bs1 = read_buildstats(args.buildstats1, args.multi)
-        bs2 = read_buildstats(args.buildstats2, args.multi)
-
-        if args.ver_diff:
-            print_ver_diff(bs1, bs2)
-        else:
-            print_task_diff(bs1, bs2, args.diff_attr, args.min_val,
-                            args.min_absdiff, sort_by, args.only_tasks)
-    except ScriptError as err:
-        log.error(str(err))
-        return 1
-    return 0
-
-if __name__ == "__main__":
-    sys.exit(main())