// memsamplerdd.cpp

// 

// Copyright (c) 2008 - 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/extrabtrace.h>

#include <platform.h>

#include <kern_priv.h>

#include "memsamplerdd.h"

#include <fshell/common.mmh>

const TInt KMinRate = 10;

const TInt KMaxRate = 10000;

const TInt KMajorVersionNumber = 1;

const TInt KMinorVersionNumber = 0;

const TInt KBuildVersionNumber = 0;

const TInt KArrayGranularity = 32;

const TInt KDfcThreadPriority = 26;

_LIT(KDfcThreadName, "MemSamplerDD");

class DDeviceMemSampler : public DLogicalDevice

	{

public:

	DDeviceMemSampler();

	virtual TInt Install();

	virtual void GetCaps(TDes8& aDes) const;

	virtual TInt Create(DLogicalChannelBase*& aChannel);

	};

class TChunkInfo

	{

public:

	TChunkInfo(DChunk& aChunk);

	TBool operator==(const TChunkInfo& aChunkInfo);

public:

	DChunk* iAddress;

	TInt iSize;

	TInt iHighWaterMark;

	TBool iSeen;

	};

TChunkInfo::TChunkInfo(DChunk& aChunk)

	: iAddress(&aChunk), iSize(aChunk.Size()), iHighWaterMark(aChunk.Size()), iSeen(ETrue)

	{

	}

TBool TChunkInfo::operator==(const TChunkInfo& aChunkInfo)

	{

	return (iSize == aChunkInfo.iSize);

	}

class DMemSamplerChannel : public DLogicalChannel

	{

public:

	DMemSamplerChannel();

	~DMemSamplerChannel();

protected:

	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);

	virtual void HandleMsg(TMessageBase* aMsg);

private:

	TInt StartSampling(TInt aRate);

	TInt StopSampling();

	TInt ResetSampling();

	TInt ReadChunks();

	void TraceNewChunk(const TChunkInfo& aChunkInfo) const;

	void TraceChangedChunk(const TChunkInfo& aChunkInfo) const;

	void TraceDeletedChunk(const TChunkInfo& aChunkInfo) const;

	void TraceNewSample() const;

#if FSHELL_PLATFORM_SYMTB >= 92

	inline TBool Running()

		{return iTimer.IsPending();}

#else

	inline TBool Running()

		{return iTimer.iState!=NTimer::EIdle;}

#endif

private:

	static void Sample(TAny*);

	static void DoSample(TAny*);

	static void ExitDfcThread(TAny*);

private:

	RArray<TChunkInfo> iChunkInfo;

	NTimer iTimer;

	TInt iPeriod;

	TInt iPeriodNumber;

	TDfcQue iPrivateDfcQ;

	TDfc iDoSampleDfc;

	TDfc iExitDfc;

	DThread* iClient;

	mutable TBool iNewSampleTraced;

	};

DECLARE_STANDARD_LDD()

	{

	return new DDeviceMemSampler;

	}

DDeviceMemSampler::DDeviceMemSampler()

	{

	iVersion=TVersion(KMajorVersionNumber, KMinorVersionNumber, KBuildVersionNumber);

	}

TInt DDeviceMemSampler::Install()

	{

	TInt r = SetName(&KMemSamplerName);

	return r;

	}

void DDeviceMemSampler::GetCaps(TDes8&) const

	{

	}

TInt DDeviceMemSampler::Create(DLogicalChannelBase*& aChannel)

	{

	aChannel = new DMemSamplerChannel;

	return aChannel ? KErrNone : KErrNoMemory;

	}

DMemSamplerChannel::DMemSamplerChannel()

	: iChunkInfo(KArrayGranularity, _FOFF(TChunkInfo, iAddress)), iTimer(Sample, this), iPeriodNumber(-1), iDoSampleDfc(DoSample, this, 1), iExitDfc(ExitDfcThread, this, 0), iNewSampleTraced(EFalse)

	{

	}

DMemSamplerChannel::~DMemSamplerChannel()

	{

	Kern::SafeClose((DObject*&)iClient, NULL);

	iExitDfc.Enque(); 

	}

void DMemSamplerChannel::ExitDfcThread(TAny*)

	{

	Kern::Exit(KErrNone);

	} 

TInt DMemSamplerChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*anInfo*/, const TVersion& aVer)

	{

	if (!Kern::QueryVersionSupported(TVersion(1,0,0),aVer))

		{

		return KErrNotSupported;

		}

	iClient=&Kern::CurrentThread();

	iClient->Open();

	TInt err = Kern::DfcQInit(&iPrivateDfcQ, KDfcThreadPriority, &KDfcThreadName);

	if (err == KErrNone)

		{

    	SetDfcQ(&iPrivateDfcQ);

		iDoSampleDfc.SetDfcQ(&iPrivateDfcQ);

		iExitDfc.SetDfcQ(&iPrivateDfcQ);

    	iMsgQ.Receive();		

		}

	return err;

	}

TInt DMemSamplerChannel::StartSampling(TInt aRate)

	{

	DEBUG_MEMSAMPLER(Kern::Printf("START");)

	ReadChunks();

	aRate = Min(KMaxRate, Max(KMinRate, aRate));

	iPeriod = NKern::TimerTicks(aRate);

	if (!Running())

		{

		iTimer.OneShot(iPeriod, EFalse);

		}

	DEBUG_MEMSAMPLER(Kern::Printf("START end");)

	return KErrNone;

	}

