memory_pool.cpp

//
// Created by wnc on 2025/9/15.
//

#include "memory_pool.h"

#include <cstdlib>
#include <iostream>

// 对齐到4字节
static inline size_t align4(size_t size) {
    return (size + 3) & ~static_cast<size_t>(3);
}

MemoryPool::MemoryPool(size_t block_size, size_t block_count)
    : block_size_(align4(block_size)), block_count_(block_count) {
    expandPool(block_count_);
}

MemoryPool::~MemoryPool() {
    for (auto &p : big_blocks_) {
        std::free(p.first);
    }
}

 // 实现移动构造函数
MemoryPool::MemoryPool(MemoryPool&& other) noexcept {
    std::lock_guard<std::mutex> lock(other.mtx_);
    block_size_ = other.block_size_;
    block_count_ = other.block_count_;
    capacity_ = other.capacity_;
    free_list_ = std::move(other.free_list_);
    big_blocks_ = std::move(other.big_blocks_);
    allocations_ = std::move(other.allocations_);
    // 注意 mutex 不能移动，只是每个对象自己管理

    // 置空被移动对象的容器，保证析构安全
    other.free_list_.clear();
    other.big_blocks_.clear();
    other.allocations_.clear();
}

// 实现移动赋值运算符
MemoryPool& MemoryPool::operator=(MemoryPool&& other) noexcept {
    if (this != &other) {
        std::lock_guard<std::mutex> lock1(mtx_);
        std::lock_guard<std::mutex> lock2(other.mtx_);

        block_size_ = other.block_size_;
        block_count_ = other.block_count_;
        capacity_ = other.capacity_;
        free_list_ = std::move(other.free_list_);
        big_blocks_ = std::move(other.big_blocks_);
        allocations_ = std::move(other.allocations_);

        // 置空被移动对象的容器，保证析构安全
        other.free_list_.clear();
        other.big_blocks_.clear();
        other.allocations_.clear();
    }
    return *this;
}

void MemoryPool::expandPool(size_t count) {
    void* bigBlock = std::malloc(block_size_ * count);
    if (!bigBlock) throw std::bad_alloc();
    // 记录每次大块的起始地址与总字节数
    big_blocks_.push_back({bigBlock, block_size_ * count});

    char* ptr = static_cast<char*>(bigBlock);
    for (size_t i = 0; i < count; ++i) {
        free_list_.push_back(ptr + i * block_size_);
    }
    capacity_ += count;
}

void* MemoryPool::allocate(const char* file, int line, const char* func) {
    std::lock_guard<std::mutex> lock(mtx_);
    if (free_list_.empty()) {
        expandPool(block_count_);
    }
    void* ptr = free_list_.back();
    free_list_.pop_back();

    AllocationInfo info;
    info.file = file;
    info.line = line;
    info.func = func;
    info.tid = std::this_thread::get_id();
    info.in_use = true;
    allocations_[ptr] = info;

    return ptr;
}

void MemoryPool::deallocate(void* ptr) {
    std::lock_guard<std::mutex> lock(mtx_);
    auto it = allocations_.find(ptr);
    if (it == allocations_.end()) {
        std::cerr << "错误：释放未记录指针 " << ptr << std::endl;
        return;
    }
    if (!it->second.in_use) {
        std::cerr << "错误：重复释放指针 " << ptr << std::endl;
        return;
    }
    it->second.in_use = false;
    free_list_.push_back(ptr);
}

void MemoryPool::reportLeaks() const {
    std::lock_guard<std::mutex> lock(mtx_);
    for (auto& it : allocations_) {
        if (it.second.in_use) {
            std::cerr << "内存泄漏指针 " << it.first
                      << " 分配于 " << it.second.file << ":" << it.second.line
                      << " 函数 " << it.second.func
                      << " 线程 " << it.second.tid
                      << " 大小 " << block_size_ << " 字节" << std::endl;
        }
    }
}

bool MemoryPool::owns(void* ptr) const {
    if (!ptr) return false;
    std::lock_guard<std::mutex> lock(mtx_);
    char* cptr = static_cast<char*>(ptr);
    for (const auto &p : big_blocks_) {
        char* base = static_cast<char*>(p.first);
        size_t sz = p.second;
        if (cptr >= base && cptr < base + sz) return true;
    }
    return false;
}