Привет, Хабр!

Принято считать, что память в Python течёт одним способом: где‑то осталась ссылка на объект, который давно пора выбросить. Привычный порядок разбора из этого и следует: включить tracemalloc или memray, найти, кто держит ссылку, и отпустить. Обычно так и выходит, и инструменты для этого хорошие.

Но есть сценарий, где этот порядок не срабатывает. Сервис с пулом потоков — синхронные ручки FastAPI, которые Starlette раздаёт в пул anyio на 40 потоков, gunicorn с воркерами gthread или обычный ThreadPoolExecutor.

После старта RSS процесса растёт, мониторинг рисует лестницу, а профайлер показывает, что живых объектов столько же, сколько было час назад. Профайлер не ошибается. RSS тоже.

Расхождение живёт уровнем ниже Python, в аллокаторе glibc. И его размер зависит от того, сколько ядер у машины, а не от того, сколько выдали контейнеру.

Профайлер говорит, что утечки нет

Я собрал маленькую модель такого сервиса. «Запрос» строит ответ из 200 байтовых строк размером от 600 до 4000 байт, десятая часть ответа уходит в кэш, остальное выбрасывается.

Кэш ограничен 20 000 элементами, и живых данных в нём всегда около 44 МБ:

cache = collections.deque(maxlen=20_000)

def handle_request(rnd):
    body = [bytes(rnd.randint(600, 4000)) for _ in range(200)]
    cache.extend(body[::10])

def worker(seed, n):
    rnd = random.Random(seed)
    for _ in range(n):
        handle_request(rnd)

Всего 12 800 запросов, которые я делю между разным числом потоков. В конце процесс печатает, сколько памяти видит tracemalloc, и RSS из /proc/self/status.

Работает Python 3.13 на glibc 2.39, машина с двумя ядрами:

потоков   1  tracemalloc   44 МБ  RSS    60 МБ
потоков   8  tracemalloc   44 МБ  RSS    95 МБ
потоков  64  tracemalloc   44 МБ  RSS   125 МБ

Работа одна и та же, живых данных столько же. Разница только в числе потоков.

tracemalloc во всех трёх случаях прав. Объектов Python в памяти на 44 МБ. Остальное он не видит, потому что считает только то, что просил у аллокатора сам Python, а не то, сколько аллокатор оставил себе.

Где лежат остальные мегабайты

У Python свой аллокатор для мелких объектов, pymalloc. Он берёт у системы блоки по 1 МБ и режет их на кусочки до 512 байт. Всё, что больше, уходит в malloc из glibc.

Наши строки от 600 до 4000 байт все до одной живут в glibc, как и большинство JSON‑ответов, буферов, строк из базы и прочих данных, которые сервис гоняет через себя.

glibc спроектирован для многопоточных программ на C, где потоки выделяют память по‑настоящему параллельно. Чтобы они не стояли в очереди на один мьютекс, у аллокатора несколько арен — независимых куч со своими блокировками.

Новый поток при первом же вызове malloc получает собственную свежую арену, и так продолжается, пока число арен не упрётся в потолок. После этого потоки делят уже созданные. Арена завершившегося потока не пропадает, а уходит в список свободных и достаётся следующему.

У каждой дополнительной арены своё хозяйство. На 64-битной системе она резервирует кусок адресного пространства в 64 МБ и по мере надобности делает его страницы доступными.

Освобождённый кусок остаётся в своей арене. Если поток A освободил 2 МБ в своей арене, а поток B в этот момент работает со своей, B возьмёт память у системы, а не у соседа.

Увидеть арены можно снаружи, без отладчика. В pmap -x каждая выглядит как пара анонимных отображений на 65 536 КБ в сумме. В начале лежит кусок с правами на чтение и запись, за ним хвост без прав, до которого арена ещё не дошла:

00007f1f60000000    3996    3996    3996 rw---   [ anon ]
00007f1f603e7000   61540       0       0 -----   [ anon ]
00007f1f68000000    4604    4604    4604 rw---   [ anon ]
00007f1f6847f000   60932       0       0 -----   [ anon ]

Чтобы не считать пары глазами, хватает короткого скрипта по /proc/PID/smaps. Он ищет пары из rw-p и ---p, которые вместе дают 64 МБ, и суммирует их RSS:

import sys

rows = []
for line in open(f"/proc/{sys.argv[1]}/smaps"):
    f = line.split()
    if "-" in f[0]:
        lo, hi = (int(x, 16) for x in f[0].split("-"))
        rows.append({"kb": (hi - lo) >> 10, "perms": f[1], "anon": len(f) == 5, "rss": 0})
    elif f[0] == "Rss:":
        rows[-1]["rss"] = int(f[1])

heaps = [a for a, b in zip(rows, rows[1:])
         if a["anon"] and b["anon"] and a["perms"] == "rw-p" and b["perms"] == "---p"
         and a["kb"] + b["kb"] == 65536]
print(f"куч по 64 МБ: {len(heaps)}, RSS в них {sum(h['rss'] for h in heaps) // 1024} МБ")

На процессе из следующего раздела, с 64 потоками и разрешёнными 128 аренами, скрипт выдал:

