This document is for an old version of Python that is no longer supported. You should upgrade, and read the Python documentation for the current stable release.

# Управління пам’яттю

## Огляд

Керування пам’яттю в Python включає приватну купу, що містить усі об’єкти та структури даних Python. Управління цією приватною купою забезпечується внутрішньо за допомогою Менеджера пам’яті Python. Менеджер пам’яті Python має різні компоненти, які стосуються різноманітних аспектів керування динамічним сховищем, наприклад спільного використання, сегментації, попереднього розподілу чи кешування.

На найнижчому рівні розподільник необробленої пам’яті забезпечує наявність достатнього місця в приватній купі для зберігання всіх пов’язаних із Python даних шляхом взаємодії з диспетчером пам’яті операційної системи. Окрім необробленого розподільника пам’яті, кілька об’єктно-специфічних розподільників працюють на одній купі та реалізують різні політики керування пам’яттю, адаптовані до особливостей кожного типу об’єкта. Наприклад, цілими об’єктами в купі керують інакше, ніж рядками, кортежами чи словниками, оскільки цілі числа передбачають різні вимоги до сховища та компроміси між швидкістю та простором. Таким чином, менеджер пам’яті Python делегує частину роботи об’єктно-специфічним розподільникам, але гарантує, що останні працюють у межах приватної купи.

Важливо розуміти, що керування купою Python виконується самим інтерпретатором і що користувач не має контролю над нею, навіть якщо вони регулярно маніпулюють покажчиками об’єктів на блоки пам’яті всередині цієї купи. Виділення простору купи для об’єктів Python та інших внутрішніх буферів виконується на вимогу менеджером пам’яті Python за допомогою функцій API Python/C, перелічених у цьому документі.

Щоб уникнути пошкодження пам’яті, автори розширень ніколи не повинні намагатися працювати з об’єктами Python за допомогою функцій, експортованих бібліотекою C: `malloc()`, `calloc()`, `realloc()` і `free()`. Це призведе до змішаних викликів між розподільником C і диспетчером пам’яті Python із фатальними наслідками, оскільки вони реалізують різні алгоритми та працюють із різними купами. Однак можна безпечно виділяти та звільняти блоки пам’яті за допомогою розподільника бібліотеки C для окремих цілей, як показано в наступному прикладі:

    PyObject *res;
    char *buf = (char *) malloc(BUFSIZ); /* for I/O */

    if (buf == NULL)
        return PyErr_NoMemory();
    ...Do some I/O operation involving buf...
    res = PyBytes_FromString(buf);
    free(buf); /* malloc'ed */
    return res;

У цьому прикладі запит пам’яті для буфера введення/виведення обробляється розподільником бібліотеки C. Менеджер пам’яті Python бере участь лише у розподілі об’єкта bytes, який повертається в результаті.

In most situations, however, it is recommended to allocate memory from the Python heap specifically because the latter is under control of the Python memory manager. For example, this is required when the interpreter is extended with new object types written in C. Another reason for using the Python heap is the desire to inform the Python memory manager about the memory needs of the extension module. Even when the requested memory is used exclusively for internal, highly-specific purposes, delegating all memory requests to the Python memory manager causes the interpreter to have a more accurate image of its memory footprint as a whole. Consequently, under certain circumstances, the Python memory manager may or may not trigger appropriate actions, like garbage collection, memory compaction or other preventive procedures. Note that by using the C library allocator as shown in the previous example, the allocated memory for the I/O buffer escapes completely the Python memory manager.

Дивись також

Змінну середовища `PYTHONMALLOC` можна використовувати для налаштування розподільників пам’яті, які використовує Python.

Змінну середовища `PYTHONMALLOCSTATS` можна використовувати для виведення статистики розподільника пам’яті pymalloc кожного разу, коли створюється нова арена об’єкта pymalloc, і після завершення роботи.

## Інтерфейс необробленої пам’яті

Наступні набори функцій є оболонками для системного розподілювача. Ці функції є потокобезпечними, GIL не потрібно зберігати.

The default raw memory allocator uses the following functions: `malloc()`, `calloc()`, `realloc()` and `free()`; call `malloc(1)` (or `calloc(1, 1)`) when requesting zero bytes.

Нове в версії 3.4.

void* `PyMem_RawMalloc`(size_t n)

  Allocates n bytes and returns a pointer of type `void*` to the allocated memory, or `NULL` if the request fails.

  Запит нульових байтів повертає окремий вказівник, відмінний від `NULL`, якщо це можливо, ніби замість цього було викликано `PyMem_RawMalloc(1)`. Пам’ять жодним чином не буде ініціалізовано.

