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

// All rights reserved.

// This component and the accompanying materials are made available

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

// e32utils\profiler\sampler.cpp

// 

//

#include "platform.h"

#include "sampler.h"

#include <kernel/kern_priv.h>		//temporary

#include <memmodel/epoc/plat_priv.h> // needed for DEpocCodeSeg

_LIT(KLddName,"Sampler");

TKName KiDFCThread = _L("Running from iDFC");

TKName KiDFCProcess = _L("N/A");

TUint  KiDFCId = (TUint)-1; //both process and thread assigned to iDFC will have 'fake' id=-1

const TInt KMajorVersionNumber=2;

const TInt KMinorVersionNumber=0;

const TInt KBuildVersionNumber=0;

const TInt KMinRate=10;

const TInt KMaxRate=1000;

const TInt KRawBufSize=256;

const TInt KCookedBufSize=0x2000;

const TInt KCodeBufSize=0x2000;

const TInt KMaxCreateCodeSegRecordSize = 300; //Max size of the encoded CodeSegCreate record.

const TInt KMaxErrorReportRecordSize = 18;    //Max size of the encoded ErrorReport record. (3 zeros and 3 integers)

const TInt KRequiredFreeSpace=512;

//Bit mask in report

const TInt KNonXIPModeActive=1; 

const TInt KNoDebugSupport=2;

#define PUT(p,x,e,s)	{*(p)++=(x); if ((p)==(e)) (p)-=(s);}

#define GET_A_BYTE(p,x,e,s)	{*(x)++=*(p)++; if ((p)==(e)) (p)-=(s);}

#define	TAG(obj)		(*(TUint32*)&(obj->iAsyncDeleteNext))

#define CODESEGBUFEND (iCodeSegBuffer+KCodeBufSize)

#define COOKEDBUFEND (iCookedBuf+KCookedBufSize)

extern TUint IntStackPtr();

extern TUint32 SPSR();

extern TUint IDFCRunning();

// global Dfc Que

TDynamicDfcQue* gDfcQ;

class DDeviceSampler : public DLogicalDevice

	{

public:

	DDeviceSampler();

	~DDeviceSampler();

	virtual TInt Install();

	virtual void GetCaps(TDes8& aDes) const;

	virtual TInt Create(DLogicalChannelBase*& aChannel);

	};

struct SRawSample

	{

	TLinAddr iPC;

	TUint32 iSampleCounter;

	TUint32 iThreadId;

	};

class DProfile : public DLogicalChannel

	{

public:

	DProfile();

	~DProfile();

protected:

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

	virtual void HandleMsg(TMessageBase* aMsg);

private:

	TInt GetSegments(TDes8* aDes);

	TInt StartSampling(TInt aRate);

	TInt StopSampling();

	TInt Reset(TBool aXIPOnly);

	TInt ResetSegments();

	TInt Drain(TDes8* aDes);

	TInt GetErrors(TDes8* aDes);

	TInt ProcessReadRequest();

	TInt DoDrainCooked();

	TInt Cook();

	void Complete(TInt aResult);

	inline TBool Running()

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

private:

	static void Sample(TAny*);

	static void Dfc(TAny*);

	static TUint KernelEventHandler(TKernelEvent aEvent, TAny* a1, TAny* a2, TAny* aPrivateData);

	void LogCodeSegEvent(TKernelEvent aEvent, DEpocCodeSeg *pCodeSeg);

private:

	static TUint8* EncodeTag(TUint8* p, TUint8* e);

	static TUint8* EncodeInt(TUint8* p, TUint8* e, TInt aValue);

	static TUint8* EncodeUint(TUint8* p, TUint8* e, TUint aValue);

	static TUint8* EncodeText(TUint8* p, TUint8* e, const TDesC& aDes);

	static TUint8* EncodeRepeat(TUint8* p, TUint8* e, DProfile* aProfile);

	TUint8* EncodeThread(TUint8* p, TUint8* e, DThread* aThread);

	TUint8* EncodeIDFC(TUint8* p, TUint8* e);

	TUint8* PutStream(TUint8* p, TUint8* e, const TUint8* aSource, TInt aSize);

	TUint8* GetStream(TUint8* p, TUint8* e, TInt8* aDest, TInt aSize);	

	TBool CookCodeSeg(TBool aPutAll, TInt aSampleCounter);

private:

	TUint32 iStartTime;

	TInt iRepeat;

	SRawSample iLast;

	TInt iPeriod;

	NTimer iTimer;

	TDfc iDfc;

	TUint* iIntStackTop;

	DThread* iClient;

	TRequestStatus* iReqStatus;

	TInt iPos;			// client des pos

	TInt iRemain;		// space left in client des

	TDes8* iDes;		// client des pointer

	TUint8 iRPut;		// raw buffer put index

	TUint8 iRGet;		// raw buffer get index

	TUint8* iCPut;		// cooked buffer put

	TUint8* iCGet;		// cooked buffer get

	SRawSample iRawBuf[KRawBufSize];

	TUint8 iCookedBuf[KCookedBufSize];

	DKernelEventHandler* iKernelEvHandler;

	TInt iNextSampleCounter;

	TBool iXIPOnly;

	TBool iMarkedOnlySegments;	// True during GettingSegments phase in which event handler...

								// ... collects only the events from marked segments.

	TUint8 iCodeSegBuffer[KCodeBufSize];

	TUint8* iCSPut;		// CodeSeg buffer put

	TUint8* iCSGet;		// CodeSeg buffer get

	TUint iIDFCSeenBefore;

	struct TReport

		{

		TUint iRowBufferErrCounter;

		TUint iCodeSegErrCounter;

		TInt  iReportMask; 

		} iReport;

	};

