// 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__)