--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/memspyui/ui/avkon/src/MemSpyViewKernelHeap.cpp Fri May 14 15:53:02 2010 +0300
@@ -0,0 +1,438 @@
+/*
+* 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:
+*
+*/
+
+#include "MemSpyViewKernelHeap.h"
+
+// Engine includes
+#include <memspy/engine/memspyengine.h>
+#include <memspy/engine/memspyengineobjectprocess.h>
+#include <memspy/engine/memspyengineobjectthread.h>
+#include <memspy/engine/memspyengineobjectcontainer.h>
+#include <memspy/engine/memspyengineobjectthreadinfoobjects.h>
+#include <memspy/engine/memspyengineobjectthreadinfocontainer.h>
+#include <memspy/engine/memspyenginehelperheap.h>
+#include <memspy/engine/memspyengineoutputlist.h>
+
+#include <memspysession.h>
+#include <memspy/api/memspyapiheap.h>
+
+// User includes
+#include "MemSpyUiUtils.h"
+#include "MemSpyViewKernel.h"
+#include "MemSpyContainerObserver.h"
+
+// Constants
+const TInt KMemSpyBufferSize = 20;
+
+// Literal constants
+_LIT(KMemSpyHexFormat, "0x%08x");
+_LIT(KMemSpyUnsignedFormat, "%u");
+_LIT(KMemSpyDecFormat, "%d");
+_LIT(KMemSpyLongFormat, "%Ld");
+_LIT(KMemSpyCaptionYes, "Yes");
+_LIT(KMemSpyCaptionNo, "No");
+
+
+CMemSpyViewKernelHeap::CMemSpyViewKernelHeap( RMemSpySession& aSession, MMemSpyViewObserver& aObserver ) //cigasto: remember to uncomment from MMP!
+: CMemSpyViewBase( aSession, aObserver )
+ {
+ }
+
+CMemSpyViewKernelHeap::~CMemSpyViewKernelHeap()
+ {
+ }
+
+
+void CMemSpyViewKernelHeap::ConstructL( const TRect& aRect, CCoeControl& aContainer, TAny* aSelectionRune )
+ {
+ _LIT( KTitle, "Kernel Heap" );
+ SetTitleL( KTitle );
+ //
+ CMemSpyViewBase::ConstructL( aRect, aContainer, aSelectionRune );
+ }
+
+
+void CMemSpyViewKernelHeap::RefreshL()
+ {
+ SetListBoxModelL();
+ CMemSpyViewBase::RefreshL();
+ }
+
+
+TMemSpyViewType CMemSpyViewKernelHeap::ViewType() const
+ {
+ return EMemSpyViewTypeKernelHeap;
+ }
+
+
+CMemSpyViewBase* CMemSpyViewKernelHeap::PrepareParentViewL()
+ {
+ CMemSpyViewKernel* parent = new(ELeave) CMemSpyViewKernel( iMemSpySession, iObserver );
+ CleanupStack::PushL( parent );
+ parent->ConstructL( Rect(), *Parent(), (TAny*) ViewType() );
+ CleanupStack::Pop( parent );
+ return parent;
+ }
+
+
+CMemSpyViewBase* CMemSpyViewKernelHeap::PrepareChildViewL()
+ {
+ CMemSpyViewBase* child = NULL;
+ return child;
+ }
+
+
+void CMemSpyViewKernelHeap::SetListBoxModelL()
+ {
+ CMemSpyApiHeap* iHeap;
+ iHeap = iMemSpySession.GetHeap( );
+
+ CDesCArrayFlat* model = new (ELeave) CDesC16ArrayFlat( 22 ); //array for formated items TODO: to remove constant
+
+ model = FormatModel( iHeap );
+
+ CAknSettingStyleListBox* listbox = static_cast< CAknSettingStyleListBox* >( iListBox );
+ listbox->Model()->SetItemTextArray( model );
+ listbox->Model()->SetOwnershipType( ELbmOwnsItemArray );
+
+ /*
+ // Get list contents
+ TMemSpyHeapInfo heapInfo;
+ iEngine.HelperHeap().GetHeapInfoKernelL( heapInfo );
+ CMemSpyEngineOutputList* list = iEngine.HelperHeap().NewHeapSummaryShortLC( heapInfo );
+
+ // Set up list box
+ CAknSettingStyleListBox* listbox = static_cast< CAknSettingStyleListBox* >( iListBox );
+ listbox->Model()->SetItemTextArray( list );
+ listbox->Model()->SetOwnershipType( ELbmOwnsItemArray );
+ CleanupStack::Pop( list );
+ */
+ }
+
+
+TBool CMemSpyViewKernelHeap::HandleCommandL( TInt aCommand )
+ {
+ TBool handled = ETrue;
+ //
+ switch ( aCommand )
+ {
+ case EMemSpyCmdKernelHeapDump:
+ OnCmdDumpKernelHeapL();
+ break;
+
+ default:
+ handled = CMemSpyViewBase::HandleCommandL( aCommand );
+ break;
+ }
+ //
+ return handled;
+ }
+
+
+void CMemSpyViewKernelHeap::OnCmdDumpKernelHeapL()
+ {
+ // TODO
+ //iEngine.HelperHeap().OutputHeapDataKernelL();
+ }
+
+
+//CDesCArrayFlat* CMemSpyViewKernelHeap::FormatModel( RArray<CMemSpyApiHeap*> &aHeap )
+CDesCArrayFlat* CMemSpyViewKernelHeap::FormatModel( CMemSpyApiHeap* aHeap )
+ {
+ CDesCArrayFlat* ret = new (ELeave) CDesC16ArrayFlat( 2 );
+
+ _LIT( KItem0, "Heap type" );
+ _LIT( KItem1, "Heap size" );
+ _LIT( KItem8b, "Heap base address" );
+ _LIT( KItem1b, "Shared" );
+ _LIT( KItem2, "Chunk size" );
+ _LIT( KItem3, "Alloc. count" );
+ _LIT( KItem4, "Free. count" );
+ _LIT( KItem5, "Biggest alloc." );
+ _LIT( KItem6, "Biggest free" );
+ _LIT( KItem6a, "Total alloc." );
+ _LIT( KItem6b, "Total free" );
+ _LIT( KItem7, "Slack free space" );
+ _LIT( KItem8a, "Fragmentation" );
+ _LIT( KItem13, "Header size (A)" );
+ _LIT( KItem14, "Header size (F)" );
+ _LIT( KItem9a, "Overhead (alloc)" );
+ _LIT( KItem9b, "Overhead (free)" );
+ _LIT( KItem9c, "Overhead (total)" );
+ _LIT( KItem9d, "Overhead" );
+ _LIT( KItem10, "Min. length" );
+ _LIT( KItem11, "Max. length" );
+ _LIT( KItem12, "Debug Allocator Library" );
+
+ HBufC* iItem = HBufC::NewL( 64 );
+
+ iItem = FormatItem( KItem0, aHeap->Type() );
+ TPtr pItem( iItem->Des() );
+ ret->AppendL( pItem );
+ pItem.Zero();
+
+ iItem = FormatItem( KItem1, aHeap->Size() );
+ pItem = iItem->Des();
+ ret->AppendL( pItem );
+ pItem.Zero();
+
+ TUint address( aHeap->BaseAddress() );
+ iItem = FormatItem( KItem8b, address );
+ pItem = iItem->Des();
+ ret->AppendL( pItem );
+ pItem.Zero();
+
+ if(aHeap->Shared()) //Yes / No value formatting
+ iItem = FormatItem( KItem1b, KMemSpyCaptionYes );
+ else
+ iItem = FormatItem( KItem1b, KMemSpyCaptionNo );
+ pItem = iItem->Des();
+ ret->AppendL( pItem );
+ pItem.Zero();
+
+ iItem = FormatItem( KItem2, aHeap->ChunkSize() );
+ pItem = iItem->Des();
+ ret->AppendL( pItem );
+ pItem.Zero();
+
+ iItem = FormatItem( KItem3, aHeap->AllocationsCount() );
+ pItem = iItem->Des();
+ ret->AppendL( pItem );
+ pItem.Zero();
+
+ iItem = FormatItem( KItem4, aHeap->FreeCount() );
+ pItem = iItem->Des();
+ ret->AppendL( pItem );
+ pItem.Zero();
+
+ iItem = FormatItem( KItem5, aHeap->BiggestAllocation() );
+ pItem = iItem->Des();
+ ret->AppendL( pItem );
+ pItem.Zero();
+
+ iItem = FormatItem( KItem6, aHeap->BiggestFree() );
+ pItem = iItem->Des();
+ ret->AppendL( pItem );
+ pItem.Zero();
+
+ iItem = FormatItem( KItem6a, aHeap->TotalAllocations() );
+ pItem = iItem->Des();
+ ret->AppendL( pItem );
+ pItem.Zero();
+
+ iItem = FormatItem( KItem6b, aHeap->TotalFree() );
+ pItem = iItem->Des();
+ ret->AppendL( pItem );
+ pItem.Zero();
+
+ iItem = FormatItem( KItem7, aHeap->SlackFreeSpace() );
+ pItem = iItem->Des();
+ ret->AppendL( pItem );
+ pItem.Zero();
+
+ TReal iOneHundred( aHeap->Size() );
+ TReal iValue( aHeap->Fragmentation() );
+ iItem = FormatPercentageItem( KItem8a, iOneHundred, iValue );
+ pItem = iItem->Des();
+ ret->AppendL( pItem );
+ pItem.Zero();
+
+ iItem = FormatItem( KItem13, aHeap->HeaderSizeA() );
+ pItem = iItem->Des();
+ ret->AppendL( pItem );
+ pItem.Zero();
+
+ iItem = FormatItem( KItem14, aHeap->HeaderSizeF() );
+ pItem = iItem->Des();
+ ret->AppendL( pItem );
+ pItem.Zero();
+
+ iItem = FormatItem( KItem9a, aHeap->AllocationOverhead() );
+ pItem = iItem->Des();
+ ret->AppendL( pItem );
+ pItem.Zero();
+
+ iItem = FormatItem( KItem9b, aHeap->FreeOverhead() );
+ pItem = iItem->Des();
+ ret->AppendL( pItem );
+ pItem.Zero();
+
+ iItem = FormatItem( KItem9c, aHeap->TotalOverhead() );
+ pItem = iItem->Des();
+ ret->AppendL( pItem );
+ pItem.Zero();
+
+ TReal iOverhead( aHeap->Overhead() );
+ iItem = FormatPercentageItem( KItem9d, iOneHundred, iOverhead );
+ pItem = iItem->Des();
+ ret->AppendL( pItem );
+ pItem.Zero();
+
+ iItem = FormatItem( KItem10, aHeap->MinLength() );
+ pItem = iItem->Des();
+ ret->AppendL( pItem );
+ pItem.Zero();
+
+ iItem = FormatItem( KItem11, aHeap->MaxLength() );
+ pItem = iItem->Des();
+ ret->AppendL( pItem );
+ pItem.Zero();
+
+ if( aHeap->DebugAllocatorLibrary() )
+ iItem = FormatItem( KItem12, KMemSpyCaptionYes );
+ else
+ iItem = FormatItem( KItem12, KMemSpyCaptionNo );
+ pItem = iItem->Des();
+ ret->AppendL( pItem );
+ pItem.Zero();
+
+ return ret;
+ }
+
+HBufC* CMemSpyViewKernelHeap::FormatItem( const TDesC& aCaption, const TDesC& aValue )
+ {
+ HBufC* retBuf = HBufC::NewL( 64 );
+ TPtr pRetBuf( retBuf->Des() );
+ pRetBuf.Zero();
+ pRetBuf.Append( _L("\t") );
+ pRetBuf.Append( aCaption );
+ pRetBuf.Append( _L("\t\t") );
+ pRetBuf.Append( aValue );
+ return retBuf;
+ }
+
+HBufC* CMemSpyViewKernelHeap::FormatItem( const TDesC& aCaption, TInt aValue )
+ {
+ HBufC* retBuf = HBufC::NewL( 64 );
+ TPtr pRetBuf( retBuf->Des() );
+ pRetBuf.Zero();
+
+ TBuf<KMemSpyBufferSize> val;
+ val.Format( KMemSpyDecFormat, aValue );
+
+ pRetBuf.Append( _L("\t") );
+ pRetBuf.Append( aCaption );
+ pRetBuf.Append( _L("\t\t") );
+ pRetBuf.Append( val );
+
+ return retBuf;
+ }
+
+HBufC* CMemSpyViewKernelHeap::FormatItem( const TDesC& aCaption, TUint aValue )
+ {
+ HBufC* retBuf = HBufC::NewL( 64 );
+ TPtr pRetBuf( retBuf->Des() );
+ pRetBuf.Zero();
+
+ TBuf<KMemSpyBufferSize> val;
+ //val.Format( KMemSpyDecFormat, aValue );
+ val.Format( KMemSpyHexFormat, aValue );
+
+ pRetBuf.Append( _L("\t") );
+ pRetBuf.Append( aCaption );
+ pRetBuf.Append( _L("\t\t") );
+ pRetBuf.Append( val );
+
+ return retBuf;
+ }
+
+HBufC* CMemSpyViewKernelHeap::FormatItem( const TDesC& aCaption, const TInt64& aValue )
+ {
+ HBufC* retBuf = HBufC::NewL( 64 );
+ TPtr pRetBuf( retBuf->Des() );
+ pRetBuf.Zero();
+
+ TBuf<KMemSpyBufferSize> val;
+ val.Format( KMemSpyLongFormat, aValue );
+
+ pRetBuf.Append( _L("\t") );
+ pRetBuf.Append( aCaption );
+ pRetBuf.Append( _L("\t\t") );
+ pRetBuf.Append( val );
+
+ return retBuf;
+ }
+
+HBufC* CMemSpyViewKernelHeap::FormatItem( const TDesC& aCaption, TAny* aValue )
+ {
+ HBufC* retBuf = HBufC::NewL( 64 );
+ TPtr pRetBuf( retBuf->Des() );
+ pRetBuf.Zero();
+
+ TBuf<KMemSpyBufferSize> val;
+ val.Format( KMemSpyHexFormat, aValue );
+
+ pRetBuf.Append( _L("\t") );
+ pRetBuf.Append( aCaption );
+ pRetBuf.Append( _L("\t\t") );
+ pRetBuf.Append( val );
+
+ return retBuf;
+ }
+
+HBufC* CMemSpyViewKernelHeap::FormatItem( const TDesC& aCaption, TUint* aValue )
+ {
+ HBufC* retBuf = HBufC::NewL( 64 );
+ TPtr pRetBuf( retBuf->Des() );
+ pRetBuf.Zero();
+
+ TBuf<KMemSpyBufferSize> val;
+ val.Format( KMemSpyHexFormat, aValue );
+
+ pRetBuf.Append( _L("\t") );
+ pRetBuf.Append( aCaption );
+ pRetBuf.Append( _L("\t\t") );
+ pRetBuf.Append( val );
+
+ return retBuf;
+ }
+
+HBufC* CMemSpyViewKernelHeap::FormatItem( const TDesC& aCaption, TUint8* aValue )
+ {
+ HBufC* retBuf = HBufC::NewL( 64 );
+ TPtr pRetBuf( retBuf->Des() );
+ pRetBuf.Zero();
+
+ TBuf<KMemSpyBufferSize> val;
+ val.Format( KMemSpyHexFormat, aValue );
+
+ pRetBuf.Append( _L("\t") );
+ pRetBuf.Append( aCaption );
+ pRetBuf.Append( _L("\t\t") );
+ pRetBuf.Append( val );
+
+ return retBuf;
+ }
+
+HBufC* CMemSpyViewKernelHeap::FormatPercentageItem( const TDesC& aCaption, TReal aOneHundredPercentValue, TReal aValue )
+ {
+ HBufC* retBuf = HBufC::NewL( 64 ); //buffer for formatted item
+ TPtr pRetBuf( retBuf->Des() );
+ pRetBuf.Zero();
+
+ const TReal value = (TInt) (( aValue / aOneHundredPercentValue) * 100.0); // percentage value calculation
+ _LIT(KPercentFormat, "%3.2f %%");
+ TMemSpyPercentText val;
+ val.Format( KPercentFormat, value );
+
+ pRetBuf.Append( _L("\t") );
+ pRetBuf.Append( aCaption );
+ pRetBuf.Append( _L("\t\t") );
+ pRetBuf.Append( val );
+
+ return retBuf;
+ }