C++ Memory Pool | "메모리 풀" 가이드

Memory Pool이란?

메모리 미리 할당

class MemoryPool {
    std::vector<void*> freeList;
    size_t blockSize;
    
public:
    MemoryPool(size_t size, size_t count) : blockSize(size) {
        for (size_t i = 0; i < count; ++i) {
            freeList.push_back(::operator new(blockSize));
        }
    }
    
    void* allocate() {
        if (freeList.empty()) {
            return ::operator new(blockSize);
        }
        void* ptr = freeList.back();
        freeList.pop_back();
        return ptr;
    }
    
    void deallocate(void* ptr) {
        freeList.push_back(ptr);
    }
};

기본 구조

template<typename T>
class ObjectPool {
    std::vector<T*> pool;
    std::vector<T*> available;
    
public:
    ObjectPool(size_t size) {
        pool.reserve(size);
        available.reserve(size);
        
        for (size_t i = 0; i < size; ++i) {
            T* obj = new T();
            pool.push_back(obj);
            available.push_back(obj);
        }
    }
    
    ~ObjectPool() {
        for (T* obj : pool) {
            delete obj;
        }
    }
    
    T* acquire() {
        if (available.empty()) {
            return nullptr;
        }
        T* obj = available.back();
        available.pop_back();
        return obj;
    }
    
    void release(T* obj) {
        available.push_back(obj);
    }
};

실전 예시

예시 1: 고정 크기 풀

template<typename T, size_t N>
class FixedPool {
    alignas(T) char buffer[N * sizeof(T)];
    std::vector<T*> freeList;
    
public:
    FixedPool() {
        for (size_t i = 0; i < N; ++i) {
            freeList.push_back(reinterpret_cast<T*>(&buffer[i * sizeof(T)]));
        }
    }
    
    T* allocate() {
        if (freeList.empty()) {
            throw std::bad_alloc();
        }
        T* ptr = freeList.back();
        freeList.pop_back();
        return new (ptr) T();  // placement new
    }
    
    void deallocate(T* ptr) {
        ptr->~T();  // 소멸자 호출
        freeList.push_back(ptr);
    }
};

int main() {
    FixedPool<int, 100> pool;
    
    int* p1 = pool.allocate();
    *p1 = 42;
    
    pool.deallocate(p1);
}

예시 2: 스레드 안전 풀

template<typename T>
class ThreadSafePool {
    std::vector<T*> pool;
    std::stack<T*> available;
    std::mutex mtx;
    
public:
    ThreadSafePool(size_t size) {
        pool.reserve(size);
        for (size_t i = 0; i < size; ++i) {
            T* obj = new T();
            pool.push_back(obj);
            available.push(obj);
        }
    }
    
    ~ThreadSafePool() {
        for (T* obj : pool) {
            delete obj;
        }
    }
    
    T* acquire() {
        std::lock_guard lock{mtx};
        if (available.empty()) {
            return nullptr;
        }
        T* obj = available.top();
        available.pop();
        return obj;
    }
    
    void release(T* obj) {
        std::lock_guard lock{mtx};
        available.push(obj);
    }
};

예시 3: RAII 래퍼

template<typename T>
class PoolPtr {
    ObjectPool<T>* pool;
    T* ptr;
    
public:
    PoolPtr(ObjectPool<T>* p) : pool(p), ptr(pool->acquire()) {}
    
    ~PoolPtr() {
        if (ptr) {
            pool->release(ptr);
        }
    }
    
    PoolPtr(const PoolPtr&) = delete;
    PoolPtr& operator=(const PoolPtr&) = delete;
    
    PoolPtr(PoolPtr&& other) noexcept 
        : pool(other.pool), ptr(other.ptr) {
        other.ptr = nullptr;
    }
    
    T* get() const { return ptr; }
    T& operator*() const { return *ptr; }
    T* operator->() const { return ptr; }
};

int main() {
    ObjectPool<std::string> pool(100);
    
    {
        PoolPtr<std::string> str{&pool};
        *str = "hello";
    }  // 자동 반환
}

예시 4: 가변 크기 풀

class VariableSizePool {
    struct Block {
        size_t size;
        void* data;
    };
    
    std::vector<Block> freeBlocks;
    
public:
    void* allocate(size_t size) {
        // 적합한 블록 찾기
        for (auto it = freeBlocks.begin(); it != freeBlocks.end(); ++it) {
            if (it->size >= size) {
                void* ptr = it->data;
                freeBlocks.erase(it);
                return ptr;
            }
        }
        
        // 새로 할당
        return ::operator new(size);
    }
    
    void deallocate(void* ptr, size_t size) {
        freeBlocks.push_back({size, ptr});
    }
};

장점

// 1. 빠른 할당
// - 미리 할당
// - 시스템 호출 감소

// 2. 단편화 방지
// - 고정 크기 블록

// 3. 캐시 친화적
// - 연속 메모리

// 4. 예측 가능
// - 할당 실패 없음 (고정 풀)

자주 발생하는 문제

문제 1: 풀 크기

// ❌ 풀 부족
ObjectPool<T> pool(10);

for (int i = 0; i < 100; ++i) {
    T* obj = pool.acquire();  // nullptr 가능
}

// ✅ 충분한 크기 또는 동적 확장

문제 2: 메모리 누수

ObjectPool<T> pool(100);

T* obj = pool.acquire();
// ❌ release 누락
// 메모리 누수

// ✅ RAII
PoolPtr<T> obj{&pool};  // 자동 반환

문제 3: 스레드 안전

// ❌ 스레드 안전 아님
ObjectPool<T> pool(100);

std::thread t1([&]() { pool.acquire(); });
std::thread t2([&]() { pool.acquire(); });  // 레이스

// ✅ 뮤텍스 또는 스레드 로컬

문제 4: 소멸자

// 풀 반환 시 소멸자 호출 안 됨
T* obj = pool.acquire();
obj->~T();  // 명시적 호출 필요
pool.release(obj);

// 또는 reset 메서드

활용 패턴

// 1. 고정 크기 객체
ObjectPool<GameObject> pool(1000);

// 2. 빈번한 할당/해제
auto obj = pool.acquire();
pool.release(obj);

// 3. RAII 래퍼
PoolPtr<T> obj{&pool};

// 4. 스레드 로컬 풀
thread_local ObjectPool<T> pool(100);

FAQ

Q1: Memory Pool?

A: 메모리 미리 할당.

Q2: 장점?

A:

• 빠른 할당
• 단편화 방지
• 캐시 친화적

Q3: 풀 크기?

A: 사용 패턴에 따라 결정.

Q4: 스레드 안전?

A: 뮤텍스 또는 스레드 로컬.

Q5: 소멸자?

A: 명시적 호출 필요.

Q6: 학습 리소스는?

A:

• “Game Programming Patterns”
• “Effective C++”
• cppreference.com

---

같이 보면 좋은 글 (내부 링크)

이 주제와 연결되는 다른 글입니다.

• C++ Stack Allocator | “스택 할당자” 가이드
• C++ Custom Allocator | “커스텀 할당자” 가이드
• C++ Object Pool | “객체 풀” 가이드

관련 글

• C++ Cache Optimization |
• C++ Custom Allocator |
• C++ Flyweight 패턴 완벽 가이드 | 공유로 메모리 절약하기
• C++ Stack Allocator |
• C++ Allocator |