Gestión de la memoria
*********************


Visión general
==============

La gestión de memoria en Python implica un montón privado que contiene
todos los objetos de Python y estructuras de datos. El *administrador
de memoria de Python* garantiza internamente la gestión de este montón
privado. El administrador de memoria de Python tiene diferentes
componentes que se ocupan de varios aspectos de la gestión dinámica
del almacenamiento, como compartir, segmentación, asignación previa o
almacenamiento en caché.

En el nivel más bajo, un asignador de memoria sin procesar asegura que
haya suficiente espacio en el montón privado para almacenar todos los
datos relacionados con Python al interactuar con el administrador de
memoria del sistema operativo. Además del asignador de memoria sin
procesar, varios asignadores específicos de objeto operan en el mismo
montón e implementan políticas de administración de memoria distintas
adaptadas a las peculiaridades de cada tipo de objeto. Por ejemplo,
los objetos enteros se administran de manera diferente dentro del
montón que las cadenas, tuplas o diccionarios porque los enteros
implican diferentes requisitos de almacenamiento y compensaciones de
velocidad / espacio. El administrador de memoria de Python delega
parte del trabajo a los asignadores específicos de objeto, pero
asegura que este último opere dentro de los límites del montón
privado.

Es importante comprender que la gestión del montón de Python la
realiza el propio intérprete y que el usuario no tiene control sobre
él, incluso si manipulan regularmente punteros de objetos a bloques de
memoria dentro de ese montón. El administrador de memoria de Python
realiza la asignación de espacio de almacenamiento dinámico para los
objetos de Python y otros búferes internos a pedido a través de las
funciones de API de Python/C enumeradas en este documento.

Para evitar daños en la memoria, los escritores de extensiones nunca
deberían intentar operar en objetos Python con las funciones
exportadas por la biblioteca C: "malloc()", "calloc()", "realloc()" y
"free()". Esto dará como resultado llamadas mixtas entre el asignador
de C y el administrador de memoria de Python con consecuencias
fatales, ya que implementan diferentes algoritmos y operan en
diferentes montones. Sin embargo, uno puede asignar y liberar de forma
segura bloques de memoria con el asignador de la biblioteca C para
fines individuales, como se muestra en el siguiente ejemplo:

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

   if (buf == NULL)
       return PyErr_NoMemory();
   ...Hacer algunas operaciones I/O incluyendo buf...
   res = PyBytes_FromString(buf);
   free(buf); /* malloc'ed */
   return res;

En este ejemplo, la solicitud de memoria para el búfer de E/S es
manejada por el asignador de la biblioteca C. El administrador de
memoria de Python solo participa en la asignación del objeto de bytes
retornado como resultado.

Sin embargo, en la mayoría de las situaciones, se recomienda asignar
memoria del montón de Python específicamente porque este último está
bajo el control del administrador de memoria de Python. Por ejemplo,
esto es necesario cuando el intérprete se amplía con nuevos tipos de
objetos escritos en C. Otra razón para usar el montón de Python es el
deseo de *informar* al administrador de memoria de Python sobre las
necesidades de memoria del módulo de extensión. Incluso cuando la
memoria solicitada se usa exclusivamente para fines internos y
altamente específicos, delegar todas las solicitudes de memoria al
administrador de memoria de Python hace que el intérprete tenga una
imagen más precisa de su huella de memoria en su conjunto. En
consecuencia, bajo ciertas circunstancias, el administrador de memoria
de Python puede o no desencadenar acciones apropiadas, como
recolección de basura, compactación de memoria u otros procedimientos
preventivos. Tenga en cuenta que al usar el asignador de la biblioteca
C como se muestra en el ejemplo anterior, la memoria asignada para el
búfer de E/S escapa completamente al administrador de memoria Python.

Ver también:

  La variable de entorno "PYTHONMALLOC" puede usarse para configurar
  los asignadores de memoria utilizados por Python.

  La variable de entorno "PYTHONMALLOCSTATS" se puede utilizar para
  imprimir estadísticas de asignador de memoria pymalloc cada vez que
  se crea un nuevo escenario de objetos pymalloc, y en el apagado.


