c/c++:efficient c++,单线程内存池

c++ efficient 的第六章，看书笔记，顺便说下理解。

对于一般直接 new 与delete 性能较差，可以自己管理写内存的申请与释放。

版本0：

class Rational
{
public:
    Rational(int a=0, int b =1 ): n(a),d(b){}
private:
    int n;
    int d;
};

版本1： 专用的内存管理器

这版本是通过重载 目标类 中的new 与delete 实现内存管理，只适用于目标类，但是速度是最快的。

实现方式是维护一个链表，类中静态声明链表头，链表维护一串空间，通过类型转换在  目标类 和 链表指针 之间转换。

如果内存不够（freelist=NULL）是一次申请较多内存进行维护。

链表的添加删除（对于函数释放空间与申请空间）是在链首操作。

书上47 行 52行通过 静态类型转换不成功，改为了 强制转换，在codeblock g++ 中能够编译运行。

主要在主函数中调用静态函数 链表的申请与释放。即74 86行。

注意65 行把原来的delete [] 改为了 delete[] (char*)  原因可以参考第二版本。

class NextOnFreeList
{
public:
    NextOnFreeList *next;
};

class Rational
{
public:
    Rational(int a=0, int b =1 ): n(a),d(b){}
    inline void *operator new(size_t size);
    inline void operator delete(void * doomed, size_t size);

    static void newMemPool(){ expandTheFreeList();   }
    static void deleteMemPool();
    static void expandTheFreeList();
private:
    int n;
    int d;
    static NextOnFreeList * freelist;
    enum{   EXPANSION_SIZE = 32 };
};

inline
void * Rational::operator new( size_t size)
{
    if(0 == freelist)
    {
        expandTheFreeList();
    }
    NextOnFreeList * head =freelist;
    freelist=head->next;
    return head;
}

inline
void Rational::operator delete(void * doomed ,size_t size)
{
    NextOnFreeList *head=static_cast<NextOnFreeList *>( doomed);
    head->next=freelist;
    freelist=head;
}

void Rational:: expandTheFreeList()
{
    size_t size= (sizeof(Rational)>sizeof(NextOnFreeList*))?sizeof(Rational):sizeof(NextOnFreeList*);
//    NextOnFreeList *runner= static_cast<NextOnFreeList *>(new char [size]);
    NextOnFreeList *runner= (NextOnFreeList *)(new char [size]);
    freelist=runner;
    for(int i=0;i<EXPANSION_SIZE;i++)
    {
//        runner->next= static_cast<NextOnFreeList *>( new char [size] );
        runner->next= (NextOnFreeList *) new char [size] ;
        runner=runner->next;
    }
    runner->next= 0;
}

void Rational::deleteMemPool()
{
    NextOnFreeList * nextPtr;
    for(nextPtr=freelist;nextPtr!=NULL;nextPtr=freelist)
    {
        freelist=freelist->next;
        delete [](char *)nextPtr;
    }
}

NextOnFreeList * Rational::freelist =0;

int main()
{
    Rational * array[1000];
    Rational::newMemPool();
    for(int j=0;j<500;j++)
    {
        for(int i=0;i<1000;i++)
        {
            array[i]=new Rational(i);
        }
        for(int i=0;i<1000;i++)
        {
            delete array[i];
        }
    }
    Rational::deleteMemPool();
    return 0;
}

版本2：固定大小对象的内存池

考虑版本1，可以通过模板实现管理特定的对象。最主要的参数是类的大小。

实现是专门声明一个管理内存的内存池类，使用模板实现，提供alloc（） free（） 接口，给类申请与释放内存。

内存池类的实现是自身有一个MemoryPool<T>* next 指针用来指向维护的链表，内存的操作都在链首位置。

第32行书上代码编译不通过，

delete [] nextPrt;

 时，nextPrt  的类型为 MemoryPool * ，这样在释放的时候再一次调用了 ~MemoryPool 而不是默认的内存释放。（第一次调用是上层类的析构函数调用的）

所以在这改为了 

delete [](char*)nextPrt;

这样才能成功释放内存。

下面的是底层类的代码。

