0 dní v řadě · 0 bodů

Python pod kapotou · 30 min

Paměť, garbage collector a bytecode

Jak Python ví, kdy objekt zahodit, kolik paměti co stojí a co doopravdy vykonává, když spustíš svůj kód.

Hloubka
Úkoly
Lidsky řečeno

Představ si balónky na provázcích. Každé jméno v programu drží jeden provázek. Dokud někdo drží aspoň jeden, balónek zůstává. Pustí-li ho poslední člověk, balónek uletí a místo se uvolní. Háček: dva balónky můžou být přivázané jeden k druhému. Nikdo z lidí je nedrží, ale provázky existují, takže samy neuletí. Na ty chodí uklízeč. Jmenuje se garbage collector, česky sběrač odpadků.

Počítadlo referencí

Každý objekt v CPythonu, tedy v běžné verzi Pythonu, si nese číslo: kolik věcí na něj právě ukazuje. Říká se tomu počet referencí. Referencí je jméno proměnné, položka seznamu, atribut objektu. Zjistíš ho funkcí sys.getrefcount. Vrací o jedničku víc, protože i její vlastní argument je dočasná reference.

import sys

data = ["a"]
print(sys.getrefcount(data))

druhe = data
print(sys.getrefcount(data))

seznam = [data, data]
print(sys.getrefcount(data))

del druhe
seznam.clear()
print(sys.getrefcount(data))
Výstup
2
3
5
2

Když počet klesne na nulu, objekt se uvolní okamžitě, ne někdy později. Je to vidět na metodě __del__, kterou Python zavolá těsně před zánikem objektu.

class Stopa:
    def __init__(self, jmeno):
        self.jmeno = jmeno
        print("vznikla", jmeno)

    def __del__(self):
        print("zanikla", self.jmeno)

a = Stopa("A")
b = a
del a
print("po del a: objekt žije, drží ho b")
b = None
print("po b = None")

def funkce():
    lokalni = Stopa("L")
    print("konec funkce")

funkce()
print("za funkcí")
Výstup
vznikla A
po del a: objekt žije, drží ho b
zanikla A
po b = None
vznikla L
konec funkce
zanikla L
za funkcí

Cykly a garbage collector

Počítadlo má slepé místo. Když se dva objekty drží navzájem, nikdy neklesnou na nulu, i když se k nim program už nedostane. Tady přichází sběrač z modulu gc. Abys viděl, co dělá, vypneme ho a spustíme ručně. Sledujeme to přes slabou referenci, ukazatel, který objekt nedrží naživu. Volání hlidac() vrátí objekt, nebo None, když už neexistuje.

import gc
import weakref

class Uzel:
    def __init__(self):
        self.soused = None

gc.disable()

a = Uzel()
b = Uzel()
a.soused = b
b.soused = a
hlidac = weakref.ref(a)

del a, b
print("po del žije:", hlidac() is not None)

gc.collect()
print("po collect žije:", hlidac() is not None)

gc.enable()
Výstup
po del žije: True
po collect žije: False

Bez cyklu by objekt zmizel už při del. Běžně se o nic starat nemusíš, sběrač je zapnutý a spouští se sám. Cykly ale znamenají, že paměť se uvolní později a v dávkách.

Slabé reference se hodí i jindy, typicky pro cache. Slovník WeakValueDictionary drží hodnoty jen tak dlouho, dokud je používá někdo jiný.

import weakref

class Obrazek:
    def __init__(self, jmeno):
        print("načítám", jmeno)
        self.jmeno = jmeno

cache = weakref.WeakValueDictionary()

def nacti(jmeno):
    obrazek = cache.get(jmeno)
    if obrazek is None:
        obrazek = Obrazek(jmeno)
        cache[jmeno] = obrazek
    return obrazek

a = nacti("logo.png")
b = nacti("logo.png")
print(a is b, len(cache))

del a, b
print(len(cache))
Výstup
načítám logo.png
True 1
0

Slabá reference nejde udělat na všechno. int, str, tuple ani obyčejný list ji nepodporují, instance vlastních tříd ano.

Úkol

Strom bez cyklů

Dítě v téhle třídě drží rodiče silně a rodič drží dítě, takže vzniká cyklus. Uprav Uzel tak, aby si dítě rodiče drželo přes weakref.ref. Atribut rodic se má dál číst stejně: vrátí rodiče, nebo None, když rodič neexistuje nebo žádný nebyl.

import weakref

class Uzel:
    def __init__(self, jmeno, rodic=None):
        self.jmeno = jmeno
        self.deti = []
        self.rodic = rodic
        if rodic is not None:
            rodic.deti.append(self)
