// Copyright (c) 1994-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:

// kernel\eka\common\heap_hybrid.cpp

// 

// Uses malloc (aka dlmalloc) written by Doug Lea version 2.8.4

//

#include "common.h"

#ifdef __KERNEL_MODE__

#include <kernel/kern_priv.h>

#endif

#include "dla.h"

#ifndef __KERNEL_MODE__

#include "slab.h"

#include "page_alloc.h"

#endif

#include "heap_hybrid.h"

// enables btrace code compiling into 

#define ENABLE_BTRACE

// if non zero this causes the iSlabs to be configured only when the chunk size exceeds this level

#define DELAYED_SLAB_THRESHOLD (64*1024)		// 64KB seems about right based on trace data

#define SLAB_CONFIG 0xabe						// Use slabs of size 48, 40, 32, 24, 20, 16, 12, and 8 bytes

#ifdef _DEBUG

#define __SIMULATE_ALLOC_FAIL(s)	if (CheckForSimulatedAllocFail()) {s}

#define __ALLOC_DEBUG_HEADER(s)  	(s += EDebugHdrSize)

#define __SET_DEBUG_DATA(p,n,c)   	(((SDebugCell*)(p))->nestingLevel = (n), ((SDebugCell*)(p))->allocCount = (c))

#define __GET_USER_DATA_BFR(p)   	((p!=0) ? (TUint8*)(p) + EDebugHdrSize : NULL)

#define __GET_DEBUG_DATA_BFR(p)   	((p!=0) ? (TUint8*)(p) - EDebugHdrSize : NULL)

#define	__ZAP_CELL(p)				memset( (TUint8*)p, 0xde, (AllocLen(__GET_USER_DATA_BFR(p))+EDebugHdrSize))

#define __DEBUG_SAVE(p)				TInt dbgNestLevel = ((SDebugCell*)p)->nestingLevel

#define __DEBUG_RESTORE(p)			if (p) {((SDebugCell*)p)->nestingLevel = dbgNestLevel;}

#define __DEBUG_HDR_SIZE			EDebugHdrSize

#define __REMOVE_DBG_HDR(n) 		(n*EDebugHdrSize)

#define __GET_AVAIL_BLOCK_SIZE(s)   ( (s<EDebugHdrSize) ? 0 : s-EDebugHdrSize )

#define __UPDATE_ALLOC_COUNT(o,n,c)	if (o!=n && n) {((SDebugCell*)n)->allocCount = (c);}

#define __INIT_COUNTERS(i)	        iCellCount=i,iTotalAllocSize=i

#define __INCREMENT_COUNTERS(p)	    iCellCount++, iTotalAllocSize += AllocLen(p)

#define __DECREMENT_COUNTERS(p)	    iCellCount--, iTotalAllocSize -= AllocLen(p)

#define __UPDATE_TOTAL_ALLOC(p,s)	iTotalAllocSize += (AllocLen(__GET_USER_DATA_BFR(p)) - s)

#else

#define __SIMULATE_ALLOC_FAIL(s)

#define __ALLOC_DEBUG_HEADER(s)

#define __SET_DEBUG_DATA(p,n,c)

#define __GET_USER_DATA_BFR(p)  (p)

#define __GET_DEBUG_DATA_BFR(p) (p)

#define	__ZAP_CELL(p)

#define __DEBUG_SAVE(p)			

#define __DEBUG_RESTORE(p)

#define __DEBUG_HDR_SIZE		0

#define __REMOVE_DBG_HDR(n) 	0

#define __GET_AVAIL_BLOCK_SIZE(s)   (s)

#define __UPDATE_ALLOC_COUNT(o,n,c)	

#define __INIT_COUNTERS(i)	        iCellCount=i,iTotalAllocSize=i

#define __INCREMENT_COUNTERS(p)

#define __DECREMENT_COUNTERS(p)

#define __UPDATE_TOTAL_ALLOC(p,s)

