新函数和结构

• 添加新的 GIL-free（无需持有 GIL）内存分配器
  • void* PyMem_RawMalloc(size_t size)
  • void* PyMem_RawRealloc(void *ptr, size_t new_size)
  • void PyMem_RawFree(void *ptr)
  • 新分配的内存将不会以任何方式初始化。
  • 如果可能，请求零字节会返回一个不同的非 NULL 指针，就像调用了 PyMem_Malloc(1) 一样。
• 添加新的 PyMemAllocator 结构

  typedef struct {
      /* user context passed as the first argument to the 3 functions */
      void *ctx;
  
      /* allocate a memory block */
      void* (*malloc) (void *ctx, size_t size);
  
      /* allocate or resize a memory block */
      void* (*realloc) (void *ctx, void *ptr, size_t new_size);
  
      /* release a memory block */
      void (*free) (void *ctx, void *ptr);
  } PyMemAllocator;
  

• 添加新的 PyMemAllocatorDomain 枚举以选择 Python 分配器域。域
  • PYMEM_DOMAIN_RAW: PyMem_RawMalloc()、PyMem_RawRealloc() 和 PyMem_RawFree()
  • PYMEM_DOMAIN_MEM: PyMem_Malloc()、PyMem_Realloc() 和 PyMem_Free()
  • PYMEM_DOMAIN_OBJ: PyObject_Malloc()、PyObject_Realloc() 和 PyObject_Free()
• 添加新的函数以获取和设置内存块分配器
  • void PyMem_GetAllocator(PyMemAllocatorDomain domain, PyMemAllocator *allocator)
  • void PyMem_SetAllocator(PyMemAllocatorDomain domain, PyMemAllocator *allocator)
  • 新分配器在请求零字节时必须返回一个不同的非 NULL 指针
  • 对于 PYMEM_DOMAIN_RAW 域，分配器必须是线程安全的：在调用分配器时不会持有 GIL。
• 添加新的 PyObjectArenaAllocator 结构

  typedef struct {
      /* user context passed as the first argument to the 2 functions */
      void *ctx;
  
      /* allocate an arena */
      void* (*alloc) (void *ctx, size_t size);
  
      /* release an arena */
      void (*free) (void *ctx, void *ptr, size_t size);
  } PyObjectArenaAllocator;
  

• 添加新的函数以获取和设置 pymalloc 使用的竞技场分配器
  • void PyObject_GetArenaAllocator(PyObjectArenaAllocator *allocator)
  • void PyObject_SetArenaAllocator(PyObjectArenaAllocator *allocator)
• 添加一个新函数，用于在内存分配器被 PyMem_SetAllocator() 替换时重新安装内存分配器上的调试检查
  • void PyMem_SetupDebugHooks(void)
  • 在所有内存块分配器上安装调试钩子。该函数可以多次调用，钩子只安装一次。
  • 如果 Python 未以调试模式编译，该函数不执行任何操作。
• 如果 size 大于 PY_SSIZE_T_MAX，内存块分配器总是返回 NULL。在调用内部函数之前进行检查。

下面是默认情况下分配器的设置方式

• PYMEM_DOMAIN_RAW, PYMEM_DOMAIN_MEM: malloc(), realloc() 和 free(); 请求零字节时调用 malloc(1)
• PYMEM_DOMAIN_OBJ: pymalloc 分配器，对于大于 512 字节的分配，回退到 PyMem_Malloc()
• pymalloc 竞技场分配器：在 Windows 上是 VirtualAlloc() 和 VirtualFree()，可用时是 mmap() 和 munmap()，否则是 malloc() 和 free()

将内存块分配器上的调试检查重新设计为钩子

自 Python 2.3 以来，Python 在调试模式下对内存分配器实施了不同的检查

• 新分配的内存用字节 0xCB 填充，释放的内存用字节 0xDB 填充。
• 检测 API 违规，例如：在 PyMem_Malloc() 分配的内存块上调用 PyObject_Free()
• 检测缓冲区开始前写入（缓冲区下溢）
• 检测缓冲区结束后写入（缓冲区溢出）

在 Python 3.3 中，通过使用宏替换 PyMem_Malloc()、PyMem_Realloc()、PyMem_Free()、PyObject_Malloc()、PyObject_Realloc() 和 PyObject_Free() 来安装这些检查。新的分配器分配一个更大的缓冲区，并写入一个模式以检测缓冲区下溢、缓冲区溢出和释放后使用（通过用字节 0xDB 填充缓冲区）。它使用原始的 PyObject_Malloc() 函数来分配内存。因此，PyMem_Malloc() 和 PyMem_Realloc() 间接调用 PyObject_Malloc() 和 PyObject_Realloc()。

本 PEP 将调试检查重新设计为调试模式下现有分配器上的钩子。没有钩子时的调用跟踪示例