Výstup
Kvíz

Co udělá del x, když na stejný objekt ukazuje i y?

Kolik co zabírá

sys.getsizeof vrací velikost samotného objektu. Seznam ale své prvky v sobě nemá, drží jen ukazatele na ně. Výsledek proto nezávisí na tom, jak velké jsou prvky.

import sys

maly = ["x"]
velky = ["x" * 1_000_000]

print(sys.getsizeof(maly) == sys.getsizeof(velky))
print(sys.getsizeof(velky[0]) > 1_000_000)
print(sys.getsizeof(range(10)) == sys.getsizeof(range(10**9)))
print(sys.getsizeof(list(range(1000))) > sys.getsizeof(range(1000)))
Výstup
True
True
True
True

range si pamatuje jen začátek, konec a krok, proto mu nezáleží na délce. Stejný princip mají generátory z lekce Generátory a líné zpracování.

Seznam navíc zabírá místo dopředu. Kdyby se při každém append přesouval celý, bylo by přidávání pomalé. Kapacitu zjistíš z velikosti: odečteš prázdný seznam a vydělíš velikostí ukazatele.

import struct
import sys

ukazatel = struct.calcsize("P")
prazdny = sys.getsizeof([])

seznam = []
kapacita = 0
for i in range(70):
    seznam.append(i)
    nova = (sys.getsizeof(seznam) - prazdny) // ukazatel
    if nova != kapacita:
        print(f"délka {len(seznam):>2}: místo pro {nova}")
        kapacita = nova
Výstup
délka  1: místo pro 4
délka  5: místo pro 8
délka  9: místo pro 16
délka 17: místo pro 24
délka 25: místo pro 32
délka 33: místo pro 40
délka 41: místo pro 52
délka 53: místo pro 64
délka 65: místo pro 76

Skutečnou spotřebu programu měří tracemalloc. Tady porovnává instance běžné třídy a třídy se __slots__, která nemá slovník a atributy drží na pevných místech.

import tracemalloc

class Bezna:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Sloty:
    __slots__ = ("x", "y")

    def __init__(self, x, y):
        self.x = x
        self.y = y

def bajtu_na_objekt(trida, pocet=20_000):
    tracemalloc.start()
    objekty = [trida(0, 0) for _ in range(pocet)]
    pouzito, _ = tracemalloc.get_traced_memory()
    tracemalloc.stop()
    return pouzito / len(objekty)

print(bajtu_na_objekt(Sloty) < bajtu_na_objekt(Bezna))
print(hasattr(Sloty(1, 2), "__dict__"), hasattr(Bezna(1, 2), "__dict__"))
Výstup
True
False True
Úkol

Skutečná velikost

Napiš hluboka_velikost(obj). Sečte sys.getsizeof objektu a všeho, co je v něm: prvků seznamů, n-tic a množin a klíčů i hodnot slovníků, do libovolné hloubky. Každý objekt počítej jen jednou (podle id), takže sdílené prvky ani seznam obsahující sám sebe nic nerozbijí.

import sys

def hluboka_velikost(obj):
    return sys.getsizeof(obj)
Výstup

Malá čísla a sdílené objekty

Některé objekty Python používá opakovaně, aby šetřil. Celá čísla od -5 do 256 existují předem a texty podobné identifikátorům se často internují, tedy sdílejí. Proto is občas „funguje“ na číslech a pak přestane.

import sys

a = int("256")
b = int("256")
print(a is b)

c = int("257")
d = int("257")
print(c is d, c == d)

e = "".join(["kl", "íč"])
f = "".join(["kl", "íč"])
print(e is f, sys.intern(e) is sys.intern(f))
Výstup
True
False True
False True

Bytecode: co se doopravdy spouští

Python tvůj text neprovádí přímo. Nejdřív ho přeloží do bytecodu, posloupnosti jednoduchých instrukcí pro virtuální stroj, a ty teprve vykonává smyčka interpretu. Prohlédneš si je modulem dis.

import dis

def mzda(hodiny, sazba):
    return hodiny * sazba + 500

for i in dis.get_instructions(mzda):
    print(f"{i.opname:<14}{i.argrepr}")

print(mzda.__code__.co_varnames, mzda.__code__.co_consts)
Výstup
RESUME
LOAD_FAST     hodiny
LOAD_FAST     sazba
BINARY_OP     *
LOAD_CONST    500
BINARY_OP     +
RETURN_VALUE
('hodiny', 'sazba') (None, 500)

