1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 #include "MemSpyEngineHelperSysMemTrackerOutputFormatter.h"

    19 

    20 // System includes

    21 #include <e32debug.h>

    22 

    23 // User includes

    24 #include "MemSpyEngineOutputListItem.h"

    25 #include <memspy/engine/memspyengine.h>

    26 #include <memspy/engine/memspyenginehelperrom.h>

    27 #include <memspy/engine/memspyengineoutputsink.h>

    28 #include <memspy/engine/memspyengineoutputlist.h>

    29 #include <memspy/engine/memspyenginehelpersysmemtrackerconfig.h>

    30 #include <memspy/engine/memspyenginehelpersysmemtrackercycle.h>

    31 #include <memspy/engine/memspyenginehelpersysmemtrackercyclechange.h>

    32 

    33 // Constants

    34 _LIT( KMemSpyHeapDeltaTrackerFormatPrefix, "[MemSpy] [SMT %04d] " );

    35 _LIT( KMemSpyHeapDeltaTrackerFormatHeaderStart, "<SYSTEM WIDE MEMORY TRACKER>" );

    36 _LIT( KMemSpyHeapDeltaTrackerFormatFooterEnd, "</SYSTEM WIDE MEMORY TRACKER>" );

    37 const TInt KMemSpySWMTDataFileFormat = 2;

    38 

    39 

    40 CMemSpyEngineHelperSysMemTrackerOutputFormatter::CMemSpyEngineHelperSysMemTrackerOutputFormatter( CMemSpyEngine& aEngine )

    41 :   iEngine( aEngine )

    42     {

    43     }

    44 

    45     

    46 CMemSpyEngineHelperSysMemTrackerOutputFormatter::~CMemSpyEngineHelperSysMemTrackerOutputFormatter()

    47     {

    48     }

    49 

    50 

    51 void CMemSpyEngineHelperSysMemTrackerOutputFormatter::ConstructL()

    52     {

    53     }

    54 

    55 

    56 CMemSpyEngineHelperSysMemTrackerOutputFormatter* CMemSpyEngineHelperSysMemTrackerOutputFormatter::NewL( CMemSpyEngine& aEngine )

    57     {

    58     CMemSpyEngineHelperSysMemTrackerOutputFormatter* self = new(ELeave) CMemSpyEngineHelperSysMemTrackerOutputFormatter( aEngine );

    59     CleanupStack::PushL( self );

    60     self->ConstructL();

    61     CleanupStack::Pop( self );

    62     return self;

    63     }

    64 

    65 

    66 void CMemSpyEngineHelperSysMemTrackerOutputFormatter::SetConfig( const TMemSpyEngineHelperSysMemTrackerConfig& aConfig )

    67     {

    68     iConfig = aConfig;

    69     }

    70 

    71 

    72 void CMemSpyEngineHelperSysMemTrackerOutputFormatter::OutputL( const CMemSpyEngineHelperSysMemTrackerCycle& aCycle )

    73     {

    74     CMemSpyEngineOutputSink& sink = iEngine.Sink();

    75     CMemSpyEngineHelperSysMemTrackerCycle& cycle = const_cast<CMemSpyEngineHelperSysMemTrackerCycle&>( aCycle );

    76 

    77     // Set up prefix for info listing

    78     sink.OutputPrefixSetFormattedLC( KMemSpyHeapDeltaTrackerFormatPrefix, aCycle.CycleNumber() );

    79 

    80     // Begin a new data stream for heap info

    81     _LIT( KMemSpyFolder1, "System Wide MT" );

    82     _LIT( KMemSpyContext1, "Summary - Cycle %03d" );

    83     HBufC* context1 = HBufC::NewLC( KMaxFileName );

    84     TPtr pContext1( context1->Des() );

    85     pContext1.Format( KMemSpyContext1, aCycle.CycleNumber() );

    86     sink.DataStreamBeginL( pContext1, KMemSpyFolder1 );

    87     CleanupStack::PopAndDestroy( context1 );

    88 

    89     // Output overall header for cycle

    90     OutputOverallHeaderL( cycle );

    91 

    92     // Output the cycle information

    93     TMemSpyEngineSysMemTrackerType lastType = EMemSpyEngineSysMemTrackerTypeCount;

    94 	const TInt changedCount = cycle.ChangeCount();

    95 	for( TInt j=0; j<changedCount; j++ )

    96 		{

    97 		CMemSpyEngineHelperSysMemTrackerCycleChange& item = cycle.ChangeAt( j );

    98         const TMemSpyEngineSysMemTrackerType type = item.Type();

    99 

   100         // Header (if needed)

   101         if  ( HaveTypesChanged( type, lastType ) )

   102             {

   103             lastType = type;

   104 

   105             CMemSpyEngineOutputSink& sink = iEngine.Sink();

   106             sink.OutputBlankLineL();

   107             sink.OutputBlankLineL();

   108             item.OutputHeaderL( sink, cycle );

   109             }

   110         

   111         // Content

   112         TRAP_IGNORE( item.OutputContentL( sink, cycle ) );

   113         }

   114    

   115     // Now dump the data for any changed entries

   116     if  ( iConfig.DumpData() )

   117         {

   118 		for( TInt j=0; j<changedCount; j++ )

   119 			{

   120 			CMemSpyEngineHelperSysMemTrackerCycleChange& item = cycle.ChangeAt( j );

   121             TRAP_IGNORE( item.OutputDataL( sink, cycle ) );

   122 			}

   123 		}

   124 

   125     // Output overall footer for cycle

   126     OutputOverallFooterL( cycle );

   127 

   128     // End summary data stream

   129     sink.DataStreamEndL();

   130 		

   131 	CleanupStack::PopAndDestroy(); // prefix

   132     }

   133 

   134 

   135 void CMemSpyEngineHelperSysMemTrackerOutputFormatter::OutputOverallHeaderL( CMemSpyEngineHelperSysMemTrackerCycle& aCycle )

   136     {

   137     CMemSpyEngineOutputSink& sink = iEngine.Sink();

   138     sink.OutputBlankLineL();

   139     sink.OutputBlankLineL();

   140     sink.OutputBlankLineL();

   141     sink.OutputBlankLineL();

   142     //

   143     sink.OutputLineL( KMemSpyHeapDeltaTrackerFormatHeaderStart );

   144     sink.OutputBlankLineL();

   145 

   146     // Lines

   147     CMemSpyEngineOutputList* list = CMemSpyEngineOutputList::NewLC( sink );

   148     

   149     _LIT( KLine0, "File format version" );

   150     list->AddItemL( KLine0, KMemSpySWMTDataFileFormat );

   151 

   152     _LIT( KLine1, "Cycle number" );

   153     list->AddItemL( KLine1, aCycle.CycleNumber() );

   154 

   155     _LIT( KLine2, "Time" );

   156     list->AddItemL( KLine2, aCycle.TimeFormatted() );

   157 

   158     _LIT( KLine3, "Change count" );

   159     list->AddItemL( KLine3, aCycle.ChangeCount() );

   160 

   161     _LIT( KLine4, "Free memory (now)" );

   162     list->AddItemL( KLine4, aCycle.MemoryFree() );

   163 

   164     _LIT( KLine5, "Free memory (previous)" );

   165     list->AddItemL( KLine5, aCycle.MemoryFreePreviousCycle() );

   166 

   167     _LIT( KLine6, "MemSpy (RAM)" );

   168     list->AddItemL( KLine6, User::Heap().Size() );

   169 

   170     // Add ROM info

   171     iEngine.HelperROM().AddInfoL( *list );

   172 

   173     list->PrintL();

   174     CleanupStack::PopAndDestroy( list );

   175 

   176     sink.OutputBlankLineL();

   177     sink.OutputBlankLineL();

   178     }

   179 

   180 

   181 void CMemSpyEngineHelperSysMemTrackerOutputFormatter::OutputOverallFooterL( CMemSpyEngineHelperSysMemTrackerCycle& /*aCycle*/ )

   182     {

   183     CMemSpyEngineOutputSink& sink = iEngine.Sink();

   184     //

   185     sink.OutputBlankLineL();

   186     sink.OutputBlankLineL();

   187     sink.OutputLineL( KMemSpyHeapDeltaTrackerFormatFooterEnd );

   188     sink.OutputBlankLineL();

   189     sink.OutputBlankLineL();

   190     }

   191 

   192 

   193 TBool CMemSpyEngineHelperSysMemTrackerOutputFormatter::HaveTypesChanged( TInt aLeft, TInt aRight )

   194     {

   195     TBool ret = ( aLeft != aRight );

   196     //

   197     if ( ret )

   198         {

   199         // Check whether heap types are kernel vs user. We silently ignore this change.

   200         if ( ( aLeft == EMemSpyEngineSysMemTrackerTypeHeapUser && aRight == EMemSpyEngineSysMemTrackerTypeHeapKernel ) ||

   201              ( aLeft == EMemSpyEngineSysMemTrackerTypeHeapKernel && aRight == EMemSpyEngineSysMemTrackerTypeHeapUser ) )

   202             {

   203             ret = EFalse;

   204             }

   205         }

   206     //

   207     return ret;

   208     }

   209