Dominios del asignador
======================

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
Asignadores de memoria predeterminados. 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()".

Los tres dominios de asignación son:

* Dominio sin formato: destinado a asignar memoria para búferes de
  memoria de uso general donde la asignación *debe* ir al asignador
  del sistema o donde el asignador puede operar sin el *GIL*. La
  memoria se solicita directamente al sistema. Consulte Interfaz de
  memoria sin formato.

* Dominio "Mem": destinado a asignar memoria para búferes de Python y
  búferes de memoria de propósito general donde la asignación debe
  realizarse con el *GIL* retenido. La memoria se toma del montículo
  privado de Python. Consulte Interfaz de Memoria.

* Dominio de objeto: destinado a asignar memoria perteneciente a
  objetos de Python. La memoria se toma del montículo privado de
  Python. Consulte Asignadores de objetos.

Nota:

  La compilación *free-threaded* requiere que solamente objetos de
  Python se asignen usando el dominio de "object" y que todos los
  objetos de Python se asignan usando ese dominio. Esto es diferente
  que los versiones anteriores de Python, donde esto fue una práctica
  buena y no un requisito.Por ejemplo, *buffers* (objetos que no son
  de Python) deben asignarse usando "PyMem_Malloc()",
  "PyMem_RawMalloc()", o "malloc()", pero no
  "PyObject_Malloc()".Consulte APIs de Asignación de Memoria.


Interfaz de memoria sin procesar
================================

Los siguientes conjuntos de funciones son envoltorios para el
asignador del sistema. Estas funciones son seguras para subprocesos,
no es necesario mantener el *GIL*.

El asignador de memoria sin formato usa las siguientes funciones:
"malloc()", "calloc()", "realloc()" y "free()"; llame a "malloc(1)" (o
"calloc(1, 1)") cuando solicita cero bytes.

Added in version 3.4.

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

   Asigna *n* bytes y retorna un puntero de tipo void* a la memoria
   asignada, o "NULL" si la solicitud falla.

   Solicitar cero bytes retorna un puntero distinto que no sea "NULL"
   si es posible, como si en su lugar se hubiera llamado a
   "PyMem_RawMalloc(1)". La memoria no se habrá inicializado de
   ninguna manera.

void *PyMem_RawCalloc(size_t nelem, size_t elsize)
    * Part of the Stable ABI since version 3.13.*

   Asigna *nelem* elementos cada uno cuyo tamaño en bytes es *elsize*
   y retorna un puntero de tipo void* a la memoria asignada, o "NULL"
   si la solicitud falla. La memoria se inicializa a ceros.

   Solicitar elementos cero o elementos de tamaño cero bytes retorna
   un puntero distinto "NULL" si es posible, como si en su lugar se
   hubiera llamado "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.*

   Cambia el tamaño del bloque de memoria señalado por *p* a *n*
   bytes. Los contenidos no se modificarán al mínimo de los tamaños
   antiguo y nuevo.

   Si *p* es "NULL", la llamada es equivalente a "PyMem_RawMalloc(n)";
   de lo contrario, si *n* es igual a cero, el bloque de memoria
   cambia de tamaño pero no se libera, y el puntero retornado no es
   "NULL".

   A menos que *p* sea "NULL", debe haber sido retornado por una
   llamada previa a "PyMem_RawMalloc()", "PyMem_RawRealloc()" o
   "PyMem_RawCalloc()".

   Si la solicitud falla, "PyMem_RawRealloc()" retorna "NULL" y *p*
   sigue siendo un puntero válido al área de memoria anterior.

void PyMem_RawFree(void *p)
    * Part of the Stable ABI since version 3.13.*

   Libera el bloque de memoria al que apunta *p*, que debe haber sido
   retornado por una llamada anterior a "PyMem_RawMalloc()",
   "PyMem_RawRealloc()" o "PyMem_RawCalloc()". De lo contrario, o si
   se ha llamado antes a "PyMem_RawFree(p)", se produce un
   comportamiento indefinido.

   Si *p* es "NULL", no se realiza ninguna operación.