void* `PyMem_RawCalloc`(size_t nelem, size_t elsize)

  Allocates nelem elements each whose size in bytes is elsize and returns a pointer of type `void*` to the allocated memory, or `NULL` if the request fails. The memory is initialized to zeros.

  Запит нульових елементів або елементів розміром нуль байтів повертає окремий вказівник, відмінний від `NULL`, якщо це можливо, ніби замість цього було викликано `PyMem_RawCalloc(1, 1)`.

  Нове в версії 3.5.

void* `PyMem_RawRealloc`(void *p, size_t n)

  Змінює розмір блоку пам’яті, на який вказує p, до n байтів. Вміст буде незмінним до мінімуму старого та нового розмірів.

  Якщо p має значення `NULL`, виклик еквівалентний `PyMem_RawMalloc(n)`; інакше, якщо n дорівнює нулю, розмір блоку пам’яті змінюється, але не звільняється, а повернутий вказівник не є `NULL`.

  Якщо p не має значення `NULL`, воно має бути повернуто попереднім викликом `PyMem_RawMalloc()`, `PyMem_RawRealloc()` або `PyMem_RawCalloc()`.

  Якщо запит завершується невдало, `PyMem_RawRealloc()` повертає `NULL`, а p залишається дійсним покажчиком на попередню область пам’яті.

void `PyMem_RawFree`(void *p)

  Звільняє блок пам’яті, на який вказує p, який мав бути повернутий попереднім викликом `PyMem_RawMalloc()`, `PyMem_RawRealloc()` або `PyMem_RawCalloc()`. В іншому випадку, або якщо `PyMem_RawFree(p)` був викликаний раніше, виникає невизначена поведінка.

  Якщо p має значення `NULL`, жодна операція не виконується.

## Інтерфейс пам’яті

Наступні набори функцій, створені за стандартом ANSI C, але вказуючи поведінку під час запиту нульових байтів, доступні для виділення та звільнення пам’яті з купи Python.

розподільник пам’яті за замовчуванням використовує розподільник пам’яті pymalloc.

Попередження

GIL має зберігатися під час використання цих функцій.

Змінено в версії 3.6: Типовим розподільником тепер є pymalloc замість system `malloc()`.

void* `PyMem_Malloc`(size_t n)

  Allocates n bytes and returns a pointer of type `void*` to the allocated memory, or `NULL` if the request fails.

  Запит нульових байтів повертає окремий вказівник, відмінний від `NULL`, якщо це можливо, ніби замість цього було викликано `PyMem_Malloc(1)`. Пам’ять жодним чином не буде ініціалізовано.

void* `PyMem_Calloc`(size_t nelem, size_t elsize)

  Allocates nelem elements each whose size in bytes is elsize and returns a pointer of type `void*` to the allocated memory, or `NULL` if the request fails. The memory is initialized to zeros.

  Запит нульових елементів або елементів розміром нуль байтів повертає окремий вказівник, відмінний від `NULL`, якщо це можливо, як якщо б замість цього було викликано `PyMem_Calloc(1, 1)`.

  Нове в версії 3.5.

void* `PyMem_Realloc`(void *p, size_t n)

  Змінює розмір блоку пам’яті, на який вказує p, до n байтів. Вміст буде незмінним до мінімуму старого та нового розмірів.

  Якщо p має значення `NULL`, виклик еквівалентний `PyMem_Malloc(n)`; інакше, якщо n дорівнює нулю, розмір блоку пам’яті змінюється, але не звільняється, а повернутий вказівник не є `NULL`.

  Якщо p не має значення `NULL`, воно має бути повернуто попереднім викликом `PyMem_Malloc()`, `PyMem_Realloc()` або `PyMem_Calloc()`.

  Якщо запит не вдається, `PyMem_Realloc()` повертає `NULL`, а p залишається дійсним покажчиком на попередню область пам’яті.

void `PyMem_Free`(void *p)

  Звільняє блок пам’яті, на який вказує p, який мав бути повернутий попереднім викликом `PyMem_Malloc()`, `PyMem_Realloc()` або `PyMem_Calloc()`. В іншому випадку, або якщо `PyMem_Free(p)` був викликаний раніше, виникає невизначена поведінка.

  Якщо p має значення `NULL`, жодна операція не виконується.

Для зручності надано наступні типоорієнтовані макроси. Зауважте, що TYPE відноситься до будь-якого типу C.

