// Copyright (c) 2006-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_cache_man.h

// 

//

/**

 @file

 @internalTechnology

*/

#if !defined(__SF_CACHE_MAN_H__)

#define __SF_CACHE_MAN_H__

#ifdef _DEBUG

#define __SIMULATE_LOCK_FAILURES__

#endif

// forward ref

class CCacheManager;

class CCacheClient;

const TInt KByteToByteShift = 10;

enum TCacheManagerFault

	{

	ENoCacheManager				= 0,

	ECacheAlreadyCreated		= 1,

	EIllegalDriveNumber			= 2,

	EIllegalCacheSize			= 3,			

	EIllegalPageSize			= 4,

	EInvalidAllocCount			= 5,

	EInvalidLockCount			= 6,

	EInvalidFillCount			= 7,

	EAppendToFreeQueueFailed	= 8,

	ESegmentNotFound			= 9,

	EUnlockFailed				= 10,

	EInvalidSegmentCount		= 11,

	EInvalidAddress				= 12,

	EInvalidDirtyCount			= 13,

	EDecommitFailed				= 14,

	EUnexpectedCommitFailure	= 15,

	EUnexpectedLockFailure		= 16,

	EInvalidCacheLine			= 17,

	EInvalidClient				= 18,

	ERemovingEmptyUnlocked		= 19,

	EFreeingLockedCacheLine		= 20,

	EFreeingDirtyCacheLine		= 21,

	ESetDirtyNotLocked			= 22,

	EClearDirtyNotLocked		= 23,

	ESetFilledNotLocked			= 24,

	EManagerNotLocked			= 25,

	EExtendingUnownedCacheline	= 26,

	EUnlockingUnownedCacheline	= 27,

	EInvalidLockedPageStart		= 28,

	EInvalidLockedPageCount		= 29,

	EInvalidLockRange			= 30,

	ESetDirtyInvalidLockRange	= 31,

	ELockingAndAlreadyDirty		= 32,

	EInvalidStats				= 33

	};

class CCacheManagerFactory

	{

public:

	static void CreateL();

	static TInt Destroy();

	static CCacheManager* CacheManager();

private:

	static CCacheManager* iCacheManager;

	};