DECLARE_STANDARD_LDD()

	{

	return new DDeviceSampler;

	}

DDeviceSampler::DDeviceSampler()

//

// Constructor

//

	{

	//iParseMask=0;

	//iUnitsMask=0;

	iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);

	}

const TInt KDSamplerThreadPriority = 27;

_LIT(KDSamplerThread,"DSamplerThread");

TInt DDeviceSampler::Install()

//

// Install the device driver.

//

	{

	// Allocate a kernel thread to run the DFC 

	TInt r = Kern::DynamicDfcQCreate(gDfcQ, KDSamplerThreadPriority, KDSamplerThread);

	if (r != KErrNone)

		return r; 	

	r=SetName(&KLddName);

	return r;

	}

void DDeviceSampler::GetCaps(TDes8& aDes) const

//

// Return the capabilities.

//

	{

	}

/**

  Destructor

*/

DDeviceSampler::~DDeviceSampler()

	{

	if (gDfcQ)

		gDfcQ->Destroy();

	}

TInt DDeviceSampler::Create(DLogicalChannelBase*& aChannel)

//

// Create a channel on the device.

//

	{

	aChannel=new DProfile;

	return aChannel?KErrNone:KErrNoMemory;

	}

DProfile::DProfile()

	:	iTimer(Sample,this),

		iDfc(Dfc,this,NULL,7)

//

// Constructor

//

	{

	}

DProfile::~DProfile()

//

// Destructor

//

	{

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

	}

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

//

// Create the channel from the passed info.

//

	{

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

		return KErrNotSupported;

	iClient=&Kern::CurrentThread();

	iClient->Open();

	Kern::SetThreadPriority(24);

	iIntStackTop=(TUint*)IntStackPtr();

	SetDfcQ(gDfcQ);

	iDfc.SetDfcQ(iDfcQ);

	iMsgQ.Receive();

	return KErrNone;

	}

void DProfile::Complete(TInt aResult)

//Completes user request

	{

	DEBUG_PROFILER(Kern::Printf("C");)

	Kern::RequestComplete(iClient,iReqStatus,aResult);

	}

TInt DProfile::StartSampling(TInt aRate)

	{

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

	//Activate timer

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

	iPeriod=1000/aRate;

	if (!Running())

		iTimer.OneShot(iPeriod);

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

	return KErrNone;

	}

TInt DProfile::GetSegments(TDes8* aDes)

//

// Collects and marks all non-XIP segments.

