// Copyright (c) 1998-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\profiler.cpp

// 

//

#include <e32cons.h>

#include <f32file.h>

#include "profiler.h"

#include "sampler.h"

// The name of the output file use to save the sample data

_LIT(KFileName,"?:\\PROFILER.DAT");

const TInt KFileNameLen=15;

// The name of the DLL used as an alternative UI controller

_LIT(KProfilerKeysDll,"ProfilerKeys");

// The size of the buffers used for reading sample data and writing to file

const TInt KBufferSize = 0x800;

// The sample rate used by the profiler

const TInt KSampleRate = 1000;

const TInt KCommandMask  = 0x00ff;

const TInt KCommandNone  = 0x0010;

const TInt KCommandNoUi  = 0x0100;

const TInt KCommandXIPOnly = 0x0200;

// The controller class used to provide the Profiler functions.

// This runs as a server in the engine thread

class CPServer : public CServer2, public MProfilerController

	{

public:

	static MProfilerController* NewL(TInt aPriority, MProfilerEngine& aEngine);

private:

	CPServer(TInt aPriority, MProfilerEngine& aEngine);

	void Release();

	CSession2* NewSessionL(const TVersion& aVersion,const RMessage2& aMessage) const;

	};

// The session class used by the server controller

class CPSession : public CSession2

	{

private:

	inline const CPServer& Server() const;

	void ServiceL(const RMessage2& aMessage);

	};

// The default UI controller class which uses a Console

class CConsole : public CActive, private MProfilerController

	{

public:

	static MProfilerController* NewL(TInt aPriority, MProfilerEngine& aEngine);

private:

	CConsole(TInt aPriority, MProfilerEngine& aEngine);

	void ConstructL();

	~CConsole();

	void Release();

//

	void Help();

	void Queue();

//

	void RunL();

	void DoCancel();

private:

	CConsoleBase* iConsole;

	};

// The buffers used for transferring data from the device driver to the file

struct TBuffer

	{

	TBuffer* iNext;

	TBuf8<KBufferSize> iBuf;

	};

class CProfiler;

// The active object responsible for reading data from the device

class CReader : public CActive

	{

public:

	CReader(TInt aPriority, CProfiler& aProfiler);

	~CReader();

//

	void ConstructL();

	void Queue(TBuffer* aBuf);

private:

	void RunL();

	void DoCancel();

private:

	CProfiler& iProfiler;

	TBuffer* iBuf;

public:

	RSampler iSampler;

	};

// The active object responsible for writing data out (to file)

class CWriter : public CActive

	{

public:

	CWriter(TInt aPriority, CProfiler& aProfiler);

	~CWriter();

	void ConstructL();

	TInt Open(const TDesC& aFile);

	void Close();

	void Queue(TBuffer* aBuf);

private:

	void RunL();

	void DoCancel();

private:

	CProfiler& iProfiler;

	TBuffer* iBuf;

	RFile iFile;

	RFs iFs;

	};

// The profiler engine itself.

class CProfiler : public CBase, private MProfilerEngine

	{

	enum {EControlPriority = 10, EReaderPriority = 0, EWriterPriority = -10};

	/** Specifies the state of the engine*/

	enum TState 

		{

		/**

		Initial state. The file is closed. Driver is inactive

		*/

		EClosed,

		/**

		Engine enters this state on client's Start request (if -xiponly is not specified).

		Opens the file.

		Resets the driver and nonXIP code segments.

		Sends GetSegments calls to the driver until driver returns zero length reply.

		Leaves this state (goes into ERunning) when the last data (obtained by GetSegment) is

		written into the file.		 

		*/

		EGettingSegments,

		/**

		Sends async. read request to the driver. Once completed, it immediately sends another while 

		writing the collected records into the file.

		*/

		ERunning,

		/**

		Get into this state from ERunning on the client's Stop, Close or Exit request.

		Sends Drain calls to the driver until driver returns zero length reply.

		Leaves this state when all records are written into the file.

		*/

		EDraining,

		/**

		No active calls to the driver. On the client's Start request, will go back into ERunning mode.

		*/

		EStopped,

		/**

		Get into this state on client's Close or Exit request.

		Sends a single GetErrorReport request to the driver. After data has been recorded into the file,

		it closes the file and goes into EClosed state or terminates application..

		*/

		EGettingErrors

		};

public:

	static CProfiler* NewLC(TInt aCmd, TDesC* aDrive);

//

	TInt Control(Profiler::TState aCommand);

//

	void ReadComplete(TBuffer* aBuf);

	void WriteComplete(TBuffer* aBuf);

private:

	CProfiler();

	~CProfiler();

	void ConstructL(TInt aCmd, TDesC* aDrive);

	MProfilerController* CreateUiL();

//

	void Read();

	void Write();

	TBool GetSegments();

	TBool Drain();

	void GetErrors();

//

	Profiler::TState State() const;

private:

	CReader* iReader;

	CWriter* iWriter;

	MProfilerController* iServer;

	RLibrary iUiCode;

	MProfilerController* iUi;

	TState iState;

	TBool iXIPOnly;

	Profiler::TState iLastCommand;

//

	// The FIFO queue of data that has to be written

	TBuffer* iHead;

	TBuffer* iTail;

//

	// The LIFO list of free buffers 

	TBuffer* iFree;

	TDesC* iDrive;

	};

