# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001 Python Software Foundation

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# python-doc bot, 2025

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.15\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2026-09-14 20:17+0000\n"

"PO-Revision-Date: 2025-09-16 00:00+0000\n"

"Last-Translator: python-doc bot, 2025\n"

"Language-Team: German (https://app.transifex.com/python-doc/teams/5390/de/)\n"

"Language: de\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Plural-Forms: nplurals=2; plural=(n != 1);\n"

#: ../../c-api/memory.rst:8

msgid "Memory Management"

msgstr ""

#: ../../c-api/memory.rst:13

msgid "Overview"

msgstr ""

#: ../../c-api/memory.rst:15

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:21

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:32

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:45

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:54

msgid ""

"PyObject *res;\n"

"char *buf = (char *) malloc(BUFSIZ); /* for I/O */\n"

"\n"

"if (buf == NULL)\n"

" return PyErr_NoMemory();\n"

"...Do some I/O operation involving buf...\n"

"res = PyBytes_FromString(buf);\n"

"free(buf); /* malloc'ed */\n"

"return res;"

msgstr ""

#: ../../c-api/memory.rst:64

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:68

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 completely "

"escapes the Python memory manager."

msgstr ""

#: ../../c-api/memory.rst:84

msgid ""

"The :envvar:`PYTHONMALLOC` environment variable can be used to configure the "

"memory allocators used by Python."

msgstr ""

#: ../../c-api/memory.rst:87

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:92

msgid "Allocator Domains"

msgstr ""

#: ../../c-api/memory.rst:96

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:`default-memory-"

"allocators`. The APIs used to allocate and free a block of memory must be "

"from the same domain. For example, :c:func:`PyMem_Free` must be used to free "

"memory allocated using :c:func:`PyMem_Malloc`."

msgstr ""

#: ../../c-api/memory.rst:105

msgid "The three allocation domains are:"

msgstr ""

#: ../../c-api/memory.rst:107

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 an :term:`attached thread state`. The memory "

"is requested directly from the system. See :ref:`Raw Memory Interface <raw-"

"memoryinterface>`."

msgstr ""

#: ../../c-api/memory.rst:112

msgid ""

"\"Mem\" domain: intended for allocating memory for Python buffers and "

"general-purpose memory buffers where the allocation must be performed with "

"an :term:`attached thread state`. The memory is taken from the Python "

"private heap. See :ref:`Memory Interface <memoryinterface>`."

msgstr ""

#: ../../c-api/memory.rst:117

msgid ""

"Object domain: intended for allocating memory for Python objects. The memory "

"is taken from the Python private heap. See :ref:`Object allocators "

"<objectinterface>`."

msgstr ""

#: ../../c-api/memory.rst:122

msgid ""

"The :term:`free-threaded <free threading>` build requires that only Python "

"objects are allocated using the \"object\" domain and that all Python "

"objects are allocated using that domain. This differs from the prior Python "

"versions, where this was only a best practice and not a hard requirement."

msgstr ""

#: ../../c-api/memory.rst:126

msgid ""

"For example, buffers (non-Python objects) should be allocated using :c:func:"

"`PyMem_Malloc`, :c:func:`PyMem_RawMalloc`, or :c:func:`malloc`, but not :c:"

"func:`PyObject_Malloc`."

msgstr ""

#: ../../c-api/memory.rst:129

msgid "See :ref:`Memory Allocation APIs <free-threaded-memory-allocation>`."

msgstr ""

#: ../../c-api/memory.rst:135

msgid "Raw Memory Interface"

msgstr ""

#: ../../c-api/memory.rst:137

msgid ""

"The following function sets are wrappers to the system allocator. These "

"functions are thread-safe, so a :term:`thread state` does not need to be :"

"term:`attached <attached thread state>`."

msgstr ""

#: ../../c-api/memory.rst:141

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:150 ../../c-api/memory.rst:228

#: ../../c-api/memory.rst:361

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:153

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:160 ../../c-api/memory.rst:238

#: ../../c-api/memory.rst:371

msgid ""