Interfaz de memoria
===================

Los siguientes conjuntos de funciones, modelados según el estándar
ANSI C, pero que especifican el comportamiento cuando se solicitan
cero bytes, están disponibles para asignar y liberar memoria del
montón de Python.

El asignador de memoria predeterminado usa el asignador de memorya
pymalloc.

Advertencia:

  El *GIL* debe mantenerse cuando se utilizan estas funciones.

Distinto en la versión 3.6: El asignador predeterminado ahora es
pymalloc en lugar del "malloc()" del sistema.

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

   Asigna *n* bytes y retorna un puntero de tipo void* a la memoria
   asignada, o "NULL" si la solicitud falla.

   Solicitar cero bytes retorna un puntero distinto que no sea "NULL"
   si es posible, como si en su lugar se hubiera llamado a
   "PyMem_Malloc(1)". La memoria no se habrá inicializado de ninguna
   manera.

void *PyMem_Calloc(size_t nelem, size_t elsize)
    * Part of the Stable ABI since version 3.7.*

   Asigna *nelem* elementos cada uno cuyo tamaño en bytes es *elsize*
   y retorna un puntero de tipo void* a la memoria asignada, o "NULL"
   si la solicitud falla. La memoria se inicializa a ceros.

   Solicitar elementos cero o elementos de tamaño cero bytes retorna
   un puntero distinto "NULL" si es posible, como si en su lugar se
   hubiera llamado "PyMem_Calloc(1, 1)".

   Added in version 3.5.

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

   Cambia el tamaño del bloque de memoria señalado por *p* a *n*
   bytes. Los contenidos no se modificarán al mínimo de los tamaños
   antiguo y nuevo.

   Si *p* es "NULL", la llamada es equivalente a "PyMem_Malloc(n)"; de
   lo contrario, si *n* es igual a cero, el bloque de memoria cambia
   de tamaño pero no se libera, y el puntero retornado no es "NULL".

   A menos que *p* sea "NULL", debe haber sido retornado por una
   llamada previa a "PyMem_Malloc()", "PyMem_Realloc()" o
   "PyMem_Calloc()".

   Si la solicitud falla, "PyMem_Realloc()" retorna "NULL" y *p* sigue
   siendo un puntero válido al área de memoria anterior.

void PyMem_Free(void *p)
    * Part of the Stable ABI.*

   Libera el bloque de memoria señalado por *p*, que debe haber sido
   retornado por una llamada anterior a "PyMem_Malloc()",
   "PyMem_Realloc()" o "PyMem_Calloc()". De lo contrario, o si se ha
   llamado antes a "PyMem_Free(p)", se produce un comportamiento
   indefinido.

   Si *p* es "NULL", no se realiza ninguna operación.

Las siguientes macros orientadas a tipos se proporcionan por
conveniencia. Tenga en cuenta que *TYPE* se refiere a cualquier tipo
de C.

PyMem_New(TYPE, n)

   Igual que "PyMem_Malloc()", pero asigna "(n * sizeof(TYPE))" bytes
   de memoria. Retorna una conversión de puntero a "TYPE*". La memoria
   no se habrá inicializado de ninguna manera.

PyMem_Resize(p, TYPE, n)

   Igual que "PyMem_Realloc()", pero el bloque de memoria cambia de
   tamaño a "(n * sizeof(TYPE))" bytes. Retorna una conversión de
   puntero a "TYPE*". Al retornar, *p* será un puntero a la nueva área
   de memoria, o "NULL" en caso de falla.

   Esta es una macro de preprocesador C; *p* siempre se reasigna.
   Guarde el valor original de *p* para evitar perder memoria al
   manejar errores.

void PyMem_Del(void *p)

   La misma que "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()"                                     |
+----------------------------------------------------+----------------------------------------------------+

Distinto en la versión 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.

Obsoleto desde la versión 2.0.


Asignadores de objetos
======================

Los siguientes conjuntos de funciones, modelados según el estándar
ANSI C, pero que especifican el comportamiento cuando se solicitan
cero bytes, están disponibles para asignar y liberar memoria del
montón de Python.

