#include<malloc.h>
#include<iostream>
using namespace std;
class memory_pool
{
private:
static const size_t min_obj_size = 8;
static const size_t max_obj_size = 128;
char * start_free; //内存池起始地址
char * end_free; //内存池结束地址
size_t heap_size; //记录从堆中分配到内存池的总数量
union obj //一个区块单元设计，有下一个区块链表和首地字节址共享
{
union obj * next_obj;
char data;
};
obj * free_list[16]; //16种不同大小的区块的链表指针数组
//可以设计成单例模式，只有一个内存池对象，私有构造
memory_pool()
{
start_free = 0;
end_free = 0;
}
~memory_pool()
{
//释放成员函数申请的堆内存
}
public:
//获取线程池类的单实例
static memory_pool* getInstance()
{
static memory_pool instance;
return &instance;
}
//将要申请的n字节升级到最近的8的倍数
size_t up_to_8s(const size_t &n) const
{
return (n + min_obj_size - 1)&(~(min_obj_size - 1)); //(n+7)&11111000，即后3位清零为8的倍数
}
//根据n获取对应的链表位置
size_t free_index(const size_t &n) const
{
return up_to_8s(n) / min_obj_size - 1; //链表位置从0开始到15
}
//重点给用户调用的分配内存的函数，C风格只提供字节数
void * allocate(const size_t &n)
{
//如果申请的内存大于最大区块，那么就直接从malloc获取
if (n>max_obj_size)
{
return malloc(n);
}
//获取对应链表的首地址
obj * list_head = free_list[free_index(n)];
obj * result = list_head;
if (NULL == result)
{
//若是没有获取到链表区块，则要重新填充该链表
void * ret = refill(up_to_8s(n));
return ret;
}
//更新链表首地址
free_list[free_index(n)] = result->next_obj;
return result;
}
//释放回内存给对应的链表
void deallocate(void *p, const size_t n)
{
//如果大于128，说明是从堆中分配的，要还给堆
if (n>max_obj_size)
{
free(p);
}
obj * list_head = free_list[free_index(n)];
obj * new_head = (obj*)p;
//将原链表头作为新表头的下一个元素
new_head->next_obj = list_head;
//新表头放到链表首部位置
free_list[free_index(n)] = new_head;
}
//重新从内存池中获取内存填充一个区块大小为n的链表
void * refill(const size_t n)
{
int nobjs = 20; //默认一次获取20个相应区块
//从内存池中获取这一整块n*nobjs的内存，传入的nobjs可能被修改为实际获取到的值
char * chunk = chunk_alloc(n, nobjs);
if (1 == nobjs)
{
//说明从内存池也只获取到了一个区块，直接返回给需要的
return chunk;
}
//从内存池中获取了多个区块，则要重新链接起来
obj * list_head = free_list[free_index(n)];
obj *result = (obj*)chunk;
obj *current_obj, *next_obj;
free_list[free_index(n)] = next_obj = (obj*)(chunk + n);
for (int i = 1; ; i++)
{
current_obj = next_obj;
next_obj = (obj*)((char*)next_obj + n);
if (nobjs-1 == i)
{
current_obj->next_obj = NULL;
break;
}
else
{
current_obj->next_obj = next_obj;
}
}
return result; //返回的是大区块首地址
}
//从内存池中获取大块内存
char * chunk_alloc(const size_t n, int &nobjs)
{
char* result;
size_t total_bytes = n*nobjs;
size_t bytes_left = end_free - start_free;
//如果内存池中剩余字节数能满足需求那就先分配
if (bytes_left>=total_bytes)
{
result = start_free; //返回结果就是内存池首地址
start_free = start_free + total_bytes; //内存池新的首地址
return result;
}
//内存池中的剩余字节还够至少一个小区快
else if (bytes_left>n)
{
nobjs = bytes_left / n; //能获取的区块个数
total_bytes = n*nobjs;
result = start_free;
start_free = start_free + total_bytes;
return result;
}
//一个小区快都不够，则要重新从堆中往内存池分一大块内存
else
{
//需要从内存池中获取的内存是当前需求的两倍，以及加上从堆空间分配的总字节数相关的一个附加值
size_t bytes_to_get = 2 * total_bytes + up_to_8s(heap_size >> 4);
//先把内存池之前剩余的小部分分到合适的链表上
if (bytes_left>0)
{
deallocate(start_free, bytes_left); //回收到链表中
}
//重新从堆空间获取内存
start_free = (char *)malloc(bytes_to_get);
if (NULL == start_free)
{
//说明堆空间都没有内存可分配了，则要从已分配的链表中找到最大的空闲区块分配过来
for (int i = max_obj_size / min_obj_size; i >= 0; i--)
{
obj* list_head = free_list[i];
if (NULL != list_head)
{
//说明找到了一个大区块
obj* p = list_head;
//将这个区块放到内存池
start_free = (char*)p;
end_free = start_free + (i + 1)*min_obj_size;
free_list[i] = p->next_obj;
return chunk_alloc(n, nobjs); //重新调整内存池后递归调用
}
}
//说明所有地方都没有内存可取
end_free = start_free = 0;
cerr << "out of memory !" << endl;
exit(1); //退出程序
}
heap_size += bytes_to_get; //更新从堆中分配给内存池的总数量
end_free = start_free + bytes_to_get;
//内存池已更新，则需要递归调用次函数重新分配区块到链表
return chunk_alloc(n, nobjs);
}
}
};
//测试代码
int main()
{
memory_pool *pMpool = memory_pool::getInstance();
double *d = (double*)pMpool->allocate(sizeof(double));
*d = 3.1415926;
cout << *d << endl; //打印出 3.1415926
pMpool->deallocate(d, sizeof(double));
cout << "success!!!" << endl; //打印出success
}
网友评论