32位Ubuntu下Python如何替代mmap实现类posix_memalign内存对齐缓冲区

嗨，我完全懂你遇到的这个头疼问题——32位Linux系统的用户空间虚拟地址本来就只有2GB左右，用mmap(MAP_SHARED)每次分配都会占用独立的虚拟内存区域（VMA），很快就把有限的地址空间耗尽了，所以循环到77次就卡壳了。下面给你两个实用的替代方案，分别对应不同的需求场景：

方案1：直接调用C标准库的posix_memalign（非共享内存场景） #

如果你的内存缓冲区不需要在进程间共享，最直接的方法是通过ctypes调用C标准库的posix_memalign函数。它会在进程的堆空间里分配对齐内存，所有分配都共享同一个虚拟地址池，不会像mmap那样快速耗尽地址空间。

示例代码：

import ctypes
import ctypes.util

# 加载系统C标准库
libc = ctypes.CDLL(ctypes.util.find_library('c'), use_errno=True)

# 定义posix_memalign的函数参数和返回值类型
libc.posix_memalign.argtypes = [ctypes.POINTER(ctypes.c_void_p), ctypes.c_size_t, ctypes.c_size_t]
libc.posix_memalign.restype = ctypes.c_int

# 配置参数：每个缓冲区25MB，对齐到4096字节（页大小）
BUF_SIZE = 50 * 512 * 1024
ALIGNMENT = 4096

def get_aligned_buffer(size, align):
    # 检查对齐要求是否合法：必须是2的幂，且不小于指针大小
    if (align & (align - 1)) != 0 or align < ctypes.sizeof(ctypes.c_void_p):
        raise ValueError("Alignment must be a power of two and >= sizeof(void*)")
    
    ptr = ctypes.c_void_p()
    # 调用posix_memalign分配内存
    ret_code = libc.posix_memalign(ctypes.byref(ptr), align, size)
    if ret_code != 0:
        raise OSError(ctypes.get_errno(), f"posix_memalign failed with error code {ret_code}")
    
    # 将指针转换为可操作的字节数组视图
    buffer = ctypes.cast(ptr, ctypes.POINTER(ctypes.c_char * size)).contents
    # 初始化内存为0
    ctypes.memset(buffer, 0, size)
    # 返回缓冲区和原始指针（用于后续释放）
    return buffer, ptr

# 测试分配
buffers = []
for idx in range(4096):
    try:
        buf, ptr = get_aligned_buffer(BUF_SIZE, ALIGNMENT)
        buffers.append((buf, ptr))
    except Exception as e:
        print(f"分配失败，第{idx}次循环: {str(e)}")
        break

# 记得用完后释放内存！
for buf, ptr in buffers:
    libc.free(ptr)

这个方案的优势是内存利用率高，所有分配都在堆空间内，不会产生大量独立的VMA，能在32位系统的2GB用户空间里分配更多对齐缓冲区。

方案2：大内存块划分（共享内存场景） #

如果你的缓冲区需要在进程间共享，那可以先创建一个超大的共享mmap块，然后在这个块内部划分多个对齐的子缓冲区。这样只占用一个VMA，避免了多次mmap导致的地址空间碎片化问题。

示例代码：

import mmap

# 配置参数：单个缓冲区25MB，总大小设为1.9GB（给系统留足空间）
MAX_TOTAL_SIZE = 1900 * 1024 * 1024
BUF_SIZE = 50 * 512 * 1024
ALIGNMENT = 4096

# 创建一个大的匿名共享内存块
large_shared_buf = mmap.mmap(-1, MAX_TOTAL_SIZE, mmap.MAP_SHARED)

def get_shared_aligned_subbuf(index):
    offset = index * BUF_SIZE
    # 确保偏移量是对齐的（这里BUF_SIZE是25MB，已经是4096的倍数）
    assert offset % ALIGNMENT == 0
    if offset + BUF_SIZE > MAX_TOTAL_SIZE:
        raise ValueError("超出大内存块的总容量")
    # 返回memoryview视图，支持读写操作
    sub_buf = memoryview(large_shared_buf)[offset:offset+BUF_SIZE]
    # 初始化0
    sub_buf[:] = b'\0' * BUF_SIZE
    return sub_buf

# 测试分配
shared_buffers = []
for idx in range(4096):
    try:
        sub_buf = get_shared_aligned_subbuf(idx)
        shared_buffers.append(sub_buf)
    except Exception as e:
        print(f"分配失败，第{idx}次循环: {str(e)}")
        break

# 用完后关闭大内存块
large_shared_buf.close()

这个方案通过复用单个大共享内存块，最大化利用了32位系统的有限虚拟地址空间，能分配远多于77个的对齐缓冲区。

总结一下：

• 不需要共享内存：优先用ctypes调用posix_memalign，简单高效。
• 需要共享内存：用大内存块划分的方式，避免多次mmap的地址空间浪费。

内容的提问来源于stack exchange，提问作者code_worker