"Allocates *nelem* elements each of size *elsize* bytes 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:164

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:173 ../../c-api/memory.rst:251

#: ../../c-api/memory.rst:384

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:176

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:180

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:184

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:190

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:195 ../../c-api/memory.rst:272

#: ../../c-api/memory.rst:405

msgid "If *p* is ``NULL``, no operation is performed."

msgstr ""

#: ../../c-api/memory.rst:201

msgid "Memory Interface"

msgstr ""

#: ../../c-api/memory.rst:203 ../../c-api/memory.rst:340

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:207

msgid ""

"In the GIL-enabled build (default build) the :ref:`default memory allocator "

"<default-memory-allocators>` uses the :ref:`pymalloc memory allocator "

"<pymalloc>`, whereas in the :term:`free-threaded build`, the default is the :"

"ref:`mimalloc memory allocator <mimalloc>` instead."

msgstr ""

#: ../../c-api/memory.rst:215 ../../c-api/memory.rst:357

msgid ""

"There must be an :term:`attached thread state` when using these functions."

msgstr ""

#: ../../c-api/memory.rst:219

msgid ""

"The default allocator is now pymalloc instead of system :c:func:`malloc`."

msgstr ""

#: ../../c-api/memory.rst:223

msgid ""

"In the :term:`free-threaded <free threading>` build, the default allocator "

"is now :ref:`mimalloc <mimalloc>`."

msgstr ""

#: ../../c-api/memory.rst:231

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:242

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:254

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:258

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:261

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:267

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:274

msgid ""

"The following type-oriented macros are provided for convenience. Note that "

"*TYPE* refers to any C type."

msgstr ""

#: ../../c-api/memory.rst:280

msgid ""

"Same as :c:func:`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."

msgstr ""

#: ../../c-api/memory.rst:287

msgid ""

"Same as :c:func:`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."

msgstr ""

#: ../../c-api/memory.rst:292

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:298

msgid "Same as :c:func:`PyMem_Free`."

msgstr ""

#: ../../c-api/memory.rst:302

msgid "Deprecated aliases"

msgstr ""

#: ../../c-api/memory.rst:304

msgid ""

"These are :term:`soft deprecated` aliases to existing functions and macros. "

"They exist solely for backwards compatibility."

msgstr ""

#: ../../c-api/memory.rst:311

msgid "Deprecated alias"

msgstr ""

#: ../../c-api/memory.rst:312

msgid "Corresponding function or macro"

msgstr ""

#: ../../c-api/memory.rst:314

msgid ":c:func:`PyMem_Malloc`"

msgstr ""

#: ../../c-api/memory.rst:316

msgid ":c:macro:`PyMem_New`"

msgstr ""

#: ../../c-api/memory.rst:318 ../../c-api/memory.rst:507

msgid ":c:func:`PyMem_Realloc`"

msgstr ""

#: ../../c-api/memory.rst:320

msgid ":c:macro:`PyMem_Resize`"

msgstr ""

#: ../../c-api/memory.rst:322 ../../c-api/memory.rst:324

#: ../../c-api/memory.rst:509

msgid ":c:func:`PyMem_Free`"

msgstr ""

#: ../../c-api/memory.rst:328

msgid ""

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

msgstr ""

#: ../../c-api/memory.rst:338

msgid "Object allocators"

msgstr ""

#: ../../c-api/memory.rst:345

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:350

msgid ""

"The :ref:`default object allocator <default-memory-allocators>` uses the :"

"ref:`pymalloc memory allocator <pymalloc>`. In the :term:`free-threaded "

"<free threading>` build, the default is the :ref:`mimalloc memory allocator "

"<mimalloc>` instead."

msgstr ""

#: ../../c-api/memory.rst:364

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:375

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:387

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:391

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:394

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:400

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:407

msgid ""

"Do not call this directly to free an object's memory; call the type's :c:"

"member:`~PyTypeObject.tp_free` slot instead."

msgstr ""

#: ../../c-api/memory.rst:410

msgid ""

"Do not use this for memory allocated by :c:macro:`PyObject_GC_New` or :c:"