Nota:

  No hay garantía de que la memoria retornada por estos asignadores se
  pueda convertir con éxito en un objeto Python al interceptar las
  funciones de asignación en este dominio mediante los métodos
  descritos en la sección Personalizar Asignadores de Memoria.

El asignador predeterminado de objetos usa el asignador de memoria
pymalloc.

Advertencia:

  El *GIL* debe mantenerse cuando se utilizan estas funciones.

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

   Asigna *n* bytes y retorna un puntero de tipo void* a la memoria
   asignada, o "NULL" si la solicitud falla.

   Solicitar cero bytes retorna un puntero distinto que no sea "NULL"
   si es posible, como si en su lugar se hubiera llamado a
   "PyObject_Malloc(1)". La memoria no se habrá inicializado de
   ninguna manera.

void *PyObject_Calloc(size_t nelem, size_t elsize)
    * Part of the Stable ABI since version 3.7.*

   Asigna *nelem* elementos cada uno cuyo tamaño en bytes es *elsize*
   y retorna un puntero de tipo void* a la memoria asignada, o "NULL"
   si la solicitud falla. La memoria se inicializa a ceros.

   Solicitar elementos cero o elementos de tamaño cero bytes retorna
   un puntero distinto "NULL" si es posible, como si en su lugar se
   hubiera llamado "PyObject_Calloc(1, 1)".

   Added in version 3.5.

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

   Cambia el tamaño del bloque de memoria señalado por *p* a *n*
   bytes. Los contenidos no se modificarán al mínimo de los tamaños
   antiguo y nuevo.

   Si *p* es "NULL", la llamada es equivalente a "PyObject_Malloc(n)";
   de lo contrario, si *n* es igual a cero, el bloque de memoria
   cambia de tamaño pero no se libera, y el puntero retornado no es
   "NULL".

   A menos que *p* sea "NULL", debe haber sido retornado por una
   llamada previa a "PyObject_Malloc()", "PyObject_Realloc()" o
   "PyObject_Calloc()".

   Si la solicitud falla, "PyObject_Realloc()" retorna "NULL" y *p*
   sigue siendo un puntero válido al área de memoria anterior.

void PyObject_Free(void *p)
    * Part of the Stable ABI.*

   Libera el bloque de memoria al que apunta *p*, que debe haber sido
   retornado por una llamada anterior a "PyObject_Malloc()",
   "PyObject_Realloc()" o "PyObject_Calloc()". De lo contrario, o si
   se ha llamado antes a "PyObject_Free(p)", se produce un
   comportamiento indefinido.

   Si *p* es "NULL", no se realiza ninguna operación.


Asignadores de memoria predeterminados
======================================

Asignadores de memoria predeterminados:

+---------------------------------+----------------------+--------------------+-----------------------+----------------------+
| Configuración                   | Nombre               | PyMem_RawMalloc    | PyMem_Malloc          | PyObject_Malloc      |
|=================================|======================|====================|=======================|======================|
| Lanzamiento de compilación      | ""pymalloc""         | "malloc"           | "malloc" + debug      | "malloc" + debug     |
+---------------------------------+----------------------+--------------------+-----------------------+----------------------+
| Compilación de depuración       | ""pymalloc_debug""   | "malloc" + debug   | "pymalloc" + debug    | "pymalloc" + debug   |
+---------------------------------+----------------------+--------------------+-----------------------+----------------------+
| Lanzamiento de compilación, sin | ""malloc""           | "malloc"           | "malloc"              | "malloc"             |
| pymalloc                        |                      |                    |                       |                      |
+---------------------------------+----------------------+--------------------+-----------------------+----------------------+
| Compilación de depuración, sin  | ""malloc_debug""     | "malloc" + debug   | "malloc" + debug      | "malloc" + debug     |
| pymalloc                        |                      |                    |                       |                      |
+---------------------------------+----------------------+--------------------+-----------------------+----------------------+

Leyenda:

* Nombre: valor para variable de entorno "PYTHONMALLOC".

* "malloc": asignadores del sistema de la biblioteca C estándar,
  funciones C: "malloc()", "calloc()", "realloc()" y "free()".