template<class T>
class MemoryPool
{
public:
    MemoryPool(size_t size =EXPANSION_SIZE);
    ~MemoryPool();

    //从空闲列表中分配T元素
    inline void * alloc(size_t size);
    inline void free(void * someElement);
private:
    MemoryPool<T>* next;
    enum{EXPANSION_SIZE=2};
    //将空闲元素添加至空闲列表
    void expanTheFreeList(int howMany=EXPANSION_SIZE);
};

template<class T>
MemoryPool<T>::MemoryPool(size_t size)
{
    expanTheFreeList( size);
}

template<class T>
MemoryPool<T>::~MemoryPool()
{
    cout<<next<<endl;
    MemoryPool<T> * nextPrt=next;
    for(nextPrt=next;nextPrt!=NULL;nextPrt=next)
    {
        next=next->next;
//        delete [] nextPrt;
        delete [](char*)nextPrt;
    }
}

template<class T>
inline
void * MemoryPool<T>::alloc(size_t size)
{
    if(!next)
    {
        expanTheFreeList();
    }
    MemoryPool<T> * head=next;
    next=head->next;
    return head;
}

template<class T>
inline
void MemoryPool<T>::free(void * doomed)
{
//    MemoryPool<T> *head=static_cast<MemoryPool<T>* >(doomed);
    MemoryPool<T> *head=(MemoryPool<T>* )(doomed);
    head->next=next;
    next=head;
}

template<class T>
void MemoryPool<T>::expanTheFreeList(int howmany)
{
    size_t size=(sizeof(T)>sizeof(MemoryPool<T>*))? sizeof(T):sizeof(MemoryPool<T>*);
//    MemoryPool<T>* runner =static_cast< MemoryPool<T>* >(new char [size]);
    MemoryPool<T>* runner =( MemoryPool<T>* )(new char [size]);
    next=runner;
    for(int i=0 ;i<howmany;i++)
    {
//        runner->next=static_cast< MemoryPool<T>* >(new char [size]);
        runner->next=( MemoryPool<T>* )(new char [size]);
        runner=runner->next;
    }
    runner->next=0;
}

下面是调用类与使用的代码：

12行的时候会调用 MemoryPool 的构造函数。

//使用内存池的类
class Rational
{
private:
    int n;
    int d;
    static MemoryPool<Rational > *memPool;
public:
    Rational(int a=0, int b=1) : n(a),d(b){}
    void *operator new(size_t size){    return memPool->alloc(size);    }
    void operator delete(void* doomed, size_t size){    memPool->free(doomed);    }
    static void newMemPool(){   memPool=new MemoryPool <Rational >;    }
    static void deleteMemPool(){    delete memPool; }
};

MemoryPool<Rational>* Rational::memPool=0;

int main()
{
    //...
    Rational::newMemPool();
    //...
    Rational::deleteMemPool();
    //..
    return 0;
}

版本3：将版本2的 固定长度改为不定长度,称为可变大小内存池

首先要有个认识，既然是可变长度，那么通常释放后，再一次申请的时候不会申请这一段内存的，（通过代码的实现是不打算复用内存的）第一是不适用，第二就算够那么将造成管理的困难

想想申请而来123连续的3段内存，第二段内存需要释放，这大小就固定下来了(13还没释放)，如果想复用，这个就另外实现吧。 - -！

实现方式是在内存池(版本2 的MemoryPool)下层在创建一个类，用来指向一个大内存块，一个计数，表示前多少内存已经使用了，如果不够就再一次申请一个内存块。至于浪费的考虑，看书上说的吧。 - -！

MemoryPool 还是第二版本的功能，提供接口，不过对于物理内存的申请就下放了。

仍然是维护链表实现，还是链首操作。

内存块 类：

因为最低成的释放free 基于设计因素什么也不赶，要想的也可以对free 修改，参数什么的都有传递。

29行书上是直接 delete [] mem;  不过这样会提示void* 操作，强制转换了

class MemoryChunk
{
private:
    MemoryChunk* next;//指向下个内存块
    void * mem;//指向可用的内存
    size_t chunkSize;//该内存块的大小
    size_t bytesAlreadyAllocated;//已经分配的字节数
public:
    MemoryChunk(MemoryChunk *nextChunk ,size_t chunkSize);
    ~MemoryChunk();