Tenhle stroj je zásobníkový. Nemá proměnné pro mezivýsledky, odkládá je na hromádku a každá operace bere vrchní hodnoty. RESUME je technická značka začátku funkce a pro výpočet nic nedělá. Pro hodiny = 10 a sazba = 200 to vypadá takto:

text
instrukce            zásobník (vrchol vpravo)
LOAD_FAST hodiny     10
LOAD_FAST sazba      10  200
BINARY_OP *          2000
LOAD_CONST 500       2000  500
BINARY_OP +          2500
RETURN_VALUE         vrátí 2500

Překladač přitom dělá drobné optimalizace. Výraz ze samých konstant spočítá rovnou a do bytecodu uloží výsledek. A na jménech vidíš, proč jsou lokální proměnné rychlé: LOAD_FAST sáhne na číslované místo, zatímco LOAD_GLOBAL hledá ve slovníku.

import dis
import math

def den():
    return 60 * 60 * 24

def odmocnina(x):
    return math.sqrt(x)

for f in (den, odmocnina):
    print(f.__name__)
    for i in dis.get_instructions(f):
        print(f"  {i.opname:<14}{i.argrepr}")
Výstup
den
  RESUME
  RETURN_CONST  86400
odmocnina
  RESUME
  LOAD_GLOBAL   NULL + math
  LOAD_ATTR     sqrt
  LOAD_FAST     x
  CALL
  RETURN_VALUE

Rozklad na instrukce vysvětluje i jednu klasickou chybu. pocet += 1 vypadá jako jeden krok, ale jsou to čtyři: načíst, načíst jedničku, sečíst, uložit. Mezi nimi se může dostat ke slovu jiné vlákno, což řeší lekce Vlákna, procesy a GIL.

import dis

pocet = 0

def pridej():
    global pocet
    pocet += 1

print([i.opname for i in dis.get_instructions(pridej)])
Výstup
['RESUME', 'LOAD_GLOBAL', 'LOAD_CONST', 'BINARY_OP', 'STORE_GLOBAL', 'RETURN_CONST']

Přeložený kód importovaných modulů si Python ukládá do složky __pycache__, aby ho příště nemusel překládat znovu. Rychlejší je tím start, ne samotný běh. Skript spuštěný přímo se nekešuje.

import importlib.util
from pathlib import Path

print(Path(importlib.util.cache_from_source("nastroje.py")).name)
Výstup
nastroje.cpython-312.pyc
Úkol

Vlastní virtuální stroj

Napiš spust(program), malý zásobníkový stroj. Program je seznam dvojic (instrukce, argument). PUSH dá argument na zásobník. ADD a MUL vezmou dvě vrchní hodnoty a vrátí na zásobník součet nebo součin. SUB vezme vrchol b a pod ním a a uloží a - b. U ostatních než PUSH je argument None. Funkce vrátí vrchol zásobníku po posledním kroku.

def spust(program):
    zasobnik = []
    # doplň
    return None

print(spust([("PUSH", 2), ("PUSH", 3), ("ADD", None), ("PUSH", 4), ("MUL", None)]))
Výstup
Kvíz

Proč je čtení lokální proměnné obvykle rychlejší než globální?

Kvíz

Co přesně měří sys.getsizeof(seznam)?

Pod kapotou · garbage collector v CPythonu 3.12

Sběrač sleduje jen kontejnery, tedy objekty, které mohou tvořit cyklus. Čísla a texty v něm nejsou a n-tice nebo slovníky s atomickými hodnotami se umí ze sledování vyřadit. Algoritmus: pro každý objekt v generaci zkopíruje refcount, odečte reference vedoucí zevnitř generace, a co zůstane nad nulou, je dosažitelné zvenčí. Zbytek je odpad.

import gc
import sys

print(gc.is_tracked(1), gc.is_tracked("text"), gc.is_tracked([]))
print(gc.is_tracked({"a": 1}), gc.is_tracked({"a": []}))
print(sys.getrefcount(None) > 10**8)
Výstup
False False True
False True
True

Generace jsou tři, výchozí prahy gc.get_threshold() jsou (700, 10, 10). Nejmladší se sbírá, když počet alokací kontejnerů mínus dealokací překročí 700. Nejstarší navíc jen tehdy, když čekajících objektů přibylo aspoň o čtvrtinu proti naposledy prošlým, jinak by plné sběry dělaly celkovou práci kvadratickou. Od 3.12 sběr běží jen v mechanismu eval breaker mezi instrukcemi, ne přímo uvnitř alokace, takže finalizéry už nenaskočí uprostřed C kódu, který si jen říká o paměť.

