实现自己内存池

Question

我希望预先分配一定数量的内存，并将该内存用于程序的其余部分。程序基本上是为一些字符串和结构分配内存。我如何实现这一点？使用什么数据结构来存储指针，以及如何使用它来为我提供一个具体的数量？

例如，如果我分配了1MB的空间，并将其放在一个指针p中，我如何从它中划分出一个250KB的块？

这只是一个快速而肮脏的实现。

Answer 1

如果您希望能够将内存返回到池中，则会变得更加复杂。但是，对于快速且不是很脏的方法，您可能希望实现一些可以重复使用的代码……

typedef struct pool
{
  char * next;
  char * end;
} POOL;

POOL * pool_create( size_t size ) {
    POOL * p = (POOL*)malloc( size + sizeof(POOL) );
    p->next = (char*)&p[1];
    p->end = p->next + size;
    return p;
}

void pool_destroy( POOL *p ) {
    free(p);
}

size_t pool_available( POOL *p ) {
    return p->end - p->next;
}

void * pool_alloc( POOL *p, size_t size ) {
    if( pool_available(p) < size ) return NULL;
    void *mem = (void*)p->next;
    p->next += size;
    return mem;
}

根据我的经验，当使用这样的池分配许多对象时，我希望预先计算需要多少内存，这样就不会浪费，但我也不想犯任何错误(比如没有分配enoudh)。因此，我将所有的分配代码放在一个循环中，并设置我的池分配函数来接受一个在空池上执行“虚拟”分配的标志。在循环的第二次，我已经计算了池的大小，这样我就可以创建池并进行实际分配，所有这些都使用相同的函数调用，没有重复的代码。您需要更改我建议的池代码，因为如果内存尚未分配，则不能使用指针算法执行此操作。

Answer 2

使用内存池进行内存管理-

内存池是预先分配相同大小的内存块的方式。例如，同一类的各种对象。因此，它更多的是关于设计你的软件的“内存模型”。

示例-一个动画gif有不同的帧。假设每个帧只需要最大1024KB。此外，如果我们知道我们最多只能有两个帧，那么我们可以通过为每个帧预先分配内存来避免碎片。

注意-内存池更适用于我们在设计时知道系统行为的情况。因此，内存池概念并不适用于所有地方。//============================================================================ //姓名: //============================================================================ //作者: //版本: //版权所有: SHREYAS JOSHI //描述: MemoryPool.cpp

#include <iostream>
#include <malloc.h>

struct memPool
{

private:

    char *m_poolPtr;
    char *m_nextAvailAddr;
    char *m_endAddr;

public:
    /** Methods for the structure **/
    void poolCreate(size_t size);
    void poolDestroy();
    void * poolAlloc(size_t size);

    memPool():m_poolPtr(NULL),m_nextAvailAddr(NULL),m_endAddr(NULL)
    {
        std::cout<<"memPool constructor Invoked"<<std::endl;
    }

    ~memPool()
    {
        std::cout<<"memPool Destructor Invoked"<<std::endl;
        m_poolPtr = NULL;
        m_nextAvailAddr = NULL;
        m_endAddr = NULL;
    }

};

/** Create a Pool of memory - makes a program hassle free of doing malloc multiple times **/
/** Also, Fragmentation can be avoided with the Memory Pool concept **/
/** A pool concept is useful, when you know at design time.how much memory is required for
the similar type of objects in total**/

void memPool::poolCreate(size_t size)
{
    m_poolPtr = (char *) malloc(size);

    if(m_poolPtr == NULL)
    {
        std::cout<<"Pool Create Failed"<<std::endl;
        //printf("Pool Create Failed \r\n");
    }

    m_nextAvailAddr = m_poolPtr;
    /** note the addressing starts from zero - thus you have already counted zero**/
    m_endAddr = m_poolPtr + size - 1;

    //printf("The Pool Head Pointer = %p \r\n",m_poolPtr);
    std::cout<<"Pool Head Pointer = "<<static_cast<void *>(m_poolPtr)<<std::endl;
    //printf("The Pool m_nextAvailAddr = %p \r\n",m_nextAvailAddr);
    std::cout<<"Pool m_nextAvailAddr = "<<static_cast<void *>(m_nextAvailAddr)<<std::endl;
    //printf("The Pool m_endAddr = %p \r\n",m_endAddr);
    std::cout<<"Pool m_endAddr = "<<static_cast<void *>(m_endAddr)<<std::endl;
}


/** Destroy the entire pool in one shot ********/
void memPool::poolDestroy()
{
    free(m_poolPtr);
    /** Remember free first then assign to NULL **/
    m_poolPtr = NULL;

    /** Update Housekeeping--data structure **/
    m_nextAvailAddr = NULL;
    m_endAddr = NULL;
}

