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

## Огляд

Керування пам’яттю в 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 here. There is no hard requirement to use the memory returned by the allocation functions belonging to a given domain for only the purposes hinted by that domain (although this is the recommended practice). For example, one could use the memory returned by `PyMem_RawMalloc()` for allocating Python objects or the memory returned by `PyObject_Malloc()` for allocating memory for buffers.

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

- 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 the GIL. The memory is requested directly to the system.

- «Mem» domain: intended for allocating memory for Python buffers and general-purpose memory buffers where the allocation must be performed with the GIL held. The memory is taken from the Python private heap.

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

When freeing memory previously allocated by the allocating functions belonging to a given domain,the matching specific deallocating functions must be used. For example, `PyMem_Free()` must be used to free memory allocated using `PyMem_Malloc()`.

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

Наступні набори функцій є оболонками для системного розподілювача. Ці функції є потокобезпечними, 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)
  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)`.

  Нове в версії 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.

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.

Примітка

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

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

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

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

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

  Нове в версії 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`, жодна операція не виконується.

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

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

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

Легенда:

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

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

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

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

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

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

Нове в версії 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: the GIL is not held when the allocator is called.

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

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

  `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 the GIL held). 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.

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 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 і блок пам’яті відстежується.

Нехай 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 the GIL is held 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 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()` інакше.

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

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

Нове в версії 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)

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

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