TYPE* `PyMem_New`(TYPE, size_t n)

  Same as `PyMem_Malloc()`, but allocates `(n * sizeof(TYPE))` bytes of memory. Returns a pointer cast to `TYPE*`. The memory will not have been initialized in any way.

TYPE* `PyMem_Resize`(void *p, TYPE, size_t n)

  Same as `PyMem_Realloc()`, but the memory block is resized to `(n * sizeof(TYPE))` bytes. Returns a pointer cast to `TYPE*`. On return, p will be a pointer to the new memory area, or `NULL` in the event of failure.

  Це макрос препроцесора C; p завжди перепризначається. Збережіть початкове значення p, щоб уникнути втрати пам’яті під час обробки помилок.

void `PyMem_Del`(void *p)

  Те саме, що `PyMem_Free()`.

Крім того, наведені нижче набори макросів надаються для безпосереднього виклику розподільника пам’яті Python без залучення функцій C API, перелічених вище. Однак зауважте, що їх використання не зберігає двійкову сумісність між версіями Python і тому не підтримується в модулях розширення.

- `PyMem_MALLOC(розмір)`

- `PyMem_NEW(тип, розмір)`

- `PyMem_REALLOC(ptr, size)`

- `PyMem_RESIZE(ptr, тип, розмір)`

- `PyMem_FREE(ptr)`

- `PyMem_DEL(ptr)`

## Розподільники об’єктів

Наступні набори функцій, створені за стандартом ANSI C, але вказуючи поведінку під час запиту нульових байтів, доступні для виділення та звільнення пам’яті з купи Python.

розподільник об’єктів за замовчуванням використовує розподільник пам’яті pymalloc.

Попередження

GIL має зберігатися під час використання цих функцій.

void* `PyObject_Malloc`(size_t n)

  Allocates n bytes and returns a pointer of type `void*` to the allocated memory, or `NULL` if the request fails.

  Запит нульових байтів повертає окремий покажчик, відмінний від `NULL`, якщо це можливо, ніби замість цього було викликано `PyObject_Malloc(1)`. Пам’ять жодним чином не буде ініціалізовано.

void* `PyObject_Calloc`(size_t nelem, size_t elsize)

  Allocates nelem elements each whose size in bytes is elsize and returns a pointer of type `void*` to the allocated memory, or `NULL` if the request fails. The memory is initialized to zeros.

  Запит нульових елементів або елементів розміром нуль байтів повертає окремий вказівник, відмінний від `NULL`, якщо це можливо, як якщо б замість цього було викликано `PyObject_Calloc(1, 1)`.

  Нове в версії 3.5.

void* `PyObject_Realloc`(void *p, size_t n)

  Змінює розмір блоку пам’яті, на який вказує p, до n байтів. Вміст буде незмінним до мінімуму старого та нового розмірів.

  Якщо p має значення `NULL`, виклик еквівалентний `PyObject_Malloc(n)`; інакше, якщо n дорівнює нулю, розмір блоку пам’яті змінюється, але не звільняється, а повернутий вказівник не є `NULL`.

  Якщо p не має значення `NULL`, воно має бути повернуто попереднім викликом `PyObject_Malloc()`, `PyObject_Realloc()` або `PyObject_Calloc()`.

  Якщо запит не вдається, `PyObject_Realloc()` повертає `NULL`, а p залишається дійсним покажчиком на попередню область пам’яті.

void `PyObject_Free`(void *p)

  Звільняє блок пам’яті, на який вказує p, який мав бути повернутий попереднім викликом `PyObject_Malloc()`, `PyObject_Realloc()` або `PyObject_Calloc()`. В іншому випадку, або якщо `PyObject_Free(p)` був викликаний раніше, виникає невизначена поведінка.

  Якщо p має значення `NULL`, жодна операція не виконується.

## Типові розподілювачі пам’яті

Розподільники пам’яті за замовчуванням:

Конфігурація | Ім’я | PyMem_RawMalloc | PyMem_Malloc | PyObject_Malloc
--- | --- | --- | --- | ---
Реліз збірки | `"pymalloc"` | `malloc` | `pymalloc` | `pymalloc`
Налагодити збірку | `"pymalloc_debug"` | `malloc` + налагодження | `pymalloc` + налагодження | `pymalloc` + налагодження
Випуск збірки без pymalloc | `"malloc"` | `malloc` | `malloc` | `malloc`
Збірка налагодження без pymalloc | `"malloc_debug"` | `malloc` + налагодження | `malloc` + налагодження | `malloc` + налагодження

Легенда:

