// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

// CMBufPoolManager.cpp

// Maintains one or more pool chains (CMBufPoolChain) on behalf of CMBufManager

// 

//

/**

@file

Maintains one or more pool chains (CMBufPoolChain) on behalf of CMBufManager

@internalComponent

*/

#include "mbufmanager.h"

#include <comms-infras/cfmacro.h>

#include "MBufPoolManager.h"

#include "MBufPoolChain.h"

#include "MBufPool.h"

#include "MBufMemoryAllocator.h"

#include <cflog.h>

static const TInt KMemoryAlignment = 8;

const TInt KNoOutstandingRequests = -1;

/** Patchable constant detailing the size of cache lines in the target architecture.

    The MBufMgr will align data to cache lines.

*/

extern const TUint KMBufCacheLineSize = 32;

#define ALIGN_CACHE_MASK    (KMBufCacheLineSize-1)

#define ALIGN_CACHE_UP(n)   (((n)+(ALIGN_MASK)) & ~ALIGN_MASK)

#define ALIGN_CACHE_DOWN(n) ((n) & ~ALIGN_MASK)

#define IS_CACHE_ALIGNED(p) ((((TUint32)(p)) & ALIGN_MASK)==0)

#ifdef __CFLOG_ACTIVE

__CFLOG_STMT(_LIT8(KComponent, "PoolManager");)

__CFLOG_STMT(_LIT8(KSubsysMBufMgr, "MBufMgr");) // subsystem name

__CFLOG_STMT(_LIT8(KComponentPerformance, "performance");)	// component name - used for any sub-optimal performance behaviuor

#endif

CMBufPoolManager* CMBufPoolManager::NewL(TInt aMaxAllocSize, CMBufManager& aMBufManager)

	{

	CMBufPoolManager* This = new(ELeave) CMBufPoolManager(aMaxAllocSize, aMBufManager);

	CleanupStack::PushL(This);

	This->ConstructL(aMaxAllocSize);

	CleanupStack::Pop(This);

	return This;

	}

// ctor

CMBufPoolManager::CMBufPoolManager(TInt aMaxAllocSize, CMBufManager& aMBufManager)

	: CActive(EPriorityStandard),

	  iMaxAllocSize(aMaxAllocSize),

	  iMBufManager(aMBufManager)

	{

#ifdef __CFLOG_ACTIVE

	__CFLOG_VAR((KSubsysMBufMgr, KComponent, _L8("CMBufPoolManager %x:\tCMBufPoolManager()"), this));

#endif

	iCommitted = EFalse;  

	iNextMBufSize = KNoOutstandingRequests;

	}

void CMBufPoolManager::ConstructL(TInt aMaxAllocSize)

	{

	User::LeaveIfError(iPoolChainLock.CreateLocal());

	iMBufMgrOwnerThread.Duplicate(RThread());

	iMemoryAllocator = CMBufMemoryAllocator::NewL(aMaxAllocSize);

	CActiveScheduler::Add(this);

	WaitForNewPoolRequest();

	}

CMBufPoolManager::~CMBufPoolManager()

	{

	// Cancel any outstanding requests

	Cancel();

	iPoolChains.ResetAndDestroy();	

	iPoolChains.Close();

	delete iMemoryAllocator;

    iPoolChainLock.Close();

	iMBufMgrOwnerThread.Close();

	}

CMBufMemoryAllocator& CMBufPoolManager::Memory()

	{

	return *iMemoryAllocator;

	}

CMBufManager& CMBufPoolManager::Manager()

	{

	return iMBufManager;		

	}

void CMBufPoolManager::WaitForNewPoolRequest()

	{

	__ASSERT_DEBUG(!IsActive(), CMBufManager::Panic(EMBuf_AlreadyActive));

	iStatus = KRequestPending;

	SetActive();

	}

void CMBufPoolManager::DoCancel()

	{

	NETWORKING_ATOMIC(;) // Codepattern below may have SMP implications

	if(!iSignalled)

		{

		// We're almost certainly the only thread doing this; now check again inside the critsec to be sure

		iPoolChainLock.Wait();

		if(!iSignalled)

			{

			iSignalled = ETrue;

			TRequestStatus* pStatus = &iStatus;

			User::RequestComplete(pStatus, KErrCancel);

			}

		iPoolChainLock.Signal();

		}

	}

