STL空间配置器（三）

上一篇没写完的代码，因为我用的是VS2013所以无法测试我的配置器，我是照着SGI的版本写的，所以不符合STL标准规范，而VS随身带的STL是符合STL规范的，所以我无法测试，等到我自己写好了迭代器，容器之后，就可以测试了，不过在这之前，我将专门用一篇文件来学习并且自己写一个内存池，然后将这个内存池部署到我的HJSTL里面，下面是完整的HJSTL 空间配置器代码 1.0.0，大规模模仿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.
 *
 * Time :2016/4/5 in nankai edu
*/
#ifndef _HJ_STL_ALLOC_H_
#define _HJ_STL_ALLOC_H_
#include<cstdio>
#include<climits>
#include<iostream>
#include<cstddef>

//if out of memory,just exit after print the info.
#define  _THROW_BAD_ALLOC cerr<<"out of memory"<<endl; exit(1);

//this is the new-handler handler,using when oom
void(*_malloc_alloc_oom_handler_hjstl)() = 0;

//this is the first class of mmu in hjstl,this class will work
//if the second dispatch the job to it.
template<int inst>
class _malloc_alloc_first{
private:
	static void* oom_malloc(size_t); //this function use to malloc and has the new-handler
	static void* oom_remalloc(void*, size_t);//re-malloc
public:
	//this function is the first allocator of hjstl
	static void* allocate(size_t size)
	{
		void* result = malloc(size);
		//check and dispatch it to oom_malloc if oom 
		if (0 == result) result = oom_malloc(size);
		return result;
	}
	//re-malloc,same as malloc
	static void* remallocate(void* old, size_t/*old mem size*/, size_t new_size)
	{
		void* result = realloc(old, new_size);
		if (0 == result) result = oom_remalloc(old, new_size);
		return result;
	}
	//de-allocate
	static void deallocate(void* mem, size_t size)
	{
		//we not use the memory pool,so just use free
		//but we will use the memory pool to manage the memory of 
		//hjstl later
		free(mem);
	}

	//we can use this function to set the new handler
	static void(*set_malloc_handler(void(*handler)()))()
	{
		//get the old oom handler,and we will return it to process
		void(*old)() = _malloc_alloc_oom_handler_hjstl;
		//set the new handler
		_malloc_alloc_oom_handler_hjstl = handler;
		return (old);
	}
};//end of malloc alloc first 


///---impelment the first allocate of hjstl
template<int inst>
void* _malloc_alloc_first<inst>::oom_malloc(size_t size)
{
	//this is the oom handler,this function will use this function when 
	//out of memory
	void(*my_malloc_handler)();
	void* result;
	for (;;){//i will loop to test till i get the memory
		my_malloc_handler = _malloc_alloc_oom_handler_hjstl;
		if (0 == my_malloc_handler) { _THROW_BAD_ALLOC; }
		//else,the handler defined,i can use it,run this handler
		(*my_malloc_handler)();
		result = malloc(size);
		if (result) return result;//succeed!!!
	}
}
//same as malloc
template<int inst>
void* _malloc_alloc_first<inst>::oom_remalloc(void* old, size_t size)
{
	void (* my_handler)();
	void* result;
	for (;;){
		my_handler = _malloc_alloc_oom_handler_hjstl;
		if (0 == myhandler) { _THROW_BAD_ALLOC; }
		(*my_handler)();
		result = realloc(old, size);
		if (result) return result;
	}
}

//ok,i need to define a first allocate,and if the second 
//allocate can not do it,let me try!
typedef _malloc_alloc_first<0> malloc_alloc_first_hjstl;

//we do this,because we need to let the HJSTL standard with STL
template<class Type,class HJALLOC>
class STD_STL_Alloc{
public:
	static Type* allocate(size_t size){
		return 0 == n ? 0 : (Type*)HJALLOC::allocate(size*sizeof(Type));
	}
	static Type* allocate(){
		return (Type*)HJALLOC::allocate(sizeof(Type));
	}
	static void deallocate(Type* mem,size_t size){
		if (size != 0){
			HJALLOC::deallocate(mem,size*sizeof(Type));
		}
	}
	static void deallocate(Type* mem){
		HJALLOC::deallocator(mem,sizeof(mem));
	}
};

//ok,start to write the second allocator
//and some auxiliary variable neeed to define here
#define  _ALIGN       8                     //the min mem block
#define  _MAX_BYTES   128               //the max mem block
#define  _NFREELISTS  _MAX_BYTES/_ALIGN  //this is the num of free list

