memspy/memspy_plat/memspy_api/include/memspy/driver/shared/MemSpyDriverObjectsSharedRHeap.h
/*
* 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 MEMSPYDRIVEROBJECTSSHAREDRHEAP_H
#define MEMSPYDRIVEROBJECTSSHAREDRHEAP_H
// System includes
#include <u32std.h>
#ifndef __KERNEL_MODE__
#include <e32debug.h>
#endif
// User includes
#include <memspy/driver/memspydriverenumerationsshared.h>
// Defines
//#define __CHECK_CHUNK_NAME
// Classes referenced
class CActiveScheduler;
class CTrapCleanup;
/**
* Base class for MemSpy RHeap statistics
*/
class TMemSpyHeapStatisticsRHeapBase
{
public: // Type
enum TType
{
ETypeAllocated = 0,
ETypeFree
};
public: // Constructors & destructor
inline TMemSpyHeapStatisticsRHeapBase( TType aType )
: iType( aType ),
iTypeCount( 0 ),
iTypeSize( 0 ),
iLargestCellAddress( NULL ),
iLargestCellSize( 0 )
{
}
public: // API
inline TType Type() const { return iType; }
//
inline TUint TypeCount() const { return iTypeCount; }
inline void SetTypeCount( TUint aValue ) { iTypeCount = aValue; }
//
inline TUint TypeSize() const { return iTypeSize; }
inline void SetTypeSize( TUint aValue ) { iTypeSize = aValue; }
//
inline TAny* LargestCellAddress() const { return iLargestCellAddress; }
inline void SetLargestCellAddress( TAny* aAddress ) { iLargestCellAddress = aAddress; }
//
inline TUint LargestCellSize() const { return iLargestCellSize; }
inline void SetLargestCellSize( TUint aSize ) { iLargestCellSize = aSize; }
private: // Data members
TType iType;
TUint iTypeCount;
TUint iTypeSize;
TAny* iLargestCellAddress;
TUint iLargestCellSize;
};
/**
* RHeap statistics for Allocated cell types
*/
class TMemSpyHeapStatisticsRHeapAllocated : public TMemSpyHeapStatisticsRHeapBase
{
public: // Constructors
inline TMemSpyHeapStatisticsRHeapAllocated()
: TMemSpyHeapStatisticsRHeapBase( TMemSpyHeapStatisticsRHeapBase::ETypeAllocated )
{
}
public:
};
/**
* RHeap statistics for Free cell types
*/
class TMemSpyHeapStatisticsRHeapFree : public TMemSpyHeapStatisticsRHeapBase
{
public: // Constructors
inline TMemSpyHeapStatisticsRHeapFree()
: TMemSpyHeapStatisticsRHeapBase( TMemSpyHeapStatisticsRHeapBase::ETypeFree ),
iSlackSpace( 0 ), iSlackSpaceCellAddress( NULL ), iChecksum( 0 )
{
}
public: // API
inline TUint SlackSpaceCellSize() const { return iSlackSpace; }
inline void SetSlackSpaceCellSize( TUint aValue ) { iSlackSpace = aValue; }
//
inline TAny* SlackSpaceCellAddress() const { return iSlackSpaceCellAddress; }
inline void SetSlackSpaceCellAddress( TAny* aAddress ) { iSlackSpaceCellAddress = aAddress; }
//
inline TUint32 Checksum() const { return iChecksum; }
inline void SetChecksum( TUint32 aValue ) { iChecksum = aValue; }
public:
TUint iSlackSpace;
TAny* iSlackSpaceCellAddress;
TUint32 iChecksum;
};
/**
* RHeap statistics class
*/
class TMemSpyHeapStatisticsRHeap
{
public: // Constructors
inline TMemSpyHeapStatisticsRHeap()
: iCommittedFreeSpace(0)
{
}
public: // API
inline TMemSpyHeapStatisticsRHeapFree& StatsFree() { return iStatisticsFree; }
inline const TMemSpyHeapStatisticsRHeapFree& StatsFree() const { return iStatisticsFree; }
//
inline TMemSpyHeapStatisticsRHeapAllocated& StatsAllocated() { return iStatisticsAllocated; }
inline const TMemSpyHeapStatisticsRHeapAllocated& StatsAllocated() const { return iStatisticsAllocated; }
private: // Data members
TMemSpyHeapStatisticsRHeapFree iStatisticsFree;
TMemSpyHeapStatisticsRHeapAllocated iStatisticsAllocated;
public: // I am fed up of all these pointless inline accessors...
TInt iCommittedFreeSpace; // The amount of committed memory that isn't payload data in allocated or free cells
};
/**
*
*/
class TMemSpyHeapMetaDataRHeap
{
public: // Constructors
inline TMemSpyHeapMetaDataRHeap()
: iChunkSize( 0 ),
iChunkHandle( NULL ),
iChunkBaseAddress( NULL ),
iDebugAllocator( EFalse ),
//iHeaderSizeFree( 0 ),
//iHeaderSizeAllocated( 0 ),
iIsUserThread( ETrue ),
iVTable(0),
iSharedHeap( EFalse ),
iHeapSize(0),
iAllocatorAddress(NULL),
iMinHeapSize(0),
iMaxHeapSize(0)
{
}
public: // API
#ifndef __KERNEL_MODE__
inline TPtrC ChunkName() const
{
TBool alreadyExpanded = ETrue;
#ifdef __CHECK_CHUNK_NAME
{
RDebug::Printf( "TMemSpyHeapMetaDataRHeap::ChunkName() - BEF - length: %d", iChunkName.Length() );
const TUint8* data2 = iChunkName.Ptr();
const TInt count = iChunkName.Length();
for( TInt i=0;i<count;i++)
{
RDebug::Printf( "TMemSpyHeapMetaDataRHeap::ChunkName() - BEF - data[%03d] = 0x%08x = %02x (%c)", i, data2, *data2, *data2 );
++data2;
}
}
#endif
// Check if it already has been converted to unicode
const TUint8* data = iChunkName.Ptr();
if ( iChunkName.Length() >= 1 )
{
const TUint8 highByte = *(data + 1);
alreadyExpanded = ( highByte == 0 );
}
// Once expanded, the descriptor is twice the length
TPtrC ret( (TUint16*) iChunkName.Ptr(), iChunkName.Length() / 2 );
//
if ( !alreadyExpanded )
{
const TInt halfLength = iChunkName.Length() / 2;
TMemSpyHeapMetaDataRHeap* self = const_cast< TMemSpyHeapMetaDataRHeap* >( this );
ret.Set( self->iChunkName.Expand() );
}
#ifdef __CHECK_CHUNK_NAME
{
RDebug::Printf( "TMemSpyHeapMetaDataRHeap::ChunkName() - AFT - length: %d", iChunkName.Length() );
const TUint8* data2 = iChunkName.Ptr();
const TInt count = iChunkName.Length();
for( TInt i=0;i<count;i++)
{
RDebug::Printf( "TMemSpyHeapMetaDataRHeap::ChunkName() - AFT - data[%03d] = 0x%08x = %02x (%c)", i, data2, *data2, *data2 );
++data2;
}
const TPtrC pNextRet( (TUint16*) iChunkName.Ptr(), iChunkName.Length() / 2 );
RDebug::Print( _L("TMemSpyHeapMetaDataRHeap::ChunkName() - ret: [%S], nextRet: [%S]"), &ret, &pNextRet );
}
#endif
//
return ret;
}
inline void SetChunkName( const TDesC16& aValue )
{
iChunkName.Copy( aValue );
iChunkName.Collapse();
}
#else
inline void SetChunkName( const TDesC8& aValue )
{
iChunkName.Copy( aValue );
}
#endif
//
inline TUint ChunkSize() const { return iChunkSize; }
inline void SetChunkSize( TUint aValue ) { iChunkSize = aValue; }
//
inline TAny* ChunkHandle() const { return iChunkHandle; }
inline void SetChunkHandle( TAny* aValue ) { iChunkHandle = aValue; }
//
inline TAny* ChunkBaseAddress() const { return iChunkBaseAddress; }
inline void SetChunkBaseAddress( TAny* aValue ) { iChunkBaseAddress = aValue; }
//
inline TBool IsDebugAllocator() const { return iDebugAllocator; }
inline void SetDebugAllocator( TBool aValue ) { iDebugAllocator = aValue; }
//
inline TBool IsUserThread() const { return iIsUserThread; }
inline void SetUserThread( TBool aValue ) { iIsUserThread = aValue; }
//
inline TBool IsSharedHeap() const { return iSharedHeap; }
inline void SetSharedHeap( TBool aValue ) { iSharedHeap = aValue; }
//
inline TUint VTable() const { return iVTable; }
inline void SetVTable( TUint aValue ) { iVTable = aValue; }
private: // Data members
TBuf8< KMaxFullName * 2 > iChunkName;
public:
TUint iChunkSize;
TAny* iChunkHandle;
TAny* iChunkBaseAddress;
TBool iDebugAllocator;
TBool iSharedHeap;
TBool iIsUserThread;
TUint iVTable;
TUint iHeapSize; // Committed size - generally the same as iChunkSize (except maybe for kernel heap)
TAny* iAllocatorAddress; // replacement for things using the RHeap base address
TUint iMinHeapSize; // Minimum committed size
TUint iMaxHeapSize; // Max committed size
};
/**
*
*/
class TMemSpyHeapInfoRHeap
{
public: // Constructors
inline TMemSpyHeapInfoRHeap()
{
}
public: // API
inline TMemSpyHeapMetaDataRHeap& MetaData() { return iMetaData; }
inline const TMemSpyHeapMetaDataRHeap& MetaData() const { return iMetaData; }
//
//inline TMemSpyHeapObjectDataRHeap& ObjectData() { return iObjectData; }
//inline const TMemSpyHeapObjectDataRHeap& ObjectData() const { return iObjectData; }
//
inline TMemSpyHeapStatisticsRHeap& Statistics() { return iStatistics; }
inline const TMemSpyHeapStatisticsRHeap& Statistics() const { return iStatistics; }
inline TInt Overhead() const { return iMetaData.iHeapSize - iStatistics.StatsAllocated().TypeSize() - iStatistics.iCommittedFreeSpace; }
private: // Data members
TMemSpyHeapMetaDataRHeap iMetaData;
//TMemSpyHeapObjectDataRHeap iObjectData;
TMemSpyHeapStatisticsRHeap iStatistics;
};
#endif