diff -r 000000000000 -r a2952bb97e68 mpx/commonframework/common/inc/mpxheapmanager.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mpx/commonframework/common/inc/mpxheapmanager.h Thu Dec 17 08:55:47 2009 +0200 @@ -0,0 +1,337 @@ +/* +* Copyright (c) 2006 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: Manages global heap/chunk +* +*/ + + + +#ifndef RMPXHEAPMANAGER_H +#define RMPXHEAPMANAGER_H + +#include "mpxdataarray.h" + + +class RMPXHeapCell + { + public: + RMPXHeapCell(TInt aNextOffset, TInt aLen): + iNextOffset(aNextOffset), + iLen(aLen) + { + } + RMPXHeapCell() + { + } + public: + /** + * Offset of next cell from the base of the chunk to the next heap + * cell, or 0 if none + */ + TInt iNextOffset; + /** + * Length of the cell, which includes the length of header + */ + TInt iLen; + /** + * Is this cell's contents paged to file storage + */ + // TBool iPaged; + }; + +/** +* Class RMPXHeapManager +*/ +class RMPXHeapManager + { +public: + /** + * The heap manager + * + * @param aClientHandle, client handle to the global chunk + */ + static inline RMPXHeapManager& HeapManager(TUint aClientHandle); + + /** + * Gets the total size and the currently used size of the global heap + * + * @param aTotal Total size of memory in bytes (out parameter) + * @param aUsed Used size of memory in bytes (out parameter) + * @leave Leave with KErrNotFound if failed to open global chunk + */ + static void HeapMemoryInfoL( TInt& aTotal, TInt& aUsed ); + + +public: + /** + * Handle which represents the current client (thread). + * This should be stored by the client and provided in all methods; + * by so doing, the Heap Manager can optimally cope with the chunk mapped + * to different addresses, thread relative handles for the chunk and mutex, + * etc. Handle should never be zero: zero indicates that it has failed. + * + * @return client handle to the global chunk + */ + static TUint ClientHandle(); + + /** + * Returns absolute address from an offset from the base of the chunk + * + * @param aClientHandle, client handle to the global chunk + * @param aOffset, offset to the glboal chunk + * @return pointer to the global address + */ + template + static inline T* Ptr(TUint aClientHandle,TInt aOffset=0); + + /** + * Returns offset from the base of the chunk from absolute pointer + * + * @param aClientHandle, client handle to the global chunk + * @param aPtr pointer to the global address + * @return offset to the glboal chunk + */ + static inline TInt Offset(TUint aClientHandle,TAny* aPtr); + +public: + /** + * Add another/new reference to a client (thread) + * + * @param aClientHandle, client handle to the global chunk + */ + void AddRef(TUint aClientHandle); + + /** + * Remove a reference to a client (thread) + * @param aClientHandle, client handle to the global chunk + */ + void Release(TUint aClientHandle); + + /** + * Allocate an object of type T on the chunk. An absolute pointer to the + * object created is returned, though the object must contain no absolute + * pointers within itself + * + * @param aClientHandle, client handle to the global chunk + * @return pointer to the memory + */ + template + inline T* Alloc(TUint aClientHandle); + + /** + * Allocate a buffer of size aSize and return an absolute pointer to the + * start of the buffer. + * + * @param aClientHandle, client handle to the global chunk + * @param aSize, size of the memory + * @return pointer to the memory + */ + TAny* Alloc(TUint aClientHandle,TInt aSize); + + /** + * Allocate a buffer of size aSize, copy aSrcOffset to the buffer, + * and return an offset to the start of the buffer. + * + * @param aClientHandle, client handle to the global chunk + * @param aSrcOffset, source data offset + * @param aSize, size of the data buffer + * @return system error code + */ + inline TInt Copy(TUint aClientHandle,TInt aSrcOffset,TInt aSize); + + /** + * Allocate a buffer of size aSize, copy aSrc to the buffer, + * and return an offset to the start of the buffer. + * + * @param aClientHandle, client handle to the global chunk + * @param aSrc, source + * @param aSize, size of the data buffer + * @return system error code + */ + TInt Copy(TUint aClientHandle,TAny* aSrc,TInt aSize); + + /** + * Delete an object/buffer on the chunk. Can return error + * + * @param aClientHandle, client handle to the global chunk + * @param aSrcPtr, memory address to be freed + * @return system error code + */ + TInt Free(TUint aClientHandle,TAny* aPtr); + + /** + * Delete an object/buffer on the chunk. Can return error + * + * @param aClientHandle, client handle to the global chunk + * @param aOffset, offset to global memory to be freed + * @return system error code + */ + inline TInt Free(TUint aClientHandle,TInt aOffset); + + /** + * Locks heap + * + * @param aClientHandle, client handle to the global chunk + */ + void Lock(TUint aClientHandle); + + /** + * Unocks heap + * + * @param aClientHandle, client handle to the global chunk + */ + void Unlock(TUint aClientHandle); + + /** + * Increment consecutive number + * + * @return current number + */ + TInt IncrementCounter(); + +#ifdef __ENABLE_MPX_GARBAGE_COLLECTOR + /** + * Run the Garbage Collector + */ + void RunGc(TUint aClientHandle); //GC + + /** + * Associate data with this client + */ + TInt AddData(TUint aClientHandle,TUint aDataHandle); //GC + + /** + * Unassociate data with this client + */ + TInt RemoveData(TUint aClientHandle,TUint aDataHandle,TBool aRemoveAll); //GC +#endif // __ENABLE_MPX_GARBAGE_COLLECTOR + +private: + /** + * Data associated with a client (thread) + */ + class TClientContext + { + public: + TClientContext(); + TClientContext(TUint8* aBase,TInt aChunkHandle,TInt aMutexHandle); + public: + TThreadId iTid; + RChunk iChunk; // Thread relative + RMutex iMutex; // Thread relative + TInt iCount; // Number of clients in this thread (media objects) + TUint8* iBase; // Base of the chunk for this process +#ifdef __ENABLE_MPX_GARBAGE_COLLECTOR + RMPXDataItemArray iData; // Dynamic array of TUint //GC +#endif // __ENABLE_MPX_GARBAGE_COLLECTOR + }; +private: + RMPXHeapManager(const RChunk& aChunk); + +private: + /** + * Index which represents the current client (thread). + * Refers to iClients array. + */ + TInt ClientIndex(const TClientContext& aContext); + + /** + * Client index from the handle. Refers to iClients array. + */ + static inline TInt ClientIndex(TUint aClientHandle); + + /** + * Returns index of first entry for that TID. There will + * only ever be one, unless the search is for KNullThreadId + */ + TInt Find(const TThreadId& aTid); + + /** + * Creates client handle + */ + static inline TUint ClientHandle(TUint8* aChunkBase,TInt aClientIndex); + + /** + * Base address of the chunk for this client + */ + static inline TUint8* ChunkBase(TUint aClientHandle); + + /** + * Finds (or creates) first Heap Cell which can fit aSize bytes + */ + RMPXHeapCell* HeapCell(TUint aClientHandle,TInt aSize); + + /** + * Finds (or creates) first Heap Cell which can fit aSize bytes + */ + RMPXHeapCell* DoHeapCell(TUint aClientHandle,TInt aSize,RMPXHeapCell*& aLastFree); + + /** + * Try to grow the global chunk + */ + TInt TryToGrowHeap(TUint aClientHandle, TInt aSize, RMPXHeapCell* aLastFree); + + /** + * Number of clients (threads) + */ + TInt ClientCount() const; + + /** + * Check if it is the last cell + */ + TBool IsLastCell(TUint aClientHandle, RMPXHeapCell* aCell); + +private: + + enum {ENumClients=0x100}; + enum {EHeapCellHeaderSize = sizeof(RMPXHeapCell)}; + enum {EMinCellSize = sizeof(RMPXHeapCell) + 4 }; + +private: + /** + * Client data (per thread) + */ + TFixedArray iClients; + /** + * Offset from the base of the chunk to the end of the chunk, i.e. + * the size of the chunk + */ + TInt iEndOffset; + /** + * Head to free cell list + */ + RMPXHeapCell iFree; + /** + * Counter + */ + TInt iCounter; + + /** + * Total memory in bytes used in Global Chunk + */ + TInt iUsedMemory; + + /** + * Maximum size of memory in bytes used in Global Chunk + */ + TInt iMaxMemory; + +#ifdef __ENABLE_MPX_GARBAGE_COLLECTOR + TInt iDeadContextIndex; +#endif // __ENABLE_MPX_GARBAGE_COLLECTOR + }; + +#include "mpxheapmanager.inl" + +#endif // RMPXHEAPMANAGER_H