// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// x86pc\nkern\tlsf.cpp
// 
//

#include <nktest/nkutils.h>

extern "C" {
extern TLinAddr RomHeaderAddress;
extern TLinAddr SuperPageAddress;
}

#define	BLOCK_STATUS_FREE	1u	// bit set if SBlock free
#define	BLOCK_STATUS_FINAL	2u	// bit set if this is last physical SBlock
#define BLOCK_SIZE_MASK		0xfffffffcu

struct SBlock
	{
	TUint32 size;					// bits 2-31 give size, bits 0,1 are status bits
	SBlock* predecessor;		// previous SBlock in physical address order
	};

struct SFreeBlock
	{
	SBlock b;
	SFreeBlock* next;			// next SBlock in same bucket, circular list
	SFreeBlock* prev;			// previous SBlock in same bucket, circular list
	};

struct STlsfAllocator
	{
public:
	static STlsfAllocator* Create(TAny* aBase, TUint32 aTotalSize);
	TAny* Alloc(TUint32 aSize);
	void Free(TAny* aCell);
	TAny* ReAlloc(TAny* aCell, TUint32 aSize);

	void Init(TUint32 aTotalSize);
	void InsertFree(SFreeBlock* aB);
	TUint32 MapSize(TUint32 aSize, TUint32* p_sli, TInt round_up);
	SFreeBlock* FindFree(TUint32 aSize);
	void RemoveFree(SFreeBlock* aB);
	TUint32 ConsistencyCheck();
public:
	TUint32	imin_size;			// minimum SBlock size
	TUint32 itotal_size;		// total size of allocated and free blocks
	TUint32 il2min;				// log2 min size
	TUint32 infl;				// number of first level lists
	TUint32 insl;				// number of second level lists
	TUint32 il2nsl;
	SFreeBlock** isll;			// pointer to first second level list pointer for minimum size
	TUint32 iflb;				// first level bitmap
	SBlock* iff;				// first free address
	TUint32 islb[1];			// second level bitmaps, one for each first level list
								// second level lists follow, nsl pointers for each first level list
	};

STlsfAllocator* TheAllocator;
NFastMutex AllocMutex;

STlsfAllocator* STlsfAllocator::Create(void* aBase, TUint32 aTotalSize)
	{
	STlsfAllocator* p = (STlsfAllocator*)aBase;
	p->Init(aTotalSize);
	return p;
	}

void STlsfAllocator::Init(TUint32 total_size)
	{
	TUint32 a;
	imin_size = 16;
	il2min = 4;
	insl = 16;
	il2nsl = 4;
	itotal_size = total_size;
	infl = __e32_find_ms1_32(total_size) - il2min + 1;
	iflb = 0;
	a = (TUint32)&islb[infl];
	a = (a+63)&~63;
	isll = (SFreeBlock**)a;
	a += insl * infl * sizeof(TUint32*);
	iff = (SBlock*)a;
	a -= (TUint32)this;
	memset(islb, 0, total_size - sizeof(STlsfAllocator) + sizeof(TUint32));
	iff->size = (total_size - a) | BLOCK_STATUS_FINAL;
	iff->predecessor = 0;
	Free(iff+1);
	}

// size already rounded up to multiple of min_size
TUint32 STlsfAllocator::MapSize(TUint32 size, TUint32* p_sli, TInt round_up)
	{
	TUint32 sli = size >> il2min;
	TUint32 fli = __e32_find_ms1_32(sli);
	sli -= (1u<<fli);
	if (fli > il2nsl)
		{
		TUint32 sls = (fli - il2nsl);
		TUint32 sz2 = sli;
		sli >>= sls;
		if (round_up && ((sli << sls) < sz2) )
			{
			if (++sli == insl)
				sli=0, ++fli;
			}
		}
	*p_sli = sli;
	return fli;
	}

