// tallochelper.cpp

// 

// Copyright (c) 2010 Accenture. All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the "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:

// Accenture - Initial contribution

//

#include <fshell/ioutils.h>

#include <fshell/common.mmh>

#include <fshell/heaputils.h>

#include <fshell/ltkutils.h>

using namespace IoUtils;

using LtkUtils::RAllocatorHelper;

class CCmdTAllocHelper : public CCommandBase

	{

public:

	static CCommandBase* NewLC();

	~CCmdTAllocHelper();

private:

	CCmdTAllocHelper();

	void PrintStats(const TDesC& aDesc);

	void AllocL(TInt aSize, TInt aNumber=1);

	void Free(TInt aNumber=1);

	void FormatSize(TDes& aBuf, TInt64 aSize);

	static TBool WalkCallback(RAllocatorHelper& aAlloc, TAny* aContext, RAllocatorHelper::TExtendedCellType aType, TLinAddr aAddress, TInt aLength);

	static void RHeapWalkCallback(TAny* aContext, RHeap::TCellType aType, TAny* aCell, TInt aLength);

private: // From CCommandBase.

	virtual const TDesC& Name() const;

	virtual const TDesC& Description() const;

	virtual void DoRunL();

	virtual void ArgumentsL(RCommandArgumentList& aArguments);

	virtual void OptionsL(RCommandOptionList& aOptions);

private:

	RAllocatorHelper iAlloc;

	RArray<TAny*> iAllocations;

	TBool iBytes;

	TBool iWaitOnExit;

	TInt iAllocationsAccordingToRHeapWalker;

	};

EXE_BOILER_PLATE(CCmdTAllocHelper)

CCommandBase* CCmdTAllocHelper::NewLC()

	{

	CCmdTAllocHelper* self = new(ELeave) CCmdTAllocHelper();

	CleanupStack::PushL(self);

	self->BaseConstructL();

	return self;

	}

CCmdTAllocHelper::~CCmdTAllocHelper()

	{

	iAlloc.Close();

	Free(iAllocations.Count());

	iAllocations.Close();

	}

CCmdTAllocHelper::CCmdTAllocHelper()

	: CCommandBase(EManualComplete)

	{

	}

const TDesC& CCmdTAllocHelper::Name() const

	{

	_LIT(KName, "tallochelper");	

	return KName;

	}

const TDesC& CCmdTAllocHelper::Description() const

	{

	_LIT(KDescription, "Test code for RAllocatorHelper");

	return KDescription;

	}

void CCmdTAllocHelper::ArgumentsL(RCommandArgumentList& /*aArguments*/)

	{

	}

void CCmdTAllocHelper::OptionsL(RCommandOptionList& aOptions)

	{

	aOptions.AppendBoolL(iBytes, 'b', _L("bytes"), _L("Display sizes in bytes rather than rounded off KB or MB"));

	aOptions.AppendBoolL(iWaitOnExit, 'w', _L("wait"), _L("Wait indefinitely before exiting - for testing remote heap walking"));

	}

void CCmdTAllocHelper::DoRunL()

	{

	LeaveIfErr(iAlloc.Open(&User::Allocator()), _L("Couldn't open RAllocatorHelper"));

	iAllocations.ReserveL(128);

	Printf(_L("Udeb allocator=%d\r\n"), iAlloc.AllocatorIsUdeb());

	PrintStats(_L("Initial stats"));

	// And do an RHeap walk, just to compare

	User::Allocator().DebugFunction(128, (TAny*)&RHeapWalkCallback, this);

	Printf(_L("allocated size according to RHeap::Walk: %d\r\n"), iAllocationsAccordingToRHeapWalker);

	AllocL(64*1024);

	PrintStats(_L("Stats after 1 64K alloc"));

	User::Allocator().DebugFunction(128, (TAny*)&RHeapWalkCallback, this); // debug

	AllocL(4, 50);

	PrintStats(_L("Stats after 50 small allocs"));

	/*

	// Open a new RAllocatorHelper cos the stats will be cached otherwise

	RAllocatorHelper h; h.Open(&User::Allocator());

	iAllocationsAccordingToRHeapWalker = 0;

	User::Allocator().DebugFunction(128, (TAny*)&RHeapWalkCallback, this);

	Printf(_L("allocated size according to RHeap::Walk: %d\r\n"), iAllocationsAccordingToRHeapWalker);

	Printf(_L("iTotalAllocSize is %d\r\n"), h.AllocatedSize());

	h.Close();

	*/

	if (!iWaitOnExit)

		{

		Free(50);

		PrintStats(_L("Stats after freeing them"));

		Complete();

		}

	}

