FCL/sf/os/kernelhwsrv: comparison kerneltest/e32utils/profiler/profiler.cpp

equal deleted inserted replaced

--1:000000000000
+:a41df078684a
+// 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);
+	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;
+	}
+void CProfiler::GetErrors()
+//
+// Gets error report from the device and pass the buffer to the write engine
+//
+	{
+	TBuffer* buf = iFree;
+	if (buf)
+		iFree = buf->iNext;
+	else
+		{
+		RDebug::Printf("PROFILER: No available buffer for GetErrors");
+		User::Invariant();
+		}
+	iReader->iSampler.GetErrors(buf->iBuf);
+	iWriter->Queue(buf);
+	}
+void CProfiler::Write()
+//
+// Pass a queued buffer to the writer
+//
+	{
+	TBuffer* buf = iHead;
+	iHead = buf->iNext;
+	if (iHead == 0)
+		iTail = 0;
+	iWriter->Queue(buf);
+	}
+void CProfiler::ReadComplete(TBuffer* aBuf)
+//
+// Handle a completed read buffer
+//
+	{
+	DEBUG_PROFILER(RDebug::Printf("*RC %d",iState);)
+	//Add the buffer to the queue
+	aBuf->iNext = 0;
+	if (iTail)
+		iTail->iNext = aBuf;
+	else
+		iHead = aBuf;
+	iTail = aBuf;
+	if (!iWriter->IsActive())
+		Write();
+	if (iLastCommand == Profiler::EStart)
+		Read();	//Request another read
+	DEBUG_PROFILER(RDebug::Printf("*RC end %d",iState);)
+	}
+void CProfiler::WriteComplete(TBuffer* aBuf)
+//
+// Handle a flushed write buffer.
+//
+	{
+	DEBUG_PROFILER(RDebug::Printf("*WC %d",iState);)
+	aBuf->iNext = iFree;//Return empty buffer to the free list
+	iFree = aBuf;
+	switch (iState)
+		{
+	case EGettingSegments:
+		if (!GetSegments())
+			break;//More code segments to be completed
+		//Always go to the running state after the segments are collected....
+		iState = ERunning;
+		iReader->iSampler.Start(KSampleRate);
+		Read();
+		//...but stop sampler immediately if we got another user command
+		if (iLastCommand != Profiler::EStart)
+			{
+			iReader->iSampler.Stop();
+			}
+		break; //the end of EGettingSegments case
+	case ERunning:
+		if (iHead)
+			{
+			Write(); // There are more buffers to go to the file.
+			break;
+			}
+		if (iLastCommand != Profiler::EStart)
+			{//The user has stopped the profiler.
+			iState = EDraining;
+			if (!Drain())
+				break;//More data to drain.
+			//Drain returned empty. May progress further with the engine state
+			if (iLastCommand == Profiler::EStop)
+				iState = EStopped;
+			else
+				{
+				iState = EGettingErrors;
+				GetErrors();
+				}
+			}
+		break;//the end of ERunning case
+	case EDraining:
+		if (!Drain())
+			break; //still draining;
+		//Drain is completed
+		switch (iLastCommand)
+			{
+		case Profiler::EStart:
+			//While draining, we received another Start command
+			iState = ERunning;
+			iReader->iSampler.Start(KSampleRate);
+			Read();
+			break;
+		case Profiler::EStop:
+			iState = EStopped;
+			break;
+		default:
+			iState = EGettingErrors;
+			GetErrors();
+			}
+		break; //the end of EDraining case
+	case EGettingErrors:
+		iWriter->Close();
+		iState = EClosed;
+		switch (iLastCommand)
+			{
+		case Profiler::EUnload:
+			CActiveScheduler::Stop(); //Terminate application.
+			break;
+		case Profiler::EStart:
+			Control(Profiler::EStart);
+			break;
+		default:
+			break;
+			}
+		break; //the end of EGettingErrors case
+	default:
+		RDebug::Printf("PROFILER: WriteComplete in %d state", iState);
+		User::Invariant();
+		break;
+		}
+	DEBUG_PROFILER(RDebug::Printf("*WC end %d",iState);)
+	}
+CReader::CReader(TInt aPriority, CProfiler& aProfiler)
+	:CActive(aPriority), iProfiler(aProfiler)
+	{
+	CActiveScheduler::Add(this);
+	}
+CReader::~CReader()
+	{
+	Cancel();
+	delete iBuf;
+	iSampler.Close();
+	User::FreeLogicalDevice(KSamplerName);
+	}
+void CReader::ConstructL()
+	{
+	TInt r=User::LoadLogicalDevice(KSamplerName);
+	if (r!=KErrNone && r!=KErrAlreadyExists)
+		User::Leave(r);
+	User::LeaveIfError(iSampler.Open());
+	}
+void CReader::RunL()
+//
+// Pass the full buffer to the engine
+//
+	{
+	TBuffer* data=iBuf;
+	iBuf = 0;
+	iProfiler.ReadComplete(data);
+	}
+void CReader::DoCancel()
+	{
+	iSampler.ReadCancel();
+	}
+void CReader::Queue(TBuffer* aBuf)
+//
+// Queue a request to read data into the empty buffer
+//
+	{
+	iBuf = aBuf;
+	iSampler.Read(aBuf->iBuf, iStatus);
+	SetActive();
+	}
+CWriter::CWriter(TInt aPriority, CProfiler& aProfiler)
+	:CActive(aPriority), iProfiler(aProfiler)
+	{
+	CActiveScheduler::Add(this);
+	}
+CWriter::~CWriter()
+	{
+	Cancel();
+	delete iBuf;
+	iFile.Close();
+	iFs.Close();
+	}
+void CWriter::ConstructL()
+	{
+	User::LeaveIfError(iFs.Connect());
+	}
+TInt CWriter::Open(const TDesC& aFile)
+//
+// Open the file for saving the sample data
+//
+	{
+	return iFile.Replace(iFs,aFile,EFileWrite);
+	}
+void CWriter::Close()
+//
+// Release the file
+//
+	{
+	iFile.Close();
+	}
+void CWriter::Queue(TBuffer* aBuf)
+//
+// Queue a request to write the full buffer into the file
+//
+	{
+	iBuf = aBuf;
+	iFile.Write(aBuf->iBuf, iStatus);
+	SetActive();
+	}
+void CWriter::RunL()
+//
+// Return the empty buffer back to the engine
+//
+	{
+	TBuffer* data=iBuf;
+	iBuf = 0;
+	iProfiler.WriteComplete(data);
+	}
+void CWriter::DoCancel()
+//
+// RFile does not provide a WriteCancel() function
+//
+	{}
+// Server controller
+inline const CPServer& CPSession::Server() const
+	{return *static_cast<const CPServer*>(CSession2::Server());}
+void CPSession::ServiceL(const RMessage2& aMessage)
+//
+// Handle a IPC request to control the profiler
+//
+	{
+	aMessage.Complete(Server().Control(Profiler::TState(aMessage.Function())));
+	}
+MProfilerController* CPServer::NewL(TInt aPriority, MProfilerEngine& aEngine)
+//
+// Create and start the server to provide the Profiler interface
+//
+	{
+	CPServer* self = new(ELeave) CPServer(aPriority, aEngine);
+	CleanupStack::PushL(self);
+	self->StartL(KProfilerName);
+	CleanupStack::Pop();
+	return self;
+	}
+CPServer::CPServer(TInt aPriority, MProfilerEngine& aEngine)
+	:CServer2(aPriority), MProfilerController(aEngine)
+	{}
+void CPServer::Release()
+	{
+	delete this;
+	}
+CSession2* CPServer::NewSessionL(const TVersion&,const RMessage2&) const
+	{
+	return new(ELeave) CPSession();
+	}
+// Console Controller
+MProfilerController* CConsole::NewL(TInt aPriority, MProfilerEngine& aEngine)
+//
+// Create and start the console UI for the profiler
+//
+	{
+	CConsole* self = new(ELeave) CConsole(aPriority, aEngine);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop();
+	return self;
+	}
+CConsole::CConsole(TInt aPriority, MProfilerEngine& aEngine)
+	:CActive(aPriority), MProfilerController(aEngine)
+	{
+	CActiveScheduler::Add(this);
+	}
+void CConsole::ConstructL()
+	{
+	iConsole = Console::NewL(KProfilerName, TSize(KConsFullScreen,KConsFullScreen));
+	Help();
+	Queue();
+	}
+CConsole::~CConsole()
+	{
+	Cancel();
+	delete iConsole;
+	}
+void CConsole::Release()
+	{
+	delete this;
+	}
+void CConsole::Help()
+//
+// Display the instructions on the console
+//
+	{
+	_LIT(KInstructions,"[S]tart, Sto[p], [C]lose or E[x]it\r\n");
+	iConsole->Write(KInstructions);
+	}
+void CConsole::Queue()
+//
+// Request a key press from the console
+//
+	{
+	iConsole->Read(iStatus);
+	SetActive();
+	}
+void CConsole::RunL()
+//
+// Handle a key press from the console
+//
+	{
+	TInt key = iConsole->KeyCode();
+	Queue();
+	Profiler::TState command;
+	switch (key)
+		{
+	case 's': case 'S':
+		command = Profiler::EStart;
+		break;
+	case 'p': case 'P':
+		command = Profiler::EStop;
+		break;
+	case 'c': case 'C':
+		command = Profiler::EClose;
+		break;
+	case 'x': case 'X':
+		command = Profiler::EUnload;
+		break;
+	case '?': case 'h': case 'H':
+		Help();
+		return;
+	default:
+		return;
+		}
+	Control(command);
+	}
+void CConsole::DoCancel()
+	{
+	iConsole->ReadCancel();
+	}
+void MainL(TInt aCmd, TDesC* aDrive)
+//
+// Construct and run the profile engine
+//
+	{
+	CProfiler* p = CProfiler::NewLC(aCmd, aDrive);
+	CActiveScheduler::Start();
+	CleanupStack::PopAndDestroy(p);
+	}
+TInt GetCommand(TDes &aDrive)
+//
+// Decode the command line arguments into a profiler control request
+//		aDrive is the drive number to store the profiler data on
+//
+	{
+	_LIT(KStart,"start");
+	_LIT(KStop,"stop");
+	_LIT(KClose,"close");
+	_LIT(KUnload,"unload");
+	_LIT(KExit,"exit");
+	_LIT(KNoUi,"-noui");
+	_LIT(KXIPOnly,"-xiponly");
+	_LIT(KDrive,"-drive=");
+	const TInt KDriveOffset=7;
+	TBuf<64> c;
+	User::CommandLine(c);
+	TInt cmd = 0;
+	if (c.FindF(KNoUi) >= 0)
+		cmd |= KCommandNoUi;
+	if (c.FindF(KXIPOnly) >= 0)
+		cmd |= KCommandXIPOnly;
+	// get the drive letter if any
+	TInt pos = c.FindF(KDrive);
+	if(pos >= 0)
+		{
+		pos += KDriveOffset;
+		TBuf<1> driveLet;
+		driveLet.SetLength(1);
+		driveLet[0] = c[pos];
+		driveLet.UpperCase();
+		if (driveLet[0] >= 'A' && driveLet[0] <= 'Z')
+			{
+			aDrive[0] = driveLet[0];
+			}
+		}
+	if (c.FindF(KStart) >= 0)
+		return cmd | Profiler::EStart;
+	if (c.FindF(KStop) >= 0)
+		return cmd | Profiler::EStop;
+	if (c.FindF(KClose) >= 0)
+		return cmd | Profiler::EClose;
+	if (c.FindF(KUnload) >= 0)
+		return cmd | Profiler::EUnload;
+	if (c.FindF(KExit) >= 0)
+		return cmd | Profiler::EUnload;
+	return cmd | KCommandNone;
+	}
+TInt E32Main()
+//
+// Profiler.exe entry point
+// Decode any command-line argument - which can be used to control a running profile engine
+// Otherwise start the engine in this process
+//
+	{
+	TBuf<1> drive;
+	drive.SetLength(1);
+	drive[0] = 'C';
+	TInt command = GetCommand(drive);
+	if ((command & KCommandMask) != KCommandNone)
+		{
+		TInt r = Profiler::Control(Profiler::TState(command & KCommandMask));
+		if (r != KErrNotFound || (command & KCommandMask) != Profiler::EStart)
+			return r;
+		}
+	CTrapCleanup::New();
+	TRAPD(r,MainL(command, &drive));
+	if (r != KErrNone)
+		RDebug::Print(_L("PROFILER: Error starting profiler"));
+	return r;
+	}