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

// f32\sfile\sf_memory_man.cpp

// 

//

/**

 @file

 @internalTechnology

*/

#include <e32std.h>

#include <e32std_private.h>

#include "sf_std.h"

#include <e32uid.h>

#include <e32wins.h>

#include <f32file.h>

#include <hal.h>

#include "sf_memory_man.h"

#include "sf_memory_client.h"

/**

Destructor of the CCacheMemoryManager, need to destroy all registered clients.

*/

CCacheMemoryManager::~CCacheMemoryManager()

	{

	for (TInt i = 0; i < iRegisteredClients.Count(); i++)

		{

		iRegisteredClients[i]->Reset();

		delete iRegisteredClients[i];

		}

	iRegisteredClients.Close();

	}

/**

Static factory function of CCacheMemoryManager

@param	aCacheSize	the total size of the virtual address space

*/

CCacheMemoryManager* CCacheMemoryManager::NewL(TInt aCacheSize)

	{

	CCacheMemoryManager* cacheMemoryManager = new (ELeave) CCacheMemoryManager(aCacheSize);

	CleanupStack::PushL(cacheMemoryManager);

	cacheMemoryManager->ConstructL();

	CleanupStack::Pop(1, cacheMemoryManager);

	return cacheMemoryManager;

	}

/**

Constructor of CCacheMemoryManager

@param	aMaxSize	the total size of the virtual address space

*/

CCacheMemoryManager::CCacheMemoryManager(TUint32 aMaxSize)

:iBase(NULL),

iSizeInBytes(aMaxSize),

iCurrentOffsetMark(0)

	{

	}

/**

Second phase constructor of CCacheMemoryManager.

Creates RChunk object and sets low memory threshold.

*/

void CCacheMemoryManager::ConstructL()

	{

	// calculate the low-memory threshold below which we fail any attempt to allocate memory

	TMemoryInfoV1Buf meminfo;

	TInt r = UserHal::MemoryInfo(meminfo);

	ASSERT(r==KErrNone);

	User::LeaveIfError(r);

	iLowMemoryThreshold = (meminfo().iTotalRamInBytes * TGlobalCacheMemorySettings::LowMemoryThreshold()) / 100;

	TChunkCreateInfo createInfo;

	createInfo.SetCache(iSizeInBytes);

	createInfo.SetOwner(EOwnerProcess);

	r = iChunk.Create(createInfo);

	ASSERT(r==KErrNone);

	User::LeaveIfError(r);

	UserSvr::RegisterTrustedChunk(iChunk.Handle());

	iBase = iChunk.Base();

	iRegisteredClients.ReserveL(10);

	__PRINT3(_L("CCacheMemoryManager::ConstructL(lowMem=%d, iSize=%d, base=0x%lx)"), iLowMemoryThreshold, iSizeInBytes, iBase);

	}

/**

Connect or register a client.

Note: callers of this function should be constructor of various caches, it is their resposibility

	to make sure that parameters are sensible when calling this function

@internalTechnology

@released

@param	aClientName	an identifier of the client to be connected

@param	aMinSizeInSegs	minimum client size in segments

@param	aMaxSizeInSegs	maximum client size in segments

@return	CCacheMemoryClient*	pointer to the client that connected, or NULL if parameters are not valid.

@leave	if no memory

*/