NONSHARABLE_CLASS(CCacheManager) : public CBase

	{

private:

	class TCacheLine

		{

	public:

		TUint8* iAddr;

		TUint8 iAllocatedSegments;	// number of allocated pages 

		TUint8 iFilledSegments;		// number of full pages (i.e. pages with data in)

		TUint8 iDirtySegments;		// number of dirty pages

		TUint8 iLockCount;			// number of times cacheline has been locked

		TUint8 iLockedSegmentStart;	// zero based index of first locked paged

		TUint8 iLockedSegmentCount;	// number of locked pages

		TUint8 iSpare[2];			// padding

		CCacheClient* iClient;		// owner of this cacheline

		TInt64 iPos;				// arbitrary data owned by client

		};

public:

	CCacheClient* CreateClientL();

	void RegisterClient(CCacheClient& aClient);

	void DeregisterClient(CCacheClient& aClient);

	TInt SegmentSize();

	TInt SegmentSizeLog2();

	TInt64 SegmentSizeMask();

	TInt CacheLineSize();

	TInt CacheLineSizeLog2();

	TInt CacheLineSizeInSegments();

	// called from CCacheClient

	TInt AllocateAndLockCacheLine(CCacheClient* aClient, TInt64 aPos, const TCacheLine*& aCacheLine, TInt aSegmentCount);

	TInt ReAllocateAndLockCacheLine(CCacheClient* aClient, TInt64 aPos, const TCacheLine& aCacheLine, TInt aSegmentCount);

	TInt ExtendCacheLine(CCacheClient* aClient, const TCacheLine& aCacheLine, TInt aSegmentCount);

	void RemoveEmptySegments(CCacheClient* aClient, const TCacheLine& aCacheLine);

	TInt LockCacheLine(CCacheClient* aClient, const TCacheLine& aCacheLine, TInt aLockedPageStart, TInt aLockedPageCount);

	TBool UnlockCacheLine(CCacheClient* aClient, const TCacheLine& aCacheLine);

	TBool FreeCacheLine(CCacheClient* aClient, const TCacheLine& aCacheLine);

	TInt LockCount(CCacheClient* aClient, const TCacheLine& aCacheLine);

	TInt FillCount(CCacheClient* aClient, const TCacheLine& aCacheLine);

	TInt DirtyCount(CCacheClient* aClient, const TCacheLine& aCacheLine);

	TBool TooManyLockedSegments();

	void SetFilled(CCacheClient* aClient, const TCacheLine& aCacheLine,  TInt aSegmentCount);

	void SetDirty(CCacheClient* aClient, const TCacheLine& aCacheLine,  TInt aSegmentCount);

	void ClearDirty(CCacheClient* aClient, const TCacheLine& aCacheLine);

	TBool InUse(const TCacheLine& aCacheLine);

	// called from CKernEventNotifier::FreeMemoryChangeCallback()

	void FreeMemoryChanged(TBool aMemoryLow);

#if defined(_DEBUG) || defined(_DEBUG_RELEASE)

	void DumpCache();

	void DumpCacheLine(TCacheLine& aCacheLine);

	void SimulateLockFailureMode(TBool aEnable);

	void AllocateMaxSegments(TBool aEnable);

	TBool AllocateMaxSegments();

	// stats

	TFileCacheStats& Stats();

	void SimulateWriteFailure();

	TBool SimulateWriteFailureEnabled();

	TBool SimulatedFailure(TInt& aFailureCount);

#endif

private:

	~CCacheManager();

	CCacheManager(TUint aCacheSize);

	void ConstructL();

	inline TUint8* Base();

	inline void CacheLock();

	inline void CacheUnlock();

	TBool StealCacheLine(CCacheClient* aClient);

	TInt Lock(TUint8* aAddr, TInt aSegmentCount);

	TInt Unlock(TUint8* aAddr, TInt aSegmentCount);

	TInt Commit(TUint8* aAddr, TInt aSegmentCount);

	TInt Decommit(TUint8* aAddr, TInt aSegmentCount);

	static CCacheManager* NewCacheL(TInt aUncommitedCacheSize);

	void FreeCacheLine(TCacheLine& aCacheLine);

private:

	RFastLock iLock;

	TCacheLine* iCacheLines;

	RPointerArray<TCacheLine> iFreeQueue;

	RPointerArray<TCacheLine> iUsedQueue;

	TUint8* iBase;

	TInt iNumOfCacheLines;

	TInt iCacheLineSize;

	TInt iCacheLineSizeLog2;

	TInt iCacheSize;

	TInt iMaxLockedSegments;

	TInt iSegmentsPerCacheLine;

	TInt iLockedSegmentCount;

	RChunk iChunk;

	TBool iSimulateLockFailureMode;

#if defined(_DEBUG) || defined(_DEBUG_RELEASE)

	TBool iManagerLocked;

	TInt iLockFailureCount;

	TInt iCommitFailureCount;

	TInt iAllocFailureCount;

	TBool iAllocateMaxSegments;

	TFileCacheStats iStats;

	TBool iSimulateWriteFailure;

#endif

	// low memory notification stuff

	TBool iMemoryLow;			// ETrue if kernel has notified us that memory has fallen below a specified threshold

	TInt iLowMemoryThreshold;

	// index of the next cacheline in iUsedQueue to steal if 

	// all cachelines are in use

	TInt iNextCacheLineToSteal;

friend class CCacheManagerFactory;

friend class CCacheClient;

	};

NONSHARABLE_CLASS(TGlobalFileCacheSettings)

	{

public:

	static void ReadPropertiesFile();

	static TBool Enabled();

	static TInt CacheSize();

	static TInt MaxLockedSize();

	static TInt LowMemoryThreshold();

private:

	static TBool iEnabled;

	static TInt32 iCacheSize;

	static TInt32 iMaxLockedSize;

	static TInt32 iLowMemoryThreshold;

	};

#endif	// !defined(__SF_CACHE_MAN_H__)