// Copyright (c) 2002-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:

 //

 #include <e32test.h>

 #include "bm_suite.h"

 class RTLatency : public BMProgram

 	{

 	struct Measurement

 		{

 		RBMChannel::TMode	iMode;

 		TPtrC				iName;

 		TBool				iForcePSwitch;

 		Measurement(RBMChannel::TMode aMode, const TDesC& aName, TBool aForcePSwitch = EFalse) : 

 			iMode(aMode), iName(aName), iForcePSwitch(aForcePSwitch) {}

 		};

 public :

 	RTLatency() : BMProgram(_L("Real-Time Latency"))

 		{}

 	virtual TBMResult* Run(TBMUInt64 aIter, TInt* aCount);

 	static TBMResult	iResults[];

 	static Measurement	iMeasurements[];

 	void Perform(RBMChannel::TMode, TBMResult*, TBMUInt64 aIter, TBool aForcePSwitch);

 	static TInt Child(TAny*);

 	};

 RTLatency::Measurement		RTLatency::iMeasurements[] =

 	{ 

 		Measurement(RBMChannel::EInterruptLatency, _L("Interrupt Latency")),

 		Measurement(RBMChannel::EKernelPreemptionLatency, _L("Kernel Thread Preemption Latency (Idle)")),

 		Measurement(RBMChannel::EKernelPreemptionLatency, _L("Kernel Thread Preemption Latency(Busy)"), ETrue),

 		Measurement(RBMChannel::EUserPreemptionLatency, _L("User Thread Preemption Latency (Idle)")),

 		Measurement(RBMChannel::EUserPreemptionLatency, _L("User Thread Preemption Latency (Busy)"), ETrue),

 		Measurement(RBMChannel::ENTimerJitter, _L("NTimer Jitter")),

 		Measurement(RBMChannel::ETimerStampOverhead, _L("Getting Time Stamp Overhead"))

 	};

 TBMResult	RTLatency::iResults[sizeof(RTLatency::iMeasurements)/sizeof(RTLatency::iMeasurements[0])];

 static RTLatency rtLatency;

 struct ChildArgs : public TBMSpawnArgs

 	{

 	RSemaphore iSem;

 	ChildArgs () : TBMSpawnArgs(RTLatency::Child, KBMPriorityLow, ETrue, sizeof(*this))

 		{

 		TInt r = KErrNone;

 		do

 			{		//"Bm_SuiteSemaphore" is created/deleted a number of times during the test.

 			if (r)	//If kernel did not clean up the previous instance, wait a sec and retry.

 				User::After(1000000);

 			r = iSem.CreateGlobal(_L("Bm_SuiteSemaphore"), 0);

 			}

 		while(KErrAlreadyExists == r);

 		BM_ERROR(r, r == KErrNone);

 		}

 	void ChildOpen()

 		{	

 		iSem.Duplicate(iParent);

 		}

 	~ChildArgs ()

 		{

 		iSem.Close();

 		}

 	};

 //

 // Child process entry point.

 //

 TInt RTLatency::Child(TAny* ptr)

 	{

 	ChildArgs* ca = (ChildArgs*) ptr;

 		// get handles to all objects shared with the parent

 	ca->ChildOpen();

 		// signal the parent that the child is ready

 	ca->iSem.Signal();

 		// loop forever

 	for(;;) {}

 	}

 void RTLatency::Perform(RBMChannel::TMode aMode, TBMResult* aResult, TBMUInt64 aIter, TBool aForcePSwitch)

 	{

 	ChildArgs ca;

 	MBMChild* child = NULL;

 	if (aForcePSwitch)

 		{

 			// spawn a busy running low-pririty child process

 		child = rtLatency.SpawnChild(&ca);

 		ca.iSem.Wait();

 		}

 	RBMChannel ch;

 	TInt r = ch.Open(aMode);

 	if(r==KErrInUse)

 		return; // Assume that resources are being used for other forms of latency testing

 	BM_ERROR(r, r == KErrNone);

 	while(aIter--) 

 		{

 			// request an interrupt

 		ch.RequestInterrupt();

 		TBMTicks ticks;

 			// wait for the result. At this point the child becomes running.

 		ch.Result(&ticks);

 		aResult->Cumulate(ticks);

 		}

 	ch.Close();

 	if (aForcePSwitch)

 		{

 		child->Kill();

 		child->WaitChildExit();

 		}

 	}

 TBMResult* RTLatency::Run(TBMUInt64 aIter, TInt* aCount)

 	{

 	TInt count = sizeof(iResults)/sizeof(iResults[0]);

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

 		{

 		iResults[i].Reset(iMeasurements[i].iName);

 		Perform(iMeasurements[i].iMode, &iResults[i], aIter, iMeasurements[i].iForcePSwitch);

 		iResults[i].Update();

 		}

 	*aCount = count;

 	return iResults;

 	}

 void AddrtLatency()

 	{

 	BMProgram* next = bmSuite;

 	bmSuite=(BMProgram*)&rtLatency;

 	bmSuite->Next()=next;

 	}