//

	{

	DEBUG_PROFILER(Kern::Printf("GS");)

	TInt max=Kern::ThreadGetDesMaxLength(iClient,aDes);

	Kern::ThreadDesWrite(iClient,aDes,KNullDesC8,0,0,iClient);//Set length to zero

	TInt current = 0;

	Kern::AccessCode();

	// Take all records that are collected by event handler first. They may be only Delete CodeSeg 

	// events of tagged(marked) segments. On the first GetSegments call, cooked buffer also contains Profile Tag.

	CookCodeSeg(ETrue, 0); // Transfer/encode from CodeSeg buffer into cooked buffer

	current = iCPut-iCGet;

	if (current)

		{

		if (current < max)

			{//Copy data into user side descriptor

			TPtrC8 aPtr(iCGet, current);

			Kern::ThreadDesWrite(iClient,aDes,aPtr,0,KChunkShiftBy0,iClient);

			}

		else

			{	

			//This is very unlikely as in this stage we collect only CodeSeg Delete events of the marked segments.

			//It cannot happen on the first call, as there are no marked segments - which means that Profiler Tag is OK.

			iReport.iCodeSegErrCounter++;

			}

		}

	iCGet = iCPut = iCookedBuf; //Reset the cooked buffer

	//Collect all non-XIP segments that are not already marked.

	SDblQue* p = Kern::CodeSegList();

	SDblQueLink* anchor=&p->iA;

	SDblQueLink* a=anchor->iNext;

	for (; a!=anchor; a=a->iNext) 

		{

		DEpocCodeSeg* pSeg = (DEpocCodeSeg*) _LOFF(a, DCodeSeg, iLink);

		if (pSeg->iXIP || pSeg->iMark&DCodeSeg::EMarkProfilerTAG)

			continue;

		if (current > (max-KMaxCreateCodeSegRecordSize))

			break;//No more space. Finish now and wait for another GetSegments request.

		pSeg->iMark |= DCodeSeg::EMarkProfilerTAG;	//Mark this segment

		LogCodeSegEvent(EEventAddCodeSeg, pSeg); 	//Place this record into CodeSeg buffer ...

		CookCodeSeg(ETrue, 0);						//...and encode it into cooked buffer

		TPtrC8 aPtr(iCGet, iCPut-iCGet);

		Kern::ThreadDesWrite(iClient,aDes,aPtr,current,KChunkShiftBy0,iClient);//Copy record into user desc.

		current += iCPut-iCGet;

		iCPut = iCGet = iCookedBuf; //Reset cooked buffer

		}

	if (!current)//This will be the last GetSegments call. From now on, all events have to be recorded.

		iMarkedOnlySegments = EFalse;

	Kern::EndAccessCode();

	DEBUG_PROFILER(Kern::Printf("GS end %d",current);)

	return KErrNone;

	}

TInt DProfile::ResetSegments()

//

// Unmarks all non-XIP segments 

// Sets device into GettingSegments mode in which only the events of the marked Code Segments will be recorder

// 

	{

	DEBUG_PROFILER(Kern::Printf("RS");)

	if (iXIPOnly)

		return KErrGeneral;

	Kern::AccessCode();

	SDblQue* p = Kern::CodeSegList();

	SDblQueLink* anchor=&p->iA;

	SDblQueLink* a=anchor->iNext;

	for (; a!=anchor; a=a->iNext) 

		{

		DEpocCodeSeg* pSeg = (DEpocCodeSeg*) _LOFF(a, DCodeSeg, iLink);

		if (!pSeg->iXIP)

			pSeg->iMark &= ~DCodeSeg::EMarkProfilerTAG;

		}

	if (DKernelEventHandler::DebugSupportEnabled())

		{

		DEBUG_PROFILER(Kern::Printf("RS add handler");)

		iKernelEvHandler->Add();

		iReport.iReportMask|= KNonXIPModeActive;

		}

	else

		iReport.iReportMask|= KNoDebugSupport;	

	iMarkedOnlySegments = ETrue;	

	Kern::EndAccessCode();

	DEBUG_PROFILER(Kern::Printf("RS end");)

	return KErrNone;

	}

