/*

* Copyright (c) 2006 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:  

*

*

*/

#include "common.h"

#ifdef TRACE_CHUNK_USAGE

void TraceChunkUsage(TInt aChunkHandle, TUint8* aBase, TInt aChunkSize)

	{

	RDebug::Print(_L("MEM: c,%d,%d,%d"), aChunkHandle, aBase, aChunkSize);

	}

#else

#define TraceChunkUsage(a,b,c)

#endif

#ifdef __NEW_ALLOCATOR__

#include "SymbianDLHeap.h"

_LIT(KDLHeapPanicCategory, "DL Heap");

#define	GET_PAGE_SIZE(x)			UserHal::PageSizeInBytes(x)

#define	__CHECK_CELL(p)

#define __POWER_OF_2(x)				((TUint32)((x)^((x)-1))>=(TUint32)(x))

#define gm  (&iGlobalMallocState)

void Panic(TCdtPanic aPanic)

	{

	User::Panic(KDLHeapPanicCategory, aPanic);

	}

#undef UEXPORT_C

#define UEXPORT_C 

UEXPORT_C RSymbianDLHeap::RSymbianDLHeap(TInt aMaxLength, TInt aAlign, TBool aSingleThread)

// constructor for a fixed heap. Just use DL allocator

	:iMinLength(aMaxLength), iMaxLength(aMaxLength), iOffset(0), iGrowBy(0), iChunkHandle(0),

	iNestingLevel(0), iAllocCount(0), iFailType(ENone), iTestData(NULL), iChunkSize(aMaxLength)

	{

	// bodge so GKIServ (hudson generic low level layer) starts up ok - it uses an aAlign of 0 which panics, so if see 0 then force to 4

	if ((TUint32)aAlign>=sizeof(TAny*) && __POWER_OF_2(iAlign))

		{

		iAlign = aAlign;

		}

	else

		{

		iAlign = 4;

		}

	iPageSize = 0;

	iFlags = aSingleThread ? (ESingleThreaded|EFixedSize) : EFixedSize;

	Init(0, 0, 0);

	}

UEXPORT_C RSymbianDLHeap::RSymbianDLHeap(TInt aChunkHandle, TInt aOffset, TInt aMinLength, TInt aMaxLength, TInt aGrowBy,

			TInt aAlign, TBool aSingleThread)

		: iMinLength(aMinLength), iMaxLength(aMaxLength), iOffset(aOffset), iChunkHandle(aChunkHandle), iNestingLevel(0), iAllocCount(0),

			iAlign(aAlign),iFailType(ENone), iTestData(NULL), iChunkSize(aMinLength)

	{

	// TODO: Locked the page size to 4 KB - change this to pick up from the OS

	GET_PAGE_SIZE(iPageSize);

	__ASSERT_ALWAYS(aOffset >=0, User::Panic(KDLHeapPanicCategory, ETHeapNewBadOffset));

	iGrowBy = _ALIGN_UP(aGrowBy, iPageSize);

	iFlags = aSingleThread ? ESingleThreaded : 0;

	// Initialise

	// if the heap is created with aMinLength==aMaxLength then it cannot allocate slab or page memory

	// so these sub-allocators should be disabled. Otherwise initialise with default values

	if (aMinLength == aMaxLength)

		Init(0, 0, 0);

	else

		Init(0x3fff, 16, 0x10000);	// all slabs, page {64KB}, trim {64KB}

//		Init(0xabe, 16, iPageSize*4);	// slabs {48, 40, 32, 24, 20, 16, 12}, page {64KB}, trim {16KB}

	}

UEXPORT_C TAny* RSymbianDLHeap::operator new(TUint aSize, TAny* aBase) __NO_THROW

	{

	__ASSERT_ALWAYS(aSize>=sizeof(RSymbianDLHeap), HEAP_PANIC(ETHeapNewBadSize));

	RSymbianDLHeap* h = (RSymbianDLHeap*)aBase;

	h->iAlign = 0x80000000;	// garbage value

	h->iBase = ((TUint8*)aBase) + aSize;

	return aBase;

	}

void RSymbianDLHeap::Init(TInt aBitmapSlab, TInt aPagePower, size_t aTrimThreshold)

	{

	__ASSERT_ALWAYS((TUint32)iAlign>=sizeof(TAny*) && __POWER_OF_2(iAlign), HEAP_PANIC(ETHeapNewBadAlignment));

	/*Moved code which does iunitilization */

	iTop = (TUint8*)this + iMinLength;

	spare_page = 0;

	memset(&mparams,0,sizeof(mparams));

	Init_Dlmalloc(iTop - iBase, 0, aTrimThreshold);

	slab_init(aBitmapSlab);

	/*10-1K,11-2K,12-4k,13-8K,14-16K,15-32K,16-64K*/

	paged_init(aPagePower);

	}

