#include "KePageAllocator.h"

 using namespace Knight;

 struct PageInfo

 {

 	PageInfo *next;

 	void *base;

 };

 class Knight::KePageAllocator

 {

 public:

 	size_t page_size;

 	size_t page_granularity;

 	PageInfo *free_pages;

 	PageInfo *page_blocks;

 };

 static void *ke_LumpPageAlloc(KePageAllocator *alloc)

 {

 	void *base;

 	char *page;

 	PageInfo *lump;

 	size_t pagesInBlock;

 #if defined KE_PLATFORM_WINDOWS

 	base = VirtualAlloc(

 		NULL,

 		alloc->page_granularity,

 		MEM_COMMIT|MEM_RESERVE,

 		PAGE_READWRITE);

 #elif defined KE_PLATFORM_POSIX

 	base = valloc(alloc->page_granularity);

 #else 

 #error "Unsupported platform"

 #endif

 	if (base == NULL)

 	{

 		return NULL;

 	}

 	lump = new PageInfo;

 	lump->base = base;

 	lump->next = alloc->page_blocks;

 	alloc->page_blocks = lump->next;

 	page = (char *)base + alloc->page_size;

 	pagesInBlock = alloc->page_granularity / alloc->page_size;

 	for (size_t i = 1; i < pagesInBlock; i++)

 	{

 		lump = new PageInfo;

 		lump->base = page;

 		lump->next = alloc->free_pages;

 		alloc->free_pages = lump;

 		page += alloc->page_size;

 	}

 	return base;

 }

 KePageAllocator *Knight::KE_CreatePageAllocator()

 {

 	KePageAllocator *alloc;

 	alloc = new KePageAllocator;

 #if defined KE_PLATFORM_WINDOWS

 	SYSTEM_INFO info;

 	GetSystemInfo(&info);

 	alloc->page_size = info.dwPageSize;

 	alloc->page_granularity = info.dwAllocationGranularity;

 #elif defined KE_PLATFORM_POSIX

 	alloc->page_size = sysconf(_SC_PAGESIZE);

 	alloc->page_granularity = alloc->page_size * 16;

 #else 

 #error "Unsupported platform"

 #endif

 	alloc->free_pages = NULL;

 	alloc->page_blocks = NULL;

 	return alloc;

 }

 void Knight::KE_DestroyPageAllocator(KePageAllocator *alloc)

 {

 	PageInfo *info, *next;

 	info = alloc->page_blocks;

 	while (info != NULL)

 	{

 		next = info->next;

 #if defined KE_PLATFORM_WINDOWS

 		VirtualFree(info->base, 0, MEM_RELEASE);

 #elif defined KE_PLATFORM_WINDOWS

 		free(info->base);

 #else 

 #error "Unsupported platform"

 #endif

 		delete info;

 		next = info;

 	}

 	info = alloc->free_pages;

 	while (info != NULL)

 	{

 		next = info->next;

 		delete info;

 		info = next;

 	}

 }

 void *Knight::KE_PageAlloc(KePageAllocator *alloc)

 {

 	if (alloc->free_pages != NULL)

 	{

 		void *base;

 		PageInfo *info;

 		info = alloc->free_pages;

 		alloc->free_pages = info->next;

 		base = info->base;

 		delete info;

 		return base;

 	}

 	return ke_LumpPageAlloc(alloc);

 }

 void Knight::KE_PageFree(KePageAllocator *alloc, void *page)

 {

 	PageInfo *info;

 	info = new PageInfo;

 	info->base = page;

 	info->next = alloc->free_pages;

 	alloc->free_pages = info->next;

 }

 size_t Knight::KE_PageSize(KePageAllocator *alloc)

 {

 	return alloc->page_size;

 }