куч по 64 МБ: 44, RSS в них 151 МБ

Сам процесс в этот момент занимал 164 МБ. Почти всё, что сверх 44 МБ живых данных, лежит в аренах потоков, а VmSize раздут до 3,3 ГБ, потому что каждая арена резервирует свои 64 МБ адресов, даже если пользуется четырьмя.

Сколько арен разрешено и при чём тут ядра

Верхняя граница числа арен у glibc по умолчанию — 8 на каждое ядро для 64-битных систем.

В документации к параметру glibc.malloc.arena_max первая фраза обещает, что он задаёт число арен «независимо от числа ядер в системе», а следующая уточняет, что по умолчанию это число от ядер и зависит.

На моей машине с двумя ядрами потолок — 16. Это и видно в первом прогоне: один поток дал 2 арены, свою и главную, восемь потоков — 9, а 64 потока упёрлись в 16.

Ядра glibc 2.39 считает по списку процессоров в /sys/devices/system/cpu/online. С 2.34 по 2.38 он смотрел на маску привязки процесса к процессорам, но в 2.39 вернул прежнее поведение, и коммит так и называется: восстановить семантику 2.33.

Ни квоты cgroup, ни привязка через taskset на этот счёт не влияют. Я проверил: запустил тот же тест под taskset -c 0, Python в os.process_cpu_count() ответил 1, а арен всё равно набралось 16.

В Kubernetes лимит по процессору реализован как квота cgroup. Под с лимитом в 2 ядра на узле с 64 ядрами получает от glibc потолок в 512 арен.

Сам по себе потолок ничего не стоит. Но каждый поток пула получает под ним свою арену. Пул anyio на 40 потоков на таком узле разложит выделения по 41 арене, считая главную.

Размер пулов в Python тоже часто считают от ядер. ThreadPoolExecutor без аргументов в Python 3.13 заводит min(32, os.process_cpu_count() + 4) потоков.

Под квотой cgroup маска привязки не меняется, и на большом узле это те же 32 потока, хотя квота разрешает процессу занимать в среднем 2 ядра. Python и glibc ошибаются в одну сторону. Ошибки складываются.

Изобразить большой узел на маленькой машине можно тем же параметром. С GLIBC_TUNABLES=glibc.malloc.arena_max=128 модель с 64 потоками набрала 45 арен, и RSS вырос до 151 МБ против 125 МБ при штатных 16.

От прогона к прогону цифры гуляют на 10–15 МБ, но направление одно:

Больше ядер у узла → больше арен → больше памяти, которую tracemalloc не покажет никогда.

Почему освобождённое не возвращается

Если бы арены просто отдавали память системе после каждого запроса, их число мало бы что значило. Мешает кэш.

Десятая часть каждого ответа остаётся жить, и раз каждый поток выделял свои ответы в своей арене, эти куски разбросаны по всем аренам вперемешку со свободными местами, которые соседние потоки могли бы занять, но не займут, потому что ходят в собственные кучи.

Арена может вернуть системе только верхушку своей кучи, а если наверху лежит живой элемент кэша, всё свободное под ним остаётся за процессом.

Для таких случаев в glibc есть malloc_trim. С версии 2.8 она проходит по всем аренам и возвращает системе каждую целиком свободную страницу, даже из середины кучи.

Python её сам не вызывает, но достать её можно через ctypes:

import ctypes
ctypes.CDLL("libc.so.6").malloc_trim(0)

В модели с 64 потоками вызов опускает RSS со 125 до 80 МБ.

Совсем до уровня одного потока он не доходит: страница возвращается, только если на ней не осталось ни одного живого байта, а кусочки кэша по 600–4000 байт успевают задеть многие страницы.

Вызывать malloc_trim периодически в фоновом потоке можно, но это лечение симптома: следующая волна запросов снова разложит кэш по тем же аренам.

Что можно поменять

Вариантов три: ограничить число арен, заменить аллокатор целиком или перевести объекты Python на другой аллокатор.

Я прогнал все на той же модели с 64 потоками:

по умолчанию, 16 арен       RSS 125 МБ   после malloc_trim  80 МБ
arena_max=2                 RSS  82 МБ   после malloc_trim  70 МБ
arena_max=128, 45 арен      RSS 151 МБ   после malloc_trim 106 МБ
jemalloc через LD_PRELOAD   RSS  90 МБ
PYTHONMALLOC=mimalloc       RSS  97 МБ

Проще всего ограничить арены.

Переменная окружения MALLOC_ARENA_MAX=2 или тот же параметр через GLIBC_TUNABLES не требуют ни пересборки, ни новых пакетов, и в модели это лучший результат.

Платить за него приходится конкуренцией за блокировку аллокатора, но под GIL её почти нет: потоки и так выполняют Python‑код по очереди.

Я гонял каждую конфигурацию без tracemalloc по пять раз, и все прогоны легли в 2,5–3,2 секунды без заметной закономерности.

Для кода, который отпускает GIL и выделяет память в нескольких потоках одновременно, — сжатие, numpy, драйверы баз — это надо мерить отдельно на своей нагрузке.

