// 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:

 // Overview:

 // Test and benchmark kernel-side utility operations  

 // API Information:

 // RBusLogicalChannel			

 // Details:

 // - Create a list of benchmark modules and start running them one by one;

 // each module contains a set of measurement units, each unit runs for a fixed

 // amount of time in a series of iterations; the results, minimum, maximum and

 // average times are displayed on the screen;

 // The tests use a high resolution timer implemented kernel side in a device

 // driver.

 // - The test contains the following benchmark modules:

 // - Real-time latency module measures:

 // - interrupt latency by calculating the time taken from when an

 // interrupt is generated until the ISR starts

 // - kernel thread latency by calculating the time taken from an ISR

 // scheduling a DFC to signal the kernel thread until the kernel thread

 // starts running

 // - kernel thread latency as above while a CPU intensive low priority

 // user thread runs at the same time

 // - user thread latency by calculating the time taken from an ISR 

 // scheduling a DFC to signal the user thread until the user thread

 // starts running

 // - user thread latency as above while a CPU intensive low priority

 // user thread runs at the same time

 // - NTimer period jitter by calculating the actual period as the delta

 // between two consecutive NTimer callbacks that store the current time;

 // the jitter is the difference between the actual period and a theoretical

 // period.

 // - timer overhead by calculating the delta of time between two consecutive

 // timestamps requested from the high precision timer implemented in the

 // device driver; the calls are made from kernel side code

 // - Overhead module measures:

 // - timer overhead by calculating the delta of time between two consecutive

 // timestamps requested from the high precision timer implemented in the

 // device driver; the calls are made from user side code

 // - Synchronization module measures: 

 // - mutex passing, local mutex contention, remote mutex contention, 

 // local semaphore latency, remote semaphore latency, 

 // local thread semaphore latency, remote thread semaphore latency.

 // - Client-server framework module measures:

 // - For local high priority, local low priority, remote high priority 

 // and remote low priority: connection request latency, connection

 // reply latency, request latency, request response time, reply latency.

 // - Threads modules measures:

 // - Thread creation latency, thread creation suicide, thread suicide,

 // thread killing, setting per thread data, getting per thread data.

 // - Properties module measures:

 // - Local int notification latency, remote int notification latency, 

 // local byte(1) notification latency, remote byte(1) notification latency, 

 // local byte(8) notification latency, remote byte(8) notification latency, 

 // local byte(512) notification latency, remote byte(512) notification latency, 

 // int set overhead, byte(1) set overhead, byte(8) set overhead, byte(512) set 

 // overhead, int get overhead, byte(1) get overhead, byte(8) get overhead, 

 // byte(512) get overhead. 

 // Platforms/Drives/Compatibility:

 // All.

 // Assumptions/Requirement/Pre-requisites:

 // Failures and causes:

 // Base Port information:

 // 

 //

 #include "bm_suite.h"

 #include <e32svr.h>

 #include <u32hal.h>

 RTest test(_L("Benchmark Suite"));

 //

 // The default value of the time allocated for one benchmark program.  

 //

 static TInt KBMSecondsPerProgram = 30;

 //

 // The initial number of iterations to estimate the acctual number of iteration. 

 //

 static TInt KBMCalibrationIter = 64;

 //

 // Global handle to high-resolution timer. 

 //

 RBMTimer bmTimer;

 //

 // The head of the benchmark programs' list

 //

 BMProgram* bmSuite; 

 //

 // Global handle to the kernel side benchmark utilty API 

 //

 static RBMDriver bmDriver;

 TBMResult::TBMResult(const TDesC& aName) : iName(aName) 

 	{

 	Reset();

 	}

 void TBMResult::Reset()

 	{

 	::bmTimer.Period(&iMinTicks);

 	iMaxTicks = 0;

 	iCumulatedTicks = 0;

 	iCumulatedIterations = 0;

 	iIterations = 0;

 	iMin = 0;

 	iMax = 0;

 	iAverage = 0;

 	}

 void TBMResult::Reset(const TDesC& aName)

 	{

 	Reset();

 	iName.Set(aName);

 	}

 void TBMResult::Cumulate(TBMTicks aTicks)

 {

 	if (aTicks < iMinTicks) iMinTicks = aTicks;

 	if (iMaxTicks < aTicks) iMaxTicks = aTicks;

 	iCumulatedTicks += aTicks;

 	if (iCumulatedIterations < KHeadSize)

 		{

 		iHeadTicks[iCumulatedIterations] = aTicks;

 		}

 		// use the array as a circular buufer to store last KTailSize results

 		// (would not really know which one was actually the last)

 	iTailTicks[iCumulatedIterations % KTailSize] = aTicks;

 	++iCumulatedIterations;

 }

 void TBMResult::Cumulate(TBMTicks aTicks, TBMUInt64 aIter)

 {

 	iCumulatedIterations += aIter;

 	iCumulatedTicks += aTicks;

 }

 void TBMResult::Update()

 {

 	if (iCumulatedIterations == 0) return;

 	iIterations = iCumulatedIterations;

 	::bmTimer.TicksToNs(&iMinTicks, &iMin);

 	::bmTimer.TicksToNs(&iMaxTicks, &iMax);

 	TBMTicks averageTicks = iCumulatedTicks/TBMUInt64(iCumulatedIterations);

 	::bmTimer.TicksToNs(&averageTicks, &iAverage);

 	TInt i;

 	for (i = 0; i < KHeadSize; ++i) 

 		{

 		::bmTimer.TicksToNs(&iHeadTicks[i], &iHead[i]);

 		}

 	for (i = 0; i < KTailSize; ++i) 

 		{

 		::bmTimer.TicksToNs(&iTailTicks[i], &iTail[i]);

 		}

 	}

 inline TBMNs TTimeIntervalMicroSecondsToTBMNs(TTimeIntervalMicroSeconds us)

 	{

 	return BMUsToNs(*(TBMUInt64*)&us);

 	}

 TBMNs TBMTimeInterval::iStampPeriodNs;

 TBMTicks TBMTimeInterval::iStampPeriod;

 void TBMTimeInterval::Init()

 	{

 	::bmTimer.Period(&iStampPeriod); 

 	::bmTimer.TicksToNs(&iStampPeriod, &iStampPeriodNs);

 }

 void TBMTimeInterval::Begin()

 	{

 	//

 	// Order is important: read first low-precision timer, then the high-precision one. 

 	// Therefore, two high-precision timer reads will be accounted in the low-precision interval,

 	// that's better than the opposite.

 	//

 	iTime.HomeTime();

 	::bmTimer.Stamp(&iStamp);

 	}

 TBMNs TBMTimeInterval::EndNs()

 	{

 	//

 	// Now, in the reverse order

 	//

 	TBMTicks stamp;

 	::bmTimer.Stamp(&stamp);

 	TTime time;	

 	time.HomeTime();

 	TBMNs ns = TTimeIntervalMicroSecondsToTBMNs(time.MicroSecondsFrom(iTime));

 	//

 	// If the interval fits in the high-precision timer period we can use it;

 	// otherwise, use the low-precision timer.

 	//

 	if (ns < iStampPeriodNs)

 		{

 		stamp = TBMTicksDelta(iStamp, stamp);

 		::bmTimer.TicksToNs(&stamp, &ns);

 		}

 	return ns;

 	}

 TBMTicks TBMTimeInterval::End()

 	{

 	//

 	// The same as the previous one but returns ticks

 	//

 	TBMTicks stamp;

 	::bmTimer.Stamp(&stamp);

 	TTime time;	

 	time.HomeTime();

 	TBMNs ns = TTimeIntervalMicroSecondsToTBMNs(time.MicroSecondsFrom(iTime));

 	if (ns < iStampPeriodNs)

 		{

 		stamp = TBMTicksDelta(iStamp, stamp);

 		}

 	else

 		{

 			// multiply first - privileging precision to improbable overflow.

 		stamp = (ns * iStampPeriod) / iStampPeriodNs; 

 		}

 	return stamp;

 	}

 TInt BMProgram::SetAbsPriority(RThread aThread, TInt aNewPrio)

 	{

 	TInt aOldPrio=0;

 	TInt r = ::bmDriver.SetAbsPriority(aThread, aNewPrio, &aOldPrio);

 	BM_ERROR(r, r == KErrNone);

 	return aOldPrio;

 	}

 const TInt TBMSpawnArgs::KMagic = 0xdeadbeef;

 TBMSpawnArgs::TBMSpawnArgs(TThreadFunction aChildFunc, TInt aChildPrio, TBool aRemote, TInt aSize)

 	{

 	iMagic = KMagic;

 	iParentId = RThread().Id();

 		// get a thread handle meaningful in the context of any other thread. 

 		// (RThread() doesn't work since contextual!)

 	TInt r = iParent.Open(iParentId);

 	BM_ERROR(r, r == KErrNone);

 	iRemote = aRemote;

 	iChildFunc = aChildFunc;

 	iChildPrio = aChildPrio;

 	iSize = aSize;

 	}

 TBMSpawnArgs::~TBMSpawnArgs()

 	{

 	iParent.Close();

 	}

 //

 // An object of CLocalChild class represents a "child" thread created by its "parent" thread 

 // in the parent's process through BmProgram::SpawnChild() interface.

 //

 // CLocalChild class is typically used (invoked) by the parent's thread. 

 //

 class CLocalChild : public CBase, public MBMChild

 	{

 private:

 	BMProgram*		iProg;

 public:

 	RThread			iChild;

 	TRequestStatus	iExitStatus;

 	CLocalChild(BMProgram* aProg)

 		{

 		iProg = aProg;

 		}

 	virtual void WaitChildExit();

 	virtual void Kill();

 	};

 void CLocalChild::Kill()

 	{

 	iChild.Kill(KErrCancel);

 	}

 void CLocalChild::WaitChildExit()

 	{

 	User::WaitForRequest(iExitStatus);

 	CLOSE_AND_WAIT(iChild);

 	//

 	// Lower the parent thread prioirty and then restore the current one 

 	// to make sure that the kernel-side thread destruction DFC had a chance to complete.

 	//

 	TInt prio = BMProgram::SetAbsPriority(RThread(), iProg->iOrigAbsPriority);

 	BMProgram::SetAbsPriority(RThread(), prio);

 	delete this;

 	}

 //

 // Local (i.e. sharing the parent's process) child's entry point

 //

 TInt LocalChildEntry(void* ptr)

 	{

 	TBMSpawnArgs* args = (TBMSpawnArgs*) ptr;

 	args->iChildOrigPriority = BMProgram::SetAbsPriority(RThread(), args->iChildPrio);

 	return args->iChildFunc(args);

 	}

 MBMChild* BMProgram::SpawnLocalChild(TBMSpawnArgs* args)

 	{

 	CLocalChild* child = new CLocalChild(this);

 	BM_ERROR(KErrNoMemory, child);

 	TInt r = child->iChild.Create(KNullDesC, ::LocalChildEntry, 0x2000, NULL, args);

 	BM_ERROR(r, r == KErrNone);

 	child->iChild.Logon(child->iExitStatus);

 	child->iChild.Resume();

 	return child;

 	}

 //

 // An object of CRemoteChild class represents a "child" thread created by its "parent" thread 

 // as a separate process through BmProgram::SpawnChild() interface.

 //

 // CRemoteChild class is typically used (invoked) by the parent's thread. 

 //

 class CRemoteChild : public CBase, public MBMChild

 	{

 private:

 	BMProgram*		iProg;

 public:

 	RProcess		iChild;

 	TRequestStatus	iExitStatus;

 	CRemoteChild(BMProgram* aProg)

 		{

 		iProg = aProg;

 		}

 	virtual void WaitChildExit();

 	virtual void Kill();

 	};

 void CRemoteChild::Kill()

 	{

 	iChild.Kill(KErrCancel);

 	}

 void CRemoteChild::WaitChildExit()

 	{

 	User::WaitForRequest(iExitStatus);

 	CLOSE_AND_WAIT(iChild);

 	//

 	// Lower the parent thread prioirty and then restore the current one 

 	// to make sure that the kernel-side thread destruction DFC had a chance to complete.

 	//

 	TInt prio = BMProgram::SetAbsPriority(RThread(), iProg->iOrigAbsPriority);

 	BMProgram::SetAbsPriority(RThread(), prio);

 	delete this;

 	}

 //

 // Remote (i.e. running in its own process) child's entry point.

 // Note that the child's process entry point is still E32Main() process (see below)

 //

 TInt ChildMain(TBMSpawnArgs* args)

 	{

 	args->iChildOrigPriority = BMProgram::SetAbsPriority(RThread(), args->iChildPrio);

 		// get a handle to the parent's thread in the child's context.

 	TInt r = args->iParent.Open(args->iParentId);

 	BM_ERROR(r, r == KErrNone);

 	return args->iChildFunc(args);

 	}

 MBMChild* BMProgram::SpawnRemoteChild(TBMSpawnArgs* args)

 	{

 	CRemoteChild* child = new CRemoteChild(this);

 	BM_ERROR(KErrNoMemory, child);

 	//

 	// Create the child process and pass args as a UNICODE command line.

 	// (we suppose that the args size is multiple of sizeof(TUint16))

 	//

 	BM_ASSERT((args->iSize % sizeof(TUint16)) == 0);

 	TInt r = child->iChild.Create(RProcess().FileName(), TPtrC((TUint16*) args, args->iSize/sizeof(TUint16)));

 	BM_ERROR(r, (r == KErrNone) );

 	child->iChild.Logon(child->iExitStatus);

 	child->iChild.Resume();

 	return child;

 	}

 MBMChild* BMProgram::SpawnChild(TBMSpawnArgs* args)

 	{

 	MBMChild* child;

 	if (args->iRemote)

 		{

 		child = SpawnRemoteChild(args);

 		}

 	else

 		{

 		child = SpawnLocalChild(args);

 		}

 	return child;

 	}

 //

 // The benchmark-suite entry point.

 //

 GLDEF_C TInt E32Main()

 	{

 	test.Title();

 	TInt r = UserSvr::HalFunction(EHalGroupKernel, EKernelHalNumLogicalCpus, 0, 0);

 	if (r != 1)

 		{

 		test.Printf(_L("%d CPUs detected ... test not run\n"), r);

 		return r;

 		}

 	AddProperty();

 	AddThread();

 	AddIpc();

 	AddSync();

 	AddOverhead();

 	AddrtLatency();

 	r = User::LoadPhysicalDevice(KBMPddFileName);

 	BM_ERROR(r, (r == KErrNone) || (r == KErrAlreadyExists));

 	r = User::LoadLogicalDevice(KBMLddFileName);

 	BM_ERROR(r, (r == KErrNone) || (r == KErrAlreadyExists));

 	r = ::bmTimer.Open();

 	BM_ERROR(r, (r == KErrNone));

 	r = ::bmDriver.Open();

 	BM_ERROR(r, (r == KErrNone));

 	TBMTimeInterval::Init();

 	TInt seconds = KBMSecondsPerProgram;

 	TInt len = User::CommandLineLength();

 	if (len)

 		{

 		//

 		// Copy the command line in a buffer

 		//

 		TInt size = len * sizeof(TUint16);

 		HBufC8* hb = HBufC8::NewMax(size);

 		BM_ERROR(KErrNoMemory, hb);

 		TPtr cmd((TUint16*) hb->Ptr(), len);

 		User::CommandLine(cmd);

 		//

 		// Check for the TBMSpawnArgs magic number.

 		//

 		TBMSpawnArgs* args = (TBMSpawnArgs*) hb->Ptr();	

 		if (args->iMagic == TBMSpawnArgs::KMagic)

 			{

 			//

 			// This is a child process -  call it's entry point

 			//

 			return ::ChildMain(args);

 			}

 		else

 			{

 			//

 			// A real command line - the time (in seconds) for each benchmark program.

 			//

 			TLex l(cmd);

 			r = l.Val(seconds);

 			if (r != KErrNone)

 				{

 				test.Printf(_L("Usage: bm_suite <seconds>\n"));

 				BM_ERROR(r, 0);

 				}

 			}

 		delete hb;

 		}

 	{

 	TBMTicks ticks = 1;

 	TBMNs ns;

 	::bmTimer.TicksToNs(&ticks, &ns);

 	test.Printf(_L("High resolution timer tick %dns\n"), TInt(ns));

 	test.Printf(_L("High resolution timer period %dms\n"), BMNsToMs(TBMTimeInterval::iStampPeriodNs));

 	}

 	test.Start(_L("Performance Benchmark Suite"));

 	BMProgram* prog = ::bmSuite;

 	while (prog) {

 		//

 		// For each program from the benchmark-suite's list

 		//

 		//

 		// Remember the number of open handles. Just for a sanity check ....

 		//

 		TInt start_thc, start_phc;

 		RThread().HandleCount(start_phc, start_thc);

 		test.Printf(_L("%S\n"), &prog->Name());

 		//

 		// A benchmark-suite's thread can run at any of three possible absolute priorities:

 		//		KBMPriorityLow, KBMPriorityMid and KBMPriorityHigh.

 		// The main thread starts individual benchmark programs at KBMPriorityMid

 		//

 		prog->iOrigAbsPriority = BMProgram::SetAbsPriority(RThread(), KBMPriorityMid);

 		//

 		// First of all figure out how many iteration would be required to run this program

 		// for the given number of seconds.

 		//

 		TInt count;

 		TBMNs ns = 0;

 		TBMUInt64 iter = KBMCalibrationIter;

 		for (;;) 

 			{

 			TBMTimeInterval ti;

 			ti.Begin();

 			prog->Run(iter, &count);

 			ns = ti.EndNs();

 				// run at least 100ms (otherwise, could be too much impricise ...)

 			if (ns > BMMsToNs(100)) break;

 			iter *= 2;

 			}

 		test.Printf(_L("%d iterations in %dms\n"), TInt(iter), BMNsToMs(ns));

 		iter = (BMSecondsToNs(seconds) * iter) / ns;

 		test.Printf(_L("Go for %d iterations ...\n"), TInt(iter));

 		//

 		// Now the real run ...

 		//

 		TBMResult* results = prog->Run(iter, &count);

 			// Restore the original prioirty

 		BMProgram::SetAbsPriority(RThread(), prog->iOrigAbsPriority);

 		//

 		// Now print out the results

 		//

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

 			{

 			if (results[i].iMax)

 				{

 				test.Printf(_L("%S. %d iterations; Avr: %dns; Min: %dns; Max: %dns\n"), 

 							&results[i].iName, TInt(results[i].iIterations),

 							TInt(results[i].iAverage), TInt(results[i].iMin), TInt(results[i].iMax));

 				TInt j;

 				BM_ASSERT((TBMResult::KHeadSize % 4) == 0);

 				test.Printf(_L("Head:"));

 				for (j = 0; j < TBMResult::KHeadSize; j += 4)

 					{

 					test.Printf(_L(" %d %d %d %d "), 

 								TInt(results[i].iHead[j]), TInt(results[i].iHead[j+1]), 

 								TInt(results[i].iHead[j+2]), TInt(results[i].iHead[j+3]));

 					}

 				test.Printf(_L("\n"));

 				BM_ASSERT((TBMResult::KTailSize % 4) == 0);

 				test.Printf(_L("Tail:"));

 				for (j = 0; j < TBMResult::KTailSize; j += 4)

 					{

 					test.Printf(_L(" %d %d %d %d "), 

 								TInt(results[i].iTail[j]), TInt(results[i].iTail[j+1]), 

 								TInt(results[i].iTail[j+2]), TInt(results[i].iTail[j+3]));

 					}

 				test.Printf(_L("\n"));

 				}

 			else

 				{

 				test.Printf(_L("%S. %d iterations; Avr: %dns\n"), 

 							&results[i].iName, TInt(results[i].iIterations), TInt(results[i].iAverage));

 				}

 			}

 		//

 		// Sanity check for open handles

 		//

 		TInt end_thc, end_phc;

 		RThread().HandleCount(end_phc, end_thc);

 		BM_ASSERT(start_thc == end_thc);

 		BM_ASSERT(start_phc == end_phc);

 			// and also for pending requests ...

 		BM_ASSERT(RThread().RequestCount() == 0);

 		prog = prog->Next();

 //

 //		This can be used to run forever ...

 //

 //		if (prog == NULL)

 //			prog = ::bmSuite;

 //

 	}

 	test.End();

 	::bmDriver.Close();

 	::bmTimer.Close();

 	return 0;

 	}

 void bm_assert_failed(char* aCond, char* aFile, TInt aLine)

 	{

 	TPtrC8 fd((TUint8*)aFile);

 	TPtrC8 cd((TUint8*)aCond);

 	HBufC* fhb = HBufC::NewMax(fd.Length());

 	test(fhb != 0);

 	HBufC* chb = HBufC::NewMax(cd.Length());

 	test(chb != 0);

 	fhb->Des().Copy(fd);

 	chb->Des().Copy(cd);

 	test.Printf(_L("Assertion %S failed;  File: %S; Line %d;\n"), chb, fhb, aLine);

 	test(0);

 	}

 void bm_error_detected(TInt aError, char* aCond, char* aFile, TInt aLine)

 	{

 	TPtrC8 fd((TUint8*)aFile);

 	TPtrC8 cd((TUint8*)aCond);

 	HBufC* fhb = HBufC::NewMax(fd.Length());

 	test(fhb != 0);

 	HBufC* chb = HBufC::NewMax(cd.Length());

 	test(chb != 0);

 	fhb->Des().Copy(fd);

 	chb->Des().Copy(cd);

 	test.Printf(_L("Error: %d; Cond: %S; File: %S; Line %d;\n"), aError, chb, fhb, aLine);

 	test(0);

 	}