void CCmdTAllocHelper::PrintStats(const TDesC& aDesc)

	{

	iAlloc.RefreshDetails();

	TBuf<16> allocSize, freeSize, dlaSize, slabSize, freeDlaSize, partiallyFreeSlabSize, freeSlabSize, pageSize;

	FormatSize(allocSize, iAlloc.SizeForCellType(RAllocatorHelper::EAllocationMask));

	FormatSize(freeSize, iAlloc.SizeForCellType(RAllocatorHelper::EFreeMask));

	FormatSize(dlaSize, iAlloc.SizeForCellType(RAllocatorHelper::EDlaAllocation));

	FormatSize(slabSize, iAlloc.SizeForCellType(RAllocatorHelper::ESlabAllocation));

	FormatSize(freeDlaSize, iAlloc.SizeForCellType(RAllocatorHelper::EDlaFreeCell));

	FormatSize(partiallyFreeSlabSize, iAlloc.SizeForCellType(RAllocatorHelper::ESlabFreeCell));

	FormatSize(freeSlabSize, iAlloc.SizeForCellType(RAllocatorHelper::ESlabFreeSlab));

	FormatSize(pageSize, iAlloc.SizeForCellType(RAllocatorHelper::EPageAllocation));

	Printf(_L("\r\n%S:\r\n\

Alloc: %d (%S), DLA: %d (%S) Slab: %d (%S) Paged: %d (%S)\r\n\

Free: %d (%S), DLA: %d (%S) Slab: %d (%S) Free slabs: %d (%S)\r\n"), 

		&aDesc, iAlloc.AllocationCount(), &allocSize,

		iAlloc.CountForCellType(RAllocatorHelper::EDlaAllocation), &dlaSize,

		iAlloc.CountForCellType(RAllocatorHelper::ESlabAllocation), &slabSize,

		iAlloc.CountForCellType(RAllocatorHelper::EPageAllocation), &pageSize,

		iAlloc.CountForCellType(RAllocatorHelper::EFreeMask), &freeSize,

		iAlloc.CountForCellType(RAllocatorHelper::EDlaFreeCell), &freeDlaSize,

		iAlloc.CountForCellType(RAllocatorHelper::ESlabFreeCell), &partiallyFreeSlabSize,

		iAlloc.CountForCellType(RAllocatorHelper::ESlabFreeSlab), &freeSlabSize

		);

	iAlloc.Walk(&WalkCallback, this); // Check cell lengths match up

	}

void CCmdTAllocHelper::AllocL(TInt aSize, TInt aNumber)

	{

	while (aNumber--)

		{

		TAny* result = User::AllocL(aSize);

		TInt err = iAllocations.Append(result);

		if (err)

			{

			User::Free(result);

			User::Leave(KErrNoMemory);

			}

		}

	}

void CCmdTAllocHelper::Free(TInt aNumber)

	{

	while (aNumber--)

		{

		TInt i = iAllocations.Count() - 1;

		User::Free(iAllocations[i]);

		iAllocations.Remove(i);

		}

	}

void CCmdTAllocHelper::FormatSize(TDes& aBuf, TInt64 aSize)

	{

	if (iBytes)

		{

		aBuf.Num(aSize);

		}

	else

		{

		LtkUtils::FormatSize(aBuf, aSize);

		}

	}

TBool CCmdTAllocHelper::WalkCallback(RAllocatorHelper& /*aAlloc*/, TAny* aContext, RAllocatorHelper::TExtendedCellType aType, TLinAddr aAddress, TInt aLength)

	{

	if (aType & RAllocatorHelper::EAllocationMask)

		{

		TInt lenFromAllocLen = User::AllocLen((TAny*)aAddress);

		if (lenFromAllocLen != aLength)

			{

			static_cast<CCmdTAllocHelper*>(aContext)->PrintWarning(_L("Walker reports cell 0x%08x size %d but AllocLen says %d\r\n"), aAddress, aLength, lenFromAllocLen);

			}

		}

	return ETrue; // Keep walking

	}

void CCmdTAllocHelper::RHeapWalkCallback(TAny* aContext, RHeap::TCellType aType, TAny* aCell, TInt aLength)

	{

	if (aType == RHeap::EGoodAllocatedCell)

		{

		CCmdTAllocHelper* self = static_cast<CCmdTAllocHelper*>(aContext);

		self->iAllocationsAccordingToRHeapWalker += aLength;

		}

	}