STL配置器（四）----内存池技术
关于内存池，我相信大家都比较感兴趣，实现的版本也很多，但无论怎么实现，我觉得很重要的一点是：不能让管理内存池的成本太大！这是关键。比如，你管理100M的内存需要花50M的空间才能搞定，那我觉得不如直接用malloc和free来得实在，除了管理内存消耗外，还要注意效率，如果效率太低那也没什么意义。
本质上，内存池技术的出现是为了减少fragment碎片问题，用malloc和free来操作内存容易造成内存区域的fragment，以至于大内存程序无法有效加载和运行，使用内存池技术，就是一次性申请很大的一段内存，然后由程序来管理内存的管理，这里很容易造成循环，就是程序代码的管理里面如果没有处理好，也会出现碎片问题，效率会很低而且没用。
基于内存管理的内存消耗和效率问题的考虑，参考了大量内存池实现版本之后，我觉得自己设计一个内存池，并且将这个内存池部署到我的HJSTL里面去，不仅如此，我将在以后的项目中大量使用内存池来管理我的内存。
说来惭愧，发现在《STL空间配置器（二）》里面的代码是有很多bug的，当时因为太过匆忙没来得及检测测试，后来今天测试的时候发现问题一大把，搞得我都没有兴趣看了....
不过这是我的HJSTL的空间配置器啊，不能不写啊，所以重拾信心，为了防止发生错误，严重依赖了SGI的空间配置器，我这样重写一遍代码的原因还有一个：学习内存池技术！
对，SGI空间配置器完美的展示了内存池技术的巧妙，这与内存池技术的初衷是一致的，内存池技术的出现很大程度是因为内存碎片问题，所以，在SGI中，它划定内存分配的粒度为8bytes，阈值为128bytes。超过128bytes则SGI认为不会造成内存碎片（我想也是，SGI应该是做了科学的统计才决定使用128bytes作为阈值的），所以内存池技术主要在第二级配置器发挥作用。
再三思考之后，我决定实现一个内存池，完全按照SGI空间配置器的逻辑与设计方法。然后用这个内存池作为HJSTL的空间配置器，我相信绰绰有余。
下面就是一个模仿SGI的内存池兼空间配置器。
/*
* CopyRight (c) 2016
* HuJian in nankai edu.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
* This file is about HJSTL's memory pool reference to SGI STL's allocate
* Time :2016/4/7 in nankai edu
*/
#ifndef _HJSTL_MEMPOOL_
#define _HJSTL_MEMPOOL_
#include<iostream>
#include<cstdio>
#include<cstdlib>
//#define HJSTL_DEBUG //for debug
using namespace std;
#define __HJSTL_PRIVATE_ private
#define __HJSTL_PUBLIC_ public
#define __HJSTL_BAD_ALLOC_ cout<<"out of memory"<<endl; exit(1)
#define __HJSTL_MIN_ALLOC_ 4 //the min align size is 4 bytes
#define __HJSTL_MAX_ALLOC_ 1024 //the max align size is 1024 bytes<1Mb>
#define __HJSTL_NFREELISTS_ (__HJSTL_MAX_ALLOC_/__HJSTL_MIN_ALLOC_)
//the free list node structure
//the user_data is funny,the memory will boot by self one by one.
//think of it yourself carefully.it's very funny and i laugh at myself.
union hjstl_free_list_node{
union hjstl_free_list_node *free_list_link;
char user_data[1];
};
//this is the free_list array,tell compile not opt this array
hjstl_free_list_node* volatile hjstl_free_list[__HJSTL_NFREELISTS_];
//and the memory pool's size
char* hjstl_memory_pool_start=0;
char* hjstl_memory_pool_end=0;
size_t hjstl_memory_pool_heap_size=0;
//*this is the first level allocate.and the allocate handler
//the memory>128bytes,and others job handle by second level allocate
//the real-memory-pool is the second level allocate.
template<int inst>
class _hjstl_first_level_memory_pool_allocate{
__HJSTL_PRIVATE_://you should not touch this part code.<hujian>
static void* hjstl_oom_malloc(size_t);
static void* hjstl_oom_realloc(void*, size_t);
//the memory also contain two level allocate,the first level allocate
//handle the memory bigger 128bytes,and the second level allocate handle
//the less 128bytes memory ask.
//you also can set an new-handler to solve the out-of-memory
//i will give the API to set/check the handler
static void(*__hjsetl_malloc_oom_handler)();
__HJSTL_PUBLIC_:
static void * hjstl_allocate(size_t size)
{
void* result = malloc(size);
if (0 == result) result = hjstl_oom_malloc(size);
return result;
}
static void hjstl_deallocate(void* mem, size_t)
{
free(mem);
}
static void* hjstl_reallocate(void* oldmem, size_t oldsz, size_t newsz)
{
void* result = realloc(oldmem, newsz);
if (0 == result) result = hjstl_oom_realloc(oldmem, newsz);
return result;
}
//you can set your oom-handler by this function,return the old handler
static void(*hjstl_set_malloc_oom_handler(void(*handler)()))()
{
void(*old)() = __hjsetl_malloc_oom_handler;
__hjsetl_malloc_oom_handler = handler;
return(old);
}
//chenck whether we install the oom handler
static bool hjstl_whether_set_oom_handler()
{
return (__hjsetl_malloc_oom_handler == 0 ? false : true);
}
};
//implement the function of first level.
template<int inst>
void* _hjstl_first_level_memory_pool_allocate<inst>::hjstl_oom_malloc(size_t size)
{
void(*my_malloc_oom_handler)();
void* result;
for (;;){
my_malloc_oom_handler = __hjsetl_malloc_oom_handler;
if (0 == my_malloc_oom_handler) { __HJSTL_BAD_ALLOC_; }
//run your oom-handler
(*my_malloc_oom_handler)();
result = malloc(size); //re-try
if (result) return result;
}
}
template<int inst>
void* _hjstl_first_level_memory_pool_allocate<inst>::hjstl_oom_realloc(void* oldmem, size_t newsz)
{
void(*my_malloc_oom_handler)();
void* result;
for (;;){
my_malloc_oom_handler = __hjsetl_malloc_oom_handler;
if (0==my_malloc_oom_handler){ __HJSTL_BAD_ALLOC_; }
//run your handler
(*my_malloc_oom_handler)();
result = realloc(oldmem, newsz);
if (result) return result;
}
}
template<int inst>
void(*_hjstl_first_level_memory_pool_allocate<inst>::__hjsetl_malloc_oom_handler)()=0;
//you can use this in your test-project
typedef _hjstl_first_level_memory_pool_allocate<0> hjstl_first_malloc;
//this is the second level allocate of hjstl memory pool
template<int inst>
class _hjstl_secnod_level_memory_pool_allocate{
//you can not touch this part's code,just for root
__HJSTL_PRIVATE_:
//round up to align 8 times bytes
static size_t HJSTL_ROUND_UP(size_t bytes){
return (((bytes)+__HJSTL_MIN_ALLOC_ - 1) & ~(__HJSTL_MIN_ALLOC_ - 1));
}
//find the free list,return the index
static size_t HJSTL_FREELISTS_INDEX(size_t bytes){
return (((bytes)+__HJSTL_MIN_ALLOC_ - 1) / __HJSTL_MIN_ALLOC_ - 1);
}
//return an node of size sz,and the left nodes append to the free list
//so,after call this function,the free list maybe change<update>
static void* hjstl_refill(size_t sz);
//Allocate a chunk from os,nnodes maybe reduce if the memory pool no enough mem
static char* hjstl_mem_pool_chunk_alloc(size_t sz, int &Nnodes);
__HJSTL_PUBLIC_://you can use this api in your project
//allocate memory,but this function just handle the memory less 128.
//if the memory bigger 128,call first levle's allocate to handle it.
static void* hjstl_allocate(size_t sz)
{
hjstl_free_list_node* volatile * my_free_list;
hjstl_free_list_node* result;
if (sz > (size_t)__HJSTL_MAX_ALLOC_){
return (hjstl_first_malloc::hjstl_allocate(sz));
}
//get the aim-free list
my_free_list = hjstl_free_list + HJSTL_FREELISTS_INDEX(sz);
result = *my_free_list;
if (0 ==result){//no,this size's free list is empty,ok,re-fill it<20 nodes>
void* r = hjstl_refill(sz);
#ifdef HJSTL_DEBUG
cout << "hjstl_refill calling..." << endl;
#endif
return (r);
}
//else,this type's free list is not empty,so,give an node to user
//and update the free list.
*my_free_list = result->free_list_link;
return (result);
}
//deallocate,i don't know how to real-know the kernel of free...
static void hjstl_deallocate(void* mem, size_t sz)
{
hjstl_free_list_node* volatile* my_free_list;
hjstl_free_list_node* append_link_node=(hjstl_free_list_node*)mem;
//dispatch it to first level deallocate if the memory size bigger [128] bytes
if (sz > (size_t)__HJSTL_MAX_ALLOC_){
hjstl_first_malloc::hjstl_deallocate(mem, sz);
return;
}
//else,release this mem,and give it to free list.
//append it front of free list.
my_free_list = hjstl_free_list + HJSTL_FREELISTS_INDEX(sz);
append_link_node->free_list_link = *my_free_list;
*my_free_list = append_link_node;
}
//you cant to re-allocate memory?use this function
static void* hjstl_reallocate(void* oldmem, size_t oldsz, size_t newsz);
#ifdef HJSTL_DEBUG
//check the free list ,return the size's free list's node num
static size_t debug_hjstl_getnodesnum(size_t sz)
{
size_t result = 0;
hjstl_free_list_node* volatile* my_free_list;
hjstl_free_list_node* p;
my_free_list = hjstl_free_list + HJSTL_FREELISTS_INDEX(sz);
p = *my_free_list;
while (p != 0){
result++;
p = p->free_list_link;
}
cout << "The size " << sz << " free list nodes num is:" << result << endl;
return result;
}
//the left memory of memory pool
static size_t debug_hjstl_leftmem()
{
cout << "The left memory of memory pool is:" << (hjstl_memory_pool_end - hjstl_memory_pool_start) << endl;
return (hjstl_memory_pool_end - hjstl_memory_pool_start);
}
#endif
};
//implement the second level memory pool.
//this is the memory pool,and return an node for user,maybe
//update the free list but maybe not update.
template<int inst>
char* _hjstl_secnod_level_memory_pool_allocate<inst>::hjstl_mem_pool_chunk_alloc(size_t sz, int& Nnodes)
{
char* result;
size_t total_bytes_to_alloc = sz*Nnodes;
//the left memory of memory pool
size_t left_bytes_mempool = hjstl_memory_pool_end - hjstl_memory_pool_start;
//case 1,if the memory's memory is enough,just allocate.change the memory pool
if (left_bytes_mempool >= total_bytes_to_alloc){
result = hjstl_memory_pool_start;
hjstl_memory_pool_start += total_bytes_to_alloc;
return (result);
}
//case 2,check whether the left bytes reah 1 nodes of this size,if true,return
//the actual nodes we can give.
else if (left_bytes_mempool >= sz){
//calc how many nodes we can allocate
Nnodes = left_bytes_mempool / sz;
//change the memory pool
total_bytes_to_alloc = Nnodes*sz;
result = hjstl_memory_pool_start;
hjstl_memory_pool_start += total_bytes_to_alloc;
return (result);
}
//case 3,ok,we find the free list not memory<maybe>,so,call first level allocate
//to malloc a big chunk from os,and continue to allocate.
else{
size_t bytes_from_os = 8* total_bytes_to_alloc + HJSTL_ROUND_UP(hjstl_memory_pool_heap_size >> 4);
//whether old pool left some fragments?
if (left_bytes_mempool > 0){
hjstl_free_list_node* volatile* my_free_list =
hjstl_free_list + HJSTL_FREELISTS_INDEX(left_bytes_mempool);
((hjstl_free_list_node*)hjstl_memory_pool_start)->free_list_link =
*my_free_list;
*my_free_list = (hjstl_free_list_node*)hjstl_memory_pool_start;
}
//reboot the memory pool
hjstl_memory_pool_start = (char*)hjstl_first_malloc::hjstl_allocate(bytes_from_os);
//if the first level memory ask error<oom?>
if (0 == hjstl_memory_pool_start){
//this is the last way to allocate.check others free list,and
//release some others nodes,and re-try...
hjstl_free_list_node* volatile* my_free_list, *find_pointer;
for (int i = sz; i <= __HJSTL_MAX_ALLOC_; i += __HJSTL_MIN_ALLOC_){
my_free_list = hjstl_free_list + HJSTL_FREELISTS_INDEX(i);
find_pointer = *my_free_list;
if (0 != find_pointer){
*my_free_list = find_pointer->free_list_link;
hjstl_memory_pool_start = (char*)find_pointer;
hjstl_memory_pool_end += i;
//retry till get enough memory,the nnodes will reduce after run sometimes
return (hjstl_mem_pool_chunk_alloc(sz, Nnodes));
}
}
}//end of oom
//adjust the memory pool,and re-try
hjstl_memory_pool_heap_size += bytes_from_os;
hjstl_memory_pool_end = hjstl_memory_pool_start + bytes_from_os;
return (hjstl_mem_pool_chunk_alloc(sz, Nnodes));
}
}
//refill the free list.maybe 20nodes,maybe none
template<int inst>
void* _hjstl_secnod_level_memory_pool_allocate<inst>::hjstl_refill(size_t sz)
{
int default_nodes = 20; //you can change the num
char* alloc_chunk = hjstl_mem_pool_chunk_alloc(sz, default_nodes);
hjstl_free_list_node* volatile * my_free_list;
hjstl_free_list_node* result, *current_p, *next_p;
//if the memory just return 1 nodes,ok,return it and kill self..
if (1 == default_nodes) return (alloc_chunk);
//else,update the free list.
my_free_list = hjstl_free_list + HJSTL_FREELISTS_INDEX(sz);
//anyway,we need to give user one nodes.
result = (hjstl_free_list_node*)alloc_chunk;
//|*connect the nodes *|
*my_free_list = next_p = (hjstl_free_list_node*)(alloc_chunk + sz);
for (int i = 1;; i++){
current_p = next_p;
next_p = (hjstl_free_list_node*)((char*)next_p + sz);
if (default_nodes - 1 == i){//this is the last node
current_p->free_list_link = 0;
break;
}
else{//this is not the last node,pointer to next
current_p->free_list_link = next_p;
}
}
//everything done,return the result.
return (result);
}
//re-allocate
template<int inst>
void* _hjstl_secnod_level_memory_pool_allocate<inst>::hjstl_reallocate(void* oldmem, size_t oldsz, size_t newsz)
{
void* result;
size_t copy_size;
if (oldsz>(size_t)__HJSTL_MAX_ALLOC_&&newsz >(size_t)__HJSTL_MAX_ALLOC_){
return (hjstl_first_malloc::hjstl_reallocate(oldmem, oldsz, newsz));
}
//if same,just return
if (HJSTL_ROUND_UP(newsz) == HJSTL_ROUND_UP(oldsz)) return (oldmem);
//else,we use the second level allocate to do this job
result = hjstl_allocate(newsz);
//you should know if the newsz<oldsz,the data will lose.
copy_size = newsz > oldsz ? oldsz : newsz;
memcpy(result, oldmem, copy_size);
//release the old memory
hjstl_deallocate(oldmem, oldsz);
return (result);
}
//you can use this in your project
typedef _hjstl_secnod_level_memory_pool_allocate<0> hjstl_second_malloc;
typedef hjstl_second_malloc hjstl_memory_pool;
#endif //end of hjstl mempool
相应的，hjst空间配置器的部署就相当简单，见下面。
/*
* CopyRight (c) 2016
* HuJian in nankai edu.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
* This file is about HJSTL's memory allocate reference to SGI STL's allocate
* Time :2016/4/5 in nankai edu
*/
#ifndef _HJ_STL_ALLOC_H_
#define _HJ_STL_ALLOC_H_
#include "hjstlMemPool.h"
#define HJSTL_VERSION "hjstl version 1.0.1,hujian,copyright C 2016"
//ok,in this file,we do nothing but define the alloc,for some reason,i will
//define some allocate,you can use the follow allocates when you need.
template<int inst>
class ___hjstl_allocate_{
public:
//you can use the follow allocate.the follow allocate will use in hjstl
typedef hjstl_first_malloc Alloc_first;
typedef hjstl_second_malloc Alloc_second;
typedef hjstl_first_malloc Alloc_user_first;
typedef hjstl_second_malloc Alloc_user_second;
//you should not use the follow allocate.the follow allocate will use in hjstl
typedef hjstl_first_malloc HJSTL_Allocate;
typedef hjstl_second_malloc HJSTL_Allocate_default;
typedef HJSTL_Allocate_default Alloc;
};
//ok,you can use this in your project
typedef ___hjstl_allocate_<0> HJSTL_Alloc;
#endif //end of _HJ_STL_ALLOC_H_
至此，STL第一部分空间配置器学习完毕，下一步将进行数据结构的复习，一级迭代器的学习。