EXPORT_C CCacheMemoryClient* CCacheMemoryManager::ConnectClientL(const TDesC& aClientName, TUint32 aMinSizeInSegs, TUint32 aMaxSizeInSegs)

	{

	__PRINT3(_L("CCacheMemoryManager::ConnectClientL([%S], minSeg=%d, maxSeg=%d)"), &aClientName, aMinSizeInSegs, aMaxSizeInSegs);

	// search for existing clients by name

	for (TInt i = 0; i < iRegisteredClients.Count(); i++)

		{

		if (aClientName.Compare(iRegisteredClients[i]->Name()) == 0)

			{

			ASSERT(iRegisteredClients[i]->iTouchedRegionFlag == 0);

			__PRINT1(_L("CCacheMemoryManager::ConnectClientL: [%S] found!"), &aClientName);

			return iRegisteredClients[i];

			}

		}

	// if it is a new drive/file system who wants to connect, create a new client for it

	// parameter validation

	ASSERT(iSizeInBytes > iCurrentOffsetMark + (aMaxSizeInSegs << SegmentSizeInBytesLog2()));

	if (iSizeInBytes < iCurrentOffsetMark + (aMaxSizeInSegs << SegmentSizeInBytesLog2()))

		{

		ASSERT(0);

		User::Leave(KErrArgument);

		}

	// note: client creation may leave under OOM conditions

	CCacheMemoryClient* client = CCacheMemoryClient::NewL(*this, aClientName, iCurrentOffsetMark, aMinSizeInSegs, aMaxSizeInSegs);

	// if error happens during client registration, the client will be deleted

	// this may leave under OOM conditions

	TInt err = iRegisteredClients.Append(client);

	if (err != KErrNone)

		{

		ASSERT(0);

		delete client;

		client = NULL;

		User::Leave(err);

		}

	// record current offset mark for next client

	iCurrentOffsetMark += (aMaxSizeInSegs << SegmentSizeInBytesLog2());

	return client;

	}

/**

Commit a contiguous set of segments.

@param	aStartRamAddr	the start ram address of the region to be committed.

@param	aSegmentCount	the segment number of the contiguous region to be committed.

@return	TInt	KErrNone if succeeded, KErrNoMemory if passed low memory threshold, otherwise a system-wide error code.

*/

TInt CCacheMemoryManager::AllocateAndLockSegments(TUint8* aStartRamAddr, TInt aSegmentCount)

	{

	__PRINT2(_L("CCacheMemoryManager::AllocateAndLockSegments(base=0x%x, seg=%d)"), aStartRamAddr, aSegmentCount);

	TMemoryInfoV1Buf meminfo;

	TInt r = UserHal::MemoryInfo(meminfo);

	__ASSERT_DEBUG(r==KErrNone,Fault(EMemoryInfoFailed));

	if (r != KErrNone)

		{

		return r;

		}

	if (isMemoryLow || (meminfo().iFreeRamInBytes < iLowMemoryThreshold))

		{

		__PRINT(_L("CCacheMemoryManager: free RAM below threshold !!!"));

		return KErrNoMemory;

		}

	return Commit(aStartRamAddr, aSegmentCount);

	}

/**

Notify the change of memory status

@param	aIsMemoryLow	the flag that sets current memory status

*/

void CCacheMemoryManager::FreeMemoryChanged(TBool aIsMemoryLow)

	{

	isMemoryLow = aIsMemoryLow;

	}

/**

Decommit a contiguous set of segments.

@param	aStartRamAddr	the start ram address of the region to be decommitted.

@param	aSegmentCount	the segment number of the contiguous region to be decommitted.

@return	TInt	KErrNone if succeeded, otherwise a system-wide error code.

*/

TInt CCacheMemoryManager::DecommitSegments(TUint8* aStartRamAddr, TUint32 aSegmentCount)

	{

	return Decommit(aStartRamAddr, aSegmentCount);

	}

/**

Lock a contiguous set of segments.

@param	aStartRamAddr	the start ram address of the region to be locked.

@param	aSegmentCount	the segment number of the contiguous region to be locked.

@return	TInt	KErrNone if succeeded, otherwise a system-wide error code.

*/

TInt CCacheMemoryManager::LockSegments(TUint8* aStartRamAddr, TUint32 aSegmentCount)

	{

	return Lock(aStartRamAddr, aSegmentCount);

	}

/**

Unlock a contiguous set of segments.

@param	aStartRamAddr	the start ram address of the region to be unlocked.

@param	aSegmentCount	the segment number of the contiguous region to be unlocked.

@return	TInt	KErrNone if succeeded, otherwise a system-wide error code.

*/

TInt CCacheMemoryManager::UnlockSegments(TUint8* aStartRamAddr, TUint32 aSegmentCount)

	{

	return Unlock(aStartRamAddr, aSegmentCount);

	}

/**

Commit a contiguous set of segments.

@param	aStartRamAddr	the start ram address of the region to be committed.

@param	aSegmentCount	the segment number of the contiguous region to be committed.

@return	TInt	KErrNone if succeeded, otherwise a system-wide error code.

*/

