// Copyright (c) 2008-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:
// @file
// @internalComponent
// 
//

#include <e32base.h>
#include "cchunkmanager.h"
#include "rmemcell.h"
#include "cmemchunk.h"
#include "rchunkpool.h"


RChunkPool::RChunkPool ( TInt aBlockSize, TInt aThresholdValue, TInt aMinGrowth, CChunkManager& aChunkManager )
		: iBlockSize ( aBlockSize ),
	      iChunkManager ( aChunkManager ),
		  iThresholdValue ( aThresholdValue ),
	      iMinGrowth ( aMinGrowth )
	{
	iFreeBlocks.Init ();
	iFreeSpace = 0;
	}

RChunkPool::RChunkPool ( CChunkManager& aChunkManager, TInt aBlockSize )
	: iBlockSize ( aBlockSize ),
	  iChunkManager ( aChunkManager )
	{	
	}
	
void RChunkPool::OpenL ()
	{
	User::LeaveIfError ( iFreeListLock.CreateLocal () );
	}
	
void RChunkPool::Close ()
	{
	iFreeListLock.Close ();
	iAllocatedChunks.Close ();
	}
	
TInt RChunkPool::Compare ( const RChunkPool& aLHSPool, const RChunkPool& aRHSPool )
	{
	if ( aLHSPool.BlockSize () < aRHSPool.BlockSize () )
		{
		return -1;
		}
	else if ( aLHSPool.BlockSize () > aRHSPool.BlockSize ()  )
		{
		return 1;
		}
	return 0;
	}
		
void RChunkPool::AppendToFreeList ( CMemChunk* aChunk )
	{
	iFreeSpace += iBlockSize * aChunk->NumBlocks ();
	iFreeBlocks.Append ( aChunk->List () );
	}	


// transfer's blocks from free list and makes self growth if necessary
TInt RChunkPool::Alloc ( RMemCellList& aList, TInt aSize )
	{
	// Lock the freelist so that 
	// Transfer of free blocks will be an atomic operation
	iFreeListLock.Wait ();
	
	TInt bytesTransfered = iFreeBlocks.Transfer ( aList, aSize );
	iFreeSpace -= bytesTransfered;
	
	TInt freeHeapSpace = iChunkManager.BytesAvailable ();
	
	if ( freeHeapSpace ) // makes sure that heap has memory atleast for CMemChunk object, but not for its chunk
		{
		// check if freeblocks is down the threshold value and make self growth if necessary
		// determine min number of blocks to allocate
		TInt minGrowth = iThresholdValue - ( iFreeSpace / iBlockSize );
		
		if ( minGrowth >= 0 )
			{
			if ( GrowPool ( iMinGrowth ) == KErrNoMemory )
				{
			 	// unable to grow the minimum value set by the client
			 	if ( minGrowth < iMinGrowth )
				 	{
			 		// so, now try with the min value adjusted with threshold value
			 		GrowPool ( minGrowth );
				 	}
			 	}
			}
		}
	
	// free the freelistlock
	iFreeListLock.Signal ();
	
	return bytesTransfered;
	}
	
TInt RChunkPool::GrowPool ( TUint aNumBlocks )
	{
	return iChunkManager.AllocChunk ( *this, aNumBlocks );
	}
	
TInt RChunkPool::GrowAndAlloc ( RMemCellList& aList, TInt aSize, TInt aNumBlocks )
	{
	// Lock the freelist so that
	// Transfer of free blocks will be an atomic operation
	TInt bytesTransfered = 0;
	iFreeListLock.Wait ();
	
	if ( GrowPool ( aNumBlocks ) != KErrNoMemory )
	 	{
	 	bytesTransfered = iFreeBlocks.Transfer ( aList, aSize );
		iFreeSpace -= bytesTransfered;
	 	}
	
	// free the freelistlock
	iFreeListLock.Signal ();
	
	return bytesTransfered;
	}
	
void RChunkPool::FreeToPool ( RMemCell* aMemCell )
	{
	iFreeBlocks.Append ( aMemCell );
	iFreeSpace += aMemCell->Size ();
	}