SFreeBlock* STlsfAllocator::FindFree(TUint32 size)
	{
	TUint32 sli;
	TUint32 fli = MapSize(size, &sli, 1);
	TUint32 sli2;
	TUint32 fli2;
	SFreeBlock** sll;
	SFreeBlock* b;
	TUint32 act_sz;

	if ((iflb >> fli) & 1)
		{
		if ((islb[fli]>>sli)==0)
			++fli, sli=0;
		}
	else
		sli = 0;
	if (fli >= infl)
		return 0;
	fli2 = __e32_find_ls1_32(iflb >> fli);
	if ((TInt)fli2 < 0)
		return 0;
	fli2 += fli;
	sli2 = __e32_find_ls1_32(islb[fli2] >> sli) + sli;	// must find a 1
	sll = &isll[(fli2 << il2nsl) | sli2];
	b = *sll;
	if (b->next == b)
		{
		// list now empty
		*sll = 0;
		if ( (islb[fli2] &= ~(1u<<sli2)) == 0 )
			iflb &= ~(1u<<fli2);
		}
	else
		{
		*sll = b->next;
		b->next->prev = b->prev;
		b->prev->next = b->next;
		}
	act_sz = b->b.size & BLOCK_SIZE_MASK;
	if (act_sz > size)
		{
		// free the extra
		SBlock* nfb = (SBlock*)((TUint32)b + size);
		nfb->size = (act_sz - size) | (b->b.size & BLOCK_STATUS_FINAL);
		nfb->predecessor = &b->b;
		if (!(b->b.size & BLOCK_STATUS_FINAL))
			{
			// if this isn't final SBlock, update predecessor of following SBlock
			SBlock* nb = (SBlock*)((TUint32)b + act_sz);
			nb->predecessor = nfb;
			}
		InsertFree((SFreeBlock*)nfb);
		b->b.size = 0;	// allocated SBlock can't be final
		}
	b->b.size &= BLOCK_STATUS_FINAL;
	b->b.size |= size;
	return b;
	}

void STlsfAllocator::InsertFree(SFreeBlock* b)
	{
	TUint32 size = b->b.size & BLOCK_SIZE_MASK;
	TUint32 sli;
	TUint32 fli = MapSize(size, &sli, 0);
	SFreeBlock** sll = &isll[(fli << il2nsl) | sli];
	if (*sll)
		{
		SFreeBlock* first = *sll;
		b->next = first;
		b->prev = first->prev;
		first->prev->next = b;
		first->prev = b;
		}
	else
		{
		b->next = b;
		b->prev = b;
		islb[fli] |= (1u<<sli);
		iflb |= (1u<<fli);
		}
	*sll = b;
	b->b.size |= BLOCK_STATUS_FREE;
	}

void STlsfAllocator::RemoveFree(SFreeBlock* b)
	{
	TUint32 size = b->b.size & BLOCK_SIZE_MASK;
	TUint32 sli;
	TUint32 fli = MapSize(size, &sli, 0);
	SFreeBlock** sll = &isll[(fli << il2nsl) | sli];
	if (b->next != b)
		{
		if (*sll == b)
			*sll = b->next;
		b->next->prev = b->prev;
		b->prev->next = b->next;
		return;
		}
	*sll = 0;
	if ( (islb[fli] &= ~(1u<<sli)) == 0)
		iflb &= ~(1u<<fli);
	}

TAny* STlsfAllocator::Alloc(TUint32 size)
	{
	SFreeBlock* b;
	TUint32 msm = imin_size - 1;

	size = (size + sizeof(SBlock) + msm) &~ msm;

	b = FindFree(size);
	if (b)
		return &b->next;
	return 0;
	}

void STlsfAllocator::Free(TAny* cell)
	{
	SBlock* b = ((SBlock*)cell) - 1;
//	SFreeBlock* fb = (SFreeBlock*)b;
	TUint32 size;
	if (!cell)
		return;
	size = b->size & BLOCK_SIZE_MASK;
	if (!(b->size & BLOCK_STATUS_FINAL))
		{
		// not last SBlock
		SBlock* nb = (SBlock*)((TUint32)b + size);
		TUint32 nbs = nb->size;
		if (nbs & BLOCK_STATUS_FREE)
			{
			// following SBlock is free
			RemoveFree((SFreeBlock*)nb);
			b->size = size + (nbs &~ BLOCK_STATUS_FREE);	// keeps final flag from following SBlock
			size = b->size & BLOCK_SIZE_MASK;
			if (!(nbs & BLOCK_STATUS_FINAL))
				{
				nb = (SBlock*)((TUint32)b + size);
				nb->predecessor = b;
				}
			}
		}
	if (b->predecessor && b->predecessor->size & BLOCK_STATUS_FREE)
		{
		// predecessor SBlock is free
		TUint32 psz = b->predecessor->size & BLOCK_SIZE_MASK;
		RemoveFree((SFreeBlock*)b->predecessor);
		psz += b->size; // keeps final flag if necessary
		b->predecessor->size = psz;
		b = b->predecessor;
		if (!(psz & BLOCK_STATUS_FINAL))
			{
			// need to adjust prev pointer of following SBlock
			SBlock* nb = (SBlock*)((TUint32)b + psz);
			nb->predecessor = b;
			}
		}
	InsertFree((SFreeBlock*)b);
	}