UEXPORT_C RSymbianDLHeap::SCell* RSymbianDLHeap::GetAddress(const TAny* aCell) const

//

// As much as possible, check a cell address and backspace it

// to point at the cell header.

//

	{

	TLinAddr m = TLinAddr(iAlign - 1);

	__ASSERT_ALWAYS(!(TLinAddr(aCell)&m), HEAP_PANIC(ETHeapBadCellAddress));

	SCell* pC = (SCell*)(((TUint8*)aCell)-EAllocCellSize);

	__CHECK_CELL(pC);

	return pC;

	}

UEXPORT_C TInt RSymbianDLHeap::AllocLen(const TAny* aCell) const

{

	if (ptrdiff(aCell, this) >= 0)

	{

		mchunkptr m = mem2chunk(aCell);

		return chunksize(m) - CHUNK_OVERHEAD;

	}

	if (lowbits(aCell, pagesize) > cellalign)

		return header_size(slab::slabfor(aCell)->header);

	if (lowbits(aCell, pagesize) == cellalign)

		return *(unsigned*)(offset(aCell,-int(cellalign)))-cellalign;

	return paged_descriptor(aCell)->size;

}

UEXPORT_C TAny* RSymbianDLHeap::Alloc(TInt aSize)

{

	__ASSERT_ALWAYS((TUint)aSize<(KMaxTInt/2),HEAP_PANIC(ETHeapBadAllocatedCellSize));

	TAny* addr;

	Lock();

	if (aSize < slab_threshold)

	{

		TInt ix = sizemap[(aSize+3)>>2];

		ASSERT(ix != 0xff);

		addr = slab_allocate(slaballoc[ix]);

	}else if((aSize >> page_threshold)==0)

		{

		addr = dlmalloc(aSize);

		}

	else

		{

		addr = paged_allocate(aSize);

		}

	Unlock();

	return addr;

}

UEXPORT_C TInt RSymbianDLHeap::Compress()

	{

	if (iFlags & EFixedSize)

		return 0;

	Lock();

	dlmalloc_trim(0);

	if (spare_page)

	{

		unmap(spare_page, pagesize);

		spare_page = 0;

	}

	Unlock();

	return 0;

	}

UEXPORT_C void RSymbianDLHeap::Free(TAny* aPtr)

{

	Lock();

	if (!aPtr)

		;

	else if (ptrdiff(aPtr, this) >= 0)

		{

		dlfree( aPtr);

		}

	else if (lowbits(aPtr, pagesize) <= cellalign)

		{

		paged_free(aPtr);

		}

	else

		{

		slab_free(aPtr);

		}

	Unlock();

}

UEXPORT_C void RSymbianDLHeap::Reset()

	{

	// TODO free everything

	}

UEXPORT_C TAny* RSymbianDLHeap::ReAlloc(TAny* aPtr, TInt aSize, TInt /*aMode = 0*/)

//

// Support aMode==0 properly: do not move the cell if the request is smaller than old size

//

	{

	if(ptrdiff(aPtr,this)>=0)

	{

		// original cell is in DL zone

		if((aSize>>page_threshold)==0 || aSize <= chunksize(mem2chunk(aPtr)) - CHUNK_OVERHEAD)

			{

			// new one is below page limit or smaller than old one (so can't be moved)

			Lock();

			TAny* addr = dlrealloc(aPtr,aSize);

			Unlock();

			return addr;

			}

	}

	else if(lowbits(aPtr,pagesize)<=cellalign)

	{

		// original cell is either NULL or in paged zone

		if (!aPtr)

			return Alloc(aSize);

		// either the new size is larger (in which case it will still be in paged zone)

		// or it is smaller, but we will never move a shrinking cell so in paged zone

		// must handle [rare] case that aSize == 0, as paged_[re]allocate() will panic

		if (aSize == 0)

			aSize = 1;

		Lock();

		TAny* addr = paged_reallocate(aPtr,aSize);

		Unlock();

		return addr;

	}

	else

	{

		// original cell is in slab zone

		// return original if new one smaller

		if(aSize <= header_size(slab::slabfor(aPtr)->header))

			return aPtr;

	}

	// can't do better than allocate/copy/free

	TAny* newp = Alloc(aSize);

	if(newp)

	{

		TInt oldsize = AllocLen(aPtr);

		memcpy(newp,aPtr,oldsize<aSize?oldsize:aSize);

		Free(aPtr);

	}

	return newp;

	}

UEXPORT_C TInt RSymbianDLHeap::Available(TInt& aBiggestBlock) const

{

	aBiggestBlock = 0;

	return 1000;

	/*Need to see how to implement this*/

	// TODO: return iHeap.Available(aBiggestBlock);

}

UEXPORT_C TInt RSymbianDLHeap::AllocSize(TInt& aTotalAllocSize) const