TInt CMBufPoolManager::BackgroundAllocateNewPool(CMBufPoolChain& aPoolChain,

					TInt aNumMBufs)

	{

	// Build a list of MBuf sizes and allow one request per MBuf pool size....

	// Note its essential that at least one request is serviced, the allocation can

	// then attempt to use the new MBufs created.  Its not essential that every 

	// request is serviced, its more important to prevent this single new pool

	// allocation routine from locking out processing on the many threads that use

	// this routine for a long time

	// The first attempted growth by aNumMBufs wins

	NETWORKING_ATOMIC(;) // Codepattern below may have SMP implications

	if (!aPoolChain.iSignalled)

		{

		// This is being most likely being called from the context of some thread other than the

		// MBufMgr owner, and there's a distinct risk of more than one thread being OOB at the same

		// time since it's a common PoolChain. 	So we have to lock here to process this PoolChain

		iPoolChainLock.Wait();

		// We're almost certainly the only thread doing this; now check again inside the critsec to be sure

		if (!aPoolChain.iSignalled)

			{

			// First do a simple test to see if the new pool will be created

			// Note in the future when CMBufPool deletion is implemented iNoMoreSpace

			// should be cleared on all pools to allow growth again.

			if (aPoolChain.iNoMoreSpace)

				{

				if (aPoolChain.iLastGrowth > aNumMBufs)

					{

					// Try this smaller allocation

					aPoolChain.iNoMoreSpace = EFalse;

					}

				else

					{

					iPoolChainLock.Signal();

					return KErrNoMBufs;

					}

				}

			aPoolChain.iLastGrowth = aNumMBufs;

			aPoolChain.iNumMBufsToAdd = aNumMBufs;

			aPoolChain.iSignalled = ETrue;

			}

		}

	else

		{

		// Its possible that first time round we missed this growth attempt

		if (iSignalled)

			{

			// already signalled so just return

			return KErrNone;

			}

		// already signalled but the first time round the growth attempt was missed

		// this is always possible because to stop the background thread slowing the

		// these threads we dont lock in the RunL.  The RunL is always run in the same 

		// thread so does not need a lock.

		iPoolChainLock.Wait();

		}

	// Here we have to guard against being completed multiple times because more than

	// one pool chain can be growing at the same time

	if (!iSignalled)

		{

		iSignalled = ETrue;

		// iNextMBufSize is the first freepool for a growth attempt

		iNextMBufSize = aPoolChain.iBufSize; 

		TRequestStatus* pStatus = &iStatus;

		// We dont need to hold onto the lock now since there is no chance

		// that the RequestComplete can be called twice

		iPoolChainLock.Signal();

		iMBufMgrOwnerThread.RequestComplete(pStatus, KErrNone);

		return KErrNone;

		}

	iPoolChainLock.Signal();

	return KErrNone;

	}

