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

## Огляд

Керування пам’яттю в 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, і після завершення роботи.

## Розподільник доменів

All allocating functions belong to one of three different «domains» (see also `PyMemAllocatorDomain`). These domains represent different allocation strategies and are optimized for different purposes. The specific details on how every domain allocates memory or what internal functions each domain calls is considered an implementation detail, but for debugging purposes a simplified table can be found at Типові розподілювачі пам’яті. The APIs used to allocate and free a block of memory must be from the same domain. For example, `PyMem_Free()` must be used to free memory allocated using `PyMem_Malloc()`.

Три домени розподілу:

- Raw domain: intended for allocating memory for general-purpose memory buffers where the allocation must go to the system allocator or where the allocator can operate without an attached thread state. The memory is requested directly from the system. See Raw Memory Interface.

- «Mem» domain: intended for allocating memory for Python buffers and general-purpose memory buffers where the allocation must be performed with an attached thread state. The memory is taken from the Python private heap. See Memory Interface.

- Object domain: intended for allocating memory for Python objects. The memory is taken from the Python private heap. See Object allocators.

Примітка

The free-threaded build requires that only Python objects are allocated using the «object» domain and that all Python objects are allocated using that domain. This differs from the prior Python versions, where this was only a best practice and not a hard requirement.

For example, buffers (non-Python objects) should be allocated using `PyMem_Malloc()`, `PyMem_RawMalloc()`, or `malloc()`, but not `PyObject_Malloc()`.

See Memory Allocation APIs.

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

The following function sets are wrappers to the system allocator. These functions are thread-safe, so a thread state does not need to be attached.

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.

Added in version 3.4.

void *PyMem_RawMalloc(size_t n)
  Part of the Stable ABI since version 3.13.

  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)
  Part of the Stable ABI since version 3.13.

  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)`.

  Added in version 3.5.

void *PyMem_RawRealloc(void *p, size_t n)
  Part of the Stable ABI since version 3.13.

  Змінює розмір блоку пам’яті, на який вказує 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)
  Part of the Stable ABI since version 3.13.

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

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

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

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

In the GIL-enabled build (default build) the default memory allocator uses the pymalloc memory allocator, whereas in the free-threaded build, the default is the mimalloc memory allocator instead.

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

There must be an attached thread state when using these functions.

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

Змінено в версії 3.13: In the free-threaded build, the default allocator is now mimalloc.

void *PyMem_Malloc(size_t n)
  Part of the Stable ABI.

  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)
  Part of the Stable ABI since version 3.7.

  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)`.

  Added in version 3.5.

void *PyMem_Realloc(void *p, size_t n)
  Part of the Stable ABI.

  Змінює розмір блоку пам’яті, на який вказує 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)
  Part of the Stable ABI.

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

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

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