    inline void* alloc(size_t size);
    inline void free (void* someElement);
    MemoryChunk* nextMemChunk() {  return next; }
    size_t spaceAvailable() {   return chunkSize - bytesAlreadyAllocated;   }
    enum{   DEFUALT_CHUNK_SIZE = 4096  };
};

MemoryChunk::MemoryChunk(MemoryChunk* nextChunk, size_t reqSize)
{
    chunkSize = (reqSize > DEFUALT_CHUNK_SIZE) ? reqSize : DEFUALT_CHUNK_SIZE;
    next = nextChunk;
    bytesAlreadyAllocated=0;
    mem= new char [chunkSize];
}

MemoryChunk::~MemoryChunk()
{
    delete [] (char*)mem;
}

void* MemoryChunk::alloc(size_t requestSize)
{
    void* addr = (void* )((size_t )mem + bytesAlreadyAllocated );
    bytesAlreadyAllocated+=requestSize;
    return addr;
}

inline void MemoryChunk::free(void* someElement ) {}

内存池类：

必须注意16行，对链表的末尾赋0，书上是没有的，这句没有会导致析构的时候不能判断结束。

第26行的时候是调用memChunk的析构函数的。

//内存池类
class ByteMemoryPool
{
private:
    MemoryChunk* listOfMemoryChunks;
    void expandStorage(size_t reqSize);
public:
    ByteMemoryPool(size_t initSize = MemoryChunk::DEFUALT_CHUNK_SIZE);
    ~ByteMemoryPool();
    inline void* alloc(size_t size);
    inline void free(void* someElement);
};

ByteMemoryPool::ByteMemoryPool(size_t initSize)
{
    listOfMemoryChunks=NULL;
    expandStorage(initSize);
}

ByteMemoryPool::~ByteMemoryPool()
{
    MemoryChunk* memChunk = listOfMemoryChunks;
    while(memChunk)
    {
        listOfMemoryChunks = memChunk->nextMemChunk();
        delete memChunk;
        memChunk = listOfMemoryChunks;
    }
}

inline
void* ByteMemoryPool::alloc(size_t requestSize)
{
    size_t space = listOfMemoryChunks->spaceAvailable();
    if(space<requestSize)
    {
        expandStorage(requestSize);
    }
    return listOfMemoryChunks->alloc(requestSize);
}

inline
void ByteMemoryPool::free(void* doomed)
{
    listOfMemoryChunks->free(doomed);
}

void ByteMemoryPool::expandStorage(size_t requestSize)
{
    listOfMemoryChunks = new MemoryChunk(listOfMemoryChunks,requestSize);
}

调用类与测试：

21 、33对应创建内存池与释放内存池，是同一个类中共享内存池。

//调用类
class Rational
{
private:
    int n;
    int d;
    static ByteMemoryPool* memPool;
public:
    Rational(int a=0, int b=1):n(a),d(b){}
    void* operator new (size_t size){   return memPool->alloc(size);    }
    void operator delete (void* doomed, size_t size){   memPool->free(doomed);  }
    static void newMemPool(){   memPool = new ByteMemoryPool;   }
    static void deleteMemPool(){    delete memPool; }
};

ByteMemoryPool* Rational::memPool=0;

int main()
{
    Rational * array[1000];
    Rational::newMemPool();
    for(int j=0;j<500;j++)
    {
        for(int i=0;i<1000;i++)
        {
            array[i]=new Rational(i);
        }
        for(int i=0;i<1000;i++)
        {
            delete array[i];
        }
    }
    Rational::deleteMemPool();
    return 0;
}

 总结：

1.灵活性以速度为代价。

2.全局内存管理器是通用的（new 和 delete），因此代价高。

3.专用内存管理器比全局内存管理器快一个数量级以上。

4.如果主要分配固定大小的内存块，专用的固定大小内存管理器将明显地提升性能。

5.如果主要分配限于单线程内存块，那么内存块管理器也会有类似的性能提高。