CProfiler* CProfiler::NewLC(TInt aCmd, TDesC* aDrive)

	{

	CProfiler* self = new(ELeave) CProfiler;

	CleanupStack::PushL(self);

	self->ConstructL(aCmd, aDrive);

	return self;

	}

CProfiler::CProfiler()

	{}

CProfiler::~CProfiler()

	{

	delete iReader;

	delete iWriter;

	if (iServer)

		iServer->Release();

	if (iUi)

		iUi->Release();

	iUiCode.Close();

	// discard the buffers in the free list

	TBuffer* b=iFree;

	while (b)

		{

		TBuffer* n = b->iNext;

		delete b;

		b = n;

		}

	// discard any buffers in the holding queue

	b=iHead;

	while (b)

		{

		TBuffer* n = b->iNext;

		delete b;

		b = n;

		}

	}

void CProfiler::ConstructL(TInt aCmd, TDesC* aDrive)

//

// Build the profiler engine

//

	{

	// Set drive letter of where to store profiler data

	iDrive = aDrive;

	// Run the engine at maximum priority to try and ensure that the sampler device

	// does not get choked and start dropping samples

	RThread me;

	me.SetPriority(EPriorityRealTime);

	User::LeaveIfError(User::RenameThread(KProfilerName));

	CActiveScheduler::Install(new(ELeave) CActiveScheduler);

	iReader = new(ELeave) CReader(EReaderPriority,*this);

	iReader->ConstructL();

	iWriter = new(ELeave) CWriter(EWriterPriority,*this);

	iWriter->ConstructL();

	iServer = CPServer::NewL(EControlPriority,*this);

	if (!(aCmd & KCommandNoUi))

		iUi = CreateUiL();

	// Start off with two buffers in the free list for sample data

	TBuffer* buf = new(ELeave) TBuffer;

	buf->iNext = 0;

	iFree = buf;

	buf = new(ELeave) TBuffer;

	buf->iNext = iFree;

	iFree = buf;

	// idenify the running mode

	iXIPOnly = aCmd & KCommandXIPOnly;

	// start profiling if requested

	if ((aCmd & KCommandMask) == Profiler::EStart)

		User::LeaveIfError(Control(Profiler::EStart));

	}

MProfilerController* CProfiler::CreateUiL()

//

// deal with the UI acquisition part of construction

// If ProfilerKeys.Dll is available, use it; otherwise create a text console

//

	{

	_LIT(KWindowServerName,"*WindowServer");

	TFindServer find(KWindowServerName);

	TFullName n;

	if (find.Next(n) == KErrNotFound)

		{

		// No UI on this device [yet]. Run without one.

		return 0;

		}

	if (iUiCode.Load(KProfilerKeysDll,TUidType(KNullUid, KUidProfilerKeys)) == KErrNone)

		{

		TProfilerControllerFactoryL factoryL = TProfilerControllerFactoryL(iUiCode.Lookup(1));

		MProfilerController* ui = NULL;

		TRAPD(error, ui = factoryL(EControlPriority, *this));

		if (error == KErrNone)

			return ui;

		// Couldn't create alternative UI, so use the console

		iUiCode.Close();

		}

	return CConsole::NewL(EControlPriority, *this);

	}

TInt CProfiler::Control(Profiler::TState aCommand)

//

// Handle a command from one of the controllers.

// This method specifies the flow of the engine state (iState attr).

// The most of transtions is not performed immediately but after all 

// current data are recorded into the file - see WriteComplete method.