TAny* STlsfAllocator::ReAlloc(TAny* cell, TUint32 newsize)
	{
	SBlock* b;
	TUint32 size;
	TUint32 msm;
	SBlock* nb;
	TAny* newcell;

	if (!cell)
		return (newsize>0) ? Alloc(newsize) : 0;
	if (newsize == 0)
		{
		Free(cell);
		return 0;
		}
	b = ((SBlock*)cell) - 1;
	size = b->size & BLOCK_SIZE_MASK;
	msm = imin_size - 1;
	newsize = (newsize + sizeof(SBlock) + msm) &~ msm;
	if (newsize > size)
		{
		nb = (SBlock*)((TUint32)b + size);
		if (nb->size & BLOCK_STATUS_FREE)
			{
			// following SBlock is free
			TUint32 nbs = nb->size;
			if (nbs + size >= newsize)
				{
				// we can expand in place - grab the entire free SBlock for now
				// it will be split if necessary in the next section of code
				RemoveFree((SFreeBlock*)nb);
				b->size = size + (nbs &~ BLOCK_STATUS_FREE);	// keeps final flag from following SBlock
				size = b->size & BLOCK_SIZE_MASK;
				if (!(nbs & BLOCK_STATUS_FINAL))
					{
					SBlock* nnb = (SBlock*)((TUint32)b + size);
					nnb->predecessor = b;
					}
				}
			}
		}
	if (newsize == size)
		return cell;
	if (newsize < size)
		{
		// shrinking - split SBlock
		TUint32 final = b->size & BLOCK_STATUS_FINAL;
		SBlock* nfb = (SBlock*)((TUint32)b + newsize);
		nfb->size = (size - newsize) | final;
		nfb->predecessor = b;
		if (!final)
			{
			// if this isn't final SBlock, update predecessor of following SBlock
			nb = (SBlock*)((TUint32)b + size);
			nb->predecessor = nfb;
			}
		b->size = newsize;	// original SBlock can't be final
		Free((SBlock*)nfb + 1);
		return cell;
		}

	// must move SBlock to expand
	newcell = Alloc(newsize);
	if (newcell)
		{
		memcpy(newcell, cell, size);
		Free(cell);
		}
	return newcell;
	}

TUint32 STlsfAllocator::ConsistencyCheck()
	{
	TUint32 a;
	TUint32 szs = 0;
	TUint32 size;
	TUint32 total_user_size;
	TUint32 total_block_size = 0;
	TUint32 block_count = 0;
	TUint32 flb = 0;
	TUint32 slb[32];
	TUint32 sli;
	TUint32 fli;
	TUint32 total_free = 0;
	SBlock* b = iff;
	SBlock* pb = 0;

	memset(slb, 0, sizeof(slb));
	__NK_ASSERT_DEBUG(imin_size == 16);
	__NK_ASSERT_DEBUG(insl == 16);
	__NK_ASSERT_DEBUG(il2min == 4);
	__NK_ASSERT_DEBUG(il2nsl == 4);
	__NK_ASSERT_DEBUG(infl == __e32_find_ms1_32(itotal_size) - il2min + 1);
	a = (TUint32)&islb[infl];
	a = (a+63)&~63;
	__NK_ASSERT_DEBUG(isll == (SFreeBlock**)a);
	a += insl * infl * sizeof(TUint32*);
	__NK_ASSERT_DEBUG(iff == (SBlock*)a);
	total_user_size = itotal_size - (a - (TUint32)this);

	do	{
		szs = b->size;
		size = szs & BLOCK_SIZE_MASK;
		__NK_ASSERT_DEBUG(b->predecessor == pb);
		__NK_ASSERT_DEBUG(size > 0);
		__NK_ASSERT_DEBUG(size <= total_user_size);
		__NK_ASSERT_DEBUG(size == ((size >> il2min) << il2min));
		total_block_size += size;
		++block_count;
		pb = b;
		b = (SBlock*)((TUint32)b + size);
		} while(!(szs & BLOCK_STATUS_FINAL));
	__NK_ASSERT_DEBUG((TUint32)b == (TUint32)this + itotal_size);
	__NK_ASSERT_DEBUG(total_block_size == total_user_size);

	b = iff;
	do	{
		szs = b->size;
		size = szs & BLOCK_SIZE_MASK;
		if (szs & BLOCK_STATUS_FREE)
			{
			SFreeBlock* fb = (SFreeBlock*)b;
			SFreeBlock* pfb = fb;
			SFreeBlock* lh;
			TUint32 lhi;
			TInt lh_found = 0;
			TInt c = (TInt)block_count;
			TUint32 fli = __e32_find_ms1_32(size) - il2min;
			TUint32 sli = (size >> il2min) - (1u << fli);
			TUint32 sli2;
			TUint32 fli2 = MapSize(size, &sli2, 0);
			(void)sli2, (void)fli2;
			if (fli > il2nsl)
				sli >>= (fli - il2nsl);
			__NK_ASSERT_DEBUG(fli == fli2);
			__NK_ASSERT_DEBUG(sli == sli2);
			flb |= (1u << fli);
			slb[fli] |= (1u << sli);
			lhi = (fli << il2nsl) | sli;
			lh = isll[lhi];
			do	{
				if (fb == lh)
					lh_found = 1;
				pfb = fb;
				fb = fb->next;
				__NK_ASSERT_DEBUG(fb->prev == pfb);
				__NK_ASSERT_DEBUG(fb->b.size & BLOCK_STATUS_FREE);
				} while ((fb != (SFreeBlock*)b) && --c>=0);
			__NK_ASSERT_DEBUG(fb == (SFreeBlock*)b);
			__NK_ASSERT_DEBUG(lh_found);
			total_free += size;
			}
		b = (SBlock*)((TUint32)b + size);
		} while(!(szs & BLOCK_STATUS_FINAL));

	__NK_ASSERT_DEBUG(flb == iflb);
	for (fli=0; fli<infl; ++fli)
		{
		__NK_ASSERT_DEBUG(slb[fli] == islb[fli]);
		if (!(flb & (1u<<fli)))
			__NK_ASSERT_DEBUG(slb[fli]==0);
		for (sli=0; sli<insl; ++sli)
			{
			TUint32 lhi = (fli << il2nsl) | sli;
			(void)lhi;
			if (!(slb[fli] & (1u<<sli)))
				__NK_ASSERT_DEBUG(!isll[lhi]);
			}
		}
	return total_free;
	}