jemalloc подключается через LD_PRELOAD.

Он заменяет malloc целиком. Арен у него по умолчанию даже больше, 4 на ядро, но неиспользуемые страницы он со временем сам возвращает системе и меньше страдает от разбросанных живых кусков.

malloc_trim из glibc к нему отношения не имеет, и вторая колонка в этой строке пустая.

Минус в том, что это ещё одна библиотека в образе, и поведение процесса начинает зависеть от переменной окружения, которую легко потерять при переезде на новый базовый образ.

PYTHONMALLOC=mimalloc работает в обычной сборке Python 3.13 без всякой пересборки.

Он переводит на mimalloc домены MEM и OBJ, в которые попадают объекты Python любого размера, а сырые выделения через PyMem_RawMalloc по‑прежнему идут в glibc.

В модели это дало 97 МБ. Вариант интересен тем, что ничего не подгружает со стороны. Но самым экономным он не оказался.

Free‑threaded сборки, кстати, используют mimalloc по умолчанию, и для них вся эта история выглядит по‑другому.

Как это найти у себя

Первый признак проверяется так: tracemalloc или memray показывают ровную линию, а RSS процесса растёт или стоит заметно выше.

Если процесс к тому же многопоточный, а в pmap -x много пар анонимных отображений на 64 МБ, разговор уже не про утечку объектов.

Точнее всего картину показывает сам glibc. У него есть функция malloc_stats, которая печатает по каждой арене, сколько памяти взято у системы и сколько из неё выдано программе.

Вызвать её в живом процессе можно через gdb:

$ gdb -p 1941 -batch -ex 'call (void)malloc_stats()'

Печатает она в stderr самого процесса, а не в терминал gdb. В контейнере результат окажется в логах пода.

На модели с 128 разрешёнными аренами конец вывода выглядел так:

Total (incl. mmap):
system bytes     =  148312064
in use bytes     =   51927088

Аллокатор держит 148 МБ. Программе из них выдано 52. Разница почти в 100 МБ — это свободные куски внутри арен, которые никто не вернул системе.

Выше в том же выводе перечислены все 45 арен, и по ним видно, что память размазана: у большинства арен по 2–4 МБ, и ни одна не держит больше 7.

Для gdb в контейнере нужен доступ на ptrace к процессу, обычно это отдельная capability SYS_PTRACE или отладочный контейнер рядом с подом.

Если такой возможности нет, остаётся скрипт по smaps из раздела про арены, ему достаточно права читать /proc.

Без gdb ту же сводку можно спросить у glibc из самого процесса. С версии 2.33 в нём есть mallinfo2, которая обходит все арены и возвращает суммы в size_t.

Старая mallinfo считала в int и на больших кучах переполнялась. Через ctypes это десяток строк:

import ctypes

class MallInfo2(ctypes.Structure):
    _fields_ = [(name, ctypes.c_size_t) for name in (
        "arena", "ordblks", "smblks", "hblks", "hblkhd", "usmblks",
        "fsmblks", "uordblks", "fordblks", "keepcost")]

libc = ctypes.CDLL("libc.so.6")
libc.mallinfo2.restype = MallInfo2

def malloc_report():
    m = libc.mallinfo2()
    mb = lambda x: x // 2**20
    return (f"взято у системы {mb(m.arena + m.hblkhd)} МБ, "
            f"выдано {mb(m.uordblks + m.hblkhd)} МБ, свободно внутри {mb(m.fordblks)} МБ")

На модели с 64 потоками и потолком в 128 арен функция вернула:

взято у системы 152 МБ, выдано 49 МБ, свободно внутри 103 МБ

Последнее число можно выставить метрикой рядом с RSS.

Пока оно маленькое, искать надо в Python. Когда оно сравнимо с живыми данными, искать надо в аренах.

Разобраться, куда уходит память, — одна задача. Понять, насколько хорошо вы знаете внутреннее устройство Python, — другая. Проверить себя и найти пробелы можно во вступительном тесте

После этого стоит посмотреть, сколько ядер у узла, на котором крутится под. Надёжнее всего прочитать /sys/devices/system/cpu/online: nproc показывает маску привязки, и там, где под привязан к части ядер, он занизит то, на что смотрит glibc.

Сам по себе этот механизм не ошибка ни Python, ни glibc. Арены придуманы для программ, где потоки работают параллельно, и там они окупаются.

В Python с GIL параллельности почти нет, а арены есть, и их число выбирается по железу, которое процесс даже не может использовать.

Одна переменная окружения в манифесте возвращает память на место, вот такие дела.

Когда RSS процесса растёт, а tracemalloc не показывает утечку, важно уметь читать системные метрики и понимать, что происходит с памятью на уровне Linux.

Разобраться в инструментах диагностики и глубже понять устройство процессов помогут бесплатные открытые уроки:

  • 17 ноября, 20:00. «/proc, /sys, /dev: как Linux превращает железо и процессы в файлы». Записаться.

  • 17 декабря, 20:00. «Процессы в Linux: глубокое погружение». Записаться.

Больше бесплатных уроков по разработке и не только — в дайджесте мероприятий OTUS на ноябрь.