원본링크 http://lunapiece.net/3787

TR1에 포함되지 않은 Boost 의 다른 요소들 중 자주 쓸 만한 것들을 한번 눈여겨 볼까 한다

첫번째 예제는 Pool이다. 메모리를 미리 생성 해 놨다가 해제/생성이 반복 될 경우 미리 생성해 놓은 메모리를 재활용 하는데 유용하게 사용 할 수 있다. 개인적으로도 많이 구현해서 써 보았고 탁월한 메모리 성능을 보여 주는 방법이다.

아래에는 예제코드를 담았다. 예제코드에 있는 주석만으로도 충분히 사용 방법과 기능을 알 수 있을것이라 본다.
첨부한 그림은 아래 코드를 실행한 속도 테스트 스크린샷이다(C++Builder 2009 + Realeas Mode)

일반적으로 메모리를 할당하는것 보다 훨신 빠름을 알 수 있다. 게다가 단편화의 문제도 적다.


#include <cstdlib>
#include <iostream>
#include <cstring>
#include <boost\pool\pool.hpp>
#include <boost\pool\object_pool.hpp>
#include <windows.h>

using namespace std;
using namespace boost;

struct MyData
{
    int i;

    MyData()
    {
        puts("Constructor!");
    };
    ~MyData()
    {
        puts("Destructor!");
    }
};
struct MyData2
{
    int i;
};

MyData2** Array; //임시저장용

void UseNormalPool()
{
    pool<> pool(sizeof(MyData));

    MyData *p = (MyData*)pool.malloc();
    //pool.free(p); //Free를 하지 않을 경우 pool이 파괴 될 때 pool에서 생성한 모든 메모리가 파괴됨.
}

void UseObjectPool()
{
    object_pool<MyData> pool;

    for (int i = 0; i < 1; ++i)
    {
        MyData *p = pool.malloc();
        //기본적으로 같지만 파괴시 Destructor 가 호출됨(주의 : Constructor 는 호출되지 않음)
    }
}
void Test1NewAndDelete()
{
    for (int i = 0;i < 1000000; ++i)
    {
        MyData2* p = new MyData2;
        delete p;
    }
}
void Test1MallocAndFree()
{
    for (int i = 0;i < 1000000; ++i)
    {
        MyData2* p = (MyData2*)malloc(sizeof(MyData2));
        free(p);
    }
}
void Test1BoostPool()
{
    pool<> pool(sizeof(MyData));
    for (int i = 0;i < 1000000; ++i)
    {
        MyData *p = (MyData*)pool.malloc();
        pool.free(p);
    }
}
void Test2NewAndDelete()
{
    for (int i = 0;i < 1000000; ++i)
    {
        Array[i] = new MyData2;
    }
    for (int i = 0;i < 1000000; ++i)
    {
        delete Array[i];
    }
    for (int i = 0;i < 1000000; ++i)
    {
        Array[i] = new MyData2;
    }
    for (int i = 0;i < 1000000; ++i)
    {
        delete Array[i];
    }
}
void Test2MallocAndFree()
{
    for (int i = 0;i < 1000000; ++i)
    {
        Array[i] = (MyData2*)malloc(sizeof(MyData2));
    }
    for (int i = 0;i < 1000000; ++i)
    {
        free(Array[i]);
    }
    for (int i = 0;i < 1000000; ++i)
    {
        Array[i] = (MyData2*)malloc(sizeof(MyData2));
    }
    for (int i = 0;i < 1000000; ++i)
    {
        free(Array[i]);
    }
}
void Test2BoostPool()
{
    pool<> pool(sizeof(MyData2));
    for (int i = 0;i < 1000000; ++i)
    {
        Array[i] = (MyData2*)pool.malloc();
    }
    for (int i = 0;i < 1000000; ++i)
    {
        pool.free(Array[i]);
    }
    for (int i = 0;i < 1000000; ++i)
    {
        Array[i] = (MyData2*)pool.malloc();
        //Free후 재할당을 할 경우 이미 생성된 메모리가 재사용됨
        //Free를 하더라도 실제 메모리는 파괴되지 않음
    }
    for (int i = 0;i < 1000000; ++i)
    {
        pool.free(Array[i]);
    }
}
int _tmain(int argc, _TCHAR* argv[])
{
    UseObjectPool();
    UseNormalPool();

    Array = new MyData2*[1000000];
    int TickCount;

    puts("Alloc and Free 1000000 count");
    TickCount = GetTickCount();
    Test1NewAndDelete();
    printf("new And delete : %dms\n", GetTickCount() - TickCount);

    TickCount = GetTickCount();
    Test1MallocAndFree();
    printf("malloc And Free : %dms\n", GetTickCount() - TickCount);

    TickCount = GetTickCount();
    Test1BoostPool();
    printf("boost pool : %dms\n", GetTickCount() - TickCount);

    puts("Alloc 1000000 count and Free 1000000 count");

    TickCount = GetTickCount();
    Test2NewAndDelete();
    printf("new And delete : %dms\n", GetTickCount() - TickCount);

    TickCount = GetTickCount();
    Test2MallocAndFree();
    printf("malloc And Free : %dms\n", GetTickCount() - TickCount);

    TickCount = GetTickCount();
    Test2BoostPool();
    printf("boost pool : %dms\n", GetTickCount() - TickCount);
    system("pause");
    return 0;
}