{

	aTotalAllocSize = 0;

	return 0;

}

UEXPORT_C TInt RSymbianDLHeap::DebugFunction(TInt /*aFunc*/, TAny* /*a1*/, TAny* /*a2*/)

	{

	return 0;

	}

UEXPORT_C TInt RSymbianDLHeap::Extension_(TUint /* aExtensionId */, TAny*& /* a0 */, TAny* /* a1 */)

	{

	return KErrNotSupported;

	}

long    sysconf		(int size )

	{

	if (UserHal::PageSizeInBytes(size)!=KErrNone)

		size = 0x1000;

	return size;

	}

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

// imported from dla.cpp

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

//#include <unistd.h>

//#define DEBUG_REALLOC

#ifdef DEBUG_REALLOC

#include <e32debug.h>

#endif

inline int RSymbianDLHeap::init_mparams(size_t aTrimThreshold /*= DEFAULT_TRIM_THRESHOLD*/)

{

	if (mparams.page_size == 0)

	{

		size_t s;

		mparams.mmap_threshold = DEFAULT_MMAP_THRESHOLD;

		mparams.trim_threshold = aTrimThreshold;

		#if MORECORE_CONTIGUOUS

			mparams.default_mflags = USE_LOCK_BIT|USE_MMAP_BIT;

		#else  /* MORECORE_CONTIGUOUS */

			mparams.default_mflags = USE_LOCK_BIT|USE_MMAP_BIT|USE_NONCONTIGUOUS_BIT;

		#endif /* MORECORE_CONTIGUOUS */

			s = (size_t)0x58585858U;

		ACQUIRE_MAGIC_INIT_LOCK(&mparams);

		if (mparams.magic == 0) {

		  mparams.magic = s;

		  /* Set up lock for main malloc area */

		  INITIAL_LOCK(&gm->mutex);

		  gm->mflags = mparams.default_mflags;

		}

		RELEASE_MAGIC_INIT_LOCK(&mparams);

		// DAN replaced

		// mparams.page_size = malloc_getpagesize;

		int temp = 0;

		GET_PAGE_SIZE(temp);

		mparams.page_size = temp;

		mparams.granularity = ((DEFAULT_GRANULARITY != 0)?

							   DEFAULT_GRANULARITY : mparams.page_size);

		/* Sanity-check configuration:

		   size_t must be unsigned and as wide as pointer type.

		   ints must be at least 4 bytes.

		   alignment must be at least 8.

		   Alignment, min chunk size, and page size must all be powers of 2.

		*/

		if ((sizeof(size_t) != sizeof(TUint8*)) ||

			(MAX_SIZE_T < MIN_CHUNK_SIZE)  ||

			(sizeof(int) < 4)  ||

			(MALLOC_ALIGNMENT < (size_t)8U) ||

			((MALLOC_ALIGNMENT    & (MALLOC_ALIGNMENT-SIZE_T_ONE))    != 0) ||

			((MCHUNK_SIZE         & (MCHUNK_SIZE-SIZE_T_ONE))         != 0) ||

			((mparams.granularity & (mparams.granularity-SIZE_T_ONE)) != 0) ||

			((mparams.page_size   & (mparams.page_size-SIZE_T_ONE))   != 0))

		  ABORT;

	}

	return 0;

}

inline void RSymbianDLHeap::init_bins(mstate m) {

  /* Establish circular links for smallbins */

  bindex_t i;

  for (i = 0; i < NSMALLBINS; ++i) {

    sbinptr bin = smallbin_at(m,i);

    bin->fd = bin->bk = bin;

  }

}

/* ---------------------------- malloc support --------------------------- */

/* allocate a large request from the best fitting chunk in a treebin */