"macro:`PyObject_GC_NewVar`; use :c:func:`PyObject_GC_Del` instead."

msgstr ""

#: ../../c-api/memory.rst:415

msgid ""

":c:func:`PyObject_GC_Del` is the equivalent of this function for memory "

"allocated by types that support garbage collection."

msgstr ""

#: ../../c-api/memory.rst:417 ../../c-api/memory.rst:515

msgid ":c:func:`PyObject_Malloc`"

msgstr ""

#: ../../c-api/memory.rst:418 ../../c-api/memory.rst:516

msgid ":c:func:`PyObject_Realloc`"

msgstr ""

#: ../../c-api/memory.rst:419 ../../c-api/memory.rst:517

msgid ":c:func:`PyObject_Calloc`"

msgstr ""

#: ../../c-api/memory.rst:420

msgid ":c:macro:`PyObject_New`"

msgstr ""

#: ../../c-api/memory.rst:421

msgid ":c:macro:`PyObject_NewVar`"

msgstr ""

#: ../../c-api/memory.rst:422

msgid ":c:func:`PyType_GenericAlloc`"

msgstr ""

#: ../../c-api/memory.rst:423

msgid ":c:member:`~PyTypeObject.tp_free`"

msgstr ""

#: ../../c-api/memory.rst:429

msgid "Default Memory Allocators"

msgstr ""

#: ../../c-api/memory.rst:431

msgid "Default memory allocators:"

msgstr ""

#: ../../c-api/memory.rst:434

msgid "Configuration"

msgstr ""

#: ../../c-api/memory.rst:434

msgid "Name"

msgstr "Name"

#: ../../c-api/memory.rst:434

msgid "PyMem_RawMalloc"

msgstr ""

#: ../../c-api/memory.rst:434

msgid "PyMem_Malloc"

msgstr ""

#: ../../c-api/memory.rst:434

msgid "PyObject_Malloc"

msgstr ""

#: ../../c-api/memory.rst:436

msgid "Release build"

msgstr ""

#: ../../c-api/memory.rst:436

msgid "``\"pymalloc\"``"

msgstr ""

#: ../../c-api/memory.rst:436 ../../c-api/memory.rst:438

msgid "``malloc``"

msgstr ""

#: ../../c-api/memory.rst:436

msgid "``pymalloc``"

msgstr ""

#: ../../c-api/memory.rst:437

msgid "Debug build"

msgstr ""

#: ../../c-api/memory.rst:437

msgid "``\"pymalloc_debug\"``"

msgstr ""

#: ../../c-api/memory.rst:437 ../../c-api/memory.rst:439

msgid "``malloc`` + debug"

msgstr ""

#: ../../c-api/memory.rst:437

msgid "``pymalloc`` + debug"

msgstr ""

#: ../../c-api/memory.rst:438

msgid "Release build, without pymalloc"

msgstr ""

#: ../../c-api/memory.rst:438

msgid "``\"malloc\"``"

msgstr ""

#: ../../c-api/memory.rst:439

msgid "Debug build, without pymalloc"

msgstr ""

#: ../../c-api/memory.rst:439

msgid "``\"malloc_debug\"``"

msgstr ""

#: ../../c-api/memory.rst:440

msgid "Free-threaded build"

msgstr ""

#: ../../c-api/memory.rst:440

msgid "``\"mimalloc\"``"

msgstr ""

#: ../../c-api/memory.rst:440

msgid "``mimalloc``"

msgstr ""

#: ../../c-api/memory.rst:441

msgid "Free-threaded debug build"

msgstr ""

#: ../../c-api/memory.rst:441

msgid "``\"mimalloc_debug\"``"

msgstr ""

#: ../../c-api/memory.rst:441

msgid "``mimalloc`` + debug"

msgstr ""

#: ../../c-api/memory.rst:444

msgid "Legend:"

msgstr ""

#: ../../c-api/memory.rst:446

msgid "Name: value for :envvar:`PYTHONMALLOC` environment variable."

msgstr ""

#: ../../c-api/memory.rst:447

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:449

msgid "``pymalloc``: :ref:`pymalloc memory allocator <pymalloc>`."