PyMem_New(TYPE, 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.

PyMem_Resize(p, TYPE, 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()`.

### Deprecated aliases

These are soft deprecated aliases to existing functions and macros. They exist solely for backwards compatibility.

Deprecated alias | Corresponding function or macro
--- | ---
PyMem_MALLOC(size) | `PyMem_Malloc()`
PyMem_NEW(type, size) | `PyMem_New`
PyMem_REALLOC(ptr, size) | `PyMem_Realloc()`
PyMem_RESIZE(ptr, type, size) | `PyMem_Resize`
PyMem_FREE(ptr) | `PyMem_Free()`
PyMem_DEL(ptr) | `PyMem_Free()`

Змінено в версії 3.4: The macros are now aliases of the corresponding functions and macros. Previously, their behavior was the same, but their use did not necessarily preserve binary compatibility across Python versions.

Застаріло починаючи з версії 2.0.

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

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

Примітка

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

The default object allocator uses the pymalloc memory allocator. In the free-threaded build, the default is the mimalloc memory allocator instead.

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

There must be an attached thread state when using these functions.

void *PyObject_Malloc(size_t n)
  Part of the Stable ABI.

  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)
  Part of the Stable ABI since version 3.7.

  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)`.

  Added in version 3.5.

void *PyObject_Realloc(void *p, size_t n)
  Part of the Stable ABI.

  Змінює розмір блоку пам’яті, на який вказує 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)
  Part of the Stable ABI.

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

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

  Do not call this directly to free an object’s memory; call the type’s `tp_free` slot instead.

  Do not use this for memory allocated by `PyObject_GC_New` or `PyObject_GC_NewVar`; use `PyObject_GC_Del()` instead.

  Дивись також

  - `PyObject_GC_Del()` is the equivalent of this function for memory allocated by types that support garbage collection.

  - `PyObject_Malloc()`

  - `PyObject_Realloc()`

  - `PyObject_Calloc()`

  - `PyObject_New`

  - `PyObject_NewVar`

  - `PyType_GenericAlloc()`

  - `tp_free`

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

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

Конфігурація | Ім’я | 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` + налагодження
Free-threaded build | `"mimalloc"` | `mimalloc` | `mimalloc` | `mimalloc`
Free-threaded debug build | `"mimalloc_debug"` | `mimalloc` + debug | `mimalloc` + debug | `mimalloc` + debug

Легенда:

- Ім’я: значення для змінної середовища `PYTHONMALLOC`.

- `malloc`: системні розподільники зі стандартної бібліотеки C, функції C: `malloc()`, `calloc()`, `realloc()` і `free()`.

- `pymalloc`: розподіл пам’яті pymalloc.

- `mimalloc`: mimalloc memory allocator.

- «+ debug»: з debug хуками розподільників пам’яті Python.

- «Налагоджувальна збірка»: Збірка Python у режимі налагодження.

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

Added in version 3.4.

type 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.

type 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: a thread state is not attached when the allocator is called.

  For the remaining domains, the allocator must also be thread-safe: the allocator may be called in different interpreters that do not share a GIL.

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

  See also `PyPreConfig.allocator` and Preinitialize Python with PyPreConfig.

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

  `PyMem_SetAllocator()` does have the following contract:

  - It can be called after `Py_PreInitialize()` and before `Py_InitializeFromConfig()` to install a custom memory allocator. There are no restrictions over the installed allocator other than the ones imposed by the domain (for instance, the Raw Domain allows the allocator to be called without an attached thread state). See the section on allocator domains for more information.

  - If called after Python has finish initializing (after `Py_InitializeFromConfig()` has been called) the allocator must wrap the existing allocator. Substituting the current allocator for some other arbitrary one is not supported.

  Змінено в версії 3.12: All allocators must be thread-safe.

void PyMem_SetupDebugHooks(void)

  Налаштування налагоджувальних хуків у розподільниках пам’яті Python для виявлення помилок пам’яті.

## Налагодження перехоплювачів розподілювачів пам’яті Python

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

Змінну оточення `PYTHONMALLOC` можна використовувати для встановлення хуків налагодження на Python, скомпільованому в режимі випуску (наприклад: `PYTHONMALLOC=debug`).

Функцію `PyMem_SetupDebugHooks()` можна використати для встановлення хуків налагодження після виклику `PyMem_SetAllocator()`.

Ці хуки налагодження заповнюють динамічно виділені блоки пам’яті спеціальними розпізнаваними бітовими шаблонами. Щойно виділена пам’ять заповнюється байтом `0xCD` (`PYMEM_CLEANBYTE`), звільнена пам’ять заповнюється байтом `0xDD` (`PYMEM_DEADBYTE`). Блоки пам’яті оточені «забороненими байтами», заповненими байтом `0xFD` (`PYMEM_FORBIDDENBYTE`). Рядки цих байтів навряд чи будуть дійсними адресами, числами з плаваючою точкою або рядками ASCII.

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

- Виявлення порушень API. Наприклад, виявити, чи викликається `PyObject_Free()` для блоку пам’яті, виділеного `PyMem_Malloc()`.

- Виявлення запису до початку буфера (переповнення буфера).

- Виявлення запису після закінчення буфера (переповнення буфера).

- Check that there is an attached thread state when allocator functions of `PYMEM_DOMAIN_OBJ` (ex: `PyObject_Malloc()`) and `PYMEM_DOMAIN_MEM` (ex: `PyMem_Malloc()`) domains are called.

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

Нехай S = `sizeof(size_t)`. `2*S` байти додаються на кожному кінці кожного запитуваного блоку N байтів. Схема пам’яті така, де p представляє адресу, повернуту функцією, подібною до malloc або realloc (`p[i:j]` означає зріз байтів з `*(p+i)` включно до `*(p+j)` винятково; зауважте, що обробка від’ємних індексів відрізняється від фрагмента Python):

`p[-2*S:-S]`

  Первісно запитана кількість байтів. Це size_t, big-endian (легше читати в дампі пам’яті).

`p[-S]`

  Ідентифікатор API (символ ASCII):

  - `'r'` for `PYMEM_DOMAIN_RAW`.

  - `'m'` for `PYMEM_DOMAIN_MEM`.

  - `'o'` for `PYMEM_DOMAIN_OBJ`.

`p[-S+1:0]`

  Копії PYMEM_FORBIDDENBYTE. Використовується для перехоплення недописів і читань.

`p[0:N]`

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

`p[N:N+S]`

  Копії PYMEM_FORBIDDENBYTE. Використовується для перехоплення перезапису та читання.

`p[N+S:N+2*S]`

  Використовується, лише якщо визначено макрос `PYMEM_DEBUG_SERIALNO` (не визначено за замовчуванням).

  A serial number, incremented by 1 on each call to a malloc-like or realloc-like function. Big-endian `size_t`. If «bad memory» is detected later, the serial number gives an excellent way to set a breakpoint on the next run, to capture the instant at which this block was passed out. The static function bumpserialno() in obmalloc.c is the only place the serial number is incremented, and exists so you can set such a breakpoint easily.

Функція, подібна до realloc або free, спочатку перевіряє, чи не пошкоджені байти PYMEM_FORBIDDENBYTE на кожному кінці. Якщо їх було змінено, діагностичний вихід записується в stderr, а програма переривається через Py_FatalError(). Інший основний тип помилки - це провокація помилки пам’яті, коли програма зчитує один із спеціальних бітових шаблонів і намагається використати його як адресу. Якщо ви зайдете в налагоджувач і подивіться на об’єкт, ви, ймовірно, побачите, що він повністю заповнений PYMEM_DEADBYTE (це означає, що звільнена пам’ять використовується) або PYMEM_CLEANBYTE (це означає, що неініціалізована пам’ять використовується).

Змінено в версії 3.6: The `PyMem_SetupDebugHooks()` 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 there is an attached thread state when functions of `PYMEM_DOMAIN_OBJ` and `PYMEM_DOMAIN_MEM` domains are called.

Змінено в версії 3.8: Шаблони байтів `0xCB` (`PYMEM_CLEANBYTE`), `0xDB` (`PYMEM_DEADBYTE`) і `0xFB` (`PYMEM_FORBIDDENBYTE`) були замінені на `0xCD`, `0xDD` і `0xFD`, щоб використовувати ті самі значення, що й `malloc()` і `free()` для налагодження Windows CRT.

## Розподільник 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 either 256 KiB on 32-bit platforms or 1 MiB on 64-bit platforms. When Python is configured with `--with-pymalloc-hugepages`, the arena size on 64-bit platforms is increased to 2 MiB to match the huge page size, and arena allocation will attempt to use huge pages (`MAP_HUGETLB` on Linux, `MEM_LARGE_PAGES` on Windows) with automatic fallback to regular pages. 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()` інакше.

Цей розподільник вимкнено, якщо Python налаштовано з параметром `--without-pymalloc`. Його також можна вимкнути під час виконання за допомогою змінної середовища `PYTHONMALLOC` (наприклад: `PYTHONMALLOC=malloc`).

Typically, it makes sense to disable the pymalloc allocator when building Python with AddressSanitizer (`--with-address-sanitizer`) which helps uncover low level bugs within the C code.

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

Added in version 3.4.

type 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)

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

## The mimalloc allocator

Added in version 3.13.

Python supports the mimalloc allocator when the underlying platform support is available. mimalloc is a general purpose allocator with excellent performance characteristics, initially developed by Daan Leijen for the runtime systems of the Koka and Lean languages.

Unlike pymalloc, which is optimized for small objects (512 bytes or fewer), mimalloc handles allocations of any size.

In the free-threaded build, mimalloc is the default and required allocator for the `PYMEM_DOMAIN_MEM` and `PYMEM_DOMAIN_OBJ` domains. It cannot be disabled in free-threaded builds. The free-threaded build uses per-thread mimalloc heaps, which allows allocation and deallocation to proceed without locking in most cases.

In the default (non-free-threaded) build, mimalloc is available but not the default allocator. It can be selected at runtime using `PYTHONMALLOC``=mimalloc` (or `mimalloc_debug` to include debug hooks). It can be disabled at build time using the `--without-mimalloc` configure option, but this option cannot be combined with `--disable-gil`.

## tracemalloc C API

Added in version 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_Free(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_Free()  */

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_Free()`.

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