"""Compile mypy using mypyc and profile type checking using perf.

By default does a self check.

Notes:

- Only Linux is supported for now (TODO: add support for other profilers)

- The profile is collected at C level

- It includes C functions compiled by mypyc and CPython runtime functions

- The names of mypy functions are mangled to C names, but usually it's clear what they mean

- Generally CPyDef_ prefix for native functions and CPyPy_ prefix for wrapper functions

- It's important to compile CPython using special flags (see below) to get good results

- Generally use the latest Python feature release (or the most recent beta if supported by mypyc)

- The tool prints a command that can be used to analyze the profile afterwards

You may need to adjust kernel parameters temporarily, e.g. this (note that this has security

implications):

sudo sysctl kernel.perf_event_paranoid=-1

This is the recommended way to configure CPython for profiling:

./configure \

--enable-optimizations \

--with-lto \

CFLAGS="-O2 -g -fno-omit-frame-pointer"

"""

from __future__ import annotations

import argparse

import glob

import os

import shutil

import subprocess

import sys

import time

from perf_compare import build_mypy, clone

# Use these C compiler flags when compiling mypy (important). Note that it's strongly recommended

# to also compile CPython using similar flags, but we don't enforce it in this script.

CFLAGS = "-O2 -fno-omit-frame-pointer -g"

# Generated files, including binaries, go under this directory to avoid overwriting user state.

TARGET_DIR = "mypy.profile.tmpdir"

def _profile_type_check(target_dir: str, code: str | None) -> None:

cache_dir = os.path.join(target_dir, ".mypy_cache")

if os.path.exists(cache_dir):

shutil.rmtree(cache_dir)

args = []

if code is None:

args.extend(["--config-file", "mypy_self_check.ini"])

for pat in "mypy/*.py", "mypy/*/*.py", "mypyc/*.py", "mypyc/test/*.py":

args.extend(glob.glob(pat))

else:

args.extend(["-c", code])

check_cmd = ["python", "-m", "mypy"] + args

cmdline = ["perf", "record", "-g"] + check_cmd

t0 = time.time()

subprocess.run(cmdline, cwd=target_dir, check=True)

elapsed = time.time() - t0

print(f"{elapsed:.2f}s elapsed")

def profile_type_check(target_dir: str, code: str | None) -> None:

try:

_profile_type_check(target_dir, code)

except subprocess.CalledProcessError:

print("\nProfiling failed! You may missing some permissions.")

print("\nThis may help (note that it has security implications):")

print(" sudo sysctl kernel.perf_event_paranoid=-1")

sys.exit(1)

def check_requirements() -> None:

if sys.platform != "linux":

# TODO: How to make this work on other platforms?

sys.exit("error: Only Linux is supported")

else: # fun fact/todo: we have to use else here, because of https://github.com/python/mypy/issues/10773

try:

subprocess.run(["perf", "-h"], capture_output=True)

except (subprocess.CalledProcessError, FileNotFoundError):

print("error: The 'perf' profiler is not installed")

sys.exit(1)

try:

subprocess.run(["clang", "--version"], capture_output=True)

except (subprocess.CalledProcessError, FileNotFoundError):

print("error: The clang compiler is not installed")

sys.exit(1)

if not os.path.isfile("mypy_self_check.ini"):

print("error: Run this in the mypy repository root")

sys.exit(1)

def main() -> None:

check_requirements()

parser = argparse.ArgumentParser(

description="Compile mypy and profile type checking using 'perf' (by default, self check)."

)

parser.add_argument(

"--multi-file",

action="store_true",

help="compile mypy into one C file per module (to reduce RAM use during compilation)",

)

parser.add_argument(

"--skip-compile", action="store_true", help="use compiled mypy from previous run"

)

parser.add_argument(

"-c",

metavar="CODE",

default=None,

type=str,

help="profile type checking Python code fragment instead of mypy self-check",

)

args = parser.parse_args()

multi_file: bool = args.multi_file

skip_compile: bool = args.skip_compile

code: str | None = args.c

target_dir = TARGET_DIR

if not skip_compile:

clone(target_dir, "HEAD")

print(f"Building mypy in {target_dir}...")

build_mypy(target_dir, multi_file, cflags=CFLAGS)

elif not os.path.isdir(target_dir):

sys.exit("error: Can't find compile mypy from previous run -- can't use --skip-compile")

profile_type_check(target_dir, code)

print()

print('NOTE: Compile CPython using CFLAGS="-O2 -g -fno-omit-frame-pointer" for good results')

print()

print("CPU profile collected. You can now analyze the profile:")

print(f" perf report -i {target_dir}/perf.data ")

if __name__ == "__main__":

main()