/////?By?Fanxiushu?2015-10-15?用于服務(wù)端接管內(nèi)存分配釋放
#include?“common.h“
#include?“base_buffer.h“

int?base_buffer::header_length?=?（int）（int64_t）（&（（base_buffer*）0）->buffer[0]）;
///////

struct?BUF_SOLT
{
	int???????????alloc_size;?///??分配的大小?64128?256?512?1K?4K?8K?16K?32K?64K?
	LIST_ENTRY????head;???????///??
	spin_lock_t???lock;???????///??
	long??????????buf_count;??///??
	////////
	BUF_SOLT（?int?alloc_size?）{
		/////
		InitializeListHead（&head）;

		spin_lock_init（lock）;
		this->alloc_size?=?alloc_size;?
		this->buf_count?=?0;?
		////////
	//	printf（“ALLOC_SIZE=%d\n“?alloc_size?）;?/////
	}
	//////////////
	~BUF_SOLT（）{

		spin_lock_deinit（lock）;?////
		/////
	}

	/////////////////

};

static?struct?BUF_SOLT??buf_solt[]?=?
{
	BUF_SOLT（32）
	BUF_SOLT（64）
	BUF_SOLT（128）?
	BUF_SOLT（256）
	BUF_SOLT（512）
	BUF_SOLT（1024）
	BUF_SOLT（4096）
	BUF_SOLT（8192）
	BUF_SOLT（16*1024）
	BUF_SOLT（32*1024）
	BUF_SOLT（64*1024）
	BUF_SOLT（128*1024）
};

/////
#define?BUF_SOLT_COUNT???（?sizeof（buf_solt）?/?sizeof（buf_solt[0]）?）


base_buffer*?alloc_buffer（int?size）
{
	if?（size?<=?0）?return?NULL;
	////
	int?alloc_size?=?0;
	int?left_size?=?0;
	BUF_SOLT*?solt?=?NULL;?
	base_buffer*?base_buf?=?NULL;?////

	for?（?int?i?=?0;?i?		BUF_SOLT*?s?=?&buf_solt[i];
		if?（?size?>?left_size?&&?size?<=?s->alloc_size?）{
			solt?=?s;
			break;
		}

		left_size?=?s->alloc_size;??///?///
		////
	}

	if?（solt）{?
		////
		alloc_size?=?solt->alloc_size;

		spin_lock（?solt->lock?）;

		if?（!IsListEmpty（&solt->head））{

			PLIST_ENTRY?entry?=?RemoveHeadList（&solt->head）;?/////
			--solt->buf_count;
			base_buf?=?CONTAINING_RECORD（entry?base_buffer?list）;?/////
		}

		spin_unlock（?solt->lock?）;?
	}
	else{
		alloc_size?=?（（size?+?7）?/?8）?*?8;?///?8?的倍數(shù)
	}

	if?（base_buf）{

//		printf（“**?ALLOC?Buffer?from?POOL.?raw_size=%d?alloc_size=%d\n“?size?base_buf->alloc_size?）;

		base_buf->data_size?=?0;
		return?base_buf;
	}

	int?sz?=?base_buffer::header_length?+?alloc_size;

	base_buffer*?buf?=?（base_buffer*）malloc（sz）;
	InitializeListHead（&buf->list）;?
	buf->alloc_size?=?alloc_size;?
	buf->data_size?=?0;?

	return?buf;?
}

void?free_buffer（base_buffer*?buf）
{
	if?（!buf）?return;?
	for?（int?i?=?0;?i?		BUF_SOLT*?s?=?&buf_solt[i];

		if?（s->alloc_size?==?buf->alloc_size）{
	//		printf（“***?free?buffer?to?POOL.\n“）;?///

			spin_lock（?s->lock）;?

			InsertTailList（&s->head?&buf->list）;?/////
			++s->buf_count;

			spin_unlock（?s->lock?）;

			return;?
		}
		///////
	}

	//////
	printf（“***?Direct?FREE?BUFFER.\n“）;
	free（buf）;?////
}

/////////////////