TInt DProfile::Reset(TBool aXIPOnly)

	{

//

// Resets the device. It is the first message sent by profiler application.

//	

	if (Running())

		return KErrGeneral;

	DEBUG_PROFILER(Kern::Printf("RST %d", aXIPOnly);)

	iXIPOnly = aXIPOnly;

	iTimer.Cancel();

	iDfc.Cancel();

	iLast.iPC=0;

	iLast.iSampleCounter=0;

	iLast.iThreadId=0;

	iRepeat=0;

	iPeriod=1;

	iReqStatus=NULL;

	iRPut=0;				// raw buffer put index

	iRGet=0;				// raw buffer get index

	iCPut=EncodeTag(iCookedBuf,COOKEDBUFEND); //cooked buffer put

	iCGet=iCookedBuf;		// cooked buffer get

	iPos=0;					// client des pos

	iDes=NULL;				// client des pointer

	iStartTime=NKern::TickCount();

	iReport.iRowBufferErrCounter = 0;

	iReport.iCodeSegErrCounter = 0;

	iReport.iReportMask = 0;

	iNextSampleCounter = 0;

	iCSPut=iCodeSegBuffer;	// CodeSeg buffer put

	iCSGet=iCodeSegBuffer;	// CodeSeg buffer get

	iMarkedOnlySegments = EFalse;

	iIDFCSeenBefore = EFalse;

	if (!iXIPOnly)

		iKernelEvHandler = new DKernelEventHandler(KernelEventHandler, this);

	DEBUG_PROFILER(Kern::Printf("RST end");)

	return KErrNone;

	}

TInt DProfile::StopSampling()

//

// Stops sampling

//

	{

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

	if (Running())

		{

		iTimer.Cancel();

		Dfc(this);

		}

	if (iReqStatus)

		Complete(KErrNone);

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

	return KErrNone;

	}

TInt DProfile::GetErrors(TDes8* aDes)

//

// Returns error report and closes event handler

//

	{

	TInt r = KErrNone;

	TBuf8<KMaxErrorReportRecordSize> localBuf; //Enough space to encode 3 zeros and 3 integers

	DEBUG_PROFILER(Kern::Printf("GE");)

	TInt max=Kern::ThreadGetDesMaxLength(iClient,aDes);

	if (max<KMaxErrorReportRecordSize)

		return KErrArgument;

	Kern::ThreadDesWrite(iClient,aDes,KNullDesC8,0,0,iClient);//set zero length

	TUint8* p = (TUint8*)localBuf.Ptr();

	TUint8* e = p+KMaxErrorReportRecordSize;

	p = EncodeInt (p, e, 0);

	p = EncodeUint(p, e, 0);

	p = EncodeUint(p, e, 0);

	p = EncodeUint(p, e, iReport.iRowBufferErrCounter);

	p = EncodeUint(p, e, iReport.iCodeSegErrCounter);

	p = EncodeUint(p, e, iReport.iReportMask);

	localBuf.SetLength(p-localBuf.Ptr());

	r=Kern::ThreadDesWrite(iClient,aDes,localBuf,0,KChunkShiftBy0,iClient);

	if(iKernelEvHandler && iKernelEvHandler->IsQueued())

		iKernelEvHandler->Close();

	DEBUG_PROFILER(Kern::Printf("GE end %d %d %d", iReport.iRowBufferErrCounter, iReport.iCodeSegErrCounter, iReport.iReportMask);)

	return r;

	}

TInt DProfile::Drain(TDes8* aDes)

//

// Collects any remaining data

//

	{

	DEBUG_PROFILER(Kern::Printf("D");)		

	if (Running())

		return KErrGeneral;

	// we can assume read request is not pending

	TInt max=Kern::ThreadGetDesMaxLength(iClient,aDes);

	if (max<0)

		return max;

	if (max==0)

		return KErrArgument;

	TInt r=Kern::ThreadDesWrite(iClient,aDes,KNullDesC8,0,0,iClient);		// set client descriptor length to zero

	if (r!=KErrNone)

		return r;

	iDes=aDes;

	iRemain=max;

	iPos=0;

	iReqStatus=NULL;

	TInt n=-1;

	while (n)

		{

		r=DoDrainCooked();				// drain any cooked data if possible

		if (r<0 && r!=KErrUnderflow)

			return r;					// error writing client buffer

		n=Cook();						// cook the samples, return number cooked

		}

	// there might still be data left over

	DEBUG_PROFILER(Kern::Printf("D end");)

	return KErrNone;

	}