TInt DMemSamplerChannel::StopSampling()

	{

	DEBUG_MEMSAMPLER(Kern::Printf("STOP");)

	if (Running())

		{

		iTimer.Cancel();

		}

	DEBUG_MEMSAMPLER(Kern::Printf("STOP end");)

	return KErrNone;

	}

TInt DMemSamplerChannel::ResetSampling()

	{

	DEBUG_MEMSAMPLER(Kern::Printf("RESET");)

	iChunkInfo.Reset();

	DEBUG_MEMSAMPLER(Kern::Printf("RESET end");)

	return KErrNone;

	}

TInt DMemSamplerChannel::ReadChunks()

	{

	++iPeriodNumber;

	iNewSampleTraced = EFalse;

	for (TInt i = (iChunkInfo.Count() - 1); i >= 0; --i)

		{

		iChunkInfo[i].iSeen = EFalse;

		}

	DObjectCon* const * containers = Kern::Containers();

	DObjectCon& container = *containers[EChunk];

	container.Wait();

	for (TInt i = (container.Count() - 1); i >= 0; --i)

		{

		TChunkInfo thisChunk(*(DChunk*)container[i]);

		TInt pos;

		TInt err = iChunkInfo.FindInUnsignedKeyOrder(thisChunk, pos);

		if (err == KErrNotFound)

			{

			if (pos < iChunkInfo.Count())

				{

				iChunkInfo.Insert(thisChunk, pos);

				}

			else

				{

				TInt err = iChunkInfo.Append(thisChunk);

				if (err)

					{

					container.Signal();

					return err;

					}

				}

			TraceNewChunk(thisChunk);

			}

		else

			{

			if (thisChunk == iChunkInfo[pos])

				{

				// Chunk size hasn't changed - ignore.

				iChunkInfo[pos].iSeen = ETrue;

				}

			else

				{

				TChunkInfo& c = iChunkInfo[pos];

				if (thisChunk.iSize > c.iHighWaterMark)

					{

					c.iHighWaterMark = thisChunk.iSize;

					}

				c.iSize = thisChunk.iSize;

				c.iSeen = ETrue;

				TraceChangedChunk(c);

				}

			}

		}

	container.Signal();

	for (TInt i = (iChunkInfo.Count() - 1); i >= 0; --i)

		{

		const TChunkInfo& chunkInfo = iChunkInfo[i];

		if (!chunkInfo.iSeen)

			{

			TraceDeletedChunk(chunkInfo);

			iChunkInfo.Remove(i);

			}

		}

	return KErrNone;

	}

void DMemSamplerChannel::TraceNewChunk(const TChunkInfo& aChunkInfo) const

	{

	TraceNewSample();

	TFullName nameBuf;

	aChunkInfo.iAddress->FullName(nameBuf);				

	BTraceN(RMemSampler::EBtraceCategory, RMemSampler::ENewChunk, aChunkInfo.iAddress, aChunkInfo.iAddress->MaxSize(), nameBuf.Ptr(), nameBuf.Size());

	TraceChangedChunk(aChunkInfo);

	}

void DMemSamplerChannel::TraceChangedChunk(const TChunkInfo& aChunkInfo) const

	{

	TraceNewSample();

	BTraceContext12(RMemSampler::EBtraceCategory, RMemSampler::EChangedChunk, aChunkInfo.iAddress, aChunkInfo.iSize, aChunkInfo.iHighWaterMark);

	}

void DMemSamplerChannel::TraceDeletedChunk(const TChunkInfo& aChunkInfo) const

	{

	TraceNewSample();

	BTraceContext4(RMemSampler::EBtraceCategory, RMemSampler::EDeletedChunk, aChunkInfo.iAddress);

	}

void DMemSamplerChannel::TraceNewSample() const

	{

	if (!iNewSampleTraced)

		{

		iNewSampleTraced = ETrue;

		BTraceContext8(RMemSampler::EBtraceCategory, RMemSampler::ENewSample, iPeriod, iPeriodNumber);

		}

	}

void DMemSamplerChannel::HandleMsg(TMessageBase* aMsg)

	{

	TInt r=KErrNone;

	TThreadMessage& m=*(TThreadMessage*)aMsg;

	TInt id=m.iValue;

	if (id==(TInt)ECloseMsg)

		{

		DEBUG_MEMSAMPLER(Kern::Printf("CLOSE");)

		iTimer.Cancel();

		m.Complete(KErrNone,EFalse);

		iMsgQ.CompleteAll(KErrServerTerminated);

		DEBUG_MEMSAMPLER(Kern::Printf("CLOSE end");)

		return;

		}

	else

		{

		switch(id)

			{

			case RMemSampler::EControlStartProfile:

				r = StartSampling(m.Int0());

				break;

			case RMemSampler::EControlStopProfile:

				r = StopSampling();

				break;

			case RMemSampler::EControlResetProfile:

				r = ResetSampling();

				break;

			default:

				r = KErrNotSupported;

				break;

			}

		}

	m.Complete(r,ETrue);

	}

void DMemSamplerChannel::Sample(TAny* aPtr)

	{

	DMemSamplerChannel& d = *(DMemSamplerChannel*)aPtr;

	d.iTimer.Again(d.iPeriod);

	d.iDoSampleDfc.Add(); 

	}

void DMemSamplerChannel::DoSample(TAny* aPtr)

	{

	DMemSamplerChannel& d = *(DMemSamplerChannel*)aPtr;

	d.ReadChunks();

	}