#endif

#define MEMORY_MONITORED  (iFlags & EMonitorMemory)

#define GM  (&iGlobalMallocState)

#define IS_FIXED_HEAP  (iFlags & EFixedSize)

#define __INIT_COUNTERS(i)	iCellCount=i,iTotalAllocSize=i

#define __POWER_OF_2(x)		(!((x)&((x)-1)))

#define __DL_BFR_CHECK(M,P) \

		  if ( MEMORY_MONITORED ) \

             if ( !IS_ALIGNED(P) || ((TUint8*)(P)<M->iSeg.iBase) || ((TUint8*)(P)>(M->iSeg.iBase+M->iSeg.iSize))) \

                  BTraceContext12(BTrace::EHeap, BTrace::EHeapCorruption, (TUint32)this, (TUint32)P, (TUint32)0), HEAP_PANIC(ETHeapBadCellAddress); \

			 else DoCheckInuseChunk(M, MEM2CHUNK(P)) 

#ifndef __KERNEL_MODE__

#define __SLAB_BFR_CHECK(S,P,B) \

	  if ( MEMORY_MONITORED ) \

		  if ( ((TUint32)P & 0x3) || ((TUint8*)P<iMemBase) || ((TUint8*)(P)>(TUint8*)this))  \

			   BTraceContext12(BTrace::EHeap, BTrace::EHeapCorruption, (TUint32)this, (TUint32)P, (TUint32)S), HEAP_PANIC(ETHeapBadCellAddress); \

		  else DoCheckSlab(S, EPartialFullSlab, P), BuildPartialSlabBitmap(B,S,P) 					  

#define __PAGE_BFR_CHECK(P) \

		if ( MEMORY_MONITORED ) \

			if ( ((TUint32)P &  ((1 << iPageSize)-1)) || ((TUint8*)P<iMemBase) || ((TUint8*)(P)>(TUint8*)this))  \

				BTraceContext12(BTrace::EHeap, BTrace::EHeapCorruption, (TUint32)this, (TUint32)P, (TUint32)0), HEAP_PANIC(ETHeapBadCellAddress)

#endif

#ifdef _MSC_VER

// This is required while we are still using VC6 to compile, so as to avoid warnings that cannot be fixed

// without having to edit the original Doug Lea source.  The 4146 warnings are due to the original code having

// a liking for negating unsigned numbers and the 4127 warnings are due to the original code using the RTCHECK

// macro with values that are always defined as 1.  It is better to turn these warnings off than to introduce

// diffs between the original Doug Lea implementation and our adaptation of it

#pragma warning( disable : 4146 ) /* unary minus operator applied to unsigned type, result still unsigned */

#pragma warning( disable : 4127 ) /* conditional expression is constant */

#endif // _MSC_VER

/**

@SYMPatchable

@publishedPartner

@released

Defines the minimum cell size of  a heap.

The constant can be changed at ROM build time using patchdata OBY keyword.

@deprecated Patching this constant no longer has any effect.

*/

#ifdef __X86GCC__	// For X86GCC we dont use the proper data import attribute

#undef IMPORT_D		// since the constants are not really imported. GCC doesn't 

#define IMPORT_D	// allow imports from self.

#endif

IMPORT_D extern const TInt KHeapMinCellSize;

/**

@SYMPatchable

@publishedPartner

@released

This constant defines the ratio that determines the amount of hysteresis between heap growing and heap

shrinking.

It is a 32-bit fixed point number where the radix point is defined to be

between bits 7 and 8 (where the LSB is bit 0) i.e. using standard notation, a Q8 or a fx24.8

fixed point number.  For example, for a ratio of 2.0, set KHeapShrinkHysRatio=0x200.

The heap shrinking hysteresis value is calculated to be:

@code

KHeapShrinkHysRatio*(iGrowBy>>8)

@endcode

where iGrowBy is a page aligned value set by the argument, aGrowBy, to the RHeap constructor.

The default hysteresis value is iGrowBy bytes i.e. KHeapShrinkHysRatio=2.0.

Memory usage may be improved by reducing the heap shrinking hysteresis

by setting 1.0 < KHeapShrinkHysRatio < 2.0.  Heap shrinking hysteresis is disabled/removed

when KHeapShrinkHysRatio <= 1.0.

The constant can be changed at ROM build time using patchdata OBY keyword.

*/