* "pymalloc": asignador de memoria pymalloc.

* "mimalloc": asignador de memoria mimalloc. El asignador pymalloc se
  usará si no hay compatibilidad con mimalloc.

* "+ debug": con enlaces de depuración en los asignadores de memoria
  de Python.

* "Debug build": Compilación de Python en modo de depuración.


Personalizar asignadores de memoria
===================================

Added in version 3.4.

type PyMemAllocatorEx

   Estructura utilizada para describir un asignador de bloque de
   memoria. La estructura tiene cuatro campos:

   +------------------------------------------------------------+-----------------------------------------+
   | Campo                                                      | Significado                             |
   |============================================================|=========================================|
   | "void *ctx"                                                | contexto de usuario pasado como primer  |
   |                                                            | argumento                               |
   +------------------------------------------------------------+-----------------------------------------+
   | "void* malloc(void *ctx, size_t size)"                     | asignar un bloque de memoria            |
   +------------------------------------------------------------+-----------------------------------------+
   | "void* calloc(void *ctx, size_t nelem, size_t elsize)"     | asignar un bloque de memoria            |
   |                                                            | inicializado con ceros                  |
   +------------------------------------------------------------+-----------------------------------------+
   | "void* realloc(void *ctx, void *ptr, size_t new_size)"     | asignar o cambiar el tamaño de un       |
   |                                                            | bloque de memoria                       |
   +------------------------------------------------------------+-----------------------------------------+
   | "void free(void *ctx, void *ptr)"                          | liberar un bloque de memoria            |
   +------------------------------------------------------------+-----------------------------------------+

   Distinto en la versión 3.5: La estructura "PyMemAllocator" se
   renombró a "PyMemAllocatorEx" y se agregó un nuevo campo "calloc".

type PyMemAllocatorDomain

   Enum se utiliza para identificar un dominio asignador. Dominios:

   PYMEM_DOMAIN_RAW

      Funciones:

      * "PyMem_RawMalloc()"

      * "PyMem_RawRealloc()"

      * "PyMem_RawCalloc()"

      * "PyMem_RawFree()"

   PYMEM_DOMAIN_MEM

      Funciones:

      * "PyMem_Malloc()",

      * "PyMem_Realloc()"

      * "PyMem_Calloc()"

      * "PyMem_Free()"

   PYMEM_DOMAIN_OBJ

      Funciones:

      * "PyObject_Malloc()"

      * "PyObject_Realloc()"

      * "PyObject_Calloc()"

      * "PyObject_Free()"

void PyMem_GetAllocator(PyMemAllocatorDomain domain, PyMemAllocatorEx *allocator)

   Obtenga el asignador de bloque de memoria del dominio especificado.

void PyMem_SetAllocator(PyMemAllocatorDomain domain, PyMemAllocatorEx *allocator)

   Establece el asignador de bloque de memoria del dominio
   especificado.

   El nuevo asignador debe retornar un puntero distinto "NULL" al
   solicitar cero bytes.

   Para el dominio "PYMEM_DOMAIN_RAW", el asignador debe ser seguro
   para hilos: el *GIL* no se mantiene cuando se llama al asignador.

   Para los dominios restantes, el asignador también debe ser seguro
   para los hilos: el asignador se podría llamar desde intérpretes
   diferentes que no comparten un "GIL".

   Si el nuevo asignador no es un enlace (no llama al asignador
   anterior), se debe llamar a la función "PyMem_SetupDebugHooks()"
   para reinstalar los enlaces de depuración en la parte superior del
   nuevo asignador.

   Vea también "PyPreConfig.allocator" y Preinicialización de Python
   con PyPreConfig.

   Advertencia:

     "PyMem_SetAllocator()" tiene el contrato siguiente:

     * Se puede llamar después de "Py_PreInitialize()" y antes de
       "Py_InitializeFromConfig()" para instalar un asignador de
       memoria personalizada. No hay restricciones para el asignador
       instalado aparte de las que se interpone el dominio (por
       ejemplo, el Dominio Crudo permite que se llame al asignador sin
       sostener el GIL). Consulte la sección sobre dominios de
       asignadores para más información.

     * Si se llama después de que Python haya terminado
       inicializándose (después de llamar "Py_InitializeFromConfig()")
       el asignador **debe** envolver el asignador existente.
       Substituyendo el asignador actual con otro arbitrario **no es
       compatible**.

   Distinto en la versión 3.12: Todos los asignadores deben ser seguro
   para los hilos.

