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

 // e32test\misc\cpumeter.cpp

 // 

 //

 #define __E32TEST_EXTENSION__

 #include <e32test.h>

 #include <e32hal.h>

 #include <e32svr.h>

 #include "u32std.h"

 RTest test(_L("CPU METER"));

 TBool CpuTimeSupported()

 	{

 	TTimeIntervalMicroSeconds time;

 	TInt err = RThread().GetCpuTime(time);

 	test(err == KErrNone || err == KErrNotSupported);

 	return err == KErrNone;

 	}

 TInt NumberOfCpus()

 	{

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

 	test(r>0);

 	return r;

 	}

 class CCpuMeter : public CBase

 	{

 public:

 	CCpuMeter();

 	~CCpuMeter();

 	static CCpuMeter* New();

 	TInt Construct();

 	void Measure();

 	void Display(TInt aInterval);

 public:

 	TInt iNumCpus;

 	TInt iNextMeas;

 	RThread* iNullThreads;

 	TTimeIntervalMicroSeconds* iMeas[2];

 	TInt* iDelta;

 	};

 CCpuMeter::CCpuMeter()

 	{

 	}

 CCpuMeter::~CCpuMeter()

 	{

 	TInt i;

 	if (iNullThreads)

 		{

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

 			iNullThreads[i].Close();

 		User::Free(iNullThreads);

 		}

 	User::Free(iMeas[0]);

 	User::Free(iMeas[1]);

 	User::Free(iDelta);

 	}

 TInt CCpuMeter::Construct()

 	{

 	iNumCpus = NumberOfCpus();

 	iNullThreads = (RThread*)User::AllocZ(iNumCpus*sizeof(RThread));

 	iDelta = (TInt*)User::AllocZ(iNumCpus*sizeof(TInt));

 	iMeas[0] = (TTimeIntervalMicroSeconds*)User::AllocZ(iNumCpus*sizeof(TTimeIntervalMicroSeconds));

 	iMeas[1] = (TTimeIntervalMicroSeconds*)User::AllocZ(iNumCpus*sizeof(TTimeIntervalMicroSeconds));

 	if (!iNullThreads || !iDelta || !iMeas[0] || !iMeas[1])

 		return KErrNoMemory;

 	TFullName kname;

 	_LIT(KLitKernelName, "ekern.exe*");

 	_LIT(KLitNull, "::Null");

 	TFindProcess fp(KLitKernelName);

 	test_KErrNone(fp.Next(kname));

 	test.Printf(_L("Found kernel process: %S\n"), &kname);

 	kname.Append(KLitNull);

 	TInt i;

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

 		{

 		TFullName tname(kname);

 		TFullName tname2;

 		if (i>0)

 			tname.AppendNum(i);

 		TFindThread ft(tname);

 		test_KErrNone(ft.Next(tname2));

 		TInt r = iNullThreads[i].Open(ft);

 		test_KErrNone(r);

 		iNullThreads[i].FullName(tname2);

 		test.Printf(_L("Found and opened %S\n"), &tname2);

 		}

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

 		iNullThreads[i].GetCpuTime(iMeas[0][i]);

 	iNextMeas = 1;

 	return KErrNone;

 	}

 CCpuMeter* CCpuMeter::New()

 	{

 	CCpuMeter* p = new CCpuMeter;

 	if (!p)

 		return 0;

 	TInt r = p->Construct();

 	if (r!=KErrNone)

 		{

 		delete p;

 		return 0;

 		}

 	return p;

 	}

 void CCpuMeter::Measure()

 	{

 	TInt i;

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

 		iNullThreads[i].GetCpuTime(iMeas[iNextMeas][i]);

 	TInt prev = 1 - iNextMeas;

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

 		iDelta[i] = TInt(iMeas[iNextMeas][i].Int64() - iMeas[prev][i].Int64());

 	iNextMeas = prev;

 	}

 void CCpuMeter::Display(TInt aInterval)

 	{

 	TBuf<80> buf;

 	TInt i;

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

 		{

 		TInt dv = (1000*(aInterval - iDelta[i]))/aInterval;

 		if (dv<0)

 			dv=0;

 		if (dv>1000)

 			dv=1000;

 		buf.AppendFormat(_L(" %4d"),dv);

 		}

 	buf.Append(TChar('\n'));

 	test.Printf(buf);

 	}

 void UseKernelCpuTime()

 	{

 	test.Start(_L("Create CCpuMeter"));

 	CCpuMeter* m = CCpuMeter::New();

 	test_NotNull(m);

 	TInt iv = 1000500;	// on average 1000.5 ms

 	TRequestStatus s;

 	CConsoleBase* console = test.Console();

 	console->Read(s);

 	FOREVER

 		{

 		User::AfterHighRes(1000000);

 		m->Measure();

 		m->Display(iv);

 		while (s!=KRequestPending)

 			{

 			User::WaitForRequest(s);

 			TKeyCode k = console->KeyCode();

 			if (k == EKeyEscape)

 				{

 				delete m;

 				return;

 				}

 			console->Read(s);

 			}

 		}

 	}

 TUint32 NopCount=0;

 TUint MaxCycles;

 _LIT(KLitThreadName,"IdleThread");

 extern TInt CountNops(TAny*);

 void MeasureByNOPs()

 	{

 	test.Start(_L("Create thread"));

 	RThread t;

 	TInt r=t.Create(KLitThreadName,CountNops,0x1000,NULL,NULL);

 	test(r==KErrNone);

 	t.SetPriority(EPriorityAbsoluteVeryLow);

 	t.Resume();

 	test.Next(_L("Get processor clock frequency"));

 	TMachineInfoV2Buf buf;

 	TMachineInfoV2& info=buf();

 	r=UserHal::MachineInfo(buf);

 	test(r==KErrNone);

 	MaxCycles=info.iProcessorClockInKHz*1000;

 	test.Printf(_L("Clock frequency %dHz\n"),MaxCycles);

 	TRequestStatus s;

 	CConsoleBase* console=test.Console();

 	console->Read(s);

 #ifdef __WINS__

 	TInt timerperiod = 5;

 	UserSvr::HalFunction(EHalGroupEmulator,EEmulatorHalIntProperty,(TAny*)"TimerResolution",&timerperiod);

 #endif

 	FOREVER

 		{

 		TUint32 init_count=NopCount;

 		TUint32 init_ms=User::NTickCount();

 		User::After(1000000);

 		TUint32 final_count=NopCount;

 		TUint32 final_ms=User::NTickCount();

 		TUint32 cycles=final_count-init_count;

 		TUint32 ms=final_ms-init_ms;

 #ifdef __WINS__

 		ms*=timerperiod;

 #endif

 		while (s!=KRequestPending)

 			{

 			User::WaitForRequest(s);

 			TKeyCode k=console->KeyCode();

 			if (k==EKeyTab)

 				{

 				// calibrate

 				TInt64 inst64 = MAKE_TINT64(0, cycles);

 				inst64*=1000;

 				inst64/=MAKE_TINT64(0,ms);

 				MaxCycles=I64LOW(inst64);

 				test.Printf(_L("NOPs per second %u\n"),MaxCycles);

 				}

 			else if (k==EKeyEscape)

 				return;

 			console->Read(s);

 			}

 		TInt64 used64=MAKE_TINT64(0, MaxCycles);

 		used64-=MAKE_TINT64(0,cycles);

 		used64*=1000000;

 		used64/=MAKE_TINT64(0,ms);

 		used64/=MAKE_TINT64(0, MaxCycles);

 		test.Printf(_L("%4d\n"),I64INT(used64));

 		}

 	}

 GLDEF_C TInt E32Main()

 	{

 	test.SetLogged(EFalse);

 	test.Title();

 	RThread().SetPriority(EPriorityAbsoluteHigh);

 	if (CpuTimeSupported())

 		{

 		UseKernelCpuTime();

 		}

 	if (NumberOfCpus()>1)

 		{

 		test.Printf(_L("Needs RThread::GetCpuTime() on SMP systems\n"));

 		}

 	else

 		MeasureByNOPs();

 	return 0;

 	}