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

//

/**

 @file

 @internalComponent

*/

#ifndef MSLABALLOC_H

#define MSLABALLOC_H

#include "mcleanup.h"

/**

Slab allocator.

*/

class RSlabAllocatorBase

	{

public:

	RSlabAllocatorBase(TBool aDelayedCleanup);

	~RSlabAllocatorBase();

	/**

	Construct a slab allocator.

	@param aMaxSlabs	Maximum number of slabs to use. (Number of bits in \a slabBits.)

	@param aObjectSize	Size of objects to allocate.

	*/

	TInt Construct(TUint aMaxSlabs, TUint aObjectSize);

	/**

	Construct a slab allocator using fixed virtual memory.

	@param aMaxSlabs	Maximum number of slabs to use. (Number of bits in \a slabBits.)

	@param aObjectSize	Size of objects to allocate.

	@param aBase		Virtual address for start of memory where slabs will be allocated.

						Zero indicates 'anywhere'.

	*/

	TInt Construct(TUint aMaxSlabs, TUint aObjectSize, TLinAddr aBase);

	/**

	Set the memory object to be used for the slab allocator.

	*/

	FORCE_INLINE void SetMemory(DMemoryObject* aMemory, TUint aReserveCount)

		{

		__NK_ASSERT_DEBUG(!iMemory);

		iMemory = aMemory;

		iReserveCount = aReserveCount;

		}

	/**

	Allocate an object.

	@return Allocated object, or the null pointer if there is insufficient memory to perform the allocation.

	@pre MmuLock held

	@post MmuLock held, but has always beet flashed

	*/

	TAny* Alloc();

	/**

	Free an object previously allocated with #Alloc.

	@param aObject The object.

	@pre MmuLock held

	@post MmuLock held, but has always beet flashed

	*/

	void Free(TAny* aObject);

protected:

	class TSlabHeader : public SDblQueLink

		{

	public:

		SDblQue iFreeList;		///< List of unallocated objects in list.

		TUint iAllocCount;		///< Number of objects allocated in this slab.

		TAny* iHighWaterMark;	///< End of initialise region in slab.

		};

private:

	TBool NewSlab();

	void InitSlab(TLinAddr aPage);

	void FreeSlab(TSlabHeader* aSlab);

	static void CleanupTrampoline(TAny* aSelf);

	void Cleanup();

#ifdef _DEBUG

	void CheckSlab(TSlabHeader* aSlab);

#endif

private:

	SDblQue iFreeList;			///< List of slabs which have unallocated objects in them.

	TUint iFreeCount;			///< Number of unallocated objects.

	TUint iReserveCount;		///< Number of unallocated objects to keep in reserve (to allow for recursion during allocation).

	TUint iObjectsPerSlab;		///< Number of objects in each slab.

	TUint iObjectSize;			///< Size, in bytes, of objects to be allocated.

	TSpinLock iSpinLock;		///< Spinlock which protects iFreeList, iFreeCount  and TSlabHeader contents.

	TMemoryCleanup iCleanup;	///< Used to queue Cleanup() if iDelayedCleanup is true.

	TBool iDelayedCleanup;		///< True, if Free() should not free empty slabs.

	TBool iAllocatingSlab;		///< True if a new slab page is being allocated.

	TBitMapAllocator* iSlabMap;	///< Bitmap of allocated slabs.

	DMemoryObject* iMemory;		///< The memory object used to store slabs.

	DMemoryMapping* iMapping;	///< The memory mapping used for slabs.

	TLinAddr iBase;				///< Address of first slab.

	};

/**

Template for a slab allocator which can allocate up to N objects of type T.

*/

template <class T, TUint N>

class RSlabAllocator : public RSlabAllocatorBase

	{

public:

	enum

		{

		EObjectSize = sizeof(T)>sizeof(SDblQueLink) ? sizeof(T) : sizeof(SDblQueLink),

		EObjectsPerSlab = (KPageSize-sizeof(TSlabHeader))/EObjectSize,

		EMaxSlabs = (N+EObjectsPerSlab-1)/EObjectsPerSlab

		};

	FORCE_INLINE RSlabAllocator()

		: RSlabAllocatorBase(EFalse)

		{

		__ASSERT_COMPILE(EObjectsPerSlab>0);

		}

	FORCE_INLINE TInt Construct()

		{

		return RSlabAllocatorBase::Construct(EMaxSlabs,EObjectSize);

		}

	/**

	Allocate an object.

	@return Allocated object, or the null pointer if there is insufficient memory to perform the allocation.

	*/

	FORCE_INLINE T* Alloc()

		{

		return (T*)RSlabAllocatorBase::Alloc();

		}

	/**

	Free an object previously allocated with #Alloc.

	@param aObject Object.

	*/

	FORCE_INLINE void Free(T* aObject)

		{

		RSlabAllocatorBase::Free(aObject);

		}

	};

/**

Template for a slab allocator for allocating objects of type T, using the

virtual address region [B..E)

*/

template <class T, TLinAddr B, TLinAddr E>

class RStaticSlabAllocator : public RSlabAllocatorBase

	{

public:

	enum

		{

		EObjectSize = sizeof(T)>sizeof(SDblQueLink) ? sizeof(T) : sizeof(SDblQueLink),

		EObjectsPerSlab = (KPageSize-sizeof(TSlabHeader))/EObjectSize,

		EMaxSlabs = (E-B)/KPageSize

		};

	FORCE_INLINE RStaticSlabAllocator()

		: RSlabAllocatorBase(ETrue)

		{

		__ASSERT_COMPILE(EObjectsPerSlab>0);

		}

	FORCE_INLINE TInt Construct()

		{

		return RSlabAllocatorBase::Construct(EMaxSlabs,EObjectSize,B);

		}

	/**

	Allocate an object.

	@return Allocated object, or the null pointer if there is insufficient memory to perform the allocation.

	*/

	FORCE_INLINE T* Alloc()

		{

		return (T*)RSlabAllocatorBase::Alloc();

		}

	/**

	Free an object previously allocated with #Alloc.

	@param aObject Object.

	*/

	FORCE_INLINE void Free(T* aObject)

		{

		RSlabAllocatorBase::Free(aObject);

		}

	};

#endif