/*

* Copyright (c) 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:

*

*/

#ifndef MEMSPYDRIVEROBJECTIX_H

#define MEMSPYDRIVEROBJECTIX_H

// System includes

#include <kernel.h>

#include <kern_priv.h>

#if MCL_ROBJECTIX_DUPLICATION

class RMemSpyObjectIx

	{

public:

	enum {ENoClose=KHandleNoClose,ELocalHandle=0x40000000};

	enum {EReserved=0x80000000u, EAttributeMask=0xfffu};

	enum {EMinSlots=8, EMaxSlots=32768};

public:

	enum {ENumFreeQ=6, EModCount=4, EBitMapSize=128, EMaxLockedIter=8};

private:

	// queue numbers

	enum {EQFree=-6, EQAltFree=-5, EQTempFree=-4, EQRsvd=-3, EQAltRsvd=-2, EQTempRsvd=-1};

	// iObjR, iRsvd fields

	enum {EObjROccupied=4u, EObjRObjMask=0xfffffffcu, EObjRRsvd=1u};

	// states

	enum {ENormal=0u, ETidying=1u, EFindingLast=2u, ECounting=3u, ESearching=4u, ETerminated=5u};

	struct	SSlotQLink

		{

		TInt16		iNext;	// pointer to next free slot, -n if no next

		TInt16		iPrev;	// pointer to previous free slot, -n if no previous

		};

	struct	SFreeSlot : public SSlotQLink

		{

		TUint32		iRsvd;	// 0 for normal, 1 for reserved slot

		};

	struct	SUsedSlot

		{

		TUint32		iAttr;	// bits 0-13 = instance (nonzero), bits 14-19 = object type, bits 20-31 = handle attributes

		TUint32		iObjR;	// pointer to object (nonzero), bit 0=1 if reserved slot

		};

	union SSlot

		{

		SFreeSlot	iFree;

		SUsedSlot	iUsed;

		};

	struct SMonitorObj

		{

		DObject*	iObj;

		TInt		iBoundary;

		TInt		iResult;

		};

	union SModList

		{

		TInt16		iIndex[EModCount];

		TUint32		iBitMap[EBitMapSize/32];

		SMonitorObj	iMonitor;

		};

private:

#ifdef __HANDLES_USE_RW_SPIN_LOCK__

// Beginning of support for spinlock-only protection (i.e. not requiring the system lock)

// for access to handles.  Requires changes everywhere objects returned from handles are

// used, and some additional work in the handle lookup code in cutils.cia.

#error "spinlocks for handle lookup not supported"

	inline void AcquireReadLock()

		{ __SPIN_LOCK_IRQ_R(iRWL); }

	inline void ReleaseReadLock()

		{ __SPIN_UNLOCK_IRQ_R(iRWL); }

	inline void AcquireWriteLock()

		{ __SPIN_LOCK_IRQ_W(iRWL); }

	inline void ReleaseWriteLock()

		{ __SPIN_UNLOCK_IRQ_W(iRWL); }

#else

	/* Places which use a read lock would already have the system lock held */

	inline void AcquireReadLock()

		{ __ASSERT_SYSTEM_LOCK; }

	inline void ReleaseReadLock()

		{  }

	inline void AcquireWriteLock()

		{ NKern::LockSystem(); }

	inline void ReleaseWriteLock()

		{ NKern::UnlockSystem(); }

#endif

private:

	static inline DObject* Occupant(SSlot* aS)

		{ return (DObject*)(aS->iUsed.iObjR & EObjRObjMask); }

	static inline TBool IsReserved(SSlot* aS)

		{ return aS->iUsed.iObjR & EObjRRsvd; }

	static inline TBool IsFreeReserved(SSlot* aS)

		{ return (aS->iUsed.iObjR & EObjRRsvd) && (aS->iUsed.iObjR<EObjROccupied); }

    /*

	void Empty(TInt aQueue);

	SSlot* Dequeue(TInt aSlotIndex);

	void AddHead(TInt aQueue, TInt aSlotIndex);

	void AddTail(TInt aQueue, TInt aSlotIndex);

	void AddBefore(TInt aBase, TInt aSlotIndex);

	void AddAfter(TInt aBase, TInt aSlotIndex);

	void AppendList(TInt aSrcQ, TInt aDestQ);

	void PrependList(TInt aSrcQ, TInt aDestQ);

	TInt DoAdd(DObject* aObj, TUint32 aAttr, SSlot* aSlot);	// add aObj using an existing slot (don't grow)

	TInt DoRemove(TInt aHandle, DObject*& aObject, TUint32& aAttr);	// remove a handle (don't shrink)

	void MarkModified(TInt aSlotIndex);

	static TUint32 GetNextInstanceValue();

	TInt UnReserveSlots(TInt aCount, TBool aAmortize);

	TInt ReserveSlots(TInt aCount);

	TInt Grow(TInt aReserve, SSlot* aSlotData);

	void TidyAndCompact();

	inline SSlotQLink* Link(TInt aIndex)

		{ return (aIndex<0) ? (iFreeQ+ENumFreeQ+aIndex) : &(iSlots+aIndex)->iFree; }

        */

public:

	// common operations

    RMemSpyObjectIx();

    //static void Wait();

	//static void Signal();

    inline TInt Count()

		{ return iCount; }

	inline TInt ActiveCount()

		{ return iActiveCount; }

public:

	// uncommon operations

	DObject* operator[](TInt aIndex);

	TBool Find(DObject* aObject);

private:

	TRWSpinLock		iRWL;

	TInt			iAllocated;			// Max entries before realloc needed

	volatile TInt	iCount;				// Points to at least 1 above the highest occupied slot or unoccupied reserved slot

	volatile TInt	iActiveCount;		// Number of occupied entries in the index (reserved or normal)

	volatile TInt	iReservedFree;		// Number of unoccupied reserved slots

	volatile TInt	iReservedTotal;		// Number of reserved slots (occupied or unoccupied)

	volatile TInt	iReservedFreeHWM;	// Points to at least 1 above the last unoccupied reserved slot

	SSlotQLink		iFreeQ[ENumFreeQ];	// queues of free slots

	SSlot*			iSlots;				// array of handle slots

	TInt			iAmortize;			// Number of handle removals before we see if we can shrink

	TUint8			iState;

	TUint8			iModCount;			// 255=not in use, 0...EModCount->use iModList.iIndex[], EModCount+1->use iModList.iBitMap

	TUint8			iModListShift;

	TUint8			iSpare1;

	SModList		iModList;			// Entries modified while array moving

public:

	static volatile TUint32 NextInstance;

	static DMutex* HandleMutex;

	};

