高并发内存池回收机制深度解析

// ThreadCache释放函数（核心回收逻辑）
void thread_cache_free(void* ptr, size_t size) {
    if (!tls_thread_cache || !ptr) return;

    // 1. 计算哈希桶索引（对齐后的Size Class）
    size_t aligned_size = align_to_power_of_two(size);
    int class_index = get_size_class_index(aligned_size);
    if (class_index < 0 || class_index >= MAX_SIZE_CLASS) {
        class_index = MAX_SIZE_CLASS - 1;  // 保险处理
    }
    void** bucket = &tls_thread_cache->buckets[class_index];

    // 2. 插入空闲链表头部（O(1)时间）
    *(void**)ptr = *bucket;  // 将新对象插入链表头部
    *bucket = ptr;           // 更新链表头指针
}

// ThreadCache批量回收函数
void thread_cache_flush_to_central(ThreadCache* cache) {
    for (int i = 0; i < MAX_SIZE_CLASS; i++) {
        void** bucket = &cache->buckets[i];
        if (*bucket == NULL) continue;

        // 加锁保护CentralCache的全局操作
        pthread_mutex_lock(&central_cache.lock);
        
        // 将本地空闲链表中的对象转移到CentralCache的空闲链表
        void* obj = *bucket;
        while (obj) {
            void* next = *(void**)obj;
            central_cache_add_free_object(&central_cache, obj, i);
            obj = next;
        }
        *bucket = NULL;  // 清空本地链表
        
        pthread_mutex_unlock(&central_cache.lock);
    }
}

// CentralCache的Span映射表（哈希表）
typedef struct {
    void* obj_addr;       // 对象地址
    Span* span;           // 对应的Span指针
} ObjectToSpanMap;

// 对象释放时查找对应的Span
Span* find_span_by_object(void* obj_addr) {
    ObjectToSpanMap* entry = hash_table_lookup(&central_cache.map, obj_addr);
    return entry ? entry->span : NULL;
}

// 合并相邻的空闲Span
void merge_adjacent_spans(CentralCache* cache, Span* span) {
    // 检查前驱Span是否空闲
    if (span->prev && span->prev->is_free) {
        // 合并前驱Span
        span->start_page = span->prev->start_page;
        span->page_count += span->prev->page_count;
        // 从空闲链表中移除前驱Span
        remove_span_from_free_list(cache, span->prev);
        free(span->prev);  // 释放前驱Span的元数据
    }

    // 检查后继Span是否空闲（类似逻辑）
    // ...
}

// 分级回收：将大Span回收到PageCache
void central_cache_recycle_to_page_cache(CentralCache* cache, Span* span) {
    if (span->page_count >= PAGE_SIZE_THRESHOLD) {  // 如超过4页（16KB）
        // 从CentralCache的空闲链表中移除
        remove_span_from_free_list(cache, span);
        
        // 回收到PageCache（调用PageCache的回收接口）
        page_cache_recycle_span(cache->page_cache, span);
    } else {
        // 保留在CentralCache的空闲链表中
        add_span_to_free_list(cache, span);
    }
}

// PageCache回收Span函数
void page_cache_recycle_span(PageCache* cache, Span* span) {
    if (!span || !span->is_free) return;

    // 1. 计算虚拟地址范围（起始地址到结束地址）
    void* start_addr = page_to_addr(span->start_page);
    void* end_addr = (char*)start_addr + span->page_count * PAGE_SIZE;

    // 2. 调用munmap释放内存（系统调用）
    int ret = munmap(start_addr, span->page_count * PAGE_SIZE);
    if (ret == 0) {
        // 释放成功，更新PageCache的统计信息
        cache->total_pages -= span->page_count;
        cache->free_pages -= span->page_count;
        free(span);  // 释放Span元数据
    } else {
        // 释放失败，记录错误日志（如内存被其他进程占用）
        perror("munmap failed");
    }
}

// 定时清理空闲页的线程函数
void* page_cache_cleanup_thread(void* arg) {
    PageCache* cache = (PageCache*)arg;
    while (1) {
        sleep(300);  // 每5分钟清理一次
        pthread_mutex_lock(&cache->lock);
        
        // 遍历空闲页列表，释放超过阈值的页
        Span* current = cache->free_spans;
        while (current) {
            if (current->page_count >= PAGE_RELEASE_THRESHOLD) {
                // 从空闲链表中移除
                remove_span_from_free_list(cache, current);
                
                // 释放系统页
                page_cache_recycle_span(cache, current);
            }
            current = current->next;
        }
        
        pthread_mutex_unlock(&cache->lock);
    }
    return NULL;
}