TInt CCacheMemoryManager::Commit(TUint8* aStartRamAddr, TInt aSegmentCount)

	{

	TInt offset = aStartRamAddr - iBase;

	TInt r = iChunk.Commit(offset, aSegmentCount << KSegmentSizeLog2);

	return r;

	}

/**

Actual implementation of DecommitSegments().

@see CCacheMemoryManager::DecommitSegments().

*/

TInt CCacheMemoryManager::Decommit(TUint8* aStartRamAddr, TInt aSegmentCount)

	{

	return iChunk.Decommit(aStartRamAddr - iBase, aSegmentCount << KSegmentSizeLog2);

	}

/**

Actual implementation of UnlockSegments().

@see CCacheMemoryManager::UnlockSegments().

*/

TInt CCacheMemoryManager::Unlock(TUint8* aStartRamAddr, TInt aSegmentCount)

	{

	TInt r = iChunk.Unlock(aStartRamAddr - iBase, aSegmentCount << KSegmentSizeLog2);

	return r;

	}

/**

Actual implementation of LockSegments().

@see CCacheMemoryManager::LockSegments().

*/

TInt CCacheMemoryManager::Lock(TUint8* aStartRamAddr, TInt aSegmentCount)

	{

	return iChunk.Lock(aStartRamAddr - iBase, aSegmentCount << KSegmentSizeLog2);

	}

//=====================================================================

TUint8* CCacheMemoryManager::Base()

	{

	return iChunk.Base();

	}

/**

Get function, returns log2 value of a segment size in bytes.

@internalTechnology

@released

*/

EXPORT_C TUint CCacheMemoryManager::SegmentSizeInBytesLog2() const

	{

	return KSegmentSizeLog2;

	}

//=============================================================================

/**

The singleton of global cache memory manager

*/

CCacheMemoryManager* CCacheMemoryManagerFactory::iCacheMemoryManager = NULL;

/**

Global factory function of CCacheMemoryManager. 

*/

void CCacheMemoryManagerFactory::CreateL()

	{

	iCacheMemoryManager = CCacheMemoryManager::NewL(TGlobalCacheMemorySettings::CacheSize());

	}

/**

Global get function of CCacheMemoryManager. 

@internalTechnology

@released

*/

EXPORT_C CCacheMemoryManager* CCacheMemoryManagerFactory::CacheMemoryManager()

	{

	return iCacheMemoryManager;

	}

/**

Global destroy function of CCacheMemoryManager. 

*/

void CCacheMemoryManagerFactory::Destroy()

	{

	delete iCacheMemoryManager;

	iCacheMemoryManager = NULL;

	}

//=============================================================================

const TInt KByteToByteShift = 10;

TInt32 TGlobalCacheMemorySettings::iCacheSizeInBytes	= KDefaultGlobalCacheMemorySize << KByteToByteShift;

TInt32 TGlobalCacheMemorySettings::iLowMemoryThreshold  = KDefaultLowMemoryThreshold;

_LIT8(KLitSectionNameCacheMemory,"CacheMemory");

/**

Read ESTART.TXT file for global cache memory settings 

*/

void TGlobalCacheMemorySettings::ReadPropertiesFile()

	{

	// Get size of cache in kilobytes

	TInt32 cacheSizeInKBytes;

	if (F32Properties::GetInt(KLitSectionNameCacheMemory, _L8("GlobalCacheMemorySize"), cacheSizeInKBytes))

		{

		iCacheSizeInBytes = cacheSizeInKBytes << KByteToByteShift;

		}

	// Get low memory threshold

	TInt32 lowMemoryThreshold;

	if (F32Properties::GetInt(KLitSectionNameCacheMemory, _L8("LowMemoryThreshold"), lowMemoryThreshold))

		iLowMemoryThreshold = lowMemoryThreshold;

	}

TInt TGlobalCacheMemorySettings::CacheSize()

	{

	return iCacheSizeInBytes;

	}

TInt TGlobalCacheMemorySettings::LowMemoryThreshold()

	{

	return iLowMemoryThreshold;

	}