#elif MCL_DOBJECTIX_DUPLICATION

class DMemSpyObjectIx : public DBase

	{

public:

    inline DMemSpyObjectIx() { }

public:

	DObject* At(TInt aHandle,TInt aUniqueID);

	DObject* At(TInt aHandle);

	TBool Find(DObject* aObject);

	TInt Count(DObject* aObject);

	DObject* operator[](TInt aIndex);

	//static void Wait( DMemSpyObjectIx* aObjectIndex );

	//static void Signal( DMemSpyObjectIx* aObjectIndex );

	inline TInt Count();

	inline TInt ActiveCount();

private:

	TInt iNextInstance;

	TInt iAllocated;		// Max entries before realloc needed

	TInt iCount;			// Points to at least 1 above the highest active index

	TInt iActiveCount;		// Number of actual entries in the index

	SDObjectIxRec* iObjects;

	TAny* iPtr;

	TInt iFree;				// The index of the first free slot or -1.

	TInt iUpdateDisabled;   // If >0, disables: iCount update, reorder of the free list and memory shrinking.

public:

	static DMutex* HandleMutex;

	};

inline TInt DMemSpyObjectIx::Count()

	{return iCount;}

inline TInt DMemSpyObjectIx::ActiveCount()

	{return iActiveCount;}

#endif

#if MCL_ROBJECTIX_DUPLICATION

    #define MemSpyObjectIx                                          RMemSpyObjectIx

    //#define MemSpyObjectIx_Wait( IX )                               RMemSpyObjectIx::Wait()

    //#define MemSpyObjectIx_Signal( IX )                             RMemSpyObjectIx::Signal()

    #define MemSpyObjectIx_GetHandlePointer_Thread( DTHREAD )       reinterpret_cast< MemSpyObjectIx* >( &DTHREAD.iHandles )

    #define MemSpyObjectIx_GetHandlePointer_Process( DPROCESS )     reinterpret_cast< MemSpyObjectIx* >( &DPROCESS.iHandles )

#elif MCL_DOBJECTIX_DUPLICATION

    #define MemSpyObjectIx                                          DMemSpyObjectIx

    //#define MemSpyObjectIx_Wait( IX )                               DMemSpyObjectIx::Wait( IX )

    //#define MemSpyObjectIx_Signal( IX )                             DMemSpyObjectIx::Signal( IX )

    #define MemSpyObjectIx_GetHandlePointer_Thread( DTHREAD )       reinterpret_cast< MemSpyObjectIx* >( DTHREAD.iHandles )

    #define MemSpyObjectIx_GetHandlePointer_Process( DPROCESS )     reinterpret_cast< MemSpyObjectIx* >( DPROCESS.iHandles )

#else

    #define MemSpyObjectIx                  DObjectIx

    //#define MemSpyObjectIx_Wait( IX )       

    //#define MemSpyObjectIx_Signal( IX )     

    #define MemSpyObjectIx_IsValid_Thread( DTHREAD )    ( DTHREAD.iHandles != NULL )

    #define MemSpyObjectIx_IsValid_Process( DPROCESS )  ( DPROCESS.iHandles != NULL )

    #define MemSpyObjectIx_GetHandlePointer_Thread( DTHREAD )       reinterpret_cast< MemSpyObjectIx* >( DTHREAD.iHandles )

    #define MemSpyObjectIx_GetHandlePointer_Process( DPROCESS )     reinterpret_cast< MemSpyObjectIx* >( DPROCESS.iHandles )

#endif

#define MemSpyObjectIx_HandleLookupLock()							NKern::LockSystem()

#define MemSpyObjectIx_HandleLookupUnlock()							NKern::UnlockSystem()

#endif