TInt DProfile::ProcessReadRequest()

	{

// If the profiler is stopped and there is available data, return it immediately and complete the request

// If the profiler is stopped and there is no data, wait.

// If the profiler is running, retrieve any data available now, if more is req'd set the trigger

	DEBUG_PROFILER(Kern::Printf("READ");)

	TInt max=Kern::ThreadGetDesMaxLength(iClient,iDes);

	if (max<0)

		return max;

	if (max==0)

		return KErrArgument;

	TInt r=Kern::ThreadDesWrite(iClient,iDes,KNullDesC8,0,0,iClient);		// set client descriptor length to zero

	if (r!=KErrNone)

		return r;

	iRemain=max;

	iPos=0;

	TInt n=-1;

	TBool read=EFalse;

	while (n)

		{

		r=DoDrainCooked();				// drain any cooked data if possible

		if (r!=KErrUnderflow)

			read=ETrue;					// we've got something

		if (r>0)

			return KErrNone;			// request completed, so finish

		if (r!=KErrNone && r!=KErrUnderflow)

			return r;					// error writing client buffer

		n=Cook();						// cook the samples, return number cooked

		}

	if (!Running() && read)

		return KErrCompletion;			// if stopped and data read, return it

	return KErrNone;					// wait

	}

TInt DProfile::DoDrainCooked()

//

// Copies encoded data from Cook buffer into user side descriptor (iDes).

// Returns:

// KErrUnderflow if all the data was already transfered or the desciptor was already full before the call.

// KErrNone if there is still remaining space available in the descriptor.

// 1  - descriptor is full and user request is completed.

// Error code other then KErrNone if writing to the user memory fails

//

	{

	TInt avail=iCPut-iCGet;

	if (avail<0)

		avail+=KCookedBufSize;

	TInt len=Min(avail,iRemain);

	if (len)

		{

		TUint8* pE=iCookedBuf+KCookedBufSize;

		TInt len1=Min(len,pE-iCGet);

		TPtrC8 local(iCGet,len1);

		TInt r=Kern::ThreadDesWrite(iClient, iDes, local, iPos, KChunkShiftBy0, iClient);

		if (r!=KErrNone)

			return r;

		len-=len1;

		TUint8* pG=iCGet+len1;

		if (pG==pE)

			pG=iCookedBuf;

		iCGet=pG;

		iRemain-=len1;

		iPos+=len1;

		if (len) // will be > 0 if there are remaining data at the beginning of Cooked buffer to be copied.

			{

			TPtrC8 local(iCGet,len);

			r=Kern::ThreadDesWrite(iClient, iDes, local, iPos, KChunkShiftBy0, iClient);

			if (r!=KErrNone)

				return r;

			iCGet+=len;

			iRemain-=len;

			iPos+=len;

			}

		if (iRemain==0 && iReqStatus)

			{

			Complete(KErrNone);

			return 1;

			}

		return KErrNone;

		}

	return KErrUnderflow;

	}

void DProfile::HandleMsg(TMessageBase* aMsg)

//

// Client requests

//

	{

	TInt r=KErrNone;

	TThreadMessage& m=*(TThreadMessage*)aMsg;

	TInt id=m.iValue;

	// Allow the client thread to send a message or system critical thread

	// to send a close message as this is probably the supervisor thread doing clean up

	if (m.Client()!=iClient && 

		!((m.Client()->iFlags&KThreadFlagSystemCritical) && id==(TInt)ECloseMsg))

		{

		m.PanicClient(_L("SAMPLER"),EAccessDenied);

		return;

		}

	if (id==(TInt)ECloseMsg)

		{

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

		iTimer.Cancel();

		iDfc.Cancel();

		m.Complete(KErrNone,EFalse);

		iMsgQ.CompleteAll(KErrServerTerminated);

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

		return;

		}

	else if (id<0)

		{

		if (id!=~RSampler::ERequestRead)

			{

			TRequestStatus* pS=(TRequestStatus*)m.Ptr0();

			Kern::RequestComplete(iClient,pS,KErrNotSupported);

			}

		if (iReqStatus)

			{

			m.PanicClient(_L("SAMPLER"),ERequestAlreadyPending);

			return;

			}

		iReqStatus=(TRequestStatus*)m.Ptr0();

		iDes=(TDes8*)m.Ptr1();

		r=ProcessReadRequest();

		if (r!=KErrNone)

			{

			if (r==KErrCompletion)

				r=KErrNone;

			Complete(r);

			}

		r=KErrNone;

		}

	else if (id==KMaxTInt)

		{

		TInt mask=m.Int0();

		if (mask & (1<<RSampler::ERequestRead))

			{

			Complete(KErrCancel);

			}

		}

	else

		{

		switch(id)

			{

			case RSampler::EControlGetSegments:

				r=GetSegments((TDes8*)m.Ptr0());

				break;

			case RSampler::EControlStartProfile:

				r=StartSampling(m.Int0());

				break;

			case RSampler::EControlStopProfile:

				r=StopSampling();

				break;

			case RSampler::EControlResetProfile:

				r=Reset((TBool)m.Ptr0());

				break;

			case RSampler::EControlResetSegments:

				r=ResetSegments();

				break;

			case RSampler::EControlDrain:

				r=Drain((TDes8*)m.Ptr0());

				break;

			case RSampler::EControlGetErrors:

				r=GetErrors((TDes8*)m.Ptr0());

				break;

			default:

				r=KErrNotSupported;

				break;

			}

		}

	m.Complete(r,ETrue);

	}