• PyMem_RawMalloc() => _PyMem_RawMalloc() => malloc()
• PyMem_Realloc() => _PyMem_RawRealloc() => realloc()
• PyObject_Free() => _PyObject_Free()

安装钩子后的调用跟踪（调试模式）

• PyMem_RawMalloc() => _PyMem_DebugMalloc() => _PyMem_RawMalloc() => malloc()
• PyMem_Realloc() => _PyMem_DebugRealloc() => _PyMem_RawRealloc() => realloc()
• PyObject_Free() => _PyMem_DebugFree() => _PyObject_Free()

结果是，PyMem_Malloc() 和 PyMem_Realloc() 现在在发布模式和调试模式下都调用 malloc() 和 realloc()，而不是在调试模式下调用 PyObject_Malloc() 和 PyObject_Realloc()。

当至少一个内存分配器被 PyMem_SetAllocator() 替换时，必须调用 PyMem_SetupDebugHooks() 函数，以便在新分配器之上重新安装调试钩子。

不再直接调用 malloc()

PyObject_Malloc() 回退到 PyMem_Malloc() 而不是 malloc()，如果大小大于或等于 512 字节，并且 PyObject_Realloc() 回退到 PyMem_Realloc() 而不是 realloc()

直接调用 malloc() 被替换为 PyMem_Malloc()，如果 GIL 没有被持有，则替换为 PyMem_RawMalloc()。

可以配置诸如 zlib 或 OpenSSL 之类的外部库使用 PyMem_Malloc() 或 PyMem_RawMalloc() 分配内存。如果库的分配器只能全局替换（而不是逐对象替换），则在 Python 嵌入到应用程序中时，不应替换它。

对于“跟踪内存使用情况”用例，跟踪外部库中分配的内存以获得准确的报告非常重要，因为这些分配可能很大（例如，它们可能引发 MemoryError 异常），否则将在内存使用报告中遗漏。

用例 1：替换内存分配器，保留 pymalloc

每次内存块浪费 2 字节，每个 pymalloc 竞技场浪费 10 字节的虚拟示例

#include <stdlib.h>

size_t alloc_padding = 2;
size_t arena_padding = 10;

void* my_malloc(void *ctx, size_t size)
{
    int padding = *(int *)ctx;
    return malloc(size + padding);
}

void* my_realloc(void *ctx, void *ptr, size_t new_size)
{
    int padding = *(int *)ctx;
    return realloc(ptr, new_size + padding);
}

void my_free(void *ctx, void *ptr)
{
    free(ptr);
}

void* my_alloc_arena(void *ctx, size_t size)
{
    int padding = *(int *)ctx;
    return malloc(size + padding);
}

void my_free_arena(void *ctx, void *ptr, size_t size)
{
    free(ptr);
}

void setup_custom_allocator(void)
{
    PyMemAllocator alloc;
    PyObjectArenaAllocator arena;

    alloc.ctx = &alloc_padding;
    alloc.malloc = my_malloc;
    alloc.realloc = my_realloc;
    alloc.free = my_free;

    PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &alloc);
    PyMem_SetAllocator(PYMEM_DOMAIN_MEM, &alloc);
    /* leave PYMEM_DOMAIN_OBJ unchanged, use pymalloc */

    arena.ctx = &arena_padding;
    arena.alloc = my_alloc_arena;
    arena.free = my_free_arena;
    PyObject_SetArenaAllocator(&arena);

    PyMem_SetupDebugHooks();
}

用例 2：替换内存分配器，覆盖 pymalloc

如果您有一个专用的分配器，针对小于 512 字节且生命周期短的对象分配进行了优化，那么可以覆盖 pymalloc（替换 PyObject_Malloc()）。

每次内存块浪费 2 字节的虚拟示例

#include <stdlib.h>

size_t padding = 2;

void* my_malloc(void *ctx, size_t size)
{
    int padding = *(int *)ctx;
    return malloc(size + padding);
}

void* my_realloc(void *ctx, void *ptr, size_t new_size)
{
    int padding = *(int *)ctx;
    return realloc(ptr, new_size + padding);
}

void my_free(void *ctx, void *ptr)
{
    free(ptr);
}

void setup_custom_allocator(void)
{
    PyMemAllocator alloc;
    alloc.ctx = &padding;
    alloc.malloc = my_malloc;
    alloc.realloc = my_realloc;
    alloc.free = my_free;

    PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &alloc);
    PyMem_SetAllocator(PYMEM_DOMAIN_MEM, &alloc);
    PyMem_SetAllocator(PYMEM_DOMAIN_OBJ, &alloc);

    PyMem_SetupDebugHooks();
}

不需要替换 pymalloc 竞技场，因为它不再被新分配器使用。

用例 3：在内存块分配器上设置钩子