template<int inst>//no thread supposed
class _malloc_alloc_second{
private:
	//round up a size
	static size_t HJSTL_ROUND_UP(size_t bytes){
		//ok,i use the SGI STL's round up method,it nice 
		return (((bytes)+_ALIGN - 1) & ~(_ALIGN - 1));
	}
	//this function will find the free list's position in the array actually
	static size_t HJSTL_FREELIST_INDEX(size_t bytes){
		//i just copy the sgi stl's code here.
		return (((bytes)+_ALIGN - 1) / _ALIGN - 1);
	}
	//this is the free list's node strcture
	//this is a usion.just copy the sgi stl's 
	union free_list_node{
		free_list_node* free_list_link;//store the next free list
		char            data[1];//if assigned,this is the user's data
	};
	//this is the array of free lists
	static free_list_node* free_list[_NFREELISTS];

	//return an object of size n,and this function will re-fill the
	//free list,update the free list array .
	static void* refill(size_t size);

	//memory pool,and allocate a chunk for nobjs of size 'size'
	//if the memory of pool is not so enough,this function will 
	//return the real num of nobjs
	static char* chunk_alloc(size_t size, int &nobjs);

	//this is a sample memory pool
	static char* pool_free_start;
	static char* pool_free_end;
	static size_t  heap_size; 

	//the second allocate
	static void* allocate(size_t size)
	{
		free_list_node*  my_free_list;
		free_list_node*  result;
		//dispatch the job,if the ask memory bigger _MAX_BYTES,use
		//the first allocate,else use the second allocate
		if (size > (size_t)_MAX_BYTES){
			return (malloc_alloc_first_hjstl::allocate(size));
		}
		//else ,use the second allocate to do this job
		//find the aim-free list 
		my_free_list = free_list + HJSTL_FREELIST_INDEX(size);
		//now,the result is the header pointer of this list
		result = *my_free_list;
		if (0 == result){//shirt,this list is empty,i will call refill to help me
			void* r = refill(HJSTL_ROUND_UP(size));
			return r;
		}
		//else,this free list is not empty,just use the header pointer
		//and change the free list.
		*my_free_list = result->free_list_link;
		return result;
	}

	//the second deallocate
	static void deallocate(void* mem, size_t size)
	{
		free_list_node* my_free_list;
		free_list_node* new_header_pointer = (free_list_node*)mem;
		//dispatch the job
		if (size > (size_t)_MAX_BYTES){
			malloc_alloc_first_hjstl::deallocate(mem, size);
			return;
		}
		//else,solve it.
		//first of all,i will find the free list's position
		my_free_list = free_list + HJSTL_FREELIST_INDEX(size);
		//change the list
		new_header_pointer->free_list_link = my_free_list;
		*my_free_list = new_header_pointer;
		return;
	}

	//this is the second reallocate
	static void* reallocate(void* old, size_t old_size, size_t new_size);

};//end of second allocator

//heihei,this is the default alloc,we will use this alloc in our project
typedef _malloc_alloc_second<0> hjstl_alloc;