#define __E32CMN_H__

#undef EXPORT_C
#define EXPORT_C /* */

class TVersion
	{
public:
	TInt8 iMajor;
	TInt8 iMinor;
	TInt16 iBuild;
	};

class TDesC;

#include <e32rom.h>
#include "kernboot.h"

extern "C" {
void SetupMemoryAllocator()
	{
	const SSuperPageBase& sp = *(const SSuperPageBase*)SuperPageAddress;
	const TRomHeader& romHdr = *(const TRomHeader*)RomHeaderAddress;
	const TRomEntry* primaryEntry = (const TRomEntry*)sp.iPrimaryEntry;
	const TRomImageHeader* primaryImageHeader = (const TRomImageHeader*)primaryEntry->iAddressLin;
	TLinAddr stack = romHdr.iKernDataAddress + round_to_page(romHdr.iTotalSvDataSize);
	TLinAddr heapbase = stack + round_to_page(primaryImageHeader->iStackSize);
	TLinAddr heapsize = sp.iInitialHeapSize;

	KPrintf("Heap base %08x size %08x", heapbase, heapsize);
	TheAllocator = STlsfAllocator::Create((TAny*)heapbase, heapsize);
	}

extern TBool InitialThreadDefined;

TAny* malloc(TUint32 aSize)
	{
//	__KTRACE_OPT(KMMU,DEBUGPRINT("malloc(%d)",aSize));
	if (InitialThreadDefined)
		NKern::FMWait(&AllocMutex);
	TAny* p = TheAllocator->Alloc(aSize);
	if (InitialThreadDefined)
		NKern::FMSignal(&AllocMutex);
	__KTRACE_OPT(KMMU,DEBUGPRINT("malloc(%d)->%08x",aSize,p));
	return p;
	}

void free(TAny* aCell)
	{
	__KTRACE_OPT(KMMU,DEBUGPRINT("free(%08x)",aCell));
#ifdef _DEBUG
	if (aCell)
		{
		SBlock* b = (SBlock*)aCell;
		TUint32 size = b[-1].size & BLOCK_SIZE_MASK;
		memset(aCell, 0xde, size - sizeof(SBlock));
		}
#endif
	NKern::FMWait(&AllocMutex);
	TheAllocator->Free(aCell);
	NKern::FMSignal(&AllocMutex);
	}

TAny* realloc(TAny* aCell, TUint32 aSize)
	{
	NKern::FMWait(&AllocMutex);
	TAny* p = TheAllocator->ReAlloc(aCell, aSize);
	NKern::FMSignal(&AllocMutex);
	return p;
	}
}