V PEP 683 přibyly nesmrtelné objekty (None, True, malá čísla a další): mají refcount zafixovaný na obří hodnotě a nikdy se nemění. Odpadá tím zápis do jejich stránek paměti. To pomáhá serverům, které po fork() sdílejí paměť přes copy-on-write, kde obyčejné čtení objektu jinak špiní stránku kvůli refcountu. Stejný účel má gc.freeze() před forkem: přesune vše do permanentní generace, aby sběr v potomcích nesahal na zděděné objekty.

Od PEP 442 cykly s __del__ nekončí v gc.garbage, finalizéry se zavolají a jsou bezpečné. Dál ale platí, že objekt může z __del__ „vstát z mrtvých“ a že výjimky z __del__ se jen vypíší.

Pod kapotou · alokátor a proč proces paměť nevrací

Objekty do 512 bajtů obsluhuje pymalloc: paměť bere v arénách (1 MiB na 64bitových systémech), dělí je na pooly po 16 KiB a každý pool drží bloky jedné velikostní třídy, zarovnané na 16 bajtů. Větší požadavky jdou do malloc. Aréna se vrátí systému až celá prázdná, takže jediný přeživší objekt ji drží. Proto po uvolnění milionu objektů RSS často neklesne, i když Python má paměť volnou pro další alokace. Není to nutně únik. Rozlišíš to přes tracemalloc.take_snapshot() a porovnání dvou snímků: skutečný únik roste v čase na stejném řádku.

Diagnostika: sys._debugmallocstats() vypíše stav arén, PYTHONMALLOC=debug zapne ochranné zóny, PYTHONTRACEMALLOC=25 měří od startu. Pro dlouho běžící workery je pragmatický lék recyklace procesů (max_tasks_per_child, max_requests u gunicornu).

Časté skutečné úniky: neomezené functools.lru_cache(maxsize=None) nad metodou (drží self), uložené výjimky s tracebackem (drží všechny rámce a jejich lokální proměnné) a registry callbacků bez WeakMethod.

Pod kapotou · adaptivní interpret a sys.monitoring

Od 3.11 se bytecode za běhu přepisuje (PEP 659). Po několika průchodech se obecná instrukce nahradí specializovanou podle skutečných typů a při změně typů se zase vrátí. Inline cache leží přímo v kódu za instrukcí, ukáže je dis.dis(f, show_caches=True). Stav vidíš přes adaptive=True.

import dis

def soucet(a, b):
    return a + b

def operace():
    return [i.opname for i in dis.get_instructions(soucet, adaptive=True) if i.opname.startswith("BINARY")]

print(operace())
for _ in range(1000):
    soucet(1, 2)
print(operace())
Výstup
['BINARY_OP']
['BINARY_OP_ADD_INT']

Bytecode není stabilní rozhraní. Mění se mezi verzemi, proto je v hlavičce .pyc magické číslo a kód závislý na konkrétních opkódech se při upgradu rozbije. marshal je formát, kterým se code objekty ukládají. Není určený pro nedůvěryhodná data.

PEP 669 přidal ve 3.12 sys.monitoring: události pro profilery a debuggery, které se dají zapnout jen tam, kde jsou potřeba, a mají výrazně nižší režii než sys.settrace.

import importlib.util
import marshal
import sys

print(int.from_bytes(importlib.util.MAGIC_NUMBER[:2], "little"))

kod = compile("print('z marshalu', 6 * 7)", "<ukazka>", "exec")
exec(marshal.loads(marshal.dumps(kod)))

def fib(n):
    return n if n < 2 else fib(n - 1) + fib(n - 2)

mon = sys.monitoring
NASTROJ = mon.PROFILER_ID
pocty = {}

def pri_startu(kod, offset):
    pocty[kod.co_name] = pocty.get(kod.co_name, 0) + 1

mon.use_tool_id(NASTROJ, "pocitadlo")
try:
    mon.register_callback(NASTROJ, mon.events.PY_START, pri_startu)
    mon.set_events(NASTROJ, mon.events.PY_START)
    fib(10)
finally:
    mon.set_events(NASTROJ, 0)
    mon.register_callback(NASTROJ, mon.events.PY_START, None)
    mon.free_tool_id(NASTROJ)

print(pocty["fib"])
Výstup
3531
z marshalu 42
177

Comprehensions jsou od 3.12 vložené přímo do funkce (PEP 709), takže nevzniká zvláštní rámec. V disassembly uvidíš LOAD_FAST_AND_CLEAR místo volání vnořené funkce. Generátorové výrazy dál svůj code objekt mají.

Vyzkoušej si: Počítání odkazů

Vytvářej a ruš odkazy na objekt a sleduj čítač. Ukáže i cyklus, který čítač sám neuvolní.