TUint8* DProfile::EncodeTag(TUint8* p, TUint8* e)

//

// Encode a tag and version to the trace data. This allows the offline analyser to 

// identify the sample data.

//

	{

	_LIT(KTraceTag,"profile");

	p=EncodeText(p,e,KTraceTag);

	p=EncodeUint(p,e,KMajorVersionNumber);

	return p;

	}

TUint8* DProfile::EncodeInt(TUint8* p, TUint8* e, TInt aValue)

//

// Encode a 32 bit signed integer into the data stream

// This has to deal with wrap around at the end of the buffer

//

	{

	TUint byte;

	for (;;)

		{

		byte = aValue & 0x7f;

		if ((aValue >> 6) == (aValue >> 7))

			break;

		aValue >>= 7;

		PUT(p,(TUint8)byte,e,KCookedBufSize);

		}

	PUT(p,(TUint8)(byte|0x80),e,KCookedBufSize);

	return p;

	}

TUint8* DProfile::EncodeUint(TUint8* p, TUint8* e, TUint aValue)

//

// Encode a 32 bit unsigned integer into the data stream

// This has to deal with wrap around at the end of the buffer

//

	{

	TUint byte;

	for (;;)

		{

		byte = aValue & 0x7f;

		aValue >>= 7;

		if (aValue == 0)

			break;

		PUT(p,(TUint8)byte,e,KCookedBufSize);

		}

	PUT(p,(TUint8)(byte|0x80),e,KCookedBufSize);

	return p;

	}

TUint8* DProfile::EncodeText(TUint8* p, TUint8* e, const TDesC& aDes)

//

// Encode a descriptor into the data stream

// This is currently limited to a descriptor that is up to 255 characters in length,

// and Unicode characters are truncated to 8 bits

//

	{

	TInt len=aDes.Length();

	PUT(p,(TUint8)len,e,KCookedBufSize);

	const TText* s = aDes.Ptr();

	while (--len >= 0)

		PUT(p,*s++,e,KCookedBufSize);

	return p;

	}

TUint8* DProfile::EncodeIDFC(TUint8* p, TUint8* e)

//

// iDFC samples do not really belong to any thread.

// However, the profiler protocol requires each sample to be associated to a particular thread.

// This method will encode 'fake' process ID & name and thread name for iDFC sample in the data stream.

// It will be embedded only for the very first sample from iDFCs.

// (For the rest of iDFCs samples, threadID is sufficient - as for the real threads.)

//

	{

	p=EncodeUint(p,e,KiDFCId);     //processID for iDFC

	p=EncodeText(p,e,KiDFCProcess);//process name for iDFC

	p=EncodeText(p,e,KiDFCThread); //thread name for iDFC

	return p;

	}

TUint8* DProfile::EncodeThread(TUint8* p, TUint8* e, DThread* aThread)

//

// Encode a thread name in the data stream.

// The thread is identified by its name, and the identity of its owning process.

// If the process has not been identified in the data stream already, it's name is

// also encoded.

