diff -r 000000000000 -r a03f92240627 memspy/Engine/Source/SysMemTracker/MemSpyEngineHelperSysMemTrackerCycle.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/memspy/Engine/Source/SysMemTracker/MemSpyEngineHelperSysMemTrackerCycle.cpp	Tue Feb 02 01:57:15 2010 +0200
@@ -0,0 +1,382 @@
+/*
+* 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 <memspy/engine/memspyenginehelpersysmemtrackercycle.h>
+
+// System includes
+#include <e32debug.h>
+#include <hal.h>
+#include <hal_data.h>
+
+// User includes
+#include <memspy/engine/memspyengine.h>
+#include <memspy/engine/memspyengineutils.h>
+#include <memspy/engine/memspyengineobjectthread.h>
+#include <memspy/engine/memspyengineobjectprocess.h>
+#include <memspy/engine/memspyengineobjectcontainer.h>
+#include <memspy/engine/memspyenginehelperheap.h>
+#include <memspy/engine/memspyenginehelperchunk.h>
+#include <memspy/engine/memspyengineoutputsink.h>
+#include <memspy/engine/memspyengineoutputlist.h>
+#include <memspy/engine/memspyengineoutputsink.h>
+#include <memspy/engine/memspyenginehelpersysmemtrackercyclechange.h>
+    
+// Literal constants
+_LIT( KMemSpySWMTDataFolderSpecification, "Data" );
+_LIT( KMemSpySWMTFolderSpecification, "System Wide MT\\Cycle %04d" );
+
+
+
+CMemSpyEngineHelperSysMemTrackerCycle::CMemSpyEngineHelperSysMemTrackerCycle( const TMemSpyEngineHelperSysMemTrackerConfig& aConfig, const CMemSpyEngineHelperSysMemTrackerCycle* aPreviousCycle )
+:   iConfig( aConfig ), iPreviousCycle( aPreviousCycle ), iCycleNumber( 1 )
+    {
+    iTime.HomeTime();
+    if  ( aPreviousCycle )
+        {
+        iCycleNumber = aPreviousCycle->CycleNumber() + 1;
+        }
+    }
+
+
+CMemSpyEngineHelperSysMemTrackerCycle::~CMemSpyEngineHelperSysMemTrackerCycle()
+    {
+    delete iFixedItems;
+    delete iCaption;
+    delete iTimeFormatted;
+    //
+    DiscardChanges();
+    iChangeDescriptors.Close();
+    }
+
+
+void CMemSpyEngineHelperSysMemTrackerCycle::ConstructL()
+    {
+    iFixedItems = CMemSpyEngineOutputList::NewL();
+
+    // Get time stamp
+    TBuf<128> timeBuf;
+    MemSpyEngineUtils::FormatTimeSimple( timeBuf, iTime );
+    iTimeFormatted = timeBuf.AllocL();
+    
+    // Get free ram
+    TInt freeRam = KErrNotFound;
+    User::LeaveIfError( HAL::Get( HALData::EMemoryRAMFree, freeRam ) );
+    iMemoryFree = freeRam;
+    }
+
+
+CMemSpyEngineHelperSysMemTrackerCycle* CMemSpyEngineHelperSysMemTrackerCycle::NewLC( const TMemSpyEngineHelperSysMemTrackerConfig& aConfig, const CMemSpyEngineHelperSysMemTrackerCycle* aPreviousCycle )
+    {
+    CMemSpyEngineHelperSysMemTrackerCycle* self = new(ELeave) CMemSpyEngineHelperSysMemTrackerCycle( aConfig, aPreviousCycle );
+    CleanupStack::PushL( self );
+    self->ConstructL();
+    return self;
+    }
+
+
+EXPORT_C TInt CMemSpyEngineHelperSysMemTrackerCycle::CycleNumber() const
+    {
+    return iCycleNumber;
+    }
+
+
+EXPORT_C const TTime& CMemSpyEngineHelperSysMemTrackerCycle::Time() const
+    {
+    return iTime;
+    }
+
+
+EXPORT_C const TDesC& CMemSpyEngineHelperSysMemTrackerCycle::TimeFormatted() const
+    {
+    return *iTimeFormatted;
+    }
+
+
+EXPORT_C const TDesC& CMemSpyEngineHelperSysMemTrackerCycle::Caption() const
+    {
+    return *iCaption;
+    }
+
+
+EXPORT_C const TInt64& CMemSpyEngineHelperSysMemTrackerCycle::MemoryFree() const
+    {
+    return iMemoryFree;
+    }
+
+
+EXPORT_C TInt64 CMemSpyEngineHelperSysMemTrackerCycle::MemoryFreePreviousCycle() const
+    {
+    TInt64 ret = MemoryFree();
+    //
+    if  ( iPreviousCycle )
+        {
+        ret = iPreviousCycle->MemoryFree();
+        }
+    //
+    return ret;
+    }
+
+
+EXPORT_C TInt64 CMemSpyEngineHelperSysMemTrackerCycle::MemoryDelta() const
+    {
+    const TInt64 ret = ( iMemoryFree - iMemoryUsed );
+    return ret;
+    }
+
+
+EXPORT_C TInt CMemSpyEngineHelperSysMemTrackerCycle::ChangeCount() const
+    {
+    return iChangeCount;
+    }
+
+
+EXPORT_C TInt CMemSpyEngineHelperSysMemTrackerCycle::MdcaCount() const
+    {
+    return iFixedItems->Count();
+    }
+
+
+EXPORT_C TPtrC CMemSpyEngineHelperSysMemTrackerCycle::MdcaPoint( TInt aIndex ) const
+    {
+    return iFixedItems->MdcaPoint( aIndex );
+    }
+
+
+void CMemSpyEngineHelperSysMemTrackerCycle::FinalizeL()
+    {
+    _LIT( KChange, "change" );
+    _LIT( KChanges, "changes" );
+
+    // Save change count
+    iChangeCount = iChangeDescriptors.Count();
+
+    // First make the main caption
+    TMemSpySizeText sizeText;
+    TMemSpySizeText deltaText;
+    TPtrC pChangeText( KChange );
+   
+    // Get free RAM formatted as a descriptor
+    sizeText = MemSpyEngineUtils::FormatSizeTextPrecise( MemoryFree() );
+
+    // Get delta formatted as a descriptor
+    const TInt64 delta( MemoryDelta() );
+    deltaText = MemSpyEngineUtils::FormatSizeTextPrecise( delta );
+
+    // Get number of changed threads as a descriptor
+    if  ( ChangeCount() == 0 || ChangeCount() > 1 )
+        {
+        pChangeText.Set( KChanges );
+        }
+
+    // Now make the caption
+    if  ( MemoryDelta() != 0 )
+        {
+        TBuf<300> buf;
+        _LIT( KMainCaption1, "\t[%03d] F: %S\t\tD: %S, %d %S" );
+        buf.Format( KMainCaption1, CycleNumber(), &sizeText, &deltaText, ChangeCount(), &pChangeText );
+        HBufC* caption = buf.AllocL();
+        delete iCaption;
+        iCaption = caption;
+        }
+    else
+        {
+        TBuf<300> buf;
+        _LIT( KMainCaption2, "\t[%03d] F: %S\t\tNo Delta, %d %S" );
+        buf.Format( KMainCaption2, CycleNumber(), &sizeText, ChangeCount(), &pChangeText );
+        HBufC* caption = buf.AllocL();
+        delete iCaption;
+        iCaption = caption;
+        }
+
+    // Now make the child entries
+    if  ( CycleNumber() > 0 )
+        {
+        _LIT(KItem1a, "Cycle");
+        iFixedItems->AddItemL( KItem1a, CycleNumber() );
+        }
+    else
+        {
+        _LIT(KItem1a, "Baseline");
+        iFixedItems->AddItemL( KItem1a );
+        }
+    //
+    _LIT(KItem1c, "Time");
+    iFixedItems->AddItemL( KItem1c, iTimeFormatted );
+    //
+    _LIT(KItem2, "Memory Free");
+    iFixedItems->AddItemL( KItem2, sizeText );
+    //
+    if  ( CycleNumber() > 0 )
+        {
+        _LIT(KItem2b, "Memory Change (vs. Last Cycle)");
+        sizeText = MemSpyEngineUtils::FormatSizeTextPrecise( MemoryFree() - MemoryFreePreviousCycle() );
+        iFixedItems->AddItemL( KItem2b, sizeText );
+        //
+        _LIT(KItem3, "Number of Changes");
+        iFixedItems->AddItemL( KItem3, ChangeCount() );
+        }
+    }
+
+
+void CMemSpyEngineHelperSysMemTrackerCycle::DiscardChanges()
+    {
+    iChangeDescriptors.ResetAndDestroy();
+    }
+
+
+CMemSpyEngineHelperSysMemTrackerCycleChange& CMemSpyEngineHelperSysMemTrackerCycle::ChangeAt( TInt aIndex )
+    {
+    return *iChangeDescriptors[ aIndex ];
+    }
+
+
+void CMemSpyEngineHelperSysMemTrackerCycle::GetDataFolderL( RFs& aFsSession, TDes& aFolder )
+    {
+    TFileName fileName;
+    fileName.Format( KMemSpySWMTFolderSpecification, CycleNumber() );
+
+    CMemSpyEngineSinkMetaData* metaData = CMemSpyEngineSinkMetaData::NewL( KNullDesC, fileName, KNullDesC, ETrue, EFalse, Time() );
+    CleanupStack::PushL( metaData );
+    MemSpyEngineUtils::GetFolderL( aFsSession, aFolder, *metaData );
+    CleanupStack::PopAndDestroy( metaData );
+
+    // This get's us something like:
+    //
+    //    E:\MemSpy\System Wide MT\Data - Cycle 001\Log.txt
+    //
+    // Now we must strip off the filename and return just the folder specification
+    const TParsePtrC parser( aFolder );
+    if  ( parser.NamePresent() && parser.ExtPresent() )
+        {
+        const TPtrC nameAndExt( parser.NameAndExt() );
+        aFolder.SetLength( aFolder.Length() - nameAndExt.Length() );
+        }
+
+    // Add "Data" on to the end so that we put all data in a clearly marked subdir)
+    aFolder.Append( KMemSpySWMTDataFolderSpecification );
+    TRACE( RDebug::Print(_L("CMemSpyEngineHelperSysMemTrackerCycle::GetDataFolderL() - folder1: %S"), &aFolder ) );
+
+    // Now we should return something like:
+    //
+    //    E:\MemSpy\System Wide MT\Data - Cycle 001
+    TRACE( RDebug::Print(_L("CMemSpyEngineHelperSysMemTrackerCycle::GetDataFolderL() - folder2: %S"), &aFolder ) );
+
+    const TInt err = aFsSession.MkDirAll( aFolder );
+    if  ( !(err == KErrNone || err == KErrAlreadyExists ) )
+        {
+        User::LeaveIfError( err );
+        }
+    }
+
+
+void CMemSpyEngineHelperSysMemTrackerCycle::DataStreamBeginL( CMemSpyEngineOutputSink& aSink, const TDesC& aContext )
+    {
+    // First make the folder...
+    HBufC* folder = HBufC::NewLC( KMemSpySWMTFolderSpecification().Length() + 10 );
+    TPtr pFolder( folder->Des() );
+    pFolder.Format( KMemSpySWMTFolderSpecification, CycleNumber() );
+
+    // Now start the data stream
+    aSink.DataStreamBeginL( aContext, pFolder, KMemSpyLogDefaultExtension, ETrue, EFalse );
+    CleanupStack::PopAndDestroy( folder );
+    }
+
+
+void CMemSpyEngineHelperSysMemTrackerCycle::DataStreamEndL( CMemSpyEngineOutputSink& aSink )
+    {
+	aSink.DataStreamEndL();
+    }
+
+
+void CMemSpyEngineHelperSysMemTrackerCycle::AddAndPopL( CMemSpyEngineHelperSysMemTrackerCycleChange* aInfo )
+    {
+    iChangeDescriptors.AppendL( aInfo );
+    CleanupStack::Pop( aInfo );
+    }
+
+
+const TMemSpyEngineHelperSysMemTrackerConfig& CMemSpyEngineHelperSysMemTrackerCycle::Config() const
+    {
+    return iConfig; 
+    }
+
+
+void CMemSpyEngineHelperSysMemTrackerCycle::AddToMemoryUsed( TInt aValue )
+    {
+    iMemoryUsed += aValue;
+    }
+
+
+void CMemSpyEngineHelperSysMemTrackerCycle::AddToMemoryHeapAllocs( TInt aValue )
+    {
+    iMemoryHeapAllocs += aValue;
+    }
+
+
+void CMemSpyEngineHelperSysMemTrackerCycle::AddToMemoryHeapFrees( TInt aValue )
+    {
+    iMemoryHeapFrees += aValue;
+    }
+
+
+void CMemSpyEngineHelperSysMemTrackerCycle::AddToCellCountFree( TInt aValue )
+    {
+    iCellCountsFrees += aValue;
+    }
+
+
+void CMemSpyEngineHelperSysMemTrackerCycle::AddToCellCountAlloc( TInt aValue )
+    {
+    iCellCountsAllocs += aValue;
+    }
+
+
+const TInt64& CMemSpyEngineHelperSysMemTrackerCycle::MemoryUsed() const
+    {
+    return iMemoryUsed;
+    }
+
+
+const TInt64& CMemSpyEngineHelperSysMemTrackerCycle::MemoryHeapAllocs() const
+    {
+    return iMemoryHeapAllocs;
+    }
+
+
+const TInt64& CMemSpyEngineHelperSysMemTrackerCycle::MemoryHeapFrees() const
+    {
+    return iMemoryHeapFrees;
+    }
+
+
+const TInt64& CMemSpyEngineHelperSysMemTrackerCycle::MemoryHeapCellCountAlloc() const
+    {
+    return iCellCountsAllocs;
+    }
+
+
+const TInt64& CMemSpyEngineHelperSysMemTrackerCycle::MemoryHeapCellCountFree() const
+    {
+    return iCellCountsFrees;
+    }
+
+
+
+
+
+
+