- Name: value for `PYTHONMALLOC` environment variable

- `malloc`: system allocators from the standard C library, C functions: `malloc()`, `calloc()`, `realloc()` and `free()`

- `pymalloc`: pymalloc memory allocator

- «+ debug»: with debug hooks installed by `PyMem_SetupDebugHooks()`

## Налаштувати розподільники пам’яті

Нове в версії 3.4.

`PyMemAllocatorEx`

  Структура, яка використовується для опису розподілювача блоків пам’яті. Структура має такі поля:

  Поле | Значення
  --- | ---
  `недійсний *ctx` | контекст користувача, переданий як перший аргумент
  `void* malloc(void *ctx, size_t size)` | виділити блок пам’яті
  `void* calloc(void *ctx, size_t nelem, size_t elsize)` | виділити блок пам’яті, ініціалізований нулями
  `void* realloc(void *ctx, void *ptr, size_t new_size)` | виділити або змінити розмір блоку пам’яті
  `void free(void *ctx, void *ptr)` | звільнити блок пам’яті

  Змінено в версії 3.5: The `PyMemAllocator` structure was renamed to `PyMemAllocatorEx` and a new `calloc` field was added.

`PyMemAllocatorDomain`

  Enum використовується для визначення домену розподілювача. Домени:

  `PYMEM_DOMAIN_RAW`

    функції:

    - `PyMem_RawMalloc()`

    - `PyMem_RawRealloc()`

    - `PyMem_RawCalloc()`

    - `PyMem_RawFree()`

  `PYMEM_DOMAIN_MEM`

    функції:

    - `PyMem_Malloc()`,

    - `PyMem_Realloc()`

    - `PyMem_Calloc()`

    - `PyMem_Free()`

  `PYMEM_DOMAIN_OBJ`

    функції:

    - `PyObject_Malloc()`

    - `PyObject_Realloc()`

    - `PyObject_Calloc()`

    - `PyObject_Free()`

void `PyMem_GetAllocator`( PyMemAllocatorDomain domain, PyMemAllocatorEx *allocator)

  Отримати розподільник блоків пам’яті вказаного домену.

void `PyMem_SetAllocator`( PyMemAllocatorDomain domain, PyMemAllocatorEx *allocator)

  Установіть розподільник блоків пам’яті для вказаного домену.

  Новий розподільник має повертати окремий покажчик, відмінний від `NULL`, коли запитує нульові байти.

  For the `PYMEM_DOMAIN_RAW` domain, the allocator must be thread-safe: the GIL is not held when the allocator is called.

  Якщо новий розподільник не є хуком (не викликає попереднього розподільника), необхідно викликати функцію `PyMem_SetupDebugHooks()`, щоб перевстановити налагоджувальні хуки поверх нового розподільника.

void `PyMem_SetupDebugHooks`(void)

  Setup hooks to detect bugs in the Python memory allocator functions.

  Newly allocated memory is filled with the byte `0xCD` (`CLEANBYTE`), freed memory is filled with the byte `0xDD` (`DEADBYTE`). Memory blocks are surrounded by «forbidden bytes» (`FORBIDDENBYTE`: byte `0xFD`).

  Перевірки виконання:

  - Detect API violations, ex: `PyObject_Free()` called on a buffer allocated by `PyMem_Malloc()`

  - Detect write before the start of the buffer (buffer underflow)

  - Detect write after the end of the buffer (buffer overflow)

  - Check that the GIL is held when allocator functions of `PYMEM_DOMAIN_OBJ` (ex: `PyObject_Malloc()`) and `PYMEM_DOMAIN_MEM` (ex: `PyMem_Malloc()`) domains are called

  У разі помилки хуки налагодження використовують модуль `tracemalloc`, щоб отримати зворотне відстеження, де було виділено блок пам’яті. Зворотне відстеження відображається, лише якщо `tracemalloc` відстежує виділення пам’яті Python і блок пам’яті відстежується.

  These hooks are installed by default if Python is compiled in debug mode. The `PYTHONMALLOC` environment variable can be used to install debug hooks on a Python compiled in release mode.

  Змінено в версії 3.6: This function now also works on Python compiled in release mode. On error, the debug hooks now use `tracemalloc` to get the traceback where a memory block was allocated. The debug hooks now also check if the GIL is held when functions of `PYMEM_DOMAIN_OBJ` and `PYMEM_DOMAIN_MEM` domains are called.

  Змінено в версії 3.8: Byte patterns `0xCB` (`CLEANBYTE`), `0xDB` (`DEADBYTE`) and `0xFB` (`FORBIDDENBYTE`) have been replaced with `0xCD`, `0xDD` and `0xFD` to use the same values than Windows CRT debug `malloc()` and `free()`.