msgstr ""

#: ../../c-api/memory.rst:450

msgid "``mimalloc``: :ref:`mimalloc memory allocator <mimalloc>`."

msgstr ""

#: ../../c-api/memory.rst:451

msgid ""

"\"+ debug\": with :ref:`debug hooks on the Python memory allocators <pymem-"

"debug-hooks>`."

msgstr ""

#: ../../c-api/memory.rst:453

msgid "\"Debug build\": :ref:`Python build in debug mode <debug-build>`."

msgstr ""

#: ../../c-api/memory.rst:458

msgid "Customize Memory Allocators"

msgstr ""

#: ../../c-api/memory.rst:464

msgid ""

"Structure used to describe a memory block allocator. The structure has the "

"following fields:"

msgstr ""

#: ../../c-api/memory.rst:468 ../../c-api/memory.rst:723

msgid "Field"

msgstr ""

#: ../../c-api/memory.rst:468 ../../c-api/memory.rst:723

msgid "Meaning"

msgstr ""

#: ../../c-api/memory.rst:470 ../../c-api/memory.rst:725

msgid "``void *ctx``"

msgstr ""

#: ../../c-api/memory.rst:470 ../../c-api/memory.rst:725

msgid "user context passed as first argument"

msgstr ""

#: ../../c-api/memory.rst:472

msgid "``void* malloc(void *ctx, size_t size)``"

msgstr ""

#: ../../c-api/memory.rst:472

msgid "allocate a memory block"

msgstr ""

#: ../../c-api/memory.rst:474

msgid "``void* calloc(void *ctx, size_t nelem, size_t elsize)``"

msgstr ""

#: ../../c-api/memory.rst:474

msgid "allocate a memory block initialized with zeros"

msgstr ""

#: ../../c-api/memory.rst:477

msgid "``void* realloc(void *ctx, void *ptr, size_t new_size)``"

msgstr ""

#: ../../c-api/memory.rst:477

msgid "allocate or resize a memory block"

msgstr ""

#: ../../c-api/memory.rst:479

msgid "``void free(void *ctx, void *ptr)``"

msgstr ""

#: ../../c-api/memory.rst:479

msgid "free a memory block"

msgstr ""

#: ../../c-api/memory.rst:482

msgid ""

"The :c:type:`!PyMemAllocator` structure was renamed to :c:type:"

"`PyMemAllocatorEx` and a new ``calloc`` field was added."

msgstr ""

#: ../../c-api/memory.rst:489

msgid "Enum used to identify an allocator domain. Domains:"

msgstr ""

#: ../../c-api/memory.rst:495 ../../c-api/memory.rst:504

#: ../../c-api/memory.rst:513

msgid "Functions:"

msgstr ""

#: ../../c-api/memory.rst:497

msgid ":c:func:`PyMem_RawMalloc`"

msgstr ""

#: ../../c-api/memory.rst:498

msgid ":c:func:`PyMem_RawRealloc`"

msgstr ""

#: ../../c-api/memory.rst:499

msgid ":c:func:`PyMem_RawCalloc`"

msgstr ""

#: ../../c-api/memory.rst:500

msgid ":c:func:`PyMem_RawFree`"

msgstr ""

#: ../../c-api/memory.rst:506

msgid ":c:func:`PyMem_Malloc`,"

msgstr ""

#: ../../c-api/memory.rst:508

msgid ":c:func:`PyMem_Calloc`"

msgstr ""

#: ../../c-api/memory.rst:518

msgid ":c:func:`PyObject_Free`"

msgstr ""

#: ../../c-api/memory.rst:522

msgid "Get the memory block allocator of the specified domain."

msgstr ""

#: ../../c-api/memory.rst:527

msgid "Set the memory block allocator of the specified domain."

msgstr ""

#: ../../c-api/memory.rst:529

msgid ""

"The new allocator must return a distinct non-``NULL`` pointer when "

"requesting zero bytes."

msgstr ""

#: ../../c-api/memory.rst:532

msgid ""

"For the :c:macro:`PYMEM_DOMAIN_RAW` domain, the allocator must be thread-"