void PyMem_SetupDebugHooks(void)

   Configurar enlaces de depuración en los asignadores de memoria de
   Python para detectar errores de memoria.


Configurar enlaces para detectar errores en las funciones del asignador de memoria de Python
============================================================================================

Cuando Python está construido en modo de depuración, la función
"PyMem_SetupDebugHooks()" se llama en Preinicialización de Python para
configurar los enlaces de depuración en Python asignadores de memoria
para detectar errores de memoria.

La variable de entorno "PYTHONMALLOC" se puede utilizar para instalar
enlaces de depuración en un Python compilado en modo de lanzamiento
(por ejemplo: "PYTHONMALLOC=debug").

La función "PyMem_SetupDebugHooks()" se puede utilizar para establecer
enlaces de depuración después de llamar a "PyMem_SetAllocator()".

Estos enlaces de depuración llenan bloques de memoria asignados
dinámicamente con patrones de bits especiales y reconocibles. La
memoria recién asignada se llena con el byte "0xCD"
("PYMEM_CLEANBYTE"), la memoria liberada se llena con el byte "0xDD"
("PYMEM_DEADBYTE"). Los bloques de memoria están rodeados por "bytes
prohibidos" rellenos con el byte "0xFD" ("PYMEM_FORBIDDENBYTE"). Es
poco probable que las cadenas de estos bytes sean direcciones válidas,
flotantes o cadenas ASCII.

Verificaciones de tiempo de ejecución:

* Detecte violaciones de API, por ejemplo: "PyObject_Free()" llamado
  en un búfer asignado por "PyMem_Malloc()".

* Detectar escritura antes del inicio del búfer (desbordamiento del
  búfer)

* Detectar escritura después del final del búfer (desbordamiento del
  búfer)

* Comprueba que *GIL* se mantiene cuando las funciones del asignador
  de "PYMEM_DOMAIN_OBJ" (ej: "PyObject_Malloc()") y dominios
  "PYMEM_DOMAIN_MEM" (por ejemplo: "PyMem_Malloc()") se llaman.

En caso de error, los enlaces de depuración usan el módulo
"tracemalloc" para obtener el rastreo donde se asignó un bloque de
memoria. El rastreo solo se muestra si "tracemalloc" rastrea las
asignaciones de memoria de Python y se rastrea el bloque de memoria.

Sea *S* = "sizeof(size_t)". Se agregan "2*S" bytes en cada extremo de
cada bloque de *N* bytes solicitados. El diseño de la memoria es así,
donde p representa la dirección retornada por una función similar a
malloc o realloc ("p[i:j]" significa el segmento de bytes de "*(p+i)"
inclusive hasta "*(p+j)" exclusivo; tenga en cuenta que el tratamiento
de los índices negativos difiere de un segmento de Python):

"p[-2*S:-S]"
   Número de bytes solicitados originalmente. Este es un size_t, big-
   endian (más fácil de leer en un volcado de memoria).

"p[-S]"
   Identificador de API (carácter ASCII):

   * "'r'" para "PYMEM_DOMAIN_RAW".

   * "'m'" para "PYMEM_DOMAIN_MEM".

   * "'o'" para "PYMEM_DOMAIN_OBJ".

"p[-S+1:0]"
   Copias de PYMEM_FORBIDDENBYTE. Se utiliza para detectar
   suscripciones y lecturas.