IMPORT_D extern const TInt KHeapShrinkHysRatio;

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

{

	const MAllocator* m = this;

	return m->AllocLen(aCell);

}

UEXPORT_C TAny* RHeap::Alloc(TInt aSize)

{

	const MAllocator* m = this;

	return ((MAllocator*)m)->Alloc(aSize);

}

UEXPORT_C void RHeap::Free(TAny* aCell)

{

	const MAllocator* m = this;

	((MAllocator*)m)->Free(aCell);

}

UEXPORT_C TAny* RHeap::ReAlloc(TAny* aCell, TInt aSize, TInt aMode)

{

	const MAllocator* m = this;

	return ((MAllocator*)m)->ReAlloc(aCell, aSize, aMode);

}

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

{

	const MAllocator* m = this;

	return ((MAllocator*)m)->DebugFunction(aFunc, a1, a2);

}

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

{

	const MAllocator* m = this;

	return ((MAllocator*)m)->Extension_(aExtensionId, a0, a1);

}

#ifndef __KERNEL_MODE__

EXPORT_C TInt RHeap::AllocSize(TInt& aTotalAllocSize) const

{

	const MAllocator* m = this;

	return m->AllocSize(aTotalAllocSize);

}

EXPORT_C TInt RHeap::Available(TInt& aBiggestBlock) const

{

	const MAllocator* m = this;

	return m->Available(aBiggestBlock);

}

EXPORT_C void RHeap::Reset()

{

	const MAllocator* m = this;

	((MAllocator*)m)->Reset();

}

EXPORT_C TInt RHeap::Compress()

{

	const MAllocator* m = this;

	return ((MAllocator*)m)->Compress();

}

#endif

RHybridHeap::RHybridHeap()

	{

	// This initialisation cannot be done in RHeap() for compatibility reasons

	iMaxLength = iChunkHandle = iNestingLevel = 0;

	iTop = NULL;

	iFailType = ENone;

	iTestData = NULL;

	}

void RHybridHeap::operator delete(TAny*, TAny*) 

/**

Called if constructor issued by operator new(TUint aSize, TAny* aBase) throws exception.

This is dummy as corresponding new operator does not allocate memory.

*/

{}

#ifndef __KERNEL_MODE__

void RHybridHeap::Lock() const

   /**

   @internalComponent

*/

   {((RFastLock&)iLock).Wait();}

void RHybridHeap::Unlock() const

   /**

   @internalComponent

*/

   {((RFastLock&)iLock).Signal();}

TInt RHybridHeap::ChunkHandle() const

   /**

   @internalComponent

*/

{

	return iChunkHandle;

}

#else

//

//  This method is implemented in kheap.cpp

//

//void RHybridHeap::Lock() const

   /**

   @internalComponent

*/

//   {;}

//

//  This method is implemented in kheap.cpp

//

//void RHybridHeap::Unlock() const

   /**

   @internalComponent

*/

//   {;}

TInt RHybridHeap::ChunkHandle() const

   /**

   @internalComponent

*/

{

	return 0;

}

#endif

RHybridHeap::RHybridHeap(TInt aChunkHandle, TInt aOffset, TInt aMinLength, TInt aMaxLength, TInt aGrowBy, TInt aAlign, TBool aSingleThread, TBool aDLOnly, TBool aUseAdjust)