在所有内存块分配器上设置钩子的示例

struct {
    PyMemAllocator raw;
    PyMemAllocator mem;
    PyMemAllocator obj;
    /* ... */
} hook;

static void* hook_malloc(void *ctx, size_t size)
{
    PyMemAllocator *alloc = (PyMemAllocator *)ctx;
    void *ptr;
    /* ... */
    ptr = alloc->malloc(alloc->ctx, size);
    /* ... */
    return ptr;
}

static void* hook_realloc(void *ctx, void *ptr, size_t new_size)
{
    PyMemAllocator *alloc = (PyMemAllocator *)ctx;
    void *ptr2;
    /* ... */
    ptr2 = alloc->realloc(alloc->ctx, ptr, new_size);
    /* ... */
    return ptr2;
}

static void hook_free(void *ctx, void *ptr)
{
    PyMemAllocator *alloc = (PyMemAllocator *)ctx;
    /* ... */
    alloc->free(alloc->ctx, ptr);
    /* ... */
}

void setup_hooks(void)
{
    PyMemAllocator alloc;
    static int installed = 0;

    if (installed)
        return;
    installed = 1;

    alloc.malloc = hook_malloc;
    alloc.realloc = hook_realloc;
    alloc.free = hook_free;
    PyMem_GetAllocator(PYMEM_DOMAIN_RAW, &hook.raw);
    PyMem_GetAllocator(PYMEM_DOMAIN_MEM, &hook.mem);
    PyMem_GetAllocator(PYMEM_DOMAIN_OBJ, &hook.obj);

    alloc.ctx = &hook.raw;
    PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &alloc);

    alloc.ctx = &hook.mem;
    PyMem_SetAllocator(PYMEM_DOMAIN_MEM, &alloc);

    alloc.ctx = &hook.obj;
    PyMem_SetAllocator(PYMEM_DOMAIN_OBJ, &alloc);
}

更具体的获取/设置内存分配器的函数

最初提议了一组更大的 C API 函数，每个分配器域都有一对函数

• void PyMem_GetRawAllocator(PyMemAllocator *allocator)
• void PyMem_GetAllocator(PyMemAllocator *allocator)
• void PyObject_GetAllocator(PyMemAllocator *allocator)
• void PyMem_SetRawAllocator(PyMemAllocator *allocator)
• void PyMem_SetAllocator(PyMemAllocator *allocator)
• void PyObject_SetAllocator(PyMemAllocator *allocator)

此替代方案被拒绝，因为使用更具体的函数无法编写通用代码：每个内存分配器域都必须复制代码。

默认情况下使 PyMem_Malloc() 重用 PyMem_RawMalloc()

如果 PyMem_Malloc() 默认调用 PyMem_RawMalloc()，那么调用 PyMem_SetAllocator(PYMEM_DOMAIN_RAW, alloc) 也将间接修补 PyMem_Malloc()。

此替代方案被拒绝，因为 PyMem_SetAllocator() 将根据域具有不同的行为。始终保持相同的行为更不容易出错。

添加新的 PYDEBUGMALLOC 环境变量

有人提议添加一个新的 PYDEBUGMALLOC 环境变量，以启用内存块分配器上的调试检查。它将与调用 PyMem_SetupDebugHooks() 具有相同的效果，而无需编写任何 C 代码。另一个优点是即使在发布模式下也可以启用调试检查：调试检查将始终被编译进去，但只有当环境变量存在且非空时才启用。

这个替代方案被拒绝了，因为新的环境变量会使 Python 初始化更加复杂。PEP 432 试图简化 CPython 的启动序列。

使用宏获取可自定义的分配器

为了在默认配置下没有开销，可定制的分配器将是一个可选功能，通过配置选项或宏启用。

此替代方案被拒绝，因为使用宏意味着必须重新编译扩展模块才能使用新的分配器和分配器钩子。无需重新编译 Python 和扩展模块使得调试钩子在实践中更易于使用。

传递 C 文件名和行号

使用 __FILE__ 和 __LINE__ 将分配器函数定义为宏，以获取内存分配的 C 文件名和行号。

修改后的 PyMemAllocator 结构的 PyMem_Malloc 宏示例

typedef struct {
    /* user context passed as the first argument
       to the 3 functions */
    void *ctx;

    /* allocate a memory block */
    void* (*malloc) (void *ctx, const char *filename, int lineno,
                     size_t size);

    /* allocate or resize a memory block */
    void* (*realloc) (void *ctx, const char *filename, int lineno,
                      void *ptr, size_t new_size);

    /* release a memory block */
    void (*free) (void *ctx, const char *filename, int lineno,
                  void *ptr);
} PyMemAllocator;

void* _PyMem_MallocTrace(const char *filename, int lineno,
                         size_t size);