"p[0:N]"
   La memoria solicitada, llena de copias de PYMEM_CLEANBYTE,
   utilizada para capturar la referencia a la memoria no inicializada.
   Cuando se llama a una función similar a realloc solicitando un
   bloque de memoria más grande, los nuevos bytes en exceso también se
   llenan con PYMEM_CLEANBYTE. Cuando se llama a una función de tipo
   free, se sobrescriben con PYMEM_DEADBYTE, para captar la referencia
   a la memoria liberada. Cuando se llama a una función similar a la
   realloc solicitando un bloque de memoria más pequeño, los bytes
   antiguos sobrantes también se llenan con PYMEM_DEADBYTE.

"p[N:N+S]"
   Copias de PYMEM_FORBIDDENBYTE. Se utiliza para detectar
   sobrescrituras y lecturas.

"p[N+S:N+2*S]"
   Solo se utiliza si la macro "PYMEM_DEBUG_SERIALNO" está definida
   (no definida por defecto).

   Un número de serie, incrementado en 1 en cada llamada a una función
   similar a malloc o realloc. Big-endian "size_t". Si se detecta
   "mala memoria" más tarde, el número de serie ofrece una excelente
   manera de establecer un punto de interrupción en la siguiente
   ejecución, para capturar el instante en el que se pasó este bloque.
   La función estática bumpserialno() en obmalloc.c es el único lugar
   donde se incrementa el número de serie, y existe para que pueda
   establecer un punto de interrupción fácilmente.

Una función de tipo realloc o de tipo free primero verifica que los
bytes PYMEM_FORBIDDENBYTE en cada extremo estén intactos. Si se han
modificado, la salida de diagnóstico se escribe en stderr y el
programa se aborta mediante Py_FatalError(). El otro modo de falla
principal es provocar un error de memoria cuando un programa lee uno
de los patrones de bits especiales e intenta usarlo como una
dirección. Si ingresa a un depurador y observa el objeto, es probable
que vea que está completamente lleno de PYMEM_DEADBYTE (lo que
significa que se está usando la memoria liberada) o PYMEM_CLEANBYTE
(que significa que se está usando la memoria no inicializada).

Distinto en la versión 3.6: La función "PyMem_SetupDebugHooks()" ahora
también funciona en Python compilado en modo de lanzamiento. En caso
de error, los enlaces de depuración ahora usan "tracemalloc" para
obtener el rastreo donde se asignó un bloque de memoria. Los ganchos
de depuración ahora también comprueban si el GIL se mantiene cuando se
llaman las funciones de "PYMEM_DOMAIN_OBJ" y "PYMEM_DOMAIN_MEM"
dominios.

Distinto en la versión 3.8: Los patrones de bytes "0xCB"
("PYMEM_CLEANBYTE"), "0xDB" ("PYMEM_DEADBYTE") y "0xFB"
("PYMEM_FORBIDDENBYTE") se han reemplazado por "0xCD", "0xDD" y "0xFD"
para usar los mismos valores que la depuración de Windows CRT
"malloc()" y "free()".


El asignador pymalloc
=====================

Python tiene un asignador *pymalloc* optimizado para objetos pequeños
(más pequeños o iguales a 512 bytes) con una vida útil corta. Utiliza
asignaciones de memoria llamadas "arenas" con un tamaño fijo de 256
KiB en plataformas de 32 bits o 1 MiB en plataformas de 64 bits.
Vuelve a "PyMem_RawMalloc()" y "PyMem_RawRealloc()" para asignaciones
de más de 512 bytes.

*pymalloc* es el asignador por defecto de "PYMEM_DOMAIN_MEM" (por
ejemplo: "PyMem_Malloc()") y "PYMEM_DOMAIN_OBJ" (por ejemplo:
"PyObject_Malloc()") dominios.

El asignador de arena utiliza las siguientes funciones:

* "VirtualAlloc()" y "VirtualFree()" en Windows,

* "mmap()" y "munmap()" si está disponible,

* "malloc()" y "free()" en caso contrario.

