"""Сколько стоит вызов и от чего эта цена зависит.

ЗАЧЕМ ЭТОТ СКРИПТ. Вокруг вызова в Python держится несколько устойчивых
утверждений, и проверяются они одним и тем же замером: «вызов метода дороже
вызова функции», «staticmethod быстрее, потому что нет self», «звёздочки
дорогие». Первые два здесь не подтверждаются, третье подтверждается только
наполовину — и половина, которая подтверждается, не та, о которой обычно
говорят.

ЧТО СРАВНИВАЕТСЯ. Пятнадцать форм вызова, и у всех вызывается пустая функция:
тело ничего не делает, и меряется только то, что происходит ВОКРУГ тела.
Шестнадцатая строка вызова не содержит вовсе — это чтение атрибута из слота,
и стоит она там, чтобы у наносекунд был масштаб.

ПРАВИЛО ЗАМЕРА. Всё меряется ВНУТРИ ОДНОГО запуска ОДНОГО интерпретатора, и
сравниваются только числа из одного прогона (bench/README.md). Между версиями
время не сравнивается вовсе: у сборок песочницы разные компиляторы и разные
флаги. Поэтому запись прогона здесь одна, без суффикса версии.

МЕТОДИКА. `timeit`, лучшее из семи раундов. Берётся лучшее, а не среднее: шум
на этой машине односторонний — соседний процесс может отнять время, но не может
его добавить.

ПОЧЕМУ ВЫЗОВ ПОВТОРЯЕТСЯ ВНУТРИ ВИТКА. Один вызов стоит десятки наносекунд, и
сам виток цикла `timeit` стоит столько же. Если мерить по одному вызову за
виток, половина числа окажется ценой цикла, а разница между двумя такими
числами — его шумом. Поэтому вызов повторяется REPEAT раз внутри одного витка,
и накладные расходы делятся на столько же. Блок 1 печатает цену витка отдельной
строкой, чтобы это не оставалось на слово.

ЗАПУСК:

    python3.13 bench/calls/cost.py
"""

import platform
import sys
import timeit

ROUNDS = 7
REPEAT = 50
NUMBER = 20_000


SETUP = """
def f0(): pass
def f1(a): pass
def f3(a, b, c): pass
def fdef(a, b=1, c=2): pass
def fkwonly(*, a=1): pass
def fstar(*args, **kwargs): pass

class C:
    def m(self): pass
    @staticmethod
    def s(): pass
    @classmethod
    def c(cls): pass
    def __call__(self): pass

o = C()
bound = o.m
lam = lambda: None

def outer():
    x = 1
    def inner(): return x
    return inner
clo = outer()

class P:
    __slots__ = ("x",)
    def __init__(self): self.x = 1
p = P()

args = (1, 2, 3)
kwargs = {"a": 1, "b": 2, "c": 3}
one = {"a": 1}
len_ = len
data = [1, 2, 3]

GLOBAL_NAME = 1

def read_local():
    x = 1
    return x

def make_reader():
    x = 1
    def read_cell():
        return x
    return read_cell
read_cell = make_reader()

def read_global():
    return GLOBAL_NAME
"""


def per_op(expr: str) -> float:
    """Наносекунды на одну операцию, с делением накладных расходов витка."""
    stmt = "; ".join([expr] * REPEAT)
    sec = min(timeit.Timer(stmt, SETUP).repeat(ROUNDS, NUMBER)) / NUMBER
    return sec / REPEAT * 1e9


def empty_loop() -> float:
    stmt = "; ".join(["pass"] * REPEAT)
    sec = min(timeit.Timer(stmt, SETUP).repeat(ROUNDS, NUMBER)) / NUMBER
    return sec / REPEAT * 1e9


def head(n: int, title: str) -> None:
    line = f"{n}. {title}"
    print(f"\n{line}\n{'-' * len(line)}")


