// 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;
	}