/** Allocate some space from the pool ********/
/** Check if the space is available or not **/
/** Do the housekeeping - update the nextAvail Addr in the structure**/
void * memPool::poolAlloc(size_t size)
{
    void *mem = NULL;

    if( (m_endAddr != NULL) && (m_nextAvailAddr != NULL))
    {

        /** This is according to fencing problem - add 1 when you are find a difference of sequence to calculate the space within **/
        size_t availableSize = m_endAddr - m_nextAvailAddr + 1;

        /** check for the availability **/
        if(size > availableSize )
        {
            //std::cout<<"Warning!! the available size = "<<availableSize<< "requested size = "<<size<<std::endl;
            printf("Warning!! the available size = %u and requested size = %u \r\n",availableSize, size);
            mem = NULL;
        }
        else
        {
            /** store the available pointer to the user**/
            mem = m_nextAvailAddr;
            //printf("The user return pointer is = %p \r\n ",mem);
            std::cout<<"The user return pointer is = "<<static_cast <void *>(mem)<<std::endl;
            /*** advance the next available pointer **/
            m_nextAvailAddr += size;
            //printf("The next available pointer is = %p \r\n ",m_nextAvailAddr);
            std::cout<<"The next available pointer is = "<<static_cast<void *>(m_nextAvailAddr)<<std::endl;
        }

    }

    return mem;
}

int main(int argc, char *argv[])
{
    memPool gifAnimatedImageFramesBlk;

    /** Let's say each frame needs 512 kb **/
    char *gifFrame1 = NULL;
    char *gifFrame2 = NULL;

    char *gifFrame3 = NULL;

    /** 1 MB Pool for the GIF IMAGE FRAMES **/
    gifAnimatedImageFramesBlk.poolCreate(1024*1024*1024);
    /*** 512 KB **/
    gifFrame1 = (char *)gifAnimatedImageFramesBlk.poolAlloc(512*1024*1024);
    //printf("Got the gifFrame1..pointer- == %p \r\n ",gifFrame1);
    std::cout<<"Got the gifFrame1..pointer- == "<<static_cast<void *>(gifFrame1)<<std::endl;


    /** again 512 MB **/
    gifFrame2 = (char *)gifAnimatedImageFramesBlk.poolAlloc(512*1024*1024);

    std::cout<<"Got the gifFrame2..pointer- == "<<static_cast<void *>(gifFrame2)<<std::endl;

    //printf("Got the gifFrame2..pointer- == %p \r\n ",gifFrame2);

    /*************Exhausted the pool memory now **************/

    /** This will fail ****************/
    gifFrame3 = (char *)gifAnimatedImageFramesBlk.poolAlloc(1);

    std::cout<<"Got the gifFrame3..pointer- == "<<static_cast<void *>(gifFrame3)<<std::endl;
    //printf("Got the gifFrame3..pointer- == %p \r\n ",gifFrame3);

    /*****Destroy the Pool now *****************/
    gifAnimatedImageFramesBlk.poolDestroy();

    gifFrame3 = (char *)gifAnimatedImageFramesBlk.poolAlloc(1);

    std::cout<<"Got the gifFrame3..pointer- == "<<static_cast<void *>(gifFrame3)<<std::endl;

    //printf("Got the gifFrame3..pointer- == %p \r\n ",gifFrame3);

    gifFrame3 = (char *)gifAnimatedImageFramesBlk.poolAlloc(1);

    std::cout<<"Got the gifFrame3..pointer- == "<<static_cast<void *>(gifFrame3)<<std::endl;
    //printf("Got the gifFrame3..pointer- == %p \r\n ",gifFrame3);


    return 0;
}

注意-为了使用ostream::operator<<在C++中打印char *的值，应该使用static_cast (pointer_Name)将char *类型转换为void *。问题是，如果C++编译器看到字符*，那么它会查找空终止符- '\0‘。在这种情况下，没有NULL终止符'\0‘。因此，您将看到一种未定义的行为。

内存池的优势

1. 您可以避免内存碎片。即使系统有所需的内存空间，当所需的连续块大小不可用时，malloc()也会失败。
2. 该空间是保留的，并且避免了频繁的malloc()和free()。这将节省时间。
3. 当为许多子块调用malloc()时，管理/元数据与每个分配的子块相关联。这将消耗不必要的空间。相反，一个大的块分配将避免多个管理/元数据。
4. 如果内存空间受到限制，则很容易调查内存泄漏。如果池中的内存耗尽，则内存池将返回NULL。因此，您可以轻松地隔离内存泄漏问题。