//

	{

	DProcess* pP=aThread->iOwningProcess;

	TKName n;

	p=EncodeUint(p,e,pP->iId);

	if (TAG(pP)!=iStartTime)	// not seen this before

		{

		TAG(pP)=iStartTime;

		// Provide the name matching this process ID

		pP->Name(n);

		p=EncodeText(p,e,n);

		}

	aThread->Name(n);

	p=EncodeText(p,e,n);

	return p;

	}

TUint8* DProfile::EncodeRepeat(TUint8* p, TUint8* e, DProfile* aP)

//

// Encode a repeated sequence of samples

//

	{

	p=EncodeInt(p,e,0);

	p=EncodeUint(p,e,aP->iRepeat);

	aP->iRepeat = 0;

	return p;

	}

TInt DProfile::CookCodeSeg(TBool aPutAll, TInt aSampleCounter)

//

// Transfers and encodes CodeSeg Create/Delete records from CodeSeg buffer into Cooked buffer.

// If aPutAll = Etrue, all records will be transferred.

// If aPutAll = EFalse, only records at the beginning of the queue that matches aSampleCounter will be transferred.

// It stopps if there is less then KRequiredFreeSpace bytes available in cooked buffer.

// Returns the number of the transferred records.

//

	{

	if (iXIPOnly)

		return 0;

	TInt n = 0;

	TInt codeSampleCounter;//Will hold the sample counter of the record

	TInt runAddress;

	TInt codeSize;

	TInt8 textLen;

	TBuf<255> text;

	TUint8* localCSGet = iCSGet;

	FOREVER

		{

		//Check if there is any Code Seg record left.

		if (iCSGet==iCSPut)

			return n;//No records left

		//Check if the next record is due to be encoded. Both Create & Delete CodeSeg records start with sample counter.

		localCSGet = iCSGet;

		localCSGet = GetStream(localCSGet, CODESEGBUFEND, (TInt8*)(&codeSampleCounter), sizeof(TInt));

		if (!aPutAll && codeSampleCounter!=aSampleCounter)

			return n; //Still too early to insert the record into Cook Buffer

		//Check for the space in cook buffer

		TInt cookAvailable = (TInt)iCGet - (TInt)iCPut;

		if (cookAvailable <= 0)	

			cookAvailable+=KCookedBufSize;

		if (cookAvailable < KRequiredFreeSpace)

			return n;//No space in Cook Buffer.

		//At this point it is for sure that we have to transfer some record to cook buffer

		n++;

		iCSGet = localCSGet;

		//The next field for both Create & Delete CodeSeg records is run address:

		iCSGet = GetStream(iCSGet, CODESEGBUFEND, (TInt8*)(&runAddress), sizeof(TInt));

		if (runAddress & 1)//LSB in run address idenifies the type of the record

			{//CodeSegment Delete record. To be encoded as Int(0), UInt(0), UInt(RunAddress | 1)

			iCPut = EncodeInt (iCPut, COOKEDBUFEND, 0);

			iCPut = EncodeUint(iCPut, COOKEDBUFEND, 0);

			iCPut = EncodeUint(iCPut, COOKEDBUFEND, runAddress);

			}

		else

			{//CodeSegment Create record.

			iCSGet = GetStream(iCSGet, CODESEGBUFEND, (TInt8*)(&codeSize), sizeof(TInt));

			iCSGet = GetStream(iCSGet, CODESEGBUFEND, (TInt8*)(&textLen), sizeof(TInt8));

			iCSGet = GetStream(iCSGet, CODESEGBUFEND, (TInt8*)(text.Ptr()), textLen);

			text.SetLength(textLen);

			//To be encoded as Int(0), UInt(0), UInt(RunAddress), UInt(SegmentSize), Text(FileNeme)

			iCPut = EncodeInt(iCPut, COOKEDBUFEND, 0);

			iCPut = EncodeUint(iCPut, COOKEDBUFEND, 0);

			iCPut = EncodeUint(iCPut, COOKEDBUFEND, runAddress);

			iCPut = EncodeUint(iCPut, COOKEDBUFEND, codeSize);

			iCPut = EncodeText(iCPut, COOKEDBUFEND, text);

			}

		}

	}

TInt DProfile::Cook()

//

// Transfers/encodes row data and code segments record into cooked buffer.