/* the function is still needed for the Python stable ABI */
void* PyMem_Malloc(size_t size);

#define PyMem_Malloc(size) \
        _PyMem_MallocTrace(__FILE__, __LINE__, size)

GC 分配器函数也必须打补丁。例如，_PyObject_GC_Malloc() 在许多 C 函数中使用，因此不同类型的对象将具有相同的分配位置。

此替代方案被拒绝，因为向每个分配器传递文件名和行号会使 API 更加复杂：向每个分配器函数传递 3 个新参数（ctx、filename、lineno），而不是仅仅一个上下文参数（ctx）。还需要修改 GC 分配器函数，这会增加太多复杂性，而收益却很小。

GIL-free PyMem_Malloc()

在 Python 3.3 中，当 Python 以调试模式编译时，PyMem_Malloc() 间接调用 PyObject_Malloc()，这需要持有 GIL（它不是线程安全的）。这就是为什么 PyMem_Malloc() 必须在持有 GIL 的情况下调用。

本 PEP 更改了 PyMem_Malloc()：它现在总是调用 malloc() 而不是 PyObject_Malloc()。因此，可以从 PyMem_Malloc() 中移除“必须持有 GIL”的限制。

此替代方案被拒绝，因为允许在不持有 GIL 的情况下调用 PyMem_Malloc() 可能会破坏设置其自己的分配器或分配器钩子的应用程序。持有 GIL 对于开发自定义分配器很方便：无需关心其他线程。对于调试分配器钩子也很方便：Python 对象可以安全地检查，并且 C API 可以用于报告。

此外，在内存分配器中调用 PyGILState_Ensure() 会产生意外行为，尤其是在 Python 启动和创建新的 Python 线程状态时。最好将获取 GIL 的责任从自定义分配器中解放出来。

不添加 PyMem_RawMalloc()

将 malloc() 替换为 PyMem_Malloc()，但仅在持有 GIL 的情况下。否则，保持 malloc() 不变。

在某些 Python 函数中，PyMem_Malloc() 在没有持有 GIL 的情况下使用。例如，Python 的 main() 和 Py_Main() 函数调用 PyMem_Malloc()，而 GIL 尚不存在。在这种情况下，PyMem_Malloc() 将被替换为 malloc()（或 PyMem_RawMalloc()）。

此替代方案被拒绝，因为 PyMem_RawMalloc() 对于准确的内存使用报告是必需的。当使用调试钩子跟踪内存使用情况时，无法跟踪直接调用 malloc() 分配的内存。PyMem_RawMalloc() 可以被钩住，因此可以跟踪 Python 分配的所有内存，包括在不持有 GIL 的情况下分配的内存。

使用现有调试工具分析内存使用情况

有许多现有的调试工具可用于分析内存使用情况。一些例子：Valgrind、Purify、Clang AddressSanitizer、failmalloc 等。

问题是如何检索与内存指针相关的 Python 对象以读取其类型和/或内容。另一个问题是检索内存分配的来源：C 回溯通常无用（与使用 __FILE__ 和 __LINE__ 的宏的理由相同，参见传递 C 文件名和行号），Python 文件名和行号（甚至 Python 回溯）更有用。

此替代方案被拒绝，因为经典工具无法内省 Python 内部以收集此类信息。能够在持有 GIL 的情况下设置分配器钩子可以收集大量来自 Python 内部的有用数据。

添加一个 msize() 函数

向 PyMemAllocator 和 PyObjectArenaAllocator 结构添加另一个函数

size_t msize(void *ptr);

此函数返回内存块或内存映射的大小。如果函数未实现或指针未知（例如：NULL 指针），则返回 (size_t)-1。

在 Windows 上，此函数可以使用 _msize() 和 VirtualQuery() 实现。

该函数可用于实现跟踪内存使用情况的钩子。分配器的 free() 方法只获取内存块的地址，而更新内存使用情况需要内存块的大小。

额外的 msize() 函数被拒绝，因为只有少数平台实现了它。例如，带 GNU libc 的 Linux 不提供获取内存块大小的函数。msize() 目前未在 Python 源代码中使用。该函数只用于跟踪内存使用，并使 API 更加复杂。调试钩子可以在内部实现该函数，无需将其添加到 PyMemAllocator 和 PyObjectArenaAllocator 结构中。

没有上下文参数

简化分配器函数的签名，移除上下文参数

• void* malloc(size_t size)
• void* realloc(void *ptr, size_t new_size)
• void free(void *ptr)

分配器钩子很可能被 PyMem_SetAllocator() 和 PyObject_SetAllocator()，甚至 PyMem_SetRawAllocator() 重用，但钩子必须根据分配器调用不同的函数。上下文是一种方便的方法，可以为不同的 Python 分配器重用相同的自定义分配器或钩子。

在 C++ 中，上下文可以用来传递 this。