def main() -> None:
    print(f"Python {platform.python_version()}")
    print(f"Сборка: {sys.version.split('[')[-1].rstrip('] ')}")
    print("\nВсе числа сняты одним запуском одного интерпретатора: сравнивать")
    print("их можно только между собой, с другими версиями — нельзя.")
    print(f"Лучшее из {ROUNDS} раундов, {REPEAT} операций внутри витка.")

    head(1, "ЧТО СТОИТ САМ ЗАМЕР")
    idle = empty_loop()
    print(f"  пустой оператор pass в том же цикле        {idle:>8.2f} нс")
    print("  Это накладные расходы витка, поделённые на 50. В числах ниже цена")
    print("  самого цикла не участвует — иначе она была бы больше всего, что")
    print("  меряется.")

    head(2, "ЦЕНА ВЫЗОВА ПО ФОРМАМ")
    forms = [
        ("p.x — чтение слота, вызова нет", "p.x"),
        ("f0() — функция без аргументов", "f0()"),
        ("f1(1) — один позиционный", "f1(1)"),
        ("f3(1, 2, 3) — три позиционных", "f3(1, 2, 3)"),
        ("f1(a=1) — то же, но по имени", "f1(a=1)"),
        ("fdef(1) — два аргумента по умолчанию", "fdef(1)"),
        ("fdef(1, 2, 3) — они же переданы", "fdef(1, 2, 3)"),
        ("fkwonly(a=1) — только по имени", "fkwonly(a=1)"),
        ("lam() — lambda", "lam()"),
        ("clo() — замыкание с одной ячейкой", "clo()"),
        ("o.m() — метод через точку", "o.m()"),
        ("bound() — метод, связанный заранее", "bound()"),
        ("C.s() — staticmethod", "C.s()"),
        ("C.c() — classmethod", "C.c()"),
        ("o() — объект с __call__", "o()"),
        ("len_(data) — функция на C", "len_(data)"),
    ]
    print("  форма                                        нс")
    got = {}
    for name, expr in forms:
        value = per_op(expr)
        got[expr] = value
        print(f"  {name:<44s} {value:>7.2f}")

    head(3, "ТРИ УТВЕРЖДЕНИЯ, КОТОРЫЕ ЭТОТ ЗАМЕР ПРОВЕРЯЕТ")
    print(f"  «вызов метода дороже вызова функции»")
    print(f"    f0()   {got['f0()']:>7.2f} нс     o.m() {got['o.m()']:>7.2f} нс"
          f"     отношение ×{got['o.m()'] / got['f0()']:.2f}")
    print(f"  «связать метод заранее — дешевле, чем каждый раз через точку»")
    print(f"    o.m()  {got['o.m()']:>7.2f} нс   bound() {got['bound()']:>7.2f} нс"
          f"     отношение ×{got['bound()'] / got['o.m()']:.2f}")
    print(f"  «staticmethod быстрее обычного метода: у него нет self»")
    print(f"    o.m()  {got['o.m()']:>7.2f} нс    C.s() {got['C.s()']:>7.2f} нс"
          f"     отношение ×{got['C.s()'] / got['o.m()']:.2f}")

    head(4, "ЗВЁЗДОЧКИ НА ПЕРЕДАЧЕ")
    star = [
        ("f3(1, 2, 3) — прямая передача", "f3(1, 2, 3)"),
        ("f3(*args) — распаковка кортежа", "f3(*args)"),
        ("f3(**kwargs) — распаковка словаря", "f3(**kwargs)"),
        ("fstar(1, 2, 3) — приём в *args", "fstar(1, 2, 3)"),
        ("fstar(a=1) — приём в **kwargs", "fstar(a=1)"),
        ("fstar(*args, **one) — и то и другое", "fstar(*args, **one)"),
    ]
    print("  форма                                        нс   к прямой передаче")
    plain = None
    for name, expr in star:
        value = per_op(expr)
        if plain is None:
            plain = value
        print(f"  {name:<44s} {value:>7.2f}   ×{value / plain:.2f}")
    print("\n  Дорого ровно одно: распаковка СЛОВАРЯ на передаче. Она и только она")
    print("  даёт пятикратную разницу — и когда стоит одна, и когда рядом с")
    print("  кортежем. Распаковка кортежа почти бесплатна, приём в звёздочки")
    print("  стоит вдвое, а это уже другой порядок разговора.")

    head(5, "ЦЕНА ЧТЕНИЯ ИМЕНИ: ЛОКАЛЬНОЕ, ЯЧЕЙКА, ГЛОБАЛЬНОЕ")
    print("  Замыкание читает имя не оттуда же, откуда функция читает своё")
    print("  локальное. Вот во что это обходится — и во что обходится вызов")
    print("  рядом, чтобы было видно масштаб.")
    names = [
        ("локальное имя — LOAD_FAST", "read_local()"),
        ("имя из ячейки — LOAD_DEREF", "read_cell()"),
        ("глобальное имя — LOAD_GLOBAL", "read_global()"),
    ]
    print("  Каждое имя читается ВНУТРИ функции, поэтому в числе сидит и вызов.")
    print("  Третья колонка — за вычетом пустого вызова, то есть само чтение.")
    empty_call = got["f0()"]
    print(f"  что читается                          вызов+чтение   чтение")
    for name, expr in names:
        total = per_op(expr)
        print(f"  {name:<36s} {total:>11.2f} {total - empty_call:>9.2f}")
    print(f"  {'для сравнения: f0() — пустой вызов':<36s} {empty_call:>11.2f} {0.0:>9.2f}")
    print("\n  Три разные инструкции чтения стоят одинаково в пределах шума этой")
    print("  машины, и все три — доли вызова. Из чего следует, что «замыкание")
    print("  медленнее обычной функции» на этих числах не подтверждается: платят")
    print("  не за чтение из ячейки, а за то, что вообще делается вызов.")


main()