grpc/tools/profiling/microbenchmarks/bm_diff/bm_main.py

#!/usr/bin/env python3
#
# Copyright 2017 gRPC authors.
#
# 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.
""" Runs the entire bm_*.py pipeline, and possible comments on the PR """

import argparse
import multiprocessing
import os
import random
import subprocess
import sys

sys.path.append(
    os.path.join(
        os.path.dirname(sys.argv[0]), "..", "..", "run_tests", "python_utils"
    )
)

sys.path.append(
    os.path.join(
        os.path.dirname(sys.argv[0]),
        "..",
        "..",
        "..",
        "run_tests",
        "python_utils",
    )
)

import bm_build
import bm_constants
import bm_diff
import bm_run
import check_on_pr
import jobset


def _args():
    argp = argparse.ArgumentParser(
        description="Perform diff on microbenchmarks"
    )
    argp.add_argument(
        "-t",
        "--track",
        choices=sorted(bm_constants._INTERESTING),
        nargs="+",
        default=sorted(bm_constants._INTERESTING),
        help="Which metrics to track",
    )
    argp.add_argument(
        "-b",
        "--benchmarks",
        nargs="+",
        choices=bm_constants._AVAILABLE_BENCHMARK_TESTS,
        default=bm_constants._AVAILABLE_BENCHMARK_TESTS,
        help="Which benchmarks to run",
    )
    argp.add_argument(
        "-d",
        "--diff_base",
        type=str,
        help="Commit or branch to compare the current one to",
    )
    argp.add_argument(
        "-o",
        "--old",
        default="old",
        type=str,
        help='Name of baseline run to compare to. Usually just called "old"',
    )
    argp.add_argument(
        "-r",
        "--regex",
        type=str,
        default="",
        help="Regex to filter benchmarks run",
    )
    argp.add_argument(
        "-l",
        "--loops",
        type=int,
        default=10,
        help=(
            "Number of times to loops the benchmarks. More loops cuts down on"
            " noise"
        ),
    )
    argp.add_argument(
        "-j",
        "--jobs",
        type=int,
        default=multiprocessing.cpu_count(),
        help="Number of CPUs to use",
    )
    argp.add_argument(
        "--pr_comment_name",
        type=str,
        default="microbenchmarks",
        help="Name that Jenkins will use to comment on the PR",
    )
    args = argp.parse_args()
    assert args.diff_base or args.old, "One of diff_base or old must be set!"
    if args.loops < 3:
        print("WARNING: This run will likely be noisy. Increase loops.")
    return args


def eintr_be_gone(fn):
    """Run fn until it doesn't stop because of EINTR"""

    def inner(*args):
        while True:
            try:
                return fn(*args)
            except IOError as e:
                if e.errno != errno.EINTR:
                    raise

    return inner


def main(args):
    bm_build.build("new", args.benchmarks, args.jobs)

    old = args.old
    if args.diff_base:
        old = "old"
        where_am_i = subprocess.check_output(
            ["git", "rev-parse", "--abbrev-ref", "HEAD"]
        ).strip()
        subprocess.check_call(["git", "checkout", args.diff_base])
        try:
            bm_build.build(old, args.benchmarks, args.jobs)
        finally:
            subprocess.check_call(["git", "checkout", where_am_i])
            subprocess.check_call(["git", "submodule", "update"])

    jobs_list = []
    jobs_list += bm_run.create_jobs(
        "new", args.benchmarks, args.loops, args.regex
    )
    jobs_list += bm_run.create_jobs(
        old, args.benchmarks, args.loops, args.regex
    )

    # shuffle all jobs to eliminate noise from GCE CPU drift
    random.shuffle(jobs_list, random.SystemRandom().random)
    jobset.run(jobs_list, maxjobs=args.jobs)

    diff, note, significance = bm_diff.diff(
        args.benchmarks, args.loops, args.regex, args.track, old, "new"
    )
    if diff:
        text = "[%s] Performance differences noted:\n%s" % (
            args.pr_comment_name,
            diff,
        )
    else:
        text = (
            "[%s] No significant performance differences" % args.pr_comment_name
        )
    if note:
        text = note + "\n\n" + text
    print("%s" % text)
    check_on_pr.check_on_pr("Benchmark", "```\n%s\n```" % text)


if __name__ == "__main__":
    args = _args()
    main(args)