void* RSymbianDLHeap::tmalloc_large(mstate m, size_t nb) {

  tchunkptr v = 0;

  size_t rsize = -nb; /* Unsigned negation */

  tchunkptr t;

  bindex_t idx;

  compute_tree_index(nb, idx);

  if ((t = *treebin_at(m, idx)) != 0) {

    /* Traverse tree for this bin looking for node with size == nb */

    size_t sizebits =

    nb <<

    leftshift_for_tree_index(idx);

    tchunkptr rst = 0;  /* The deepest untaken right subtree */

    for (;;) {

      tchunkptr rt;

      size_t trem = chunksize(t) - nb;

      if (trem < rsize) {

        v = t;

        if ((rsize = trem) == 0)

          break;

      }

      rt = t->child[1];

      t = t->child[(sizebits >> (SIZE_T_BITSIZE-SIZE_T_ONE)) & 1];

      if (rt != 0 && rt != t)

        rst = rt;

      if (t == 0) {

        t = rst; /* set t to least subtree holding sizes > nb */

        break;

      }

      sizebits <<= 1;

    }

  }

  if (t == 0 && v == 0) { /* set t to root of next non-empty treebin */

    binmap_t leftbits = left_bits(idx2bit(idx)) & m->treemap;

    if (leftbits != 0) {

      bindex_t i;

      binmap_t leastbit = least_bit(leftbits);

      compute_bit2idx(leastbit, i);

      t = *treebin_at(m, i);

    }

  }

  while (t != 0) { /* find smallest of tree or subtree */

    size_t trem = chunksize(t) - nb;

    if (trem < rsize) {

      rsize = trem;

      v = t;

    }

    t = leftmost_child(t);

  }

  /*  If dv is a better fit, return 0 so malloc will use it */

  if (v != 0 && rsize < (size_t)(m->dvsize - nb)) {

    if (RTCHECK(ok_address(m, v))) { /* split */

      mchunkptr r = chunk_plus_offset(v, nb);

      assert(chunksize(v) == rsize + nb);

      if (RTCHECK(ok_next(v, r))) {

        unlink_large_chunk(m, v);

        if (rsize < MIN_CHUNK_SIZE)

          set_inuse_and_pinuse(m, v, (rsize + nb));

        else {

          set_size_and_pinuse_of_inuse_chunk(m, v, nb);

          set_size_and_pinuse_of_free_chunk(r, rsize);

          insert_chunk(m, r, rsize);

        }

        return chunk2mem(v);

      }

    }

    CORRUPTION_ERROR_ACTION(m);

  }

  return 0;

}

/* allocate a small request from the best fitting chunk in a treebin */

void* RSymbianDLHeap::tmalloc_small(mstate m, size_t nb) {

  tchunkptr t, v;

  size_t rsize;

  bindex_t i;

  binmap_t leastbit = least_bit(m->treemap);

  compute_bit2idx(leastbit, i);

  v = t = *treebin_at(m, i);

  rsize = chunksize(t) - nb;

  while ((t = leftmost_child(t)) != 0) {

    size_t trem = chunksize(t) - nb;

    if (trem < rsize) {

      rsize = trem;

      v = t;

    }

  }

  if (RTCHECK(ok_address(m, v))) {

    mchunkptr r = chunk_plus_offset(v, nb);

    assert(chunksize(v) == rsize + nb);

    if (RTCHECK(ok_next(v, r))) {

      unlink_large_chunk(m, v);

      if (rsize < MIN_CHUNK_SIZE)

        set_inuse_and_pinuse(m, v, (rsize + nb));

      else {

        set_size_and_pinuse_of_inuse_chunk(m, v, nb);

        set_size_and_pinuse_of_free_chunk(r, rsize);

        replace_dv(m, r, rsize);

      }

      return chunk2mem(v);

    }

  }

  CORRUPTION_ERROR_ACTION(m);

  return 0;

}

inline void RSymbianDLHeap::init_top(mstate m, mchunkptr p, size_t psize)

{

	/* Ensure alignment */

	size_t offset = align_offset(chunk2mem(p));

	p = (mchunkptr)((TUint8*)p + offset);

	psize -= offset;

	m->top = p;

	m->topsize = psize;

	p->head = psize | PINUSE_BIT;

	/* set size of fake trailing chunk holding overhead space only once */

	mchunkptr chunkPlusOff = chunk_plus_offset(p, psize);

	chunkPlusOff->head = TOP_FOOT_SIZE;

	m->trim_check = mparams.trim_threshold; /* reset on each update */

}

void* RSymbianDLHeap::internal_realloc(mstate m, void* oldmem, size_t bytes)

{

  if (bytes >= MAX_REQUEST) {

    MALLOC_FAILURE_ACTION;

    return 0;

  }

  if (!PREACTION(m)) {

    mchunkptr oldp = mem2chunk(oldmem);

    size_t oldsize = chunksize(oldp);

    mchunkptr next = chunk_plus_offset(oldp, oldsize);

    mchunkptr newp = 0;

    void* extra = 0;

    /* Try to either shrink or extend into top. Else malloc-copy-free */

    if (RTCHECK(ok_address(m, oldp) && ok_cinuse(oldp) &&

                ok_next(oldp, next) && ok_pinuse(next))) {

      size_t nb = request2size(bytes);

      if (is_mmapped(oldp))

        newp = mmap_resize(m, oldp, nb);

      else

	  if (oldsize >= nb) { /* already big enough */

        size_t rsize = oldsize - nb;

        newp = oldp;

        if (rsize >= MIN_CHUNK_SIZE) {

          mchunkptr remainder = chunk_plus_offset(newp, nb);

          set_inuse(m, newp, nb);

          set_inuse(m, remainder, rsize);

          extra = chunk2mem(remainder);

        }

      }

		/*AMOD: Modified to optimized*/

		else if (next == m->top && oldsize + m->topsize > nb)

		{

			/* Expand into top */