profiling/bloat/bloat_diff.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.

import argparse
import csv
import glob
import math
import multiprocessing
import os
import pathlib
import shutil
import subprocess
import sys

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

argp = argparse.ArgumentParser(description="Perform diff on microbenchmarks")

argp.add_argument(
    "-d",
    "--diff_base",
    type=str,
    help="Commit or branch to compare the current one to",
)

argp.add_argument("-j", "--jobs", type=int, default=multiprocessing.cpu_count())

args = argp.parse_args()

# the libraries for which check bloat difference is calculated
LIBS = [
    "libgrpc.so",
    "libgrpc++.so",
]


def _build(output_dir):
    """Perform the cmake build under the output_dir."""
    shutil.rmtree(output_dir, ignore_errors=True)
    subprocess.check_call("mkdir -p %s" % output_dir, shell=True, cwd=".")
    subprocess.check_call(
        [
            "cmake",
            "-DgRPC_BUILD_TESTS=OFF",
            "-DBUILD_SHARED_LIBS=ON",
            "-DCMAKE_BUILD_TYPE=RelWithDebInfo",
            '-DCMAKE_C_FLAGS="-gsplit-dwarf"',
            '-DCMAKE_CXX_FLAGS="-gsplit-dwarf"',
            "..",
        ],
        cwd=output_dir,
    )
    subprocess.check_call("make -j%d" % args.jobs, shell=True, cwd=output_dir)


def _rank_diff_bytes(diff_bytes):
    """Determine how significant diff_bytes is, and return a simple integer representing that"""
    mul = 1
    if diff_bytes < 0:
        mul = -1
        diff_bytes = -diff_bytes
    if diff_bytes < 2 * 1024:
        return 0
    if diff_bytes < 16 * 1024:
        return 1 * mul
    if diff_bytes < 128 * 1024:
        return 2 * mul
    return 3 * mul


_build("bloat_diff_new")

if args.diff_base:
    where_am_i = (
        subprocess.check_output(["git", "rev-parse", "--abbrev-ref", "HEAD"])
        .decode()
        .strip()
    )
    # checkout the diff base (="old")
    subprocess.check_call(["git", "checkout", args.diff_base])
    subprocess.check_call(["git", "submodule", "update"])
    try:
        _build("bloat_diff_old")
    finally:
        # restore the original revision (="new")
        subprocess.check_call(["git", "checkout", where_am_i])
        subprocess.check_call(["git", "submodule", "update"])

pathlib.Path("bloaty-build").mkdir(exist_ok=True)
subprocess.check_call(
    ["cmake", "-G", "Unix Makefiles", "../third_party/bloaty"],
    cwd="bloaty-build",
)
subprocess.check_call("make -j%d" % args.jobs, shell=True, cwd="bloaty-build")

text = ""
diff_size = 0
for lib in LIBS:
    text += (
        "****************************************************************\n\n"
    )
    text += lib + "\n\n"
    old_version = glob.glob("bloat_diff_old/%s" % lib)
    new_version = glob.glob("bloat_diff_new/%s" % lib)
    for filename in [old_version, new_version]:
        if filename:
            subprocess.check_call(
                "strip %s -o %s.stripped" % (filename[0], filename[0]),
                shell=True,
            )
    assert len(new_version) == 1
    cmd = "bloaty-build/bloaty -d compileunits,symbols"
    if old_version:
        assert len(old_version) == 1
        text += subprocess.check_output(
            "%s -n 0 --debug-file=%s --debug-file=%s %s.stripped -- %s.stripped"
            % (
                cmd,
                new_version[0],
                old_version[0],
                new_version[0],
                old_version[0],
            ),
            shell=True,
        ).decode()
        sections = [
            x
            for x in csv.reader(
                subprocess.check_output(
                    "bloaty-build/bloaty -n 0 --csv %s -- %s"
                    % (new_version[0], old_version[0]),
                    shell=True,
                )
                .decode()
                .splitlines()
            )
        ]
        print(sections)
        for section in sections[1:]:
            # skip debug sections for bloat severity calculation
            if section[0].startswith(".debug"):
                continue
            # skip dynamic loader sections too
            if section[0].startswith(".dyn"):
                continue
            diff_size += int(section[2])
    else:
        text += subprocess.check_output(
            "%s %s.stripped -n 0 --debug-file=%s"
            % (cmd, new_version[0], new_version[0]),
            shell=True,
        ).decode()
    text += "\n\n"

severity = _rank_diff_bytes(diff_size)
print("SEVERITY: %d" % severity)

print(text)
check_on_pr.check_on_pr("Bloat Difference", "```\n%s\n```" % text)
check_on_pr.label_significance_on_pr("bloat", severity)