## Розподільник pymalloc

Python has a pymalloc allocator optimized for small objects (smaller or equal to 512 bytes) with a short lifetime. It uses memory mappings called «arenas» with a fixed size of 256 KiB. It falls back to `PyMem_RawMalloc()` and `PyMem_RawRealloc()` for allocations larger than 512 bytes.

pymalloc is the default allocator of the `PYMEM_DOMAIN_MEM` (ex: `PyMem_Malloc()`) and `PYMEM_DOMAIN_OBJ` (ex: `PyObject_Malloc()`) domains.

Розподільник арени використовує такі функції:

- `VirtualAlloc()` and `VirtualFree()` on Windows,

- `mmap()` and `munmap()` if available,

- `malloc()` і `free()` інакше.

### Налаштувати pymalloc Arena Allocator

Нове в версії 3.4.

`PyObjectArenaAllocator`

  Структура, яка використовується для опису розподільника арен. Структура має три поля:

  Поле | Значення
  --- | ---
  `недійсний *ctx` | контекст користувача, переданий як перший аргумент
  `void* alloc(void *ctx, size_t size)` | виділити арену розміром байт
  `void free(void *ctx, void *ptr, size_t size)` | звільнити арену

void `PyObject_GetArenaAllocator`( PyObjectArenaAllocator *allocator)

  Отримайте розподільник арен.

void `PyObject_SetArenaAllocator`( PyObjectArenaAllocator *allocator)

  Встановіть розподільник арен.

## tracemalloc C API

Нове в версії 3.7.

int `PyTraceMalloc_Track`(unsigned int domain, uintptr_t ptr, size_t size)

  Відстежуйте виділений блок пам’яті в модулі `tracemalloc`.

  Повертає `0` у разі успіху, повертає `-1` у разі помилки (не вдалося виділити пам’ять для збереження трасування). Повертає `-2`, якщо tracemalloc вимкнено.

  Якщо блок пам’яті вже відстежується, оновіть наявне трасування.

int `PyTraceMalloc_Untrack`(unsigned int domain, uintptr_t ptr)

  Скасувати відстеження виділеного блоку пам’яті в модулі `tracemalloc`. Нічого не робити, якщо блок не відстежується.

  Повертає `-2`, якщо tracemalloc вимкнено, інакше повертає `0`.

## Приклади

Ось приклад із розділу Огляд, переписаний таким чином, що буфер введення/виведення виділяється з купи Python за допомогою першого набору функцій:

    PyObject *res;
    char *buf = (char *) PyMem_Malloc(BUFSIZ); /* for I/O */

    if (buf == NULL)
        return PyErr_NoMemory();
    /* ...Do some I/O operation involving buf... */
    res = PyBytes_FromString(buf);
    PyMem_Free(buf); /* allocated with PyMem_Malloc */
    return res;

Той самий код із використанням типу орієнтованого набору функцій:

    PyObject *res;
    char *buf = PyMem_New(char, BUFSIZ); /* for I/O */

    if (buf == NULL)
        return PyErr_NoMemory();
    /* ...Do some I/O operation involving buf... */
    res = PyBytes_FromString(buf);
    PyMem_Del(buf); /* allocated with PyMem_New */
    return res;

Зауважте, що у двох наведених вище прикладах буфером завжди керують функції, що належать одному набору. Дійсно, для певного блоку пам’яті потрібно використовувати одне й те саме сімейство API пам’яті, щоб ризик змішування різних розподільників був зведений до мінімуму. Наступна кодова послідовність містить дві помилки, одна з яких позначена як фатальна, оскільки вона змішує два різних розподільника, що працюють на різних купах.

    char *buf1 = PyMem_New(char, BUFSIZ);
    char *buf2 = (char *) malloc(BUFSIZ);
    char *buf3 = (char *) PyMem_Malloc(BUFSIZ);
    ...
    PyMem_Del(buf3);  /* Wrong -- should be PyMem_Free() */
    free(buf2);       /* Right -- allocated via malloc() */
    free(buf1);       /* Fatal -- should be PyMem_Del()  */

In addition to the functions aimed at handling raw memory blocks from the Python heap, objects in Python are allocated and released with `PyObject_New()`, `PyObject_NewVar()` and `PyObject_Del()`.

Це буде пояснено в наступному розділі про визначення та реалізацію нових типів об’єктів у C.