// 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 "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:
//

#include "WsMemMgr.h"
#include "inifile.h"
#include "panics.h"
#include "wstop.h"

static const TTimeIntervalMicroSeconds KBurstDuration = 1000000; //one second
static const TInt KMaxMemoryReleasesPerBurst = 5;
CWsMemoryManager * CWsMemoryManager::iStatic = NULL;

CWsMemoryManager * CWsMemoryManager::Static()
	{
	return iStatic;
	}

CWsMemoryManager * CWsMemoryManager::NewLC()
	{
	CWsMemoryManager * self = new (ELeave) CWsMemoryManager;
	CleanupStack::PushL(self);
	self->ConstructL();
	iStatic = self;
	return iStatic;
	}

CWsMemoryManager::CWsMemoryManager()
	{
	iImpl = User::SwitchAllocator(this);
	}
	
CWsMemoryManager::~CWsMemoryManager()
	{
	WS_ASSERT_ALWAYS(this == User::SwitchAllocator(iImpl),EWsPanicMemoryManager);
	iStatic = 0;
	if (iReserve!=NULL)
		{
		Free(iReserve);
		}
	}

void CWsMemoryManager::ConstructL()
	{
	_LIT(KMemMgrReserve, "MEMORYRESERVE");
	const TInt KDefaultMemMgrReserve = 1024;
	
	if (!WsIniFile->FindVar(KMemMgrReserve, iReserveSize))
		iReserveSize = KDefaultMemMgrReserve;

	if (iReserveSize > 0)
		iReserve = Alloc(iReserveSize);
	
	iCurrentBurstStart.UniversalTime();
	}

/**
Tells the memory manager to fail on next retry.
I.e. whenever the next allocation failure occurs, the memory manager won't try 
to free up memory to have another go at the allocation.

N.B. this only applies for the next failure, the state is reset when there is an
allocation failure.

This method is only to be used for OOM testing.
*/
void CWsMemoryManager::SetFailNextRetry()
	{
	iFailNextRetry = ETrue;
	}

/**
Implementing RAllocator
*/

/**
Alloc and ReAlloc attempt to obtain memory through CWsTop::ReleaseMemory when they run low.
ReleaseMemory looks for blocks of memory that the window server doesn't need urgently and frees
them.
*/
TAny* CWsMemoryManager::Alloc(TInt aSize)
	{
	TBool keepTrying = ETrue;
	do
		{
		if(iReleasing)
			return iImpl->Alloc(aSize); //fallback on RAllocator
		
		if(TAny* ret = iImpl->Alloc(aSize)) //normal case
			return ret;
		
		TTime now;
		now.UniversalTime();
		if(now.MicroSecondsFrom(iCurrentBurstStart) < KBurstDuration)
			{
			iCurrentBurstReleaseCount++;
			if(iCurrentBurstReleaseCount > KMaxMemoryReleasesPerBurst)
				return NULL;
			}
		else
			{
			iCurrentBurstStart = now;
			iCurrentBurstReleaseCount = 1;
			}
		
		if(iReserveEnabled && iReserve && (aSize < iReserveSize))
			{
			Free(iReserve);
			iReserve = NULL;
			}
		else
			{
			iReleasing = ETrue;
			keepTrying = CWsTop::ReleaseMemory();
			if(keepTrying)
 				{
 				const TInt reclaimed = Compress(); //Try to give back to the OS
 				}
			iReleasing = EFalse;
			}
		
		//used for OOM testing only
		if(iFailNextRetry)
			{
			iFailNextRetry = EFalse;
			keepTrying = EFalse;
			}
		
		} while(keepTrying);

	return NULL;
	}

TAny* CWsMemoryManager::ReAlloc(TAny* aPtr, TInt aSize, TInt aMode)
	{
	TBool keepTrying = ETrue;
	do
		{
		if(iReleasing)
			return iImpl->ReAlloc(aPtr, aSize, aMode); //fallback on RAllocator
		
		if(TAny* ret = iImpl->ReAlloc(aPtr, aSize, aMode)) //normal case
			return ret;
			
		TTime now;
		now.UniversalTime();
		if(now.MicroSecondsFrom(iCurrentBurstStart) < KBurstDuration)
			{
			iCurrentBurstReleaseCount++;
			if(iCurrentBurstReleaseCount > KMaxMemoryReleasesPerBurst)
				return NULL;
			}
		else
			{
			iCurrentBurstStart = now;
			iCurrentBurstReleaseCount = 1;
			}
			
		if(iReserveEnabled && iReserve && (aSize < iReserveSize))
			{
			Free(iReserve);
			iReserve = NULL;
			}
		else
			{
			iReleasing = ETrue;
			keepTrying = CWsTop::ReleaseMemory();
			if(keepTrying)
 				{
 				const TInt reclaimed = Compress(); //Try to give back to the OS
 				}	
			iReleasing = EFalse;
			}
			
		//used for OOM testing only
		if(iFailNextRetry)
			{
			iFailNextRetry = EFalse;
			keepTrying = EFalse;
			}

		} while(keepTrying);

	return NULL;
	}

/**
The rest of these functions just call the default implementation
*/
void CWsMemoryManager::Free(TAny* aPtr)
	{
	return iImpl->Free(aPtr);
	}

TInt CWsMemoryManager::AllocLen(const TAny* aCell) const
	{
	return iImpl->AllocLen(aCell);
	}

TInt CWsMemoryManager::Compress()
	{
	return iImpl->Compress();
	}

void CWsMemoryManager::Reset()
	{
	iImpl->Reset();
	}

TInt CWsMemoryManager::AllocSize(TInt& aTotalAllocSize) const
	{
	return iImpl->AllocSize(aTotalAllocSize);
	}

TInt CWsMemoryManager::Available(TInt& aBiggestBlock) const
	{
	return iImpl->Available(aBiggestBlock);
	}

TInt CWsMemoryManager::DebugFunction(TInt aFunc, TAny* a1, TAny* a2)
	{
	return iImpl->DebugFunction(aFunc,a1,a2);
	}

TInt CWsMemoryManager::Count() const
	{
	return iImpl->Count();
	}
/** This is a fairly dumb way to enable and disable the reserve, but we normally
get away with it because wserv is high priority.  A better approach would be to
use placement new into the reserve memory and manage it directly.  This would also
allow us to track misbehaving code which allocated during OOM drawing and didn't
free at the end.
*/
void CWsMemoryManager::EnableReserve()
	{
	WS_ASSERT_DEBUG(!iReserveEnabled, EWsPanicMemoryManager);
	iReserveEnabled = ETrue;
	}

void CWsMemoryManager::DisableReserve()
	{
	WS_ASSERT_DEBUG(iReserveEnabled, EWsPanicMemoryManager);
	iReserveEnabled = EFalse;
	if((!iReserve) && (iReserveSize > 0))
		iReserve = Alloc(iReserveSize);
	}