"""Ускоряет ли `__slots__` доступ к атрибуту.

ЗАЧЕМ ЭТОТ СКРИПТ. «Слоты ещё и быстрее» — второе по частоте утверждение о
теме после «слоты экономят память». Первое верно и измерено в `memory.py`.
Второе проверяется здесь, и результат у него другой.

ЧТО СРАВНИВАЕТСЯ. Чтение и запись атрибута у трёх экземпляров одного и того же
класса по форме: со слотами, без слотов (значения лежат inline, если версия
это умеет) и без слотов после обращения к `__dict__` — то есть когда inline
values уже развернулись в настоящий словарь. Третий случай важен: именно в него
попадает всякий код, который трогал `vars(obj)`.

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

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

ПОЧЕМУ ОПЕРАЦИЯ ПОВТОРЯЕТСЯ ВНУТРИ ЗАМЕРА. Первый черновик мерил ровно одно
`o.a` за виток цикла `timeit` и получил числа, из которых следовало «разница
есть, но маленькая». Проверка 2 показала, чего они стоят: пустой оператор
`pass` в том же цикле стоит почти столько же, сколько сам доступ. То есть
мерился цикл, а не доступ, и любая «разница» между двумя такими числами — его
шум.

Поэтому оператор повторяется `REPEAT` раз внутри одного витка, и накладные
расходы цикла делятся на столько же. Проверка 2 печатает ОБА режима рядом —
амортизированный и однооперационный, — чтобы это не оставалось на слово: видно
и дно каждого, и какая доля числа в неамортизированном режиме приходится на сигнал.

ЗАПУСК:

    python3.13 bench/slots/access.py
"""

import dis
import io
import sys
import timeit

ROUNDS = 7
INNER = 20_000

# Сколько раз операция повторяется ВНУТРИ одного витка цикла timeit. Делит
# накладные расходы витка на себя: проверка 2 печатает дно в обоих режимах,
# и разница между ними — это и есть цена самого цикла.
REPEAT = 50


class Plain:
    def __init__(self):
        self.a = 1
        self.b = 2
        self.c = 3


class Slotted:
    __slots__ = ("a", "b", "c")

    def __init__(self):
        self.a = 1
        self.b = 2
        self.c = 3


def best(stmt, setup, rounds=ROUNDS, inner=INNER, repeat=REPEAT):
    """Наносекунды на одну операцию.

    Оператор повторяется `repeat` раз в одном витке, поэтому накладные расходы
    цикла timeit делятся на `repeat` (см. «ПОЧЕМУ ОПЕРАЦИЯ ПОВТОРЯЕТСЯ» выше).
    """
    body = "\n".join([stmt] * repeat)
    times = timeit.repeat(body, setup=setup, repeat=rounds, number=inner,
                          globals=globals())
    return min(times) / (inner * repeat) * 1e9


def rule(title):
    print(f"\n=== {title} ===\n")


def block_read():
    rule("БЛОК 1. ЧТЕНИЕ АТРИБУТА")

    slotted = best("o.a", "o = Slotted()")
    plain = best("o.a", "o = Plain()")
    materialized = best("o.a", "o = Plain(); o.__dict__")

    print(f"  наносекунд на одно чтение o.a, лучшее из {ROUNDS} раундов "
          f"по {INNER}×{REPEAT}:")
    print()
    print(f"  со слотами                          {slotted:6.2f} нс")
    print(f"  без слотов                          {plain:6.2f} нс")
    print(f"  без слотов, после vars(obj)         {materialized:6.2f} нс")
    print()
    diff = plain - slotted
    print(f"  разница слоты против inline:        {diff:+6.2f} нс "
          f"({100 * diff / plain:+.1f} %)")
    return slotted, plain, materialized


def block_write():
    rule("БЛОК 2. ЗАПИСЬ АТРИБУТА")

    slotted = best("o.a = 5", "o = Slotted()")
    plain = best("o.a = 5", "o = Plain()")
    materialized = best("o.a = 5", "o = Plain(); o.__dict__")

    print("  наносекунд на одну запись o.a = 5:")
    print()
    print(f"  со слотами                          {slotted:6.2f} нс")
    print(f"  без слотов                          {plain:6.2f} нс")
    print(f"  без слотов, после vars(obj)         {materialized:6.2f} нс")
    return slotted, plain, materialized


def block_verdict(read, write):
    rule("БЛОК 3. ЧТО ИЗ ЭТОГО СЛЕДУЕТ")

    r_slot, r_plain, r_mat = read
    w_slot, w_plain, w_mat = write

    print("  Утверждение, которое проверялось: «__slots__ ускоряет доступ».")
    print()
    for name, slot, plain in (("чтение", r_slot, r_plain), ("запись", w_slot, w_plain)):
        rel = 100 * (plain - slot) / plain
        if abs(rel) < 5:
            verdict = "различие в пределах шума метода"
        elif rel > 0:
            verdict = f"слоты быстрее на {rel:.0f} %"
        else:
            verdict = f"слоты МЕДЛЕННЕЕ на {-rel:.0f} %"
        print(f"    {name:<8} слоты {slot:6.2f} нс, inline {plain:6.2f} нс — {verdict}")
    print()
    print("  Разница между слотами и inline values мала, потому что это два")
    print("  способа сделать одно и то же: значение по фиксированному смещению")
    print("  в самом объекте. Слот адресуется дескриптором, inline value —")
    print("  через кеш ключей, и обе дороги короткие.")
    print()
    print("  А вот третья строка блоков 1 и 2 — не шум:")
    for name, mat, plain in (("чтение", r_mat, r_plain), ("запись", w_mat, w_plain)):
        rel = 100 * (mat - plain) / plain
        print(f"    {name:<8} после vars(obj) {mat:6.2f} нс против {plain:6.2f} — "
              f"{rel:+.0f} %")
    print()
    print("  То есть обращение к __dict__ бьёт и по памяти (memory.py, блок 1),")
    print("  и по времени. Из этих двух замеров и складывается практический")
    print("  вывод темы: выигрыш слотов — в памяти, а не в скорости, и главный")
    print("  способ его потерять — тронуть vars(obj).")


def specialization(obj):
    """Во что превращается прогретое `o.a` после специализации.

    Печатает имя опкода из адаптивного дизассемблера. Это не украшение: без
    него замер читается как «дескриптор против словаря», а на самом деле
    сравниваются два РАЗНЫХ специализированных опкода, и оба — загрузка по
    фиксированному смещению. Отсюда и равенство времён.
    """
    g = {}
    exec("def f(o):\n    return o.a\n", g)  # noqa: S102
    f = g["f"]
    for _ in range(3000):
        f(obj)
    buf = io.StringIO()
    dis.dis(f, file=buf, adaptive=True)
    for line in buf.getvalue().splitlines():
        for tok in line.split():
            if tok.startswith("LOAD_ATTR"):
                return tok
    return "?"


def block_specialization():
    rule("БЛОК 4. ВО ЧТО СПЕЦИАЛИЗИРУЕТСЯ ПРОГРЕТОЕ ЧТЕНИЕ")

    plain = Plain()
    slotted = Slotted()
    touched = Plain()
    touched.__dict__  # noqa: B018

    print("  Замер выше меряет ПРОГРЕТУЮ операцию, а прогретую операцию в")
    print("  современном CPython исполняет не общий опкод, а специализированный.")
    print("  Вот какой достаётся каждому случаю:")
    print()
    print(f"    со слотами                        {specialization(slotted)}")
    print(f"    без слотов                        {specialization(plain)}")
    print(f"    без слотов, после vars(obj)       {specialization(touched)}")
    print()
    print("  Отсюда видно, что именно сравнивалось. Не «дескриптор против")
    print("  словаря»: обе первые строки — специализированные опкоды, и каждый")
    print("  читает значение по фиксированному смещению в объекте. Разными")
    print("  путями пришли к одной и той же работе, поэтому и времена равны.")
    print()
    print("  Третья строка объясняет третий столбец замера: после vars(obj)")
    print("  специализация другая, а на некоторых сборках её нет вовсе — тогда")
    print("  работает общий LOAD_ATTR со всем протоколом поиска атрибута.")
    print()
    print("  Практический вывод: этот замер отвечает не на вопрос «какой")
    print("  механизм короче в принципе», а на вопрос «сколько стоит прогретая")
    print("  операция в этой сборке после оптимизаций интерпретатора».")


def block_method():
    rule("БЛОК 5. ПРОВЕРКА МЕТОДА")

    print("  1. Разброс между раундами — насколько числам выше можно верить")
    print()
    body = "\n".join(["o.a"] * REPEAT)
    times = timeit.repeat(body, setup="o = Slotted()", repeat=ROUNDS,
                          number=INNER, globals=globals())
    ns = sorted(t / (INNER * REPEAT) * 1e9 for t in times)
    print(f"     лучшее   {ns[0]:6.2f} нс")
    print(f"     медиана  {ns[len(ns) // 2]:6.2f} нс")
    print(f"     худшее   {ns[-1]:6.2f} нс")
    print(f"     худшее больше лучшего на {100 * (ns[-1] - ns[0]) / ns[0]:.0f} %")
    print()
    print("     Вот почему берётся лучшее и почему вывод строится на")
    print("     кратностях, а не на абсолютных числах.")
    print()

    print("  2. Пустой оператор — сколько стоит сам цикл timeit")
    print()
    empty = best("pass", "pass")
    print(f"     амортизированный режим (REPEAT = {REPEAT}):  {empty:6.3f} нс")
    print()
    print("     А вот то же самое БЕЗ амортизации — так мерил первый черновик,")
    print("     и так делают почти все замеры доступа к атрибуту:")
    print()
    raw_empty = best("pass", "pass", repeat=1)
    raw_slot = best("o.a", "o = Slotted()", repeat=1)
    raw_plain = best("o.a", "o = Plain()", repeat=1)
    print(f"     pass, одна операция за виток:    {raw_empty:6.2f} нс")
    print(f"     o.a со слотами, одна за виток:   {raw_slot:6.2f} нс")
    print(f"     o.a без слотов, одна за виток:   {raw_plain:6.2f} нс")
    print()
    print(f"     Полезного сигнала здесь {100 * (raw_slot - raw_empty) / raw_slot:.0f} % от числа: всё остальное —")
    print("     цикл. «Разница» между двумя последними строками лежит внутри")
    print("     его шума, и любой вывод из неё ничего не стоит.")
    print()
    print(f"     После амортизации дно {empty:.2f} нс против измеряемых восьми —")
    print("     на порядок ниже, как и должно быть.")
    print()

    print("  3. Разные атрибуты одного объекта дают одно и то же")
    print()
    for attr in ("a", "b", "c"):
        print(f"     o.{attr} со слотами                 "
              f"{best(f'o.{attr}', 'o = Slotted()'):6.2f} нс")
    print("     Если бы числа разъезжались, мерился бы не доступ, а порядок")
    print("     слотов или попадание в кеш.")


def main():
    print("__SLOTS__ И СКОРОСТЬ ДОСТУПА К АТРИБУТУ")
    print()
    print(f"Python {sys.version.split()[0]}")
    build = sys.version.split("[", 1)[1].rstrip("]") if "[" in sys.version else "?"
    print(f"Сборка: {build}")
    print()
    print("Числа этого файла сравниваются ТОЛЬКО между собой: они получены")
    print("одним процессом на одной сборке. Между версиями время не")
    print("сравнивается (bench/README.md).")

    read = block_read()
    write = block_write()
    block_verdict(read, write)
    block_specialization()
    block_method()

    print()
    print("Все строки выше напечатаны этой программой.")


if __name__ == "__main__":
    main()