/**

Constructor for a non fixed heap.  Unlike the fixed heap, this heap is quite flexible in terms of its minimum and

maximum lengths and in that it can use the hybrid allocator if all of its requirements are met.

*/

	: iOffset(aOffset), iChunkSize(aMinLength)

	{

	__ASSERT_ALWAYS(iOffset>=0, HEAP_PANIC(ETHeapNewBadOffset));	

	iChunkHandle = aChunkHandle;

	iMinLength = aMinLength;

	iMaxLength = aMaxLength;

	// If the user has explicitly specified 0 as the aGrowBy value, set it to 1 so that it will be rounded up to the nearst page size

	if (aGrowBy == 0)

		aGrowBy = 1;

	GET_PAGE_SIZE(iPageSize);

	iGrowBy = _ALIGN_UP(aGrowBy, iPageSize);

	Construct(aSingleThread, aDLOnly, aUseAdjust, aAlign);

	}

RHybridHeap::RHybridHeap(TInt aMaxLength, TInt aAlign, TBool aSingleThread)

/**

Constructor for a fixed heap.  We have restrictions in that we have fixed minimum and maximum lengths and cannot grow

and we only use DL allocator.

*/

	: iOffset(0), iChunkSize(aMaxLength)

	{

	iChunkHandle = NULL;

	iMinLength = aMaxLength;

	iMaxLength = aMaxLength;

	iGrowBy = 0;

	Construct(aSingleThread, ETrue, ETrue, aAlign);

	}

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

{

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

	RHybridHeap* h = (RHybridHeap*)aBase;

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

	return aBase;

}

void RHybridHeap::Construct(TBool aSingleThread, TBool aDLOnly, TBool aUseAdjust, TInt aAlign)

{

	iAlign = aAlign ? aAlign : RHybridHeap::ECellAlignment;

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

	// This initialisation cannot be done in RHeap() for compatibility reasons

	iTop = NULL;

	iFailType = ENone;

	iNestingLevel = 0;

	iTestData = NULL;

	iHighWaterMark = iMinLength;

	iAllocCount = 0;

	iFlags = aSingleThread ? ESingleThreaded : 0;

	iGrowBy = _ALIGN_UP(iGrowBy, iPageSize);

	if ( iMinLength == iMaxLength )

		{

		iFlags |= EFixedSize;

		aDLOnly = ETrue;

		}

#ifndef __KERNEL_MODE__

#ifdef DELAYED_SLAB_THRESHOLD

	iSlabInitThreshold = DELAYED_SLAB_THRESHOLD;

#else

	iSlabInitThreshold = 0;

#endif // DELAYED_SLAB_THRESHOLD

	iUseAdjust = aUseAdjust;

	iDLOnly    = aDLOnly;

#else

	(void)aUseAdjust;	

#endif 

	// Initialise suballocators

	// if DL only is required then it cannot allocate slab or page memory

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

	if ( aDLOnly )

		{

		Init(0, 0);

		}

	else

		{

		Init(SLAB_CONFIG, 16);

		}

#ifdef ENABLE_BTRACE

	TUint32 traceData[4];

	traceData[0] = iMinLength;

	traceData[1] = iMaxLength;

	traceData[2] = iGrowBy;

	traceData[3] = iAlign;

	BTraceContextN(BTrace::ETest1, 90, (TUint32)this, 11, traceData, sizeof(traceData));

#endif

}

#ifndef __KERNEL_MODE__

TInt RHybridHeap::ConstructLock(TUint32 aMode)