Este asignador está deshabilitado si Python está configurado con la
opción "--without-pymalloc". También se puede deshabilitar en tiempo
de ejecución usando la variable de entorno "PYTHONMALLOC" (por
ejemplo: "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.


Personalizar asignador de arena de pymalloc
-------------------------------------------

Added in version 3.4.

type PyObjectArenaAllocator

   Estructura utilizada para describir un asignador de arena. La
   estructura tiene tres campos:

   +----------------------------------------------------+-----------------------------------------+
   | Campo                                              | Significado                             |
   |====================================================|=========================================|
   | "void *ctx"                                        | contexto de usuario pasado como primer  |
   |                                                    | argumento                               |
   +----------------------------------------------------+-----------------------------------------+
   | "void* alloc(void *ctx, size_t size)"              | asignar una arena de bytes de tamaño    |
   +----------------------------------------------------+-----------------------------------------+
   | "void free(void *ctx, void *ptr, size_t size)"     | liberar la arena                        |
   +----------------------------------------------------+-----------------------------------------+

void PyObject_GetArenaAllocator(PyObjectArenaAllocator *allocator)

   Consigue el asignador de arena.

void PyObject_SetArenaAllocator(PyObjectArenaAllocator *allocator)

   Establecer el asignador de arena.


El asignador mimalloc
=====================

Added in version 3.13.

Python admite el asignador mimalloc cuando la plataforma subyacente lo
admite. mimalloc "es un asignador de propósito general con excelentes
característicos de rendimiento. Desarrollado originalmente por Daan
Leijen para los sistemas de tiempo de ejecución de las lenguajes Koka
y Lean"


tracemalloc C API
=================

Added in version 3.7.

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

   Rastree un bloque de memoria asignado en el módulo "tracemalloc".

   Retorna "0" en caso de éxito, retorna "-1" en caso de error (no se
   pudo asignar memoria para almacenar la traza). Retorna "-2" si
   tracemalloc está deshabilitado.

   Si el bloque de memoria ya está rastreado, actualice el rastreo
   existente.

int PyTraceMalloc_Untrack(unsigned int domain, uintptr_t ptr)

   Descomprima un bloque de memoria asignado en el módulo
   "tracemalloc". No haga nada si el bloque no fue rastreado.

   Retorna "-2" si tracemalloc está deshabilitado; de lo contrario,
   retorna "0".


Ejemplos
========

Aquí está el ejemplo de la sección Visión general, reescrito para que
el búfer de E/S se asigne desde el montón de Python utilizando el
primer conjunto de funciones:

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

   if (buf == NULL)
       return PyErr_NoMemory();
   /* ...Hacer algunas operaciones I/O incluyendo buf... */
   res = PyBytes_FromString(buf);
   PyMem_Free(buf); /* destinado con PyMem_Malloc */
   return res;

El mismo código que utiliza el conjunto de funciones orientado a
tipos:

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

   if (buf == NULL)
       return PyErr_NoMemory();
   /* ...Hacer algunas operaciones I/O incluyendo buf... */
   res = PyBytes_FromString(buf);
   PyMem_Del(buf); /* destinado con PyMem_New */
   return res;

Tenga en cuenta que en los dos ejemplos anteriores, el búfer siempre
se manipula a través de funciones que pertenecen al mismo conjunto. De
hecho, es necesario usar la misma familia de API de memoria para un
bloque de memoria dado, de modo que el riesgo de mezclar diferentes
asignadores se reduzca al mínimo. La siguiente secuencia de código
contiene dos errores, uno de los cuales está etiquetado como *fatal*
porque mezcla dos asignadores diferentes que operan en montones
diferentes.:

   char *buf1 = PyMem_New(char, BUFSIZ);
   char *buf2 = (char *) malloc(BUFSIZ);
   char *buf3 = (char *) PyMem_Malloc(BUFSIZ);
   ...
   PyMem_Del(buf3);  /* Incorrecto -- debe ser PyMem_Free() */
   free(buf2);       /* Correcto -- asignado por malloc() */
   free(buf1);       /* Fatal -- debe ser PyMem_Del()  */

Además de las funciones destinadas a manejar bloques de memoria sin
procesar del montón de Python, los objetos en Python se asignan y
liberan con "PyObject_New", "PyObject_NewVar" y "PyObject_Del()" .

Esto se explicará en el próximo capítulo sobre cómo definir e
implementar nuevos tipos de objetos en C.
