内存管理器 API

内存管理的完整参考文档。

类定义

class MemoryManager {
public:
    static MemoryManager& getInstance();

    // 页锁定主机内存
    void* allocatePinned(size_t size);
    void freePinned(void* ptr);

    // 设备内存
    void* allocateDevice(size_t size);
    void freeDevice(void* ptr);

    // 异步传输
    cudaError_t copyToDeviceAsync(void* dst, const void* src, 
                                  size_t size, cudaStream_t stream);
    cudaError_t copyToHostAsync(void* dst, const void* src, 
                                size_t size, cudaStream_t stream);

    // 内存池管理
    void setPinnedPoolSize(size_t size);
    void setDevicePoolSize(size_t size);

    // 分配器模式 (v2)
    void setDeviceAllocatorMode(DeviceAllocatorMode mode);
    DeviceAllocatorMode getRequestedDeviceAllocatorMode() const;
    DeviceAllocatorMode getEffectiveDeviceAllocatorMode() const;
    bool supportsAsyncDeviceAllocator() const;

    // 清理
    void shutdown();
};

方法

单例访问

MemoryManager& mm = MemoryManager::getInstance();

页锁定内存

页锁定（page-locked）内存可实现更快的 DMA 传输：

void* h_data = mm.allocatePinned(size);
// ... 使用内存 ...
mm.freePinned(h_data);

设备内存

void* d_data = mm.allocateDevice(size);
// ... 使用内存 ...
mm.freeDevice(d_data);

异步传输

cudaStream_t stream;
cudaStreamCreate(&stream);

// 主机到设备
mm.copyToDeviceAsync(d_data, h_data, size, stream);

// 设备到主机
mm.copyToHostAsync(h_data, d_data, size, stream);

cudaStreamSynchronize(stream);

内存池配置

MemoryManager& mm = MemoryManager::getInstance();

// 在首次分配前配置内存池大小
mm.setPinnedPoolSize(128 * 1024 * 1024);  // 128MB
mm.setDevicePoolSize(512 * 1024 * 1024);  // 512MB

线程安全

MemoryManager 是线程安全的。所有方法都可以从多个线程并发调用。

最佳适应分配

内存管理器使用最佳适应分配策略：

1. 搜索能满足请求的最小块
2. 必要时分割较大的块
3. 释放时合并相邻的空闲块
4. 随时间推移最小化碎片化

内存池架构

┌─────────────────────────────────────────────────────────────┐
│                    MemoryManager                             │
├─────────────────────────────────────────────────────────────┤
│  页锁定内存池                 │  设备内存池                   │
│  ┌─────────────────────┐     │  ┌─────────────────────┐     │
│  │ Block 1 (256KB)     │     │  │ Block 1 (1MB)       │     │
│  │ Block 2 (512KB)     │     │  │ Block 2 (2MB)       │     │
│  │ Block 3 (1MB)       │     │  │ Block 3 (4MB)       │     │
│  │ ...                 │     │  │ ...                 │     │
│  └─────────────────────┘     │  └─────────────────────┘     │
├─────────────────────────────────────────────────────────────┤
│  优势:                                                       │
│  • 跨 Pipeline 执行复用                                      │
│  • 降低分配开销                                              │
│  • 减少碎片化                                                │
└─────────────────────────────────────────────────────────────┘

v2 运行时扩展

流有序分配 (CUDA 11.2+)

mm.setDeviceAllocatorMode(DeviceAllocatorMode::ASYNC_STREAM_ORDERED);

void* d_data = mm.allocateDevice(size, stream);
mm.freeDevice(d_data, stream);

异步内存池

如果可用，使用 CUDA 原生异步内存池：

// 如果支持则自动使用 cudaMemPool
mm.setDeviceAllocatorMode(DeviceAllocatorMode::CUDA_ASYNC_POOL);