{

	TBool duplicateLock = EFalse;

	TInt r = KErrNone;

	if (!(iFlags & ESingleThreaded))

		{

		duplicateLock = aMode & UserHeap::EChunkHeapSwitchTo;

		r = iLock.CreateLocal(duplicateLock ? EOwnerThread : EOwnerProcess);

		if( r != KErrNone)

			{

			iChunkHandle = 0;

			return r;

			}

		}

	if ( aMode & UserHeap::EChunkHeapSwitchTo )

		User::SwitchHeap(this);

	iHandles = &iChunkHandle;

	if (!(iFlags & ESingleThreaded))

		{

		// now change the thread-relative chunk/semaphore handles into process-relative handles

		iHandleCount = 2;

		if(duplicateLock)

			{

			RHandleBase s = iLock;

			r = iLock.Duplicate(RThread());

			s.Close();

			}

		if (r==KErrNone && (aMode & UserHeap::EChunkHeapDuplicate))

			{

			r = ((RChunk*)&iChunkHandle)->Duplicate(RThread());

			if (r!=KErrNone)

				iLock.Close(), iChunkHandle=0;

			}

		}

	else

		{

		iHandleCount = 1;

		if (aMode & UserHeap::EChunkHeapDuplicate)

			r = ((RChunk*)&iChunkHandle)->Duplicate(RThread(), EOwnerThread);

		}

	return r;

}

#endif

void RHybridHeap::Init(TInt aBitmapSlab, TInt aPagePower)

{

	/*Moved code which does initilization */

	iTop  = (TUint8*)this + iMinLength;

	iBase = Ceiling(iBase, ECellAlignment);	// Align iBase address 

    __INIT_COUNTERS(0);

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

	InitDlMalloc(iTop - iBase, 0);

#ifndef __KERNEL_MODE__	

	SlabInit();

	iSlabConfigBits = aBitmapSlab;

	if ( iChunkSize > iSlabInitThreshold )

		{

		iSlabInitThreshold = KMaxTInt32;

		SlabConfig(aBitmapSlab);   // Delayed slab configuration done

		}

	if ( aPagePower )

		{

		RChunk chunk;

		chunk.SetHandle(iChunkHandle);

		iMemBase = chunk.Base();    // Store base address for paged allocator

		}

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

	PagedInit(aPagePower);

#ifdef ENABLE_BTRACE

	TUint32 traceData[3];

	traceData[0] = aBitmapSlab;

	traceData[1] = aPagePower;

	traceData[2] = GM->iTrimCheck;

	BTraceContextN(BTrace::ETest1, 90, (TUint32)this, 0, traceData, sizeof(traceData));

#endif

#else

	(void)aBitmapSlab;

	(void)aPagePower;

#endif	// __KERNEL_MODE__

}

TInt RHybridHeap::AllocLen(const TAny* aCell) const

{

	aCell = __GET_DEBUG_DATA_BFR(aCell);

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

		{

		mchunkptr m = MEM2CHUNK(aCell);

		return CHUNKSIZE(m) - OVERHEAD_FOR(m) - __DEBUG_HDR_SIZE;

		}

#ifndef __KERNEL_MODE__		

	if ( aCell )

		{

		if (LowBits(aCell, iPageSize) )

			return SlabHeaderSize(slab::SlabFor(aCell)->iHeader) - __DEBUG_HDR_SIZE;

		return PagedSize((void*)aCell) - __DEBUG_HDR_SIZE;

		}

#endif	

	return 0; // NULL pointer situation, should PANIC !!

}

#ifdef __KERNEL_MODE__

TAny* RHybridHeap::Alloc(TInt aSize)

{

	__CHECK_THREAD_STATE;

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

	__SIMULATE_ALLOC_FAIL(return NULL;)

	Lock();

	__ALLOC_DEBUG_HEADER(aSize);

	TAny* addr = DlMalloc(aSize);

	if ( addr )

		{

//		iCellCount++;

		__SET_DEBUG_DATA(addr, iNestingLevel, ++iAllocCount);

		addr = __GET_USER_DATA_BFR(addr);

		__INCREMENT_COUNTERS(addr);

		memclr(addr, AllocLen(addr));

		}

	Unlock();

#ifdef ENABLE_BTRACE

	if (iFlags & ETraceAllocs)

		{

		if ( addr )

			{

			TUint32 traceData[3];

			traceData[0] = AllocLen(addr);