sl@0: // Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: //
sl@0: 
sl@0: #include "WsMemMgr.h"
sl@0: #include "inifile.h"
sl@0: #include "panics.h"
sl@0: #include "wstop.h"
sl@0: 
sl@0: static const TTimeIntervalMicroSeconds KBurstDuration = 1000000; //one second
sl@0: static const TInt KMaxMemoryReleasesPerBurst = 5;
sl@0: CWsMemoryManager * CWsMemoryManager::iStatic = NULL;
sl@0: 
sl@0: CWsMemoryManager * CWsMemoryManager::Static()
sl@0: 	{
sl@0: 	return iStatic;
sl@0: 	}
sl@0: 
sl@0: CWsMemoryManager * CWsMemoryManager::NewLC()
sl@0: 	{
sl@0: 	CWsMemoryManager * self = new (ELeave) CWsMemoryManager;
sl@0: 	CleanupStack::PushL(self);
sl@0: 	self->ConstructL();
sl@0: 	iStatic = self;
sl@0: 	return iStatic;
sl@0: 	}
sl@0: 
sl@0: CWsMemoryManager::CWsMemoryManager()
sl@0: 	{
sl@0: 	iImpl = User::SwitchAllocator(this);
sl@0: 	}
sl@0: 	
sl@0: CWsMemoryManager::~CWsMemoryManager()
sl@0: 	{
sl@0: 	WS_ASSERT_ALWAYS(this == User::SwitchAllocator(iImpl),EWsPanicMemoryManager);
sl@0: 	iStatic = 0;
sl@0: 	if (iReserve!=NULL)
sl@0: 		{
sl@0: 		Free(iReserve);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CWsMemoryManager::ConstructL()
sl@0: 	{
sl@0: 	_LIT(KMemMgrReserve, "MEMORYRESERVE");
sl@0: 	const TInt KDefaultMemMgrReserve = 1024;
sl@0: 	
sl@0: 	if (!WsIniFile->FindVar(KMemMgrReserve, iReserveSize))
sl@0: 		iReserveSize = KDefaultMemMgrReserve;
sl@0: 
sl@0: 	if (iReserveSize > 0)
sl@0: 		iReserve = Alloc(iReserveSize);
sl@0: 	
sl@0: 	iCurrentBurstStart.UniversalTime();
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Tells the memory manager to fail on next retry.
sl@0: I.e. whenever the next allocation failure occurs, the memory manager won't try 
sl@0: to free up memory to have another go at the allocation.
sl@0: 
sl@0: N.B. this only applies for the next failure, the state is reset when there is an
sl@0: allocation failure.
sl@0: 
sl@0: This method is only to be used for OOM testing.
sl@0: */
sl@0: void CWsMemoryManager::SetFailNextRetry()
sl@0: 	{
sl@0: 	iFailNextRetry = ETrue;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Implementing RAllocator
sl@0: */
sl@0: 
sl@0: /**
sl@0: Alloc and ReAlloc attempt to obtain memory through CWsTop::ReleaseMemory when they run low.
sl@0: ReleaseMemory looks for blocks of memory that the window server doesn't need urgently and frees
sl@0: them.
sl@0: */
sl@0: TAny* CWsMemoryManager::Alloc(TInt aSize)
sl@0: 	{
sl@0: 	TBool keepTrying = ETrue;
sl@0: 	do
sl@0: 		{
sl@0: 		if(iReleasing)
sl@0: 			return iImpl->Alloc(aSize); //fallback on RAllocator
sl@0: 		
sl@0: 		if(TAny* ret = iImpl->Alloc(aSize)) //normal case
sl@0: 			return ret;
sl@0: 		
sl@0: 		TTime now;
sl@0: 		now.UniversalTime();
sl@0: 		if(now.MicroSecondsFrom(iCurrentBurstStart) < KBurstDuration)
sl@0: 			{
sl@0: 			iCurrentBurstReleaseCount++;
sl@0: 			if(iCurrentBurstReleaseCount > KMaxMemoryReleasesPerBurst)
sl@0: 				return NULL;
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			iCurrentBurstStart = now;
sl@0: 			iCurrentBurstReleaseCount = 1;
sl@0: 			}
sl@0: 		
sl@0: 		if(iReserveEnabled && iReserve && (aSize < iReserveSize))
sl@0: 			{
sl@0: 			Free(iReserve);
sl@0: 			iReserve = NULL;
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			iReleasing = ETrue;
sl@0: 			keepTrying = CWsTop::ReleaseMemory();
sl@0: 			if(keepTrying)
sl@0:  				{
sl@0:  				const TInt reclaimed = Compress(); //Try to give back to the OS
sl@0:  				}
sl@0: 			iReleasing = EFalse;
sl@0: 			}
sl@0: 		
sl@0: 		//used for OOM testing only
sl@0: 		if(iFailNextRetry)
sl@0: 			{
sl@0: 			iFailNextRetry = EFalse;
sl@0: 			keepTrying = EFalse;
sl@0: 			}
sl@0: 		
sl@0: 		} while(keepTrying);
sl@0: 
sl@0: 	return NULL;
sl@0: 	}
sl@0: 
sl@0: TAny* CWsMemoryManager::ReAlloc(TAny* aPtr, TInt aSize, TInt aMode)
sl@0: 	{
sl@0: 	TBool keepTrying = ETrue;
sl@0: 	do
sl@0: 		{
sl@0: 		if(iReleasing)
sl@0: 			return iImpl->ReAlloc(aPtr, aSize, aMode); //fallback on RAllocator
sl@0: 		
sl@0: 		if(TAny* ret = iImpl->ReAlloc(aPtr, aSize, aMode)) //normal case
sl@0: 			return ret;
sl@0: 			
sl@0: 		TTime now;
sl@0: 		now.UniversalTime();
sl@0: 		if(now.MicroSecondsFrom(iCurrentBurstStart) < KBurstDuration)
sl@0: 			{
sl@0: 			iCurrentBurstReleaseCount++;
sl@0: 			if(iCurrentBurstReleaseCount > KMaxMemoryReleasesPerBurst)
sl@0: 				return NULL;
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			iCurrentBurstStart = now;
sl@0: 			iCurrentBurstReleaseCount = 1;
sl@0: 			}
sl@0: 			
sl@0: 		if(iReserveEnabled && iReserve && (aSize < iReserveSize))
sl@0: 			{
sl@0: 			Free(iReserve);
sl@0: 			iReserve = NULL;
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			iReleasing = ETrue;
sl@0: 			keepTrying = CWsTop::ReleaseMemory();
sl@0: 			if(keepTrying)
sl@0:  				{
sl@0:  				const TInt reclaimed = Compress(); //Try to give back to the OS
sl@0:  				}	
sl@0: 			iReleasing = EFalse;
sl@0: 			}
sl@0: 			
sl@0: 		//used for OOM testing only
sl@0: 		if(iFailNextRetry)
sl@0: 			{
sl@0: 			iFailNextRetry = EFalse;
sl@0: 			keepTrying = EFalse;
sl@0: 			}
sl@0: 
sl@0: 		} while(keepTrying);
sl@0: 
sl@0: 	return NULL;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: The rest of these functions just call the default implementation
sl@0: */
sl@0: void CWsMemoryManager::Free(TAny* aPtr)
sl@0: 	{
sl@0: 	return iImpl->Free(aPtr);
sl@0: 	}
sl@0: 
sl@0: TInt CWsMemoryManager::AllocLen(const TAny* aCell) const
sl@0: 	{
sl@0: 	return iImpl->AllocLen(aCell);
sl@0: 	}
sl@0: 
sl@0: TInt CWsMemoryManager::Compress()
sl@0: 	{
sl@0: 	return iImpl->Compress();
sl@0: 	}
sl@0: 
sl@0: void CWsMemoryManager::Reset()
sl@0: 	{
sl@0: 	iImpl->Reset();
sl@0: 	}
sl@0: 
sl@0: TInt CWsMemoryManager::AllocSize(TInt& aTotalAllocSize) const
sl@0: 	{
sl@0: 	return iImpl->AllocSize(aTotalAllocSize);
sl@0: 	}
sl@0: 
sl@0: TInt CWsMemoryManager::Available(TInt& aBiggestBlock) const
sl@0: 	{
sl@0: 	return iImpl->Available(aBiggestBlock);
sl@0: 	}
sl@0: 
sl@0: TInt CWsMemoryManager::DebugFunction(TInt aFunc, TAny* a1, TAny* a2)
sl@0: 	{
sl@0: 	return iImpl->DebugFunction(aFunc,a1,a2);
sl@0: 	}
sl@0: 
sl@0: TInt CWsMemoryManager::Count() const
sl@0: 	{
sl@0: 	return iImpl->Count();
sl@0: 	}
sl@0: /** This is a fairly dumb way to enable and disable the reserve, but we normally
sl@0: get away with it because wserv is high priority.  A better approach would be to
sl@0: use placement new into the reserve memory and manage it directly.  This would also
sl@0: allow us to track misbehaving code which allocated during OOM drawing and didn't
sl@0: free at the end.
sl@0: */
sl@0: void CWsMemoryManager::EnableReserve()
sl@0: 	{
sl@0: 	WS_ASSERT_DEBUG(!iReserveEnabled, EWsPanicMemoryManager);
sl@0: 	iReserveEnabled = ETrue;
sl@0: 	}
sl@0: 
sl@0: void CWsMemoryManager::DisableReserve()
sl@0: 	{
sl@0: 	WS_ASSERT_DEBUG(iReserveEnabled, EWsPanicMemoryManager);
sl@0: 	iReserveEnabled = EFalse;
sl@0: 	if((!iReserve) && (iReserveSize > 0))
sl@0: 		iReserve = Alloc(iReserveSize);
sl@0: 	}