高并发内存池大页内存申请释放及定长内存池优化

（3）PageCache::NewSpan 大页申请核心

NewSpan 是大页申请的核心，逻辑为"先查空闲 span→无则向系统申请连续页"：

// PageCache.cpp
span* PageCache::NewSpan(size_t kPages) {
    // 1. 优先从对应页数的空闲 span 链表中取
    if (!_spanlist[kPages].Empty()) {
        span* span = _spanlist[kPages].Pop_front();
        // 初始化页 ID 到 span 的映射（仅首尾页，高效）
        _idSpanMap[span->_pageId] = span;
        _idSpanMap[span->_pageId + span->_n - 1] = span;
        span->_isUse = true;
        return span;
    }
    // 2. 无空闲 span，向更大页数的 span 链表找（拆分）
    for (size_t i = kPages + 1; i < MAX_PAGE_BUCKETS; ++i) {
        if (!_spanlist[i].Empty()) {
            span* bigSpan = _spanlist[i].Pop_front();
            // 拆分出 kPages 页的 span
            span* newSpan = new span;
            newSpan->_pageId = bigSpan->_pageId;
            newSpan->_n = kPages;
            newSpan->_isUse = true;
            // 剩余页放回 PageCache
            bigSpan->_pageId += kPages;
            bigSpan->_n -= kPages;
            _spanlist[bigSpan->_n].Push_front(bigSpan);
            // 更新映射
            _idSpanMap[newSpan->_pageId] = newSpan;
            _idSpanMap[newSpan->_pageId + newSpan->_n - 1] = newSpan;
            _idSpanMap[bigSpan->_pageId] = bigSpan;
            _idSpanMap[bigSpan->_pageId + bigSpan->_n - 1] = bigSpan;
            return newSpan;
        }
    }
    // 3. 无任何空闲 span，向系统申请 128 页（大页）
    size_t allocPages = MAX_PAGE_BUCKETS - 1;
    void* ptr = SystemAlloc(allocPages); // 封装 VirtualAlloc/mmap
    span* newSpan = new span;
    newSpan->_pageId = (PAGE_ID)ptr >> PAGE_SHIFT; // 地址转页 ID
    newSpan->_n = allocPages;
    _spanlist[allocPages].Push_front(newSpan);
    // 递归拆分（仅 1 层，无栈溢出风险）
    return NewSpan(kPages);
}

2.2 大页内存的释放逻辑

大页释放的核心是"归还 span 到 PageCache + 双向合并空闲 span"，避免内存碎片化，核心代码：

// ConcurrentAlloc.h - 用户层大对象释放接口
void ConcurrentFree(void* ptr, size_t size) {
    assert(ptr);
    if (size > MAX_BYTES) {
        // 1. 通过地址反查对应的 span（核心：_idSpanMap 映射）
        PageCache::GetInstance()->_pageMutex.lock();
        span* bigSpan = PageCache::GetInstance()->MapObjectToSpan(ptr);
        // 2. 归还 span 到 PageCache 并合并
        PageCache::GetInstance()->ReleaseSpanToPageCache(bigSpan);
        PageCache::GetInstance()->_pageMutex.unlock();
        return;
    }
    // 小对象走 ThreadCache...
}

// PageCache.cpp - span 合并核心
void PageCache::ReleaseSpanToPageCache(span* obj) {
    // 1. 前向合并：合并前一页的空闲 span
    while (true) {
        PAGE_ID prevId = obj->_pageId - 1;
        auto it = _idSpanMap.find(prevId);
        if (it == _idSpanMap.end()) break;
        span* prevSpan = it->second;
        if (prevSpan->_isUse || prevSpan->_n + obj->_n > MAX_PAGE_BUCKETS - 1) break;
        // 合并 prevSpan 到当前 span
        _spanlist[prevSpan->_n].Erase(prevSpan);
        obj->_pageId = prevSpan->_pageId;
        obj->_n += prevSpan->_n;
        delete prevSpan; // 此处后续用定长内存池优化
    }
    // 2. 后向合并：合并后一页的空闲 span（逻辑同上）
    while (true) {
        PAGE_ID nextId = obj->_pageId + obj->_n;
        auto it = _idSpanMap.find(nextId);
        if (it == _idSpanMap.end()) break;
        span* nextSpan = it->second;
        if (nextSpan->_isUse || nextSpan->_n + obj->_n > MAX_PAGE_BUCKETS - 1) break;
        _spanlist[nextSpan->_n].Erase(nextSpan);
        obj->_n += nextSpan->_n;
        delete nextSpan; // 此处后续用定长内存池优化
    }
    // 3. 标记为空闲，更新首尾页映射（高效设计）
    obj->_isUse = false;
    _spanlist[obj->_n].Push_front(obj);
    _idSpanMap[obj->_pageId] = obj;
    _idSpanMap[obj->_pageId + obj->_n - 1] = obj;
}

2.3 大页内存管理的核心优势

1. 低碎片化：连续页块通过 span 合并，避免原生 malloc 的"内存洞"；
2. 少系统调用：向系统一次申请 128 页，拆分后复用，大幅减少 VirtualAlloc/mmap 调用；
3. 高并发安全：全局页锁仅在申请/释放大页时持有，持有时间极短，不影响小对象并发；
4. 地址映射高效：仅维护 span 首尾页的映射，而非全量页，哈希表开销降低 90%+。