// Returns the number of records (incl. both samples and codeSeg records) cooked.

//

	{

	TUint8* p=iCPut;

	TUint8* e=iCookedBuf+KCookedBufSize;

	TInt n=0;

	FOREVER

		{

		iCPut=p; //update iCPut before calling CookCodeSeg

		if ((iRGet==iRPut))

			{//No more samples.

			n+=CookCodeSeg(ETrue, 0); //Cook the remaining content of CodeSeg buffer.

			break;

			}

		SRawSample* s=iRawBuf+iRGet;	// pointer to the next sample to be cooked

		n+=CookCodeSeg(EFalse, s->iSampleCounter);//cook all codeSeg records than matches this sample counter

		p=iCPut; //CookCodeSeg might have changed iCPut

		TInt space=iCGet-p;

		if (space<=0)

			space+=KCookedBufSize;		// space remaining in cooked buffer

		if (space<KRequiredFreeSpace)

			break;						// if insufficient, finish

		//Cook the next sample record from Row buffer		

		++iRGet;

		++n;

		TBool newthread=s->iPC & 1;		// bit 0 of PC means so far unknown thread

		TLinAddr pc=s->iPC &~ 1;

		TUint rp = iRepeat;

		TInt diff=TInt(pc-iLast.iPC);

		if (!newthread)

			{

			if (s->iThreadId!=iLast.iThreadId)

				diff|=1;

			if (diff == 0)

				{

				iRepeat = rp + 1;	// Identical sample, bump up the repeat count

				continue;

				}

			if (rp)

				{

				// Encode the repeat data

				p = EncodeRepeat(p,e,this);

				}

			// Encode the PC difference

			p = EncodeInt(p, e, diff);

			if (diff & 1)

				{

				// Encode the new thread ID

				iLast.iThreadId = s->iThreadId;

				p = EncodeUint(p, e, s->iThreadId);

				}

			}

		else

			{

			if (rp)

				{

				// Encode the repeat data

				p = EncodeRepeat(p,e,this);

				}

			// Encode the PC difference

			p = EncodeInt(p, e, diff|1);

			if (s->iThreadId == KiDFCId)

				{

				// This is the first sample from iDFC. Encode 'threadID'

				iLast.iThreadId = KiDFCId;

				p = EncodeUint(p, e, KiDFCId);

				// and encode processID, processName & threadName for this sample

				p = EncodeIDFC(p, e);

				}

			else

				{

				// Encode the new thread ID

				DThread* pT=(DThread*)s->iThreadId;

				iLast.iThreadId = pT->iId;

				p = EncodeUint(p, e, pT->iId);

				// The thread is 'unknown' to this sample, so encode the thread name

				p = EncodeThread(p, e, pT);

				}

			}

		iLast.iPC=pc;

		}

	return n;

	}

void DProfile::Dfc(TAny* aPtr)

//

// Tranfers/encodes Row & CodeSeg buffers' content into Cook buffer (by Cook()), 

// and copies encoded data into user side descriptor (by DoDrainCooked())

//

	{

	DProfile& d=*(DProfile*)aPtr;

	TInt n=-1;

	while (n)

		{

		TInt r=d.DoDrainCooked();		// drain any cooked data if possible

		if (r<0 && r!=KErrUnderflow)

			{

			d.Complete(r);				// error writing client buffer

			break;

			}

		n=d.Cook();						// cook the samples, return number cooked

		}

	}

TUint8* DProfile::PutStream(TUint8* p, TUint8* e, const TUint8* aSource, TInt aSize)

//

// Put data into CodeSeg stream 

// This has to deal with wrap around at the end of the buffer

//

	{

	for (TInt i = 0 ; i< aSize ; i++)

		{

		PUT(p,(TUint8)(*aSource),e,KCodeBufSize);

		aSource++;

		}

	return p;

	}

TUint8* DProfile::GetStream(TUint8* p, TUint8* e, TInt8* aDest, TInt aSize)

//

// Get 32 bits from CodeSeg stream.

// This has to deal with wrap around at the end of the buffer

//

	{

	for (TInt i = 0 ; i< aSize ; i++)

		GET_A_BYTE(p,aDest,e,KCodeBufSize);

	return p;

	}