forked from AFPy/python-docs-fr
1064 lines
32 KiB
Plaintext
1064 lines
32 KiB
Plaintext
# Copyright (C) 2001-2018, Python Software Foundation
|
|
# For licence information, see README file.
|
|
#
|
|
msgid ""
|
|
msgstr ""
|
|
"Project-Id-Version: Python 3\n"
|
|
"Report-Msgid-Bugs-To: \n"
|
|
"POT-Creation-Date: 2023-01-15 22:33+0100\n"
|
|
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
|
|
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
|
|
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
|
|
"Language: fr\n"
|
|
"MIME-Version: 1.0\n"
|
|
"Content-Type: text/plain; charset=UTF-8\n"
|
|
"Content-Transfer-Encoding: 8bit\n"
|
|
|
|
#: c-api/memory.rst:8
|
|
msgid "Memory Management"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:17
|
|
msgid "Overview"
|
|
msgstr "Aperçu"
|
|
|
|
#: c-api/memory.rst:19
|
|
msgid ""
|
|
"Memory management in Python involves a private heap containing all Python "
|
|
"objects and data structures. The management of this private heap is ensured "
|
|
"internally by the *Python memory manager*. The Python memory manager has "
|
|
"different components which deal with various dynamic storage management "
|
|
"aspects, like sharing, segmentation, preallocation or caching."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:25
|
|
msgid ""
|
|
"At the lowest level, a raw memory allocator ensures that there is enough "
|
|
"room in the private heap for storing all Python-related data by interacting "
|
|
"with the memory manager of the operating system. On top of the raw memory "
|
|
"allocator, several object-specific allocators operate on the same heap and "
|
|
"implement distinct memory management policies adapted to the peculiarities "
|
|
"of every object type. For example, integer objects are managed differently "
|
|
"within the heap than strings, tuples or dictionaries because integers imply "
|
|
"different storage requirements and speed/space tradeoffs. The Python memory "
|
|
"manager thus delegates some of the work to the object-specific allocators, "
|
|
"but ensures that the latter operate within the bounds of the private heap."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:36
|
|
msgid ""
|
|
"It is important to understand that the management of the Python heap is "
|
|
"performed by the interpreter itself and that the user has no control over "
|
|
"it, even if they regularly manipulate object pointers to memory blocks "
|
|
"inside that heap. The allocation of heap space for Python objects and other "
|
|
"internal buffers is performed on demand by the Python memory manager through "
|
|
"the Python/C API functions listed in this document."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:49
|
|
msgid ""
|
|
"To avoid memory corruption, extension writers should never try to operate on "
|
|
"Python objects with the functions exported by the C library: :c:func:"
|
|
"`malloc`, :c:func:`calloc`, :c:func:`realloc` and :c:func:`free`. This will "
|
|
"result in mixed calls between the C allocator and the Python memory manager "
|
|
"with fatal consequences, because they implement different algorithms and "
|
|
"operate on different heaps. However, one may safely allocate and release "
|
|
"memory blocks with the C library allocator for individual purposes, as shown "
|
|
"in the following example::"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:68
|
|
msgid ""
|
|
"In this example, the memory request for the I/O buffer is handled by the C "
|
|
"library allocator. The Python memory manager is involved only in the "
|
|
"allocation of the bytes object returned as a result."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:72
|
|
msgid ""
|
|
"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."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:88
|
|
msgid ""
|
|
"The :envvar:`PYTHONMALLOC` environment variable can be used to configure the "
|
|
"memory allocators used by Python."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:91
|
|
msgid ""
|
|
"The :envvar:`PYTHONMALLOCSTATS` environment variable can be used to print "
|
|
"statistics of the :ref:`pymalloc memory allocator <pymalloc>` every time a "
|
|
"new pymalloc object arena is created, and on shutdown."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:96
|
|
msgid "Allocator Domains"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:100
|
|
msgid ""
|
|
"All allocating functions belong to one of three different \"domains\" (see "
|
|
"also :c:type:`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 :ref:`here <default-memory-"
|
|
"allocators>`. 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 :c:func:`PyMem_RawMalloc` for "
|
|
"allocating Python objects or the memory returned by :c:func:"
|
|
"`PyObject_Malloc` for allocating memory for buffers."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:112
|
|
msgid "The three allocation domains are:"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:114
|
|
msgid ""
|
|
"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 :term:`GIL`. The memory is requested "
|
|
"directly to the system."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:119
|
|
msgid ""
|
|
"\"Mem\" domain: intended for allocating memory for Python buffers and "
|
|
"general-purpose memory buffers where the allocation must be performed with "
|
|
"the :term:`GIL` held. The memory is taken from the Python private heap."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:123
|
|
msgid ""
|
|
"Object domain: intended for allocating memory belonging to Python objects. "
|
|
"The memory is taken from the Python private heap."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:126
|
|
msgid ""
|
|
"When freeing memory previously allocated by the allocating functions "
|
|
"belonging to a given domain,the matching specific deallocating functions "
|
|
"must be used. For example, :c:func:`PyMem_Free` must be used to free memory "
|
|
"allocated using :c:func:`PyMem_Malloc`."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:131
|
|
msgid "Raw Memory Interface"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:133
|
|
msgid ""
|
|
"The following function sets are wrappers to the system allocator. These "
|
|
"functions are thread-safe, the :term:`GIL <global interpreter lock>` does "
|
|
"not need to be held."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:137
|
|
msgid ""
|
|
"The :ref:`default raw memory allocator <default-memory-allocators>` uses the "
|
|
"following functions: :c:func:`malloc`, :c:func:`calloc`, :c:func:`realloc` "
|
|
"and :c:func:`free`; call ``malloc(1)`` (or ``calloc(1, 1)``) when requesting "
|
|
"zero bytes."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:217 c-api/memory.rst:325
|
|
msgid ""
|
|
"Allocates *n* bytes and returns a pointer of type :c:expr:`void*` to the "
|
|
"allocated memory, or ``NULL`` if the request fails."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:149
|
|
msgid ""
|
|
"Requesting zero bytes returns a distinct non-``NULL`` pointer if possible, "
|
|
"as if ``PyMem_RawMalloc(1)`` had been called instead. The memory will not "
|
|
"have been initialized in any way."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:227 c-api/memory.rst:335
|
|
msgid ""
|
|
"Allocates *nelem* elements each whose size in bytes is *elsize* and returns "
|
|
"a pointer of type :c:expr:`void*` to the allocated memory, or ``NULL`` if "
|
|
"the request fails. The memory is initialized to zeros."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:160
|
|
msgid ""
|
|
"Requesting zero elements or elements of size zero bytes returns a distinct "
|
|
"non-``NULL`` pointer if possible, as if ``PyMem_RawCalloc(1, 1)`` had been "
|
|
"called instead."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:240 c-api/memory.rst:348
|
|
msgid ""
|
|
"Resizes the memory block pointed to by *p* to *n* bytes. The contents will "
|
|
"be unchanged to the minimum of the old and the new sizes."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:172
|
|
msgid ""
|
|
"If *p* is ``NULL``, the call is equivalent to ``PyMem_RawMalloc(n)``; else "
|
|
"if *n* is equal to zero, the memory block is resized but is not freed, and "
|
|
"the returned pointer is non-``NULL``."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:176
|
|
msgid ""
|
|
"Unless *p* is ``NULL``, it must have been returned by a previous call to :c:"
|
|
"func:`PyMem_RawMalloc`, :c:func:`PyMem_RawRealloc` or :c:func:"
|
|
"`PyMem_RawCalloc`."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:180
|
|
msgid ""
|
|
"If the request fails, :c:func:`PyMem_RawRealloc` returns ``NULL`` and *p* "
|
|
"remains a valid pointer to the previous memory area."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:186
|
|
msgid ""
|
|
"Frees the memory block pointed to by *p*, which must have been returned by a "
|
|
"previous call to :c:func:`PyMem_RawMalloc`, :c:func:`PyMem_RawRealloc` or :c:"
|
|
"func:`PyMem_RawCalloc`. Otherwise, or if ``PyMem_RawFree(p)`` has been "
|
|
"called before, undefined behavior occurs."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:261 c-api/memory.rst:369
|
|
msgid "If *p* is ``NULL``, no operation is performed."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:197
|
|
msgid "Memory Interface"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:305
|
|
msgid ""
|
|
"The following function sets, modeled after the ANSI C standard, but "
|
|
"specifying behavior when requesting zero bytes, are available for allocating "
|
|
"and releasing memory from the Python heap."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:203
|
|
msgid ""
|
|
"The :ref:`default memory allocator <default-memory-allocators>` uses the :"
|
|
"ref:`pymalloc memory allocator <pymalloc>`."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:320
|
|
msgid ""
|
|
"The :term:`GIL <global interpreter lock>` must be held when using these "
|
|
"functions."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:213
|
|
msgid ""
|
|
"The default allocator is now pymalloc instead of system :c:func:`malloc`."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:220
|
|
msgid ""
|
|
"Requesting zero bytes returns a distinct non-``NULL`` pointer if possible, "
|
|
"as if ``PyMem_Malloc(1)`` had been called instead. The memory will not have "
|
|
"been initialized in any way."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:231
|
|
msgid ""
|
|
"Requesting zero elements or elements of size zero bytes returns a distinct "
|
|
"non-``NULL`` pointer if possible, as if ``PyMem_Calloc(1, 1)`` had been "
|
|
"called instead."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:243
|
|
msgid ""
|
|
"If *p* is ``NULL``, the call is equivalent to ``PyMem_Malloc(n)``; else if "
|
|
"*n* is equal to zero, the memory block is resized but is not freed, and the "
|
|
"returned pointer is non-``NULL``."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:247
|
|
msgid ""
|
|
"Unless *p* is ``NULL``, it must have been returned by a previous call to :c:"
|
|
"func:`PyMem_Malloc`, :c:func:`PyMem_Realloc` or :c:func:`PyMem_Calloc`."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:250
|
|
msgid ""
|
|
"If the request fails, :c:func:`PyMem_Realloc` returns ``NULL`` and *p* "
|
|
"remains a valid pointer to the previous memory area."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:256
|
|
msgid ""
|
|
"Frees the memory block pointed to by *p*, which must have been returned by a "
|
|
"previous call to :c:func:`PyMem_Malloc`, :c:func:`PyMem_Realloc` or :c:func:"
|
|
"`PyMem_Calloc`. Otherwise, or if ``PyMem_Free(p)`` has been called before, "
|
|
"undefined behavior occurs."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:263
|
|
msgid ""
|
|
"The following type-oriented macros are provided for convenience. Note that "
|
|
"*TYPE* refers to any C type."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:269
|
|
msgid ""
|
|
"Same as :c:func:`PyMem_Malloc`, but allocates ``(n * sizeof(TYPE))`` bytes "
|
|
"of memory. Returns a pointer cast to :c:expr:`TYPE*`. The memory will not "
|
|
"have been initialized in any way."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:276
|
|
msgid ""
|
|
"Same as :c:func:`PyMem_Realloc`, but the memory block is resized to ``(n * "
|
|
"sizeof(TYPE))`` bytes. Returns a pointer cast to :c:expr:`TYPE*`. On "
|
|
"return, *p* will be a pointer to the new memory area, or ``NULL`` in the "
|
|
"event of failure."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:281
|
|
msgid ""
|
|
"This is a C preprocessor macro; *p* is always reassigned. Save the original "
|
|
"value of *p* to avoid losing memory when handling errors."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:287
|
|
msgid "Same as :c:func:`PyMem_Free`."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:289
|
|
msgid ""
|
|
"In addition, the following macro sets are provided for calling the Python "
|
|
"memory allocator directly, without involving the C API functions listed "
|
|
"above. However, note that their use does not preserve binary compatibility "
|
|
"across Python versions and is therefore deprecated in extension modules."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:294
|
|
msgid "``PyMem_MALLOC(size)``"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:295
|
|
msgid "``PyMem_NEW(type, size)``"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:296
|
|
msgid "``PyMem_REALLOC(ptr, size)``"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:297
|
|
msgid "``PyMem_RESIZE(ptr, type, size)``"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:298
|
|
msgid "``PyMem_FREE(ptr)``"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:299
|
|
msgid "``PyMem_DEL(ptr)``"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:303
|
|
msgid "Object allocators"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:310
|
|
msgid ""
|
|
"There is no guarantee that the memory returned by these allocators can be "
|
|
"successfully cast to a Python object when intercepting the allocating "
|
|
"functions in this domain by the methods described in the :ref:`Customize "
|
|
"Memory Allocators <customize-memory-allocators>` section."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:315
|
|
msgid ""
|
|
"The :ref:`default object allocator <default-memory-allocators>` uses the :"
|
|
"ref:`pymalloc memory allocator <pymalloc>`."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:328
|
|
msgid ""
|
|
"Requesting zero bytes returns a distinct non-``NULL`` pointer if possible, "
|
|
"as if ``PyObject_Malloc(1)`` had been called instead. The memory will not "
|
|
"have been initialized in any way."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:339
|
|
msgid ""
|
|
"Requesting zero elements or elements of size zero bytes returns a distinct "
|
|
"non-``NULL`` pointer if possible, as if ``PyObject_Calloc(1, 1)`` had been "
|
|
"called instead."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:351
|
|
msgid ""
|
|
"If *p* is ``NULL``, the call is equivalent to ``PyObject_Malloc(n)``; else "
|
|
"if *n* is equal to zero, the memory block is resized but is not freed, and "
|
|
"the returned pointer is non-``NULL``."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:355
|
|
msgid ""
|
|
"Unless *p* is ``NULL``, it must have been returned by a previous call to :c:"
|
|
"func:`PyObject_Malloc`, :c:func:`PyObject_Realloc` or :c:func:"
|
|
"`PyObject_Calloc`."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:358
|
|
msgid ""
|
|
"If the request fails, :c:func:`PyObject_Realloc` returns ``NULL`` and *p* "
|
|
"remains a valid pointer to the previous memory area."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:364
|
|
msgid ""
|
|
"Frees the memory block pointed to by *p*, which must have been returned by a "
|
|
"previous call to :c:func:`PyObject_Malloc`, :c:func:`PyObject_Realloc` or :c:"
|
|
"func:`PyObject_Calloc`. Otherwise, or if ``PyObject_Free(p)`` has been "
|
|
"called before, undefined behavior occurs."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:375
|
|
msgid "Default Memory Allocators"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:377
|
|
msgid "Default memory allocators:"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:380
|
|
msgid "Configuration"
|
|
msgstr "Configuration"
|
|
|
|
#: c-api/memory.rst:380
|
|
msgid "Name"
|
|
msgstr "Nom"
|
|
|
|
#: c-api/memory.rst:380
|
|
msgid "PyMem_RawMalloc"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:380
|
|
msgid "PyMem_Malloc"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:380
|
|
msgid "PyObject_Malloc"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:382
|
|
msgid "Release build"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:382
|
|
msgid "``\"pymalloc\"``"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:384
|
|
msgid "``malloc``"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:382
|
|
msgid "``pymalloc``"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:383
|
|
msgid "Debug build"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:383
|
|
msgid "``\"pymalloc_debug\"``"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:385
|
|
msgid "``malloc`` + debug"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:383
|
|
msgid "``pymalloc`` + debug"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:384
|
|
msgid "Release build, without pymalloc"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:384
|
|
msgid "``\"malloc\"``"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:385
|
|
msgid "Debug build, without pymalloc"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:385
|
|
msgid "``\"malloc_debug\"``"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:388
|
|
msgid "Legend:"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:390
|
|
msgid "Name: value for :envvar:`PYTHONMALLOC` environment variable."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:391
|
|
msgid ""
|
|
"``malloc``: system allocators from the standard C library, C functions: :c:"
|
|
"func:`malloc`, :c:func:`calloc`, :c:func:`realloc` and :c:func:`free`."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:393
|
|
msgid "``pymalloc``: :ref:`pymalloc memory allocator <pymalloc>`."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:394
|
|
msgid ""
|
|
"\"+ debug\": with :ref:`debug hooks on the Python memory allocators <pymem-"
|
|
"debug-hooks>`."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:396
|
|
msgid "\"Debug build\": :ref:`Python build in debug mode <debug-build>`."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:401
|
|
msgid "Customize Memory Allocators"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:407
|
|
msgid ""
|
|
"Structure used to describe a memory block allocator. The structure has the "
|
|
"following fields:"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:649
|
|
msgid "Field"
|
|
msgstr "Champ"
|
|
|
|
#: c-api/memory.rst:649
|
|
msgid "Meaning"
|
|
msgstr "Signification"
|
|
|
|
#: c-api/memory.rst:651
|
|
msgid "``void *ctx``"
|
|
msgstr "``void *ctx``"
|
|
|
|
#: c-api/memory.rst:651
|
|
msgid "user context passed as first argument"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:415
|
|
msgid "``void* malloc(void *ctx, size_t size)``"
|
|
msgstr "``void* malloc(void *ctx, size_t size)``"
|
|
|
|
#: c-api/memory.rst:415
|
|
msgid "allocate a memory block"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:417
|
|
msgid "``void* calloc(void *ctx, size_t nelem, size_t elsize)``"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:417
|
|
msgid "allocate a memory block initialized with zeros"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:420
|
|
msgid "``void* realloc(void *ctx, void *ptr, size_t new_size)``"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:420
|
|
msgid "allocate or resize a memory block"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:422
|
|
msgid "``void free(void *ctx, void *ptr)``"
|
|
msgstr "``void free(void *ctx, void *ptr)``"
|
|
|
|
#: c-api/memory.rst:422
|
|
msgid "free a memory block"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:425
|
|
msgid ""
|
|
"The :c:type:`PyMemAllocator` structure was renamed to :c:type:"
|
|
"`PyMemAllocatorEx` and a new ``calloc`` field was added."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:432
|
|
msgid "Enum used to identify an allocator domain. Domains:"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:445 c-api/memory.rst:454
|
|
#, fuzzy
|
|
msgid "Functions:"
|
|
msgstr "Fonctions"
|
|
|
|
#: c-api/memory.rst:438
|
|
#, fuzzy
|
|
msgid ":c:func:`PyMem_RawMalloc`"
|
|
msgstr ":c:func:`PyMem_RawCalloc`,"
|
|
|
|
#: c-api/memory.rst:439
|
|
#, fuzzy
|
|
msgid ":c:func:`PyMem_RawRealloc`"
|
|
msgstr ":c:func:`PyMem_RawCalloc`,"
|
|
|
|
#: c-api/memory.rst:440
|
|
#, fuzzy
|
|
msgid ":c:func:`PyMem_RawCalloc`"
|
|
msgstr ":c:func:`PyMem_RawCalloc`,"
|
|
|
|
#: c-api/memory.rst:441
|
|
msgid ":c:func:`PyMem_RawFree`"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:447
|
|
#, fuzzy
|
|
msgid ":c:func:`PyMem_Malloc`,"
|
|
msgstr ":c:func:`PyMem_Calloc`,"
|
|
|
|
#: c-api/memory.rst:448
|
|
#, fuzzy
|
|
msgid ":c:func:`PyMem_Realloc`"
|
|
msgstr ":c:func:`PyMem_Calloc`,"
|
|
|
|
#: c-api/memory.rst:449
|
|
#, fuzzy
|
|
msgid ":c:func:`PyMem_Calloc`"
|
|
msgstr ":c:func:`PyMem_Calloc`,"
|
|
|
|
#: c-api/memory.rst:450
|
|
msgid ":c:func:`PyMem_Free`"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:456
|
|
msgid ":c:func:`PyObject_Malloc`"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:457
|
|
msgid ":c:func:`PyObject_Realloc`"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:458
|
|
msgid ":c:func:`PyObject_Calloc`"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:459
|
|
msgid ":c:func:`PyObject_Free`"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:463
|
|
msgid "Get the memory block allocator of the specified domain."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:468
|
|
msgid "Set the memory block allocator of the specified domain."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:470
|
|
msgid ""
|
|
"The new allocator must return a distinct non-``NULL`` pointer when "
|
|
"requesting zero bytes."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:473
|
|
msgid ""
|
|
"For the :c:data:`PYMEM_DOMAIN_RAW` domain, the allocator must be thread-"
|
|
"safe: the :term:`GIL <global interpreter lock>` is not held when the "
|
|
"allocator is called."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:477
|
|
msgid ""
|
|
"If the new allocator is not a hook (does not call the previous allocator), "
|
|
"the :c:func:`PyMem_SetupDebugHooks` function must be called to reinstall the "
|
|
"debug hooks on top on the new allocator."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:481
|
|
msgid ""
|
|
"See also :c:member:`PyPreConfig.allocator` and :ref:`Preinitialize Python "
|
|
"with PyPreConfig <c-preinit>`."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:486
|
|
msgid ":c:func:`PyMem_SetAllocator` does have the following contract:"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:488
|
|
msgid ""
|
|
"It can be called after :c:func:`Py_PreInitialize` and before :c:func:"
|
|
"`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 :ref:`the section on allocator domains <allocator-"
|
|
"domains>` for more information."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:496
|
|
msgid ""
|
|
"If called after Python has finish initializing (after :c:func:"
|
|
"`Py_InitializeFromConfig` has been called) the allocator **must** wrap the "
|
|
"existing allocator. Substituting the current allocator for some other "
|
|
"arbitrary one is **not supported**."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:505
|
|
msgid ""
|
|
"Setup :ref:`debug hooks in the Python memory allocators <pymem-debug-hooks>` "
|
|
"to detect memory errors."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:512
|
|
msgid "Debug hooks on the Python memory allocators"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:514
|
|
msgid ""
|
|
"When :ref:`Python is built in debug mode <debug-build>`, the :c:func:"
|
|
"`PyMem_SetupDebugHooks` function is called at the :ref:`Python "
|
|
"preinitialization <c-preinit>` to setup debug hooks on Python memory "
|
|
"allocators to detect memory errors."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:519
|
|
msgid ""
|
|
"The :envvar:`PYTHONMALLOC` environment variable can be used to install debug "
|
|
"hooks on a Python compiled in release mode (ex: ``PYTHONMALLOC=debug``)."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:522
|
|
msgid ""
|
|
"The :c:func:`PyMem_SetupDebugHooks` function can be used to set debug hooks "
|
|
"after calling :c:func:`PyMem_SetAllocator`."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:525
|
|
msgid ""
|
|
"These debug hooks fill dynamically allocated memory blocks with special, "
|
|
"recognizable bit patterns. Newly allocated memory is filled with the byte "
|
|
"``0xCD`` (``PYMEM_CLEANBYTE``), freed memory is filled with the byte "
|
|
"``0xDD`` (``PYMEM_DEADBYTE``). Memory blocks are surrounded by \"forbidden "
|
|
"bytes\" filled with the byte ``0xFD`` (``PYMEM_FORBIDDENBYTE``). Strings of "
|
|
"these bytes are unlikely to be valid addresses, floats, or ASCII strings."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:532
|
|
msgid "Runtime checks:"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:534
|
|
msgid ""
|
|
"Detect API violations. For example, detect if :c:func:`PyObject_Free` is "
|
|
"called on a memory block allocated by :c:func:`PyMem_Malloc`."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:536
|
|
msgid "Detect write before the start of the buffer (buffer underflow)."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:537
|
|
msgid "Detect write after the end of the buffer (buffer overflow)."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:538
|
|
msgid ""
|
|
"Check that the :term:`GIL <global interpreter lock>` is held when allocator "
|
|
"functions of :c:data:`PYMEM_DOMAIN_OBJ` (ex: :c:func:`PyObject_Malloc`) and :"
|
|
"c:data:`PYMEM_DOMAIN_MEM` (ex: :c:func:`PyMem_Malloc`) domains are called."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:543
|
|
msgid ""
|
|
"On error, the debug hooks use the :mod:`tracemalloc` module to get the "
|
|
"traceback where a memory block was allocated. The traceback is only "
|
|
"displayed if :mod:`tracemalloc` is tracing Python memory allocations and the "
|
|
"memory block was traced."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:548
|
|
msgid ""
|
|
"Let *S* = ``sizeof(size_t)``. ``2*S`` bytes are added at each end of each "
|
|
"block of *N* bytes requested. The memory layout is like so, where p "
|
|
"represents the address returned by a malloc-like or realloc-like function "
|
|
"(``p[i:j]`` means the slice of bytes from ``*(p+i)`` inclusive up to "
|
|
"``*(p+j)`` exclusive; note that the treatment of negative indices differs "
|
|
"from a Python slice):"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:555
|
|
msgid "``p[-2*S:-S]``"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:555
|
|
msgid ""
|
|
"Number of bytes originally asked for. This is a size_t, big-endian (easier "
|
|
"to read in a memory dump)."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:562
|
|
msgid "``p[-S]``"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:558
|
|
msgid "API identifier (ASCII character):"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:560
|
|
msgid "``'r'`` for :c:data:`PYMEM_DOMAIN_RAW`."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:561
|
|
msgid "``'m'`` for :c:data:`PYMEM_DOMAIN_MEM`."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:562
|
|
msgid "``'o'`` for :c:data:`PYMEM_DOMAIN_OBJ`."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:565
|
|
msgid "``p[-S+1:0]``"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:565
|
|
msgid "Copies of PYMEM_FORBIDDENBYTE. Used to catch under- writes and reads."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:574
|
|
msgid "``p[0:N]``"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:568
|
|
msgid ""
|
|
"The requested memory, filled with copies of PYMEM_CLEANBYTE, used to catch "
|
|
"reference to uninitialized memory. When a realloc-like function is called "
|
|
"requesting a larger memory block, the new excess bytes are also filled with "
|
|
"PYMEM_CLEANBYTE. When a free-like function is called, these are overwritten "
|
|
"with PYMEM_DEADBYTE, to catch reference to freed memory. When a realloc- "
|
|
"like function is called requesting a smaller memory block, the excess old "
|
|
"bytes are also filled with PYMEM_DEADBYTE."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:577
|
|
msgid "``p[N:N+S]``"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:577
|
|
msgid "Copies of PYMEM_FORBIDDENBYTE. Used to catch over- writes and reads."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:588
|
|
msgid "``p[N+S:N+2*S]``"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:580
|
|
msgid ""
|
|
"Only used if the ``PYMEM_DEBUG_SERIALNO`` macro is defined (not defined by "
|
|
"default)."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:583
|
|
msgid ""
|
|
"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."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:590
|
|
msgid ""
|
|
"A realloc-like or free-like function first checks that the "
|
|
"PYMEM_FORBIDDENBYTE bytes at each end are intact. If they've been altered, "
|
|
"diagnostic output is written to stderr, and the program is aborted via "
|
|
"Py_FatalError(). The other main failure mode is provoking a memory error "
|
|
"when a program reads up one of the special bit patterns and tries to use it "
|
|
"as an address. If you get in a debugger then and look at the object, you're "
|
|
"likely to see that it's entirely filled with PYMEM_DEADBYTE (meaning freed "
|
|
"memory is getting used) or PYMEM_CLEANBYTE (meaning uninitialized memory is "
|
|
"getting used)."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:599
|
|
msgid ""
|
|
"The :c:func:`PyMem_SetupDebugHooks` function now also works on Python "
|
|
"compiled in release mode. On error, the debug hooks now use :mod:"
|
|
"`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 :c:data:"
|
|
"`PYMEM_DOMAIN_OBJ` and :c:data:`PYMEM_DOMAIN_MEM` domains are called."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:607
|
|
msgid ""
|
|
"Byte patterns ``0xCB`` (``PYMEM_CLEANBYTE``), ``0xDB`` (``PYMEM_DEADBYTE``) "
|
|
"and ``0xFB`` (``PYMEM_FORBIDDENBYTE``) have been replaced with ``0xCD``, "
|
|
"``0xDD`` and ``0xFD`` to use the same values than Windows CRT debug "
|
|
"``malloc()`` and ``free()``."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:617
|
|
msgid "The pymalloc allocator"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:619
|
|
msgid ""
|
|
"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 :c:func:"
|
|
"`PyMem_RawMalloc` and :c:func:`PyMem_RawRealloc` for allocations larger than "
|
|
"512 bytes."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:624
|
|
msgid ""
|
|
"*pymalloc* is the :ref:`default allocator <default-memory-allocators>` of "
|
|
"the :c:data:`PYMEM_DOMAIN_MEM` (ex: :c:func:`PyMem_Malloc`) and :c:data:"
|
|
"`PYMEM_DOMAIN_OBJ` (ex: :c:func:`PyObject_Malloc`) domains."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:628
|
|
msgid "The arena allocator uses the following functions:"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:630
|
|
msgid ":c:func:`VirtualAlloc` and :c:func:`VirtualFree` on Windows,"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:631
|
|
msgid ":c:func:`mmap` and :c:func:`munmap` if available,"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:632
|
|
msgid ":c:func:`malloc` and :c:func:`free` otherwise."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:634
|
|
msgid ""
|
|
"This allocator is disabled if Python is configured with the :option:`--"
|
|
"without-pymalloc` option. It can also be disabled at runtime using the :"
|
|
"envvar:`PYTHONMALLOC` environment variable (ex: ``PYTHONMALLOC=malloc``)."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:639
|
|
msgid "Customize pymalloc Arena Allocator"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:645
|
|
msgid ""
|
|
"Structure used to describe an arena allocator. The structure has three "
|
|
"fields:"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:653
|
|
msgid "``void* alloc(void *ctx, size_t size)``"
|
|
msgstr "``void* alloc(void *ctx, size_t size)``"
|
|
|
|
#: c-api/memory.rst:653
|
|
msgid "allocate an arena of size bytes"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:655
|
|
#, fuzzy
|
|
msgid "``void free(void *ctx, void *ptr, size_t size)``"
|
|
msgstr "``void free(void *ctx, void *ptr)``"
|
|
|
|
#: c-api/memory.rst:655
|
|
msgid "free an arena"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:660
|
|
msgid "Get the arena allocator."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:664
|
|
msgid "Set the arena allocator."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:668
|
|
msgid "tracemalloc C API"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:674
|
|
msgid "Track an allocated memory block in the :mod:`tracemalloc` module."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:676
|
|
msgid ""
|
|
"Return ``0`` on success, return ``-1`` on error (failed to allocate memory "
|
|
"to store the trace). Return ``-2`` if tracemalloc is disabled."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:679
|
|
msgid "If memory block is already tracked, update the existing trace."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:683
|
|
msgid ""
|
|
"Untrack an allocated memory block in the :mod:`tracemalloc` module. Do "
|
|
"nothing if the block was not tracked."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:686
|
|
msgid "Return ``-2`` if tracemalloc is disabled, otherwise return ``0``."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:692
|
|
msgid "Examples"
|
|
msgstr "Exemples"
|
|
|
|
#: c-api/memory.rst:694
|
|
msgid ""
|
|
"Here is the example from section :ref:`memoryoverview`, rewritten so that "
|
|
"the I/O buffer is allocated from the Python heap by using the first function "
|
|
"set::"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:707
|
|
msgid "The same code using the type-oriented function set::"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:719
|
|
msgid ""
|
|
"Note that in the two examples above, the buffer is always manipulated via "
|
|
"functions belonging to the same set. Indeed, it is required to use the same "
|
|
"memory API family for a given memory block, so that the risk of mixing "
|
|
"different allocators is reduced to a minimum. The following code sequence "
|
|
"contains two errors, one of which is labeled as *fatal* because it mixes two "
|
|
"different allocators operating on different heaps. ::"
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:734
|
|
msgid ""
|
|
"In addition to the functions aimed at handling raw memory blocks from the "
|
|
"Python heap, objects in Python are allocated and released with :c:func:"
|
|
"`PyObject_New`, :c:func:`PyObject_NewVar` and :c:func:`PyObject_Del`."
|
|
msgstr ""
|
|
|
|
#: c-api/memory.rst:738
|
|
msgid ""
|
|
"These will be explained in the next chapter on defining and implementing new "
|
|
"object types in C."
|
|
msgstr ""
|
|
|
|
#~ msgid "``void free(void *ctx, size_t size, void *ptr)``"
|
|
#~ msgstr "``void free(void *ctx, size_t size, void *ptr)``"
|