void CMBufPoolManager::RunL()

	{

	// Now that we're in the thread that owns pools and ultimately the

	// memory allocation so attempt to create the new pool

	CMBufPoolChain* selectedPoolChain(NULL);

	TInt growThisPoolChain = iNextMBufSize;

	iNextMBufSize = KNoOutstandingRequests;

	// There is a chance that there are other pools to grow as well

	// looking for them now can save future locking and speed allocation.

	// Note we dont have to catch every growth attempt because background

	// allocation should be triggered from an early threshold.  This allocation

	// might satisfy the immediate growth requirement so no need to lock.

	// Ensure that each time RunL is called a different pool growth attempt

	// by stepping through the available pools looking for the next request.

	TInt poolChainCount = iPoolChains.Count();

	TInt lowestRequest = KNoOutstandingRequests;

	for (TInt i = 0; i < poolChainCount; i++)

		{

		CMBufPoolChain* poolInfo = iPoolChains[i];

		TInt thisMBufSize = poolInfo->BufSize();

		// locate this growth attempt

		if (thisMBufSize == growThisPoolChain)

			{

			selectedPoolChain = poolInfo;

			}

		if (poolInfo->iSignalled)

			{

			if (lowestRequest == KNoOutstandingRequests)

				{

				lowestRequest = thisMBufSize;

				}

			if ( (iNextMBufSize == KNoOutstandingRequests) &&

					(thisMBufSize > growThisPoolChain) )

				{

				// found the next freepool to grow

				iNextMBufSize = thisMBufSize;

				break;

				}

			}

		}

	// Might have wrapped round all the PoolChains

	if ( (iNextMBufSize == KNoOutstandingRequests)  

			&& (lowestRequest != growThisPoolChain) )

		{

		iNextMBufSize = lowestRequest;

		}

	// Now prepare for the next pool growth if any

	if (iNextMBufSize != KNoOutstandingRequests)

		{

#ifdef __CFLOG_ACTIVE

		__CFLOG_VAR((KSubsysMBufMgr, KComponent, _L8("CMBufPoolManager::RunL() - One of several pool growth attempts")));

#endif

		// Still more requests outstanding

		// iSignalled = ETrue;

		iStatus = KRequestPending;

		SetActive();

		// complete the request so we get called again

		TRequestStatus* pStatus = &iStatus;

		User::RequestComplete(pStatus, KErrNone);

		}

	else

		{

		// There are no more outstanding requests so prepare for next

		// pool creation request

		iStatus = KRequestPending;

		// open the door for more allocate requests on other pool chains

		iSignalled = EFalse;

		SetActive();

		}

	// No need to surround the pool creation with a lock

	// allocate a pool & associate with the pool chain

	CMBufPool* newpool = NULL;

	CreatePool(newpool, *selectedPoolChain);

	if (newpool == NULL)

    	{

    	// Pool create fails perhaps due to insufficient memory

		// Each buffer size gets its own out of space indicator

    	selectedPoolChain->iNoMoreSpace = ETrue;

    	}

	else

		{

		// add the pool to the pool list

		// No need to lock if synchronous allocation is removed

		iPoolChainLock.Wait();

		selectedPoolChain->iPools.AddLast(*newpool);

		iPoolChainLock.Signal();

   		// first grab the freelist lock

		selectedPoolChain->iLockFreeList.Wait();

		selectedPoolChain->ExtendFreeList(newpool);

		selectedPoolChain->iLockFreeList.Signal();

		}

	// open the door for more allocate requests on this poolchain

	selectedPoolChain->iSignalled = EFalse;

	}

TInt CMBufPoolManager::Commit()

/**

Ensures that no additional pool chains can be created (ie. via MMBufSizeAllocator::AddL())

Calling this method is useful (but not mandated) to ensure that operations within MMBufSizeAllocator::AddL do not create any adverse affects

@return KErrNone or KErrAlreadyExists if already called.

*/

	{

	TInt result = KErrAlreadyExists;

	if (iCommitted == EFalse)

		{

		iCommitted = ETrue;

		result = KErrNone;

		}

	return result;

	}

// create a pool chain with the specified values

// - Deliberately have not exposed the concept of a pool or chain in the api, as these concepts are intended to be hidden within MBM

//   as a private implementation detail.

// - Mbuf size guidelines;

//   1. 128 byte is mandatory for some (poorly writen) legacy code that assumes the existance of mbufs of this size.

//   b. < 128 byte is acceptable, but could break some (poorly written) legacy code that assumes that minimum mbuf size is 128

// - 128 byte guideline is due to K_MBufSmallSize definition having been made public;

//   a. Externally - numerous instances within our codebase (and thus similar assumptions are likely within licensee code) that assume

//		             mbufs of at least this size are available for allocation.

//   b. Internally - When the allocation size is not specified, the value is defaulted to K_MBufSmallSize.  Refer ::AllocL notes.

//                 - RMBufCells are assumed to be no larger than K_MBufSmallSize.

//   Since the first point can't be fixed without a source break, there is little point in not creating a default pool chain of

//   K_MBufSmallSize size in order to rectify the assumptions made within the other points.

void CMBufPoolManager::AddL(TInt aMBufSize, TInt aInitialAllocation, TInt aMinGrowth, TInt aGrowthThreshold, TInt aPoolCeiling)

