// 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:
// Maintains a free queue of single size RMBuf's on behalf of CMBufPoolManager
// 
//

/**
 @file
 @internalComponent
*/

#include "MBufPoolChain.h"
#include "MBufPool.h"
#include "MBufPoolManager.h"

RMBufPoolChain::RMBufPoolChain(TInt aMBufSize, CMBufPoolManager& aMBufPoolManager)
	: iMBufSize(aMBufSize), iInitialAllocation(0), iMBufPoolManager(aMBufPoolManager)
	{
	}

RMBufPoolChain::RMBufPoolChain(TInt aMBufSize, TInt aInitialAllocation, TInt aMinGrowth, TInt aGrowthThreshold, CMBufPoolManager& aMBufPoolManager)
    : iMBufSize(aMBufSize), iInitialAllocation(aInitialAllocation), iMinGrowth(aMinGrowth), iGrowthThreshold(aGrowthThreshold), iMBufPoolManager(aMBufPoolManager)
	{
	iLenFree = 0;
	iLenTotal = 0;
    iFreeMBufs.Init();
    iPools.Reset();

	iSignalled = EFalse;
	iNumMBufsToAdd = 0;
	iNoMoreSpace = 0;
	iLastGrowth = 0;
	iMaxGrowthAttempt = 0;

	iDbgPoolLimit = 0;

	iPools.SetOffset(_FOFF(CMBufPool, iLink));
	}

void RMBufPoolChain::OpenL()
	{
	User::LeaveIfError(iLockFreeList.CreateLocal());
	iPools.Reset();
	iPools.SetOffset(_FOFF(CMBufPool, iLink));
	}

void RMBufPoolChain::Close()
	{
	iLockFreeList.Close();
	}

// get the growth amount
TInt RMBufPoolChain::GrowthSize(TInt aSize)
{
	// small request so grow by minimum size
	if (aSize < iMinGrowth)
		{
		return iMinGrowth;
		}

	// Have we tried as big as this in the past?
	if ( (iMaxGrowthAttempt > 0) && (aSize >= iMaxGrowthAttempt) )
		{
		// try smaller size again
		aSize = iMaxGrowthAttempt;
		}

	// Attempt to grow the pool by requested amount
	if (!iNoMoreSpace)
		{
		return aSize;
		}

	// Last growth attempt failed so check if its worth
	// trying again
	if ( iLastGrowth < (iMinGrowth + 2))
		{
		return 0;
		}

	// Last growth attempt failed so lets try a smaller
	iMaxGrowthAttempt = iMinGrowth + (iLastGrowth - iMinGrowth) / 2;

	return iMaxGrowthAttempt;
}

// merge new pool into the pool chain
void RMBufPoolChain::ExtendFreeList(CMBufPool* aPool)
	{
	// The caller must already have acquired the freelist lock
	// - justification;
	//   a. limitation in RWorkerLock's RFastLock which does not support nested requests by the same thread without hanging the thread
	//   b. performance is adversely affected by continuoulsy locking & releasing the lock by the caller, refer ::Alloc
	// - assumption is checked for debug builds, but not for release builds as it is too expensive & indicates a serous coding error that
	//   could/should of been fixed within a debug build anyhow
	__ASSERT_DEBUG(iLockFreeList.IsOwned(), CMBufManager::Panic(EMBuf_FreeLockNotOwned));

	iFreeMBufs.Append(aPool->MBufQ());
    iLenFree += aPool->Count() * iMBufSize;
    iLenTotal += aPool->Count() * iMBufSize;
	}

// allocate a chain of MBufs from the pool chain
TInt RMBufPoolChain::Alloc(RMBufQ& aList, TInt aSize, TBool aIsAllocPool)
	{

	// Lock the freelist so that the transfer of mbufs and statistics update is an atomic operation
	iLockFreeList.Wait();

	TInt transfered = iFreeMBufs.Transfer(aList, aSize);
	iLenFree -= transfered;

	// If necessary gather data from the poolChain within the freelist lock to ensure integrity of statistics used
	TInt preAllocationLength = 0;
	if (aIsAllocPool)
		{
		preAllocationLength = iGrowthThreshold - (iLenFree/iMBufSize); // determine in terms of number of mbufs.
		}

	// adjust the growth if necessary
	TInt growth = 0;
	if (preAllocationLength >= 0)
		{
		growth = GrowthSize(preAllocationLength); // determine in terms of number of mbufs.
		}

	// Now free the freelist lock
	iLockFreeList.Signal();

	// check if the growth threshold trigger has been exceeded, and if so perform a background pool (pre)allocation
	if (aIsAllocPool)
		{
		if (preAllocationLength >= 0)
			{
			// a failed background (pre)allocation shall not error the user since they shouldn't know (and hence care), thus
			// the return code is only used to avoid a perpetual loop
			if (growth > 0)
				{
				if (KErrNoMBufs == iMBufPoolManager.AllocPool(*this, growth, EFalse))
					{
					iMaxGrowthAttempt = growth;
					}
				}
			}
		}
	return transfered;
	}

// compare function to find the suitable pool chain
TInt RMBufPoolChain::Compare(const TInt* aMBufSize, const RMBufPoolChain& aRHSPoolChain)
	{
	if (*aMBufSize < aRHSPoolChain.iMBufSize)
		{
		return -1;
		}
	else if (*aMBufSize > aRHSPoolChain.iMBufSize)
		{
		return 1;
		}
	return 0;
	}

TInt RMBufPoolChain::Compare(const RMBufPoolChain& aLHSPoolChain, const RMBufPoolChain& aRHSPoolChain)
	{
	return Compare((TInt*)&(aLHSPoolChain.iMBufSize), aRHSPoolChain);
	}

CMBufPoolManager& RMBufPoolChain::MBufPoolManager()
	{
	return iMBufPoolManager;
	}