"safe: a :term:`thread state` is not :term:`attached <attached thread state>` "

"when the allocator is called."

msgstr ""

#: ../../c-api/memory.rst:536

msgid ""

"For the remaining domains, the allocator must also be thread-safe: the "

"allocator may be called in different interpreters that do not share a :term:"

"`GIL`."

msgstr ""

#: ../../c-api/memory.rst:540

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:544

msgid ""

"See also :c:member:`PyPreConfig.allocator` and :ref:`Preinitialize Python "

"with PyPreConfig <c-preinit>`."

msgstr ""

#: ../../c-api/memory.rst:549

msgid ":c:func:`PyMem_SetAllocator` does have the following contract:"

msgstr ""

#: ../../c-api/memory.rst:551

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 an :term:`attached thread state`). See :ref:`the section on "

"allocator domains <allocator-domains>` for more information."

msgstr ""

#: ../../c-api/memory.rst:559

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:564

msgid "All allocators must be thread-safe."

msgstr ""

#: ../../c-api/memory.rst:570

msgid ""

"Setup :ref:`debug hooks in the Python memory allocators <pymem-debug-hooks>` "

"to detect memory errors."

msgstr ""

#: ../../c-api/memory.rst:577

msgid "Debug hooks on the Python memory allocators"

msgstr ""

#: ../../c-api/memory.rst:579

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:584

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:587

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:590

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:597

msgid "Runtime checks:"

msgstr ""

#: ../../c-api/memory.rst:599

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:601

msgid "Detect write before the start of the buffer (buffer underflow)."

msgstr ""

#: ../../c-api/memory.rst:602

msgid "Detect write after the end of the buffer (buffer overflow)."

msgstr ""

#: ../../c-api/memory.rst:603

msgid ""

"Check that there is an :term:`attached thread state` when allocator "

"functions of :c:macro:`PYMEM_DOMAIN_OBJ` (ex: :c:func:`PyObject_Malloc`) "

"and :c:macro:`PYMEM_DOMAIN_MEM` (ex: :c:func:`PyMem_Malloc`) domains are "

"called."

msgstr ""

#: ../../c-api/memory.rst:608

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:613

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:619

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

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

#: ../../c-api/memory.rst:620

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:622

msgid "``p[-S]``"

msgstr "``p[-S]``"

#: ../../c-api/memory.rst:623

msgid "API identifier (ASCII character):"

msgstr ""

#: ../../c-api/memory.rst:625

msgid "``'r'`` for :c:macro:`PYMEM_DOMAIN_RAW`."

msgstr ""

#: ../../c-api/memory.rst:626

msgid "``'m'`` for :c:macro:`PYMEM_DOMAIN_MEM`."

msgstr ""

#: ../../c-api/memory.rst:627

msgid "``'o'`` for :c:macro:`PYMEM_DOMAIN_OBJ`."

msgstr ""

#: ../../c-api/memory.rst:629

msgid "``p[-S+1:0]``"

msgstr "``p[-S+1:0]``"

#: ../../c-api/memory.rst:630

msgid "Copies of PYMEM_FORBIDDENBYTE. Used to catch under- writes and reads."

msgstr ""

#: ../../c-api/memory.rst:632

msgid "``p[0:N]``"

msgstr ""

#: ../../c-api/memory.rst:633

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:641

msgid "``p[N:N+S]``"

msgstr ""

#: ../../c-api/memory.rst:642

msgid "Copies of PYMEM_FORBIDDENBYTE. Used to catch over- writes and reads."

msgstr ""

#: ../../c-api/memory.rst:644

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

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

#: ../../c-api/memory.rst:645

msgid ""

"Only used if the ``PYMEM_DEBUG_SERIALNO`` macro is defined (not defined by "

"default)."

msgstr ""

#: ../../c-api/memory.rst:648

msgid ""

"A serial number, incremented by 1 on each call to a malloc-like or realloc-"

"like function. Big-endian :c:type:`size_t`. If \"bad memory\" is detected "

"later, the serial number gives an excellent way to set a breakpoint on the "