/**

Populate a free pool of specified size with RMBuf's.  Each RMBuf in this free pool will have the same size.  

RMbuf size guidelines:

At least one free pool with 128 byte RMBuf's is mandatory for some legacy code that assumes the existance of mbufs of this size.

RMBuf size < 128 byte is acceptable, but could break some legacy code that assumes that minimum mbuf size is 128

These 128 byte guideline are due to KMBufSmallSize definition having been made public.  Ideally, this constant should not be published.

Instead, inspect the available sizes via RMBufAllocator::NextMBufSize() or the size of this RMBuf with RMBuf::Size().

DO NOT ASSUME UNDER ANY CIRCUMSTANCES THAT ALL MBUFS ARE THE SAME SIZE!

@param aMBufSize the size in bytes of the RMBuf's created.

@param aInitialAllocation the number of RMBuf's in the initial free pool.

@param aMinGrowth the number of RMBuf's added to the free pool.

@param aGrowthThreshold when the free pool has less than this number of RMBuf's it will trigger allocation of more memory for more RMBuf's.

*/

	{

	// check args

	// - on the surface it makes sense to declare the args as unsigned and rely on the compiler's type checking instead of writing code

	//   to manually check (which has an inherit performance penalty), but as requested this was deliberately not done because;

	//   a. concerns about strict compilers which warn/error arithmetic operations with literals that are not explicitly designeated as unsigned

	//      eg. 1U versus 1

	//   b. encourages type casting by user to avoid warnings, which circumvents useful compiler type checking & often leads to unexpected results

	//	    eg. type casting -1 to unsigned using a 2's compliment compiler resulting in an unexpectedingly large allocation of 2GB

	__ASSERT_ALWAYS(aMBufSize > 0, CMBufManager::Panic(EMBuf_PoolManager_NegativeMBufSize));

	__ASSERT_ALWAYS(aInitialAllocation >= 0, CMBufManager::Panic(EMBuf_PoolManager_NegativePoolSize));

	__ASSERT_ALWAYS(aMinGrowth >= 0, CMBufManager::Panic(EMBuf_PoolManager_NegativeMinGrowth));

	__ASSERT_ALWAYS(aGrowthThreshold >= 0, CMBufManager::Panic(EMBuf_PoolManager_NegativeGrowthThreshold));

	// ensure we are not already committed - refer CMBufPoolManager::Commit notes

	if (iCommitted)

		{

		User::Leave(KErrNotReady);

		}

	TInt alignmentPadding = aMBufSize % KMemoryAlignment;

	if (aMBufSize == 0)

		{

#ifdef __CFLOG_ACTIVE

		__CFLOG_VAR((KSubsysMBufMgr, KComponent, _L8("CMBufPoolManager::AddAllocSizeL() - Warning! requested mbufSize=0 serves no useful purpose; accepted anyhow")));

#endif

		}

	else if (alignmentPadding != 0)

		{

#ifdef __CFLOG_ACTIVE

		__CFLOG_VAR((KSubsysMBufMgr, KComponent, _L8("CMBufPoolManager::AddAllocSizeL() - Warning! requested mbufSize=%d is not (armv5) dword aligned, size has been increased to %d"),

			aMBufSize, aMBufSize + KMemoryAlignment - alignmentPadding));

#endif

		aMBufSize += KMemoryAlignment - alignmentPadding;

		}

	if ((aInitialAllocation * aMBufSize) > iMaxAllocSize)

		{

#ifdef __CFLOG_ACTIVE

		__CFLOG_VAR((KSubsysMBufMgr, KComponent, _L8("CMBufPoolManager::AddAllocSizeL() - Warning! requested initialAllocation=%d exceeds the maxAllocSize=%d; accepted anyhow"),

			(aInitialAllocation * aMBufSize), iMaxAllocSize));

#endif

		}

	if (aMinGrowth == 0)

		{

#ifdef __CFLOG_ACTIVE

		__CFLOG_VAR((KSubsysMBufMgr, KComponent, _L8("CMBufPoolManager::AddAllocSizeL() - Warning! requested minGrowth=0 increased to the minimum value of 1")));

#endif

		aMinGrowth = 1;

		}

	else if ((aMinGrowth * aMBufSize) > iMaxAllocSize)

		{

#ifdef __CFLOG_ACTIVE

		__CFLOG_VAR((KSubsysMBufMgr, KComponent, _L8("CMBufPoolManager::AddAllocSizeL() - Warning! requested minGrowth=%d exceeds the maxAllocSize=%d; accepted anyhow"),

			(aMinGrowth * aMBufSize), iMaxAllocSize));

#endif

		}

	if (aGrowthThreshold > aMinGrowth)

		{

#ifdef __CFLOG_ACTIVE

		__CFLOG_VAR((KSubsysMBufMgr, KComponent, _L8("CMBufPoolManager::AddAllocSizeL() - Warning! requested growthThreshold=%d exceeds minGrowth=%d, hence potentially requiring multiple/iterative growth allocation; accepted anyhow"),

			aGrowthThreshold, aMinGrowth));

#endif

		}

	// check pool chain already exists

	TInt index = 0;

	TInt found = KErrNone;

	if (found == KErrNone)

		{

		CMBufPoolChain poolChain(aMBufSize, *this);

  		found = iPoolChains.FindInOrder(&poolChain, index, TLinearOrder<CMBufPoolChain>(CMBufPoolChain::Compare));		

		}

	if (found == KErrNotFound)

		{

		// create a new pool chain

		CMBufPoolChain* chain = CMBufPoolChain::NewL(aMBufSize, aInitialAllocation, aMinGrowth, aGrowthThreshold, aPoolCeiling, *this);

		CleanupStack::PushL(chain);

		iPoolChains.InsertL(chain, index);

		CleanupStack::Pop(); // chain

		// pre-allocate the initial pool

		if (aInitialAllocation > 0)

			{

			// Lock the freelist so that the MBufs can be added to the freepool

			chain->iLockFreeList.Wait();

			// Use synchronous allocate to ensure that the initial pool allocation gives immediate feedback

			// to the rootserver or calling method.

			// This can only be called from the owner thread for CMBufManager 

			// Thus synchronous AllocPool is possible because no conflict with asynchronous 

			// background AllocPool occurs because this also is run from the owner thread

			// for the CMBufManager.  Synchronous AllocPool is not allowed from other threads

			TInt res = AllocPool(*chain, aInitialAllocation, ETrue); 

			chain->iLockFreeList.Signal();

			User::LeaveIfError(res);

			}

		}

	else

		{

		CMBufPoolChain* poolChain = iPoolChains[index];

		// update existing chain's values - these will take affect the next time they are used (eg. next allocation)

		poolChain->iMinGrowth = aMinGrowth;

		poolChain->iGrowthThreshold = aGrowthThreshold;

		}

	// maintain/update the largest mbuf size - for background allocation

    if (iLargestMBufSize < aMBufSize)

    	{

		iLargestMBufSize = aMBufSize;

    	}

	}

void CMBufPoolManager::CreatePool(CMBufPool* &aNewpool, CMBufPoolChain& aMBufPoolChain)

	{

	aNewpool = CMBufPool::New(aMBufPoolChain.iBufSize

							, aMBufPoolChain.iNumMBufsToAdd

							, aMBufPoolChain

							, *iMemoryAllocator);

	}

// Search algorithm to find the pool chain satisfying the request size

// Algorithm first narrows down to pools chains with free mbufs to satisfy the request size

// Then, searches through the remaining pool chains starting from the largest possible pool chain

// towards the smallest pool chain until the whole request is satisfied

void CMBufPoolManager::LinearSearchAlloc(RMBufQ& aList, TInt aSize

					, TInt aMinMBufSize, TInt aMaxMBufSize, TBool aIsAllocPool)

	{

	// Check to see if an empty mbuf with zero length is requested

	TBool zeroLengthMBuf = (aSize == 0);

	TInt poolChainMax = iPoolChains.Count() - 1;

//	CMBufPoolChain* start = iPoolChains[0];

//	CMBufPoolChain* chain = iPoolChains[poolChainMax];

	CMBufPoolChain* chosen = NULL;

	TInt chainIndex = poolChainMax;

	// First narrow the pool chains to those that are acceptable

	// Each pool chain represents a free list of mbufs of a particular size

	// The mbuf size must be within aMinMBufSize - aMaxMBufSize range

	// The free pool must have space

	do

		{

		CMBufPoolChain* chain = iPoolChains[chainIndex];

		// Look for the free pool with the largest mbufs

		if ( (chain->iBufSize <= aMaxMBufSize) && 

				(chain->iLenFree > 0) )

			{

			// Check that the chosen free pool is within the limits set

			if (chain->iBufSize >= aMinMBufSize)