三、核心 2：定长内存池（ObjectPool）脱离 new/delete

上述代码中，new span 和 delete span 会引入额外开销：new 需要调用构造函数 + 内存分配，delete 需要调用析构函数 + 内存释放，而 span 作为内存池的元对象，创建/销毁频率极高，必须优化。此外，核心目标是替换 malloc 和 new，若内部仍依赖 new/delete，则违背设计初衷。

3.1 定长内存池的设计思路

定长内存池（ObjectPool）的核心是"预分配一块连续内存，按固定大小切割，管理空闲链表"，适用于：

• 频繁创建/销毁的定长对象（如 span、ThreadCache）
• 避免 new/delete 的系统调用和锁竞争
• 支持定位 new 和显式析构，兼容 C++ 对象生命周期

3.2 ObjectPool 核心实现

// Fixed-size_memory_pool.h
template<class T>
class ObjectPool {
public:
    // 申请对象（脱离 new）
    T* New() {
        T* obj = nullptr;
        // 1. 优先从空闲链表取
        if (_freeList) {
            obj = (T*)_freeList;
            _freeList = *((void**)_freeList); // 头删
        } else {
            // 2. 空闲链表空，向系统申请大块内存
            if (_leftBytes < sizeof(T)) {
                _leftBytes = 128 * 1024; // 预分配 128KB
                // 按页申请，避免内存碎片
                size_t pageNum = _leftBytes / PAGE_SIZE;
                _memory = (char*)SystemAlloc(pageNum);
                if (_memory == nullptr) throw std::bad_alloc();
            }
            // 切割内存块
            obj = (T*)_memory;
            size_t objSize = sizeof(T) < sizeof(void*) ? sizeof(void*) : sizeof(T);
            _memory += objSize;
            _leftBytes -= objSize;
        }
        // 3. 定位 new：仅初始化对象，不分配内存（核心）
        new(obj)T();
        return obj;
    }
    // 释放对象（脱离 delete）
    void Delete(T* obj) {
        // 1. 显式析构：仅清理对象，不释放内存
        obj->~T();
        // 2. 头插到空闲链表
        size_t objSize = sizeof(T) < sizeof(void*) ? sizeof(void*) : sizeof(T);
        *((void**)obj) = _freeList;
        _freeList = obj;
    }
private:
    char* _memory = nullptr; // 预分配的连续内存块
    int _leftBytes = 0; // 剩余可用字节数
    void* _freeList = nullptr; // 空闲对象链表
};

3.3 替换 new/delete：以 span 和 ThreadCache 为例

（1）管理 span 对象

将 PageCache 中所有 new span/delete span 替换为 ObjectPool：

// PageCache.h
class PageCache {
private:
    ObjectPool<span> _spanPool; // 定长内存池管理 span
public:
    span* NewSpan(size_t kPages) {
        // 替换 new span
        span* newSpan = _spanPool.New();
        // ... 其他逻辑
    }
    void ReleaseSpanToPageCache(span* obj) {
        // ... 合并逻辑
        // 替换 delete span
        _spanPool.Delete(prevSpan);
        _spanPool.Delete(nextSpan);
    }
};

（2）管理 ThreadCache 对象

ThreadCache 是线程私有对象，创建频率高，用 ObjectPool 管理：

// ConcurrentAlloc.h
static __thread ThreadCache* pTLSThreadCache = nullptr;
void* ConcurrentAlloc(size_t size) {
    if (size <= MAX_BYTES) {
        if (pTLSThreadCache == nullptr) {
            // 替换 new ThreadCache
            static ObjectPool<ThreadCache> tcPool;
            pTLSThreadCache = tcPool.New();
        }
        return pTLSThreadCache->Allocate(size);
    }
    // ... 大对象逻辑
}

3.4 定长内存池的核心收益

1. 零开销创建/销毁：空闲对象直接从链表取，无需系统调用，速度比 new 快；
2. 内存连续：预分配的大块内存减少 TLB 缺失，访问效率更高；
3. 对象生命周期可控：定位 new + 显式析构，既兼容 C++ 对象，又脱离 new/delete 的束缚；
4. 无锁（线程私有）：每个 ThreadCache 的 ObjectPool 是线程私有，无并发竞争。

四、整体性能对比

五、总结

高并发内存池的性能优化，本质是"场景适配 + 开销极致压缩"：

1. 大页内存管理：通过 span 抽象连续页块，批量申请、双向合并，解决大对象碎片化和系统调用频繁问题
2. 定长内存池：针对高频创建的元对象，预分配连续内存、管理空闲链表，彻底脱离 new/delete，实现零开销对象管理

这两个设计的结合，让内存池既保证了大内存的高效管理，又解决了元数据的性能损耗，是 TCMalloc 等工业级内存池的核心精髓，也是高并发场景下内存管理的最优解之一。

附：核心注意事项

1. 大页合并时仅维护首尾页映射，兼顾效率和正确
2. 定长内存池的对象大小需对齐到 void*，避免越界访问
3. 线程私有 ObjectPool 需配合 TLS 使用，避免并发竞争
4. 向系统申请的大页内存，需在进程退出时主动释放（封装 SystemFree）