//

	{

	DEBUG_PROFILER(RDebug::Printf("*CTRL %d",iState);)

	TInt r = KErrNone;

	Profiler::TState oldCommand = iLastCommand;

	//Record the command. In most cases, it is WriteComplete method

	//to perform state transition (based on this value)

	iLastCommand = aCommand;

	switch (aCommand)

		{

	case Profiler::EStart:

		switch (iState)

			{

		case EClosed:

			{

			// Set the path of the output file to include the drive letter

			// specified at the command line or the default

			TBuf<KFileNameLen> path;

			path.Copy(KFileName);

			path[0] = (*iDrive)[0];

		 	r = iWriter->Open(path);

			}

			if (KErrNone != r)	 	// Re-open the file

				return r;

			iReader->iSampler.Reset(iXIPOnly);				// Reset the sampler

			if(iXIPOnly)

				{

				iState = ERunning;

				iReader->iSampler.Start(KSampleRate);		// Start sampler

				if (!iReader->IsActive())

					Read();									// Start reading

				}

			else	

				{

				iState = EGettingSegments;

				iReader->iSampler.ResetSegments();			// Reset segments

				GetSegments();								// Start getting segments

				}

			break;

		case EStopped:

			iState = ERunning;

			iReader->iSampler.Start(KSampleRate);			// Start sampler

			if (!iReader->IsActive())

				Read();										//Start reading

			break;

		case ERunning:			//Already started. No action required.

		case EGettingSegments:	//Already started. No action required.

		case EDraining:			//Will restart after draining is completed.

		case EGettingErrors:    //Will restart after getting errors is completed;

			break;

			}

		break; //end of case Profiler::EStart

	case Profiler::EStop:

		switch (iState)

			{

		case EClosed:

		case EGettingErrors:

			iLastCommand = oldCommand; 		

			return KErrGeneral; 			//The command makes no sense in this state

		case ERunning:

			iReader->iSampler.Stop();		//Stop sampling.

			break;

		case EGettingSegments:	//Will do GettingSegments->Running->Stopped transitions

		case EDraining:			//Stopping already in progress

		case EStopped:			//Already stopped.

			break;

			}

		break; //end of case Profiler::EStop

	case Profiler::EClose:

		switch (iState)

			{

		case EStopped:

			iState = EGettingErrors;

			GetErrors();

			break;

		case ERunning:

			iReader->iSampler.Stop();

			break;

		case EClosed:   		//Already closed.

		case EGettingErrors:	//Closing in progress

		case EGettingSegments:

		case EDraining:

			break;

			}

		break; //end of case Profiler::EStop

	case Profiler::EUnload:

		switch (iState)

			{

		case EClosed:

			CActiveScheduler::Stop();	// Terminate application.

			break;

		case EStopped:

			iState = EGettingErrors;

			GetErrors();

			break;

		case ERunning:

			iReader->iSampler.Stop();

			break;

		case EDraining:

		case EGettingErrors:

		case EGettingSegments:

			break;

			}

		break;//end of case Profiler::Unload

		}

	DEBUG_PROFILER(RDebug::Printf("*CTRL end %d",iState);)

	return KErrNone;

	}

Profiler::TState CProfiler::State() const

//

// Report the current state of the engine

//

	{

	switch (iState)

		{

	case EGettingErrors:

	case EStopped:

		return Profiler::EStop;

	case EClosed:

		return Profiler::EClose;

	default:

		return Profiler::EStart;

		}

	}

void CProfiler::Read()

//

// Pass a free buffer to the reader, allocating one if necessary

//

	{

	TBuffer* buf = iFree;

	if (buf)

		iFree = buf->iNext;

	else

		{

		buf = new TBuffer;

		if(!buf)

			{

			RDebug::Print(_L("PROFILER: No more memory ... stopping"));

			CProfiler::Control(Profiler::EStop);

			return;

			}

		}

	iReader->Queue(buf);

	}

TBool CProfiler::GetSegments()

//

// Gets the list of the current non-XIP segments from device.

// Returns true if zero-length desc is returned, otherwise ...

// ...passes the buffer to write engine and returns false.

	{

	TBuffer* buf = iFree;

	if (buf)

		iFree = buf->iNext;

	else

		{

		RDebug::Printf("PROFILER: No available buffer for GetSegments");

		User::Invariant();

		}

	iReader->iSampler.GetSegments(buf->iBuf);

	if (!buf->iBuf.Length())

		{

		buf->iNext = iFree;//Return empty buffer to the free list

		iFree = buf;

		return ETrue;

		}

	iWriter->Queue(buf);//Pass the buffer to the write engine.

	return EFalse;

	}

TBool CProfiler::Drain()

//

// Drains all remaining records from the device

// Returns true if zero-length desc is returned, otherwise ...

// ...passes the buffer to the write engine and returns false.

	{

	TBuffer* buf = iFree;

	if (buf)

		iFree = buf->iNext;

	else

		{

		RDebug::Printf("PROFILER: No available buffer for Drain");

		User::Invariant();

		}

	iReader->iSampler.Drain(buf->iBuf);