//the follow function is the memory pool of hjstl
//and this function will allocate a large memory chunk in
//order to avoid fragement.
template<int inst>
char*    _malloc_alloc_second<inst>::chunk_alloc(size_t size, int&nobjs)
{
	char*  result;
	//the size the the num of each objs
	size_t total_bytes = size*nobjs;
	//the left bytes current
	size_t left_bytes = pool_free_end - pool_free_start;
	//then,if the memory pool's memory is enough,just give it and update the memory pool.
	if (total_bytes <= left_bytes){
		result = pool_free_start;
		pool_free_start += total_bytes;
		return result;
	}
	//else ,the pool's memory is not enough to allocate.
	//but the pool's memory left at least 1 size memory
	//just return it.
	//but,this part maybe left some fragment in the pool
	//so,before we re-fill this pool,we need to handle the lefe mem in pool
	else if (left_bytes >= size){
		//calc the counts we can allocate
		nobjs = left_bytes / size;
		//update the pool's size
		total_bytes = nobjs*size;
		result = pool_free_start;
		pool_free_start += total_bytes;
		return result;
	}
	//ok,the pool's memory is not enough to allocate 1 obj
	//then,we need to re-alloc memory to fill pool from os
	//but before doing this job,we need to check the pool's left memory
	//and handle it.<append the left mem to free list>
	else{
		size_t ask_bytes = 8* total_bytes + HJSTL_ROUND_UP(heap_size >> 4);
		//is any fragments in pool's 
		if (left_bytes > 0){
			free_list_node* my_free_list = free_list + HJSTL_FREELIST_INDEX(left_bytes);
			//append this fragment to free list
			((free_list_node*)pool_free_start)->free_list_link = *my_free_list;
			*my_free_list = (free_list_node*)pool_free_start;
		}
		//is any little fragment in pool now? if it is,just free it
		if (left_bytes<_ALIGN){
#ifdef _HJSTL_DUBUG_
			cout<<"little fragments left pool now...<in function chunk_alloc>"<<endl;
#endif
			int free_len = 0;
			while (free_len < left_bytes){
				free(pool_free_start);
				pool_free_start++;
			}
		}
		//it's time to re-allocate a big memory from os
		pool_free_start = (char*)malloc(ask_bytes);
		//but if the malloc fail
		if (0 == pool_free_start){
			free_list_node*  my_free_list, *find_list;
			//ok,we need to check the free lists and get some aproval size's
			//node to free,and re-try malloc,loop till we get the memory
			//but we will down to half ask to do it.
			if (ask_bytes / 2 && ask_bytes>(2* total_bytes + HJSTL_ROUND_UP(heap_size >> 4)))
					ask_bytes /= 2;
			for (int i = size; i <= _MAX_BLOCKS; i += _ALIGN){
				my_free_list = free_list + HJSTL_FREELIST_INDEX(i);
				find_list = *my_free_list;
				if (0 != find_list){
					//free an node of this list
					*my_free_list = find_list->free_list_link;
					//update the pool's size
					pool_free_start = (char*)find_list;
					pool_free_end = pool_free_start + i;
					//re-try
					return (chunk_alloc(size, njobs));
				}
			}// end of for loop
			//ok,you need to know we have no choice but ask first-allocate for help
			pool_free_end = 0;
			pool_free_start = (char*)malloc_alloc_first_hjstl::allocate(ask_bytes);
		}
		//well,if the program run to here,it say i have asked first-allocate for help
		//and now i have enough memory to give you
		//so,just adjust the pool's size and heap's size
		heap_size += ask_bytes;
		pool_free_end = pool_free_start + ask_bytes;
		//you can re-call self to complete the job now.
		//cause the pool's size is enough to  work.
		return (chunk_alloc(size, nobjs));
	}//end of re-allocate
}

//this is the re-fill function,and this function will adjust the free list
//and the main operator is call the chunk_alloc..
template<int inst>
void* _malloc_alloc_second<inst>::refill(size_t size)
{
	//the default nodes is 20,but you can adjust the num
	int default_nodes = 20;
	//allocate memory from pool
	char* chunk = chunk_alloc(size, default_nodes);
	free_list_node*  my_free_list, *result;
	free_list_node*  current_node, *next_node;
	//if the chunk_alloc just return 1 nodes,it's ok to use it,but do not 
	//need to adjust the free list
	if (1 == default_nodes)  return chunk;
	//else,not only return 1 node,but also adjust the free list
	my_free_list = free_list + HJSTL_FREELIST_INDEX(size);
	result = (free_list_node*)chunk;//just get one node,and return to user
	//connect the list,the first node give the user
	//the next_node pointer to the start of chunk we can use to adjust free list
	next_node = (free_list_node*)(chunk + size);
	*my_free_list = next_node;
	for (int i = 1;; i++){
		current_node = next_node;
		next_node = (free_list_node*)((char*)next_node + size);
		//if this is the last node
		if (i == default_nodes - 1){
			current_node->free_list_link = 0;
		}
		else{
			//this is not the last node
			current_node->free_list_link = next_node;
		}
	}
	return (result);
}

//re-allocate
template<int inst>
void* _malloc_alloc_second<inst>::reallocate(void* oldmem, size_t oldsz, size_t newsz)
{
	void* result;
	//if the size is no change.just return
	if (HJSTL_ROUND_UP(oldsz) == HJSTL_ROUND_UP(newsz)) return oldmem;
	//if the new size <old size,just return
	if (oldsz > newsz) return oldmem;
	//else,malloc,and copy data
	result = allocate(newsz);
	memcpy(rsult, oldmem, newsz);
	deallocate(oldmem, oldsz);
	return result;
}
#endif  //end of _HJ_STL_ALLOC_H_