"""
Снимает реальные трассы для визуализаций статьи про управление памятью.

Ничего здесь не смоделировано: каждое число — то, что вернул сам
интерпретатор в момент прогона. Запуск:

    python3.13 bench/memory/measure.py > bench/memory/measurements.json
"""
import gc
import json
import sys

out = {
    "python": sys.version.split()[0],
    "implementation": sys.implementation.name,
    "gil_enabled": getattr(sys, "_is_gil_enabled", lambda: True)(),
    "maxsize_bits": sys.maxsize.bit_length() + 1,
}

# --- 1. Счётчик ссылок по шагам ------------------------------------------
# sys.getrefcount сам создаёт временную ссылку на аргумент, поэтому его
# ответ всегда на единицу больше «настоящего» числа. Вычитаем её явно, а не
# молча: расхождение на единицу — самая частая причина недоумения при
# первом знакомстве с refcount.
#
# И ровно поэтому здесь НЕ вынесена функция-помощник rc(obj). Проверено на
# 3.13.13: при вызове через функцию параметр obj — это ещё одна ссылка, и
# ответ становится больше уже на две, а не на одну. Замер счётчика ссылок
# сам меняет то, что замеряет, и размер помехи зависит от того, как именно
# вы замеряете. Поэтому выражение везде записано на месте.
trace = []


class Thing:
    __slots__ = ("name",)

    def __init__(self, name):
        self.name = name


a = Thing("payload")
trace.append({"code": 'a = Thing("payload")', "refcount": sys.getrefcount(a) - 1, "note": "одна ссылка: имя a"})

b = a
trace.append({"code": "b = a", "refcount": sys.getrefcount(a) - 1, "note": "второе имя на тот же объект"})

box = [a]
trace.append({"code": "box = [a]", "refcount": sys.getrefcount(a) - 1, "note": "список тоже держит ссылку"})

del b
trace.append({"code": "del b", "refcount": sys.getrefcount(a) - 1, "note": "имя удалено, объект жив"})

box.clear()
trace.append({"code": "box.clear()", "refcount": sys.getrefcount(a) - 1, "note": "список отпустил ссылку"})

out["refcount_trace"] = trace

# Насколько сам замер искажает результат: то же значение, снятое на месте и
# через функцию-помощник.
def _rc_via_helper(obj):
    return sys.getrefcount(obj) - 1


probe = Thing("probe")
out["measurement_overhead"] = {
    "inline": sys.getrefcount(probe) - 1,
    "via_helper": _rc_via_helper(probe),
}

# --- 2. Что происходит, когда счётчик доходит до нуля ---------------------
freed = []


class Loud:
    def __init__(self, name):
        self.name = name

    def __del__(self):
        freed.append(self.name)


x = Loud("сразу")
del x
out["deallocated_immediately"] = list(freed)

# --- 3. Цикл: почему одного счётчика мало --------------------------------
freed.clear()
gc.collect()


class Node:
    def __init__(self, name):
        self.name = name
        self.ref = None

    def __del__(self):
        freed.append(self.name)


left = Node("left")
right = Node("right")
left.ref = right
right.ref = left

cycle = {
    "left_refcount_after_link": sys.getrefcount(left) - 1,
    "right_refcount_after_link": sys.getrefcount(right) - 1,
}
del left
del right
cycle["freed_after_del"] = list(freed)
cycle["objects_in_gc_before_collect"] = sum(
    1 for o in gc.get_objects() if isinstance(o, Node)
)
collected = gc.collect()
cycle["gc_collect_returned"] = collected
cycle["freed_after_collect"] = list(freed)
out["cycle"] = cycle

# --- 4. Пороги и счётчики поколений --------------------------------------
gc.collect()
gc.enable()
out["thresholds"] = list(gc.get_threshold())

counts = [{"allocated": 0, "counts": list(gc.get_count())}]
holder = []
for i in range(1, 6):
    # Каждый объект в цикле отслеживается сборщиком, поэтому счётчик
    # нулевого поколения растёт предсказуемо.
    holder.append([None])
    if i in (1, 2, 3, 4, 5):
        counts.append({"allocated": i, "counts": list(gc.get_count())})
out["generation_counts_sample"] = counts
out["stats"] = gc.get_stats()

# --- 5. Раскладка pymalloc ------------------------------------------------
import contextlib
import io
import re

# Две ловушки подряд, обе молчаливые.
#
# Первая: sys._debugmallocstats() печатает в stderr, а не в stdout.
# Вторая, и более коварная: печатает он из C через fprintf, поэтому
# contextlib.redirect_stderr его не ловит — эта подмена работает на уровне
# объекта sys.stderr, а не файлового дескриптора. Перехват "срабатывает",
# возвращает пустую строку, разбор даёт пустой словарь, и измерение молча
# не измеряет ничего. Поэтому подменяем сам дескриптор 2.
import os
import tempfile

with tempfile.TemporaryFile(mode="w+", encoding="utf-8") as tmp:
    saved_fd = os.dup(2)
    try:
        sys.stderr.flush()
        os.dup2(tmp.fileno(), 2)
        sys._debugmallocstats()
        sys.stderr.flush()
    finally:
        os.dup2(saved_fd, 2)
        os.close(saved_fd)
    tmp.seek(0)
    raw = tmp.read()

arena = {}
m = re.search(r"(\d+) arenas \* (\d+) bytes/arena", raw)
if m:
    arena["arenas"] = int(m.group(1))
    arena["arena_bytes"] = int(m.group(2))
m = re.search(r"(\d+) unused pools \* (\d+) bytes", raw)
if m:
    arena["unused_pools"] = int(m.group(1))
    arena["pool_bytes"] = int(m.group(2))
m = re.search(r"Small block threshold = (\d+), in (\d+) size classes", raw)
if m:
    arena["small_request_threshold"] = int(m.group(1))
    arena["size_classes"] = int(m.group(2))
m = re.search(r"# bytes in allocated blocks\s+=\s+([\d,]+)", raw)
if m:
    arena["allocated_block_bytes"] = int(m.group(1).replace(",", ""))
m = re.search(r"# bytes lost to pool headers\s+=\s+([\d,]+)", raw)
if m:
    arena["pool_header_bytes"] = int(m.group(1).replace(",", ""))
m = re.search(r"# bytes lost to quantization\s+=\s+([\d,]+)", raw)
if m:
    arena["quantization_bytes"] = int(m.group(1).replace(",", ""))

# Занятость по классам размеров — это и есть содержимое пулов.
classes = []
for line in raw.splitlines():
    m = re.match(r"\s*(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s*$", line)
    if m:
        classes.append(
            {
                "class": int(m.group(1)),
                "size": int(m.group(2)),
                "pools": int(m.group(3)),
                "in_use": int(m.group(4)),
                "available": int(m.group(5)),
            }
        )
arena["size_class_table"] = classes
if arena.get("arena_bytes") and arena.get("pool_bytes"):
    arena["pools_per_arena"] = arena["arena_bytes"] // arena["pool_bytes"]
out["pymalloc"] = arena

# --- 6. Размеры объектов --------------------------------------------------
out["object_sizes"] = {
    "object()": sys.getsizeof(object()),
    "float": sys.getsizeof(1.5),
    "empty tuple": sys.getsizeof(()),
    "empty list": sys.getsizeof([]),
    "empty dict": sys.getsizeof({}),
}

# --- 7. Бессмертные объекты ----------------------------------------------
out["immortal_refcounts"] = {
    "None": sys.getrefcount(None),
    "True": sys.getrefcount(True),
    "0": sys.getrefcount(0),
    "256": sys.getrefcount(256),
    "257": sys.getrefcount(257),
}

json.dump(out, sys.stdout, ensure_ascii=False, indent=2)