"""Когда ленивость памяти НЕ экономит.

ЗАЧЕМ ЭТОТ ФАЙЛ. Урок говорил: «генератор выигрывает память всегда». Замер, на
который он опирался, честный, но узкий: миллион ВЫЧИСЛЯЕМЫХ значений против
того же миллиона, материализованного списком. Слово «всегда» превращает это
наблюдение в свойство языка — а оно неверно ровно тогда, когда материализовать
нечего.

Здесь тот же инструмент (tracemalloc вокруг участка) применён к трём случаям,
и разница между ними — не в генераторе, а в том, есть ли альтернатива,
которая занимает память.

ПОЧЕМУ ПИКОВАЯ, А НЕ ТЕКУЩАЯ ПАМЯТЬ. Вопрос «сколько это стоило» — про
максимум, который программа держала одновременно: именно он определяет, влезет
ли работа в машину. tracemalloc.get_traced_memory() возвращает обе величины,
берётся вторая.

ЗАПУСК: python3.13 bench/iterators/memory_when_not.py
Вывод по версиям: runs/memory_when_not-3.11.txt и соседние.
"""

import sys
import tracemalloc

N = 1_000_000


def peak(fn) -> int:
    """Пик выделенной памяти на время работы fn, в байтах."""
    tracemalloc.start()
    tracemalloc.reset_peak()
    fn()
    _, high = tracemalloc.get_traced_memory()
    tracemalloc.stop()
    return high


def human(size: int) -> str:
    if size >= 1024 * 1024:
        return f"{size / 1024 / 1024:.2f} МиБ"
    if size >= 1024:
        return f"{size / 1024:.2f} КиБ"
    return f"{size} Б"


def show(title: str) -> None:
    print()
    print(title)
    print("-" * len(title))


def row(label: str, value: str) -> None:
    print(f"  {label:<52} {value}")


def main() -> None:
    print(f"Python {sys.version.split()[0]} ({sys.implementation.name})")
    print(f"N = {N:_}")

    show("1. Случай урока: альтернатива материализует весь набор")
    listcomp = peak(lambda: sum([i * i for i in range(N)]))
    genexp = peak(lambda: sum(i * i for i in range(N)))
    row("sum([i * i for i in range(N)])", human(listcomp))
    row("sum(i * i for i in range(N))", human(genexp))
    row("разница", f"{human(listcomp - genexp)} в пользу ленивого")

    show("2. Данные уже есть в памяти: экономить нечего")
    data = list(range(N))
    over_list = peak(lambda: sum(data))
    over_genexp = peak(lambda: sum(x for x in data))
    row("sum(data) по готовому списку", human(over_list))
    row("sum(x for x in data) по нему же", human(over_genexp))
    row("разница", f"{human(abs(over_list - over_genexp))}")
    row("почему", "список уже занят до замера; генератор его не отменяет")

    show("3. Результат всё равно нужен целиком: ленивость лишь откладывает")
    from_listcomp = peak(lambda: [i * i for i in range(N)])
    from_genexp = peak(lambda: list(i * i for i in range(N)))
    row("[i * i for i in range(N)]", human(from_listcomp))
    row("list(i * i for i in range(N))", human(from_genexp))
    row("вывод", "оба держат миллион значений; выигрыша нет")

    show("4. Генератор держит кадр и ссылки — это тоже память")
    def gen():
        buffer = [0] * 100_000          # то, что генератор удерживает между yield
        for i in range(10):
            yield i, len(buffer)

    def make_many():
        alive = [gen() for _ in range(100)]
        for g in alive:
            next(g)                      # запускаем: кадр и буфер созданы
        return alive

    hundred_generators = peak(make_many)
    row("сто приостановленных генераторов с буфером", human(hundred_generators))
    row("вывод", "приостановленный генератор — живой кадр, а не ноль")


if __name__ == "__main__":
    main()