// Copyright (c) 2009-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\t_loadsim.cpp

// 

//

//-------------------------------------------------------------------------------------------

//! @SYMTestCaseID				KBASE-t_loadsim-2705

//! @SYMTestCaseDesc			verifying the behaviour of the load balancer

//! @SYMPREQ					417-52765/417-58889

//! @SYMTestPriority			Critical

//! @SYMTestActions				

//! 1. This test runs a variety of loads on an SMP system. Loads types are:

//!    1.1 Cpu intensive loads

//!    1.2 memory intensive loads (high locality)

//!    1.3 memory intensive loads (low locality)

//!    1.4 memory intensive loads with atomic operations

//!    1.5 cpu intensive loads with some serialization

//! 2. For each test, the load is first run on a single cpu locked thread as a baseline

//!    benchmark. Then the tests are run in the following configurations:

//!    2.1 For n = 1 to 2*Number of cpus do a run with i threads.

//!    2.2 For h = 1 to NumCpus ; For n = h to 2*NumCpus; run with h high priorty threads and 

//!         n standard priority threads, with high priority threads cpu locked.

//!    2.3 For h = 1 to NumCpus ; For n = h to 2*NumCpus; run with h high priorty threads and 

//!         n standard priority threads.

//! @SYMTestExpectedResults 

//!     test passed. TTest is manual:

//! 1. For each test we expect to see that the amount of CPU time obtained by each CPU is 

//!     balanced. That is, all standard priority threads get roughly same amount of CPU time

//!     and all high priority threads get roughly same amount of CPU time and a higher value

//!     than lower priority threads.

//! 2. We also expect the relative efficiency reported by the test between the benchmark

//!    and each test run to be >=95% on average. Values well below this are acceptable in 

//!    test runs involving atomic operations (1.4)

//-------------------------------------------------------------------------------------------

#define __E32TEST_EXTENSION__

#include <e32test.h>

#include <e32base.h>

#include <hal.h>

#include <e32atomics.h>

#include <u32hal.h>

#include <e32svr.h>

//#define	TRACE(x)	x

#define	TRACE(x)

void Panic(TInt aLine)

	{

	User::Panic(_L("T_LOADSIM"),aLine);

	}

#define	assert(x)		((void)((x)||(Panic(__LINE__),0)))

RTest test(_L("T_LOADSIM"));

const TInt KErrCouldNotStart = -99;

volatile TInt STFU = 1;

/******************************************************************************

 * Random Number Generation

 ******************************************************************************/

void LFSR(TUint64& a)

	{

	TInt i;

	for (i=64; i>0; --i)

		{

		TUint64 x = a<<1;

		TUint64 y = x<<1;

		x^=y;

		a = (y>>1) | (x>>63);

		}

	}

// Returns 256*log2(a/2^64)

TInt Log2(TUint64 a)

	{

	const TUint64 KBit63 = UI64LIT(0x8000000000000000);

	TInt n = __e32_find_ms1_64(a);

	a <<= (63-n);

	n -= 64;

	TInt i;

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

		{

		a >>= 32;

		a *= a;

		n <<= 1;

		if (a & KBit63)

			{

			++n;

			}

		else

			{

			a <<= 1;

			}

		}

	return n;

	}

TUint32 ExpRV(TUint64 aU, TUint32 aMean, TUint32 aTick)

	{

	TInt n = -Log2(aU);

	TUint64 x = TUint64(n) * TUint64(aMean);

	x *= TUint64(22713);	// 2^15 * ln2

	TUint64 p(aTick);

	p <<= 22;

	x += p;

	p += p;

	x /= p;

	return I64LOW(x);

	}

/******************************************************************************

 * Generic High-Resolution Timing

 ******************************************************************************/

class TTimestamp

	{

public:

	typedef void (*TSampleFunc)(TAny*);

public:

	void Sample();

	void Sample(TSampleFunc aFunc, TAny* aPtr);

	TInt64 operator-(const TTimestamp&) const;

	static void Init();

private:

	TUint32		iF;		// User::FastCounter() value

	TUint32		iN;		// User::NTickCount() value

private:

	static TUint32 FF;	// User::FastCounter() frequency

	static TUint32 NP;	// User::NTickCount() period

	static TBool FU;	// User::FastCounter() counts up

	static TUint32 FWrapM;	// Number of nanokernel ticks for FastCounter() to wrap / 2 * 2^FWrapS

	static TInt FWrapS;	// Shift so that 2^31<=FWrapM<2^32

	};

TUint32	TTimestamp::FF;

TUint32	TTimestamp::NP;

TBool	TTimestamp::FU;

TUint32	TTimestamp::FWrapM;

TInt	TTimestamp::FWrapS;

void TTimestamp::Sample()

	{

	TUint32 n = User::NTickCount();

	do	{

		iN = n;

		iF = User::FastCounter();

		n = User::NTickCount();

		} while (n!=iN);

	}

void TTimestamp::Sample(TSampleFunc aFunc, TAny* aPtr)

	{

	TUint32 n = User::NTickCount();

	do	{

		iN = n;

		(*aFunc)(aPtr);

		iF = User::FastCounter();

		n = User::NTickCount();

		} while (n!=iN);

	}

// return (x*a)/b

TUint64 scale(TUint64 x, TUint32 a, TUint32 b)

	{

	TUint64 mask = KMaxTUint32;

	TUint64 x0 = x & mask;

	TUint64 x1 = x >> 32;

	x0 *= TUint64(a);

	x1 *= TUint64(a);

	x1 += (x0 >> 32);

	x0 &= mask;

	TUint64	q1 = x1 / TUint64(b);

	TUint64 q0 = x1 - q1*TUint64(b);

	q0 <<= 32;

	q0 |= x0;

	q0 /= TUint64(b);

	return (q1<<32)|q0;

	}

// Return difference between a and this in microseconds

TInt64 TTimestamp::operator-(const TTimestamp& a) const

	{

	TInt sign = 1;

	TTimestamp start;

	TTimestamp end;

	if (iN-a.iN >= 0x80000000u)

		{

		sign = -1;

		start = *this;

		end = a;

		}

	else

		{

		start = a;

		end = *this;

		}

	TUint32 fd32 = end.iF - start.iF;

	if (!FU)

		fd32 = ~fd32 + 1u;

	TUint64 nd = TUint64(end.iN) - TUint64(start.iN);

	nd <<= 31;	// 2^31 * difference in NTickCount

	TUint64 x = TUint64(fd32) * TUint64(FWrapM);

	x >>= FWrapS;	// ftick difference * (FWrapM/2^FWrapS) = 2^31 * ntick difference

	nd -= x;	// Should now be a multiple of 2^31N where N=2^32*ftickp/ntickp

				// i.e. should be a multiple of 2^63*ftickp/ntickp

	// FWrapM = 2^(31+FWrapS)*ftickp/ntickp

	// FWrapM << (32-FWrapS) = 2^63*ftickp/ntickp

	TUint64 m = TUint64(FWrapM) << (32-FWrapS);

	nd += (m>>1);

	nd /= m;

	nd = (nd<<32) + TUint64(fd32);	// final result in fast counter ticks

	TInt64 r = scale(nd, 1000000, FF);	// convert to microseconds

	if (sign<0)

		r = -r;

	return r;

	}

void TTimestamp::Init()

	{

	TInt r;

	r = HAL::Get(HAL::ENanoTickPeriod, (TInt&)NP);

	assert(r==KErrNone);

	r = HAL::Get(HAL::EFastCounterFrequency, (TInt&)FF);

	assert(r==KErrNone);

	r = HAL::Get(HAL::EFastCounterCountsUp, (TInt&)FU);

	assert(r==KErrNone);

	TReal fpn = TReal(FF) * TReal(NP) / 1000000.0;	// fast counter ticks per NTick

	TReal fwrap = 2147483648.0 / fpn;	// NTicks between fast counter wraparounds / 2

	TInt exp = 0;

	while (fwrap < 2147483648.0)

		{

		fwrap *= 2.0;

		++exp;

		}

	fwrap += 0.5;

	if (fwrap >= 4294967296.0)

		{

		fwrap *= 0.5;

		--exp;

		}

	FWrapM = (TUint32)fwrap;

	FWrapS = exp;	// NTicks for 2^31 fast ticks = FWrapM/2^FWrapS

	test.Printf(_L("FastCounter frequency  %uHz\n"), FF);

	if (FU)

		test.Printf(_L("FastCounter counts     UP\n"));

	else

		test.Printf(_L("FastCounter counts     DOWN\n"));

	test.Printf(_L("Nanokernel tick period %uus\n"), NP);

	test.Printf(_L("FWrapM                 %08x\n"), FWrapM);

	test.Printf(_L("FWrapS                 %d\n"), FWrapS);

	}

/******************************************************************************

 * CPU Usage Measurement

 ******************************************************************************/

class TThreadCpuUsageSample

	{

public:

	void Sample(RThread aThread);

	TInt64 ElapsedTimeDelta(const TThreadCpuUsageSample& aStart) const;

	TInt64 CpuTimeDelta(const TThreadCpuUsageSample& aStart) const;

private:

	static void SampleThreadCpuTime(TAny* aPtr);

private:

	TTimestamp	iElapsedTime;

	TInt64		iCpuTime;

	RThread		iThread;

	};

void TThreadCpuUsageSample::Sample(RThread aThread)

	{

	iThread = aThread;

	iElapsedTime.Sample(&SampleThreadCpuTime, this);

	}

void TThreadCpuUsageSample::SampleThreadCpuTime(TAny* aPtr)

	{

	TThreadCpuUsageSample& me = *(TThreadCpuUsageSample*)aPtr;

	TTimeIntervalMicroSeconds& rt = *(TTimeIntervalMicroSeconds*)&me.iCpuTime;

	assert(me.iThread.GetCpuTime(rt) == KErrNone);

	}

TInt64 TThreadCpuUsageSample::ElapsedTimeDelta(const TThreadCpuUsageSample& aStart) const

	{

	return iElapsedTime - aStart.iElapsedTime;

	}

TInt64 TThreadCpuUsageSample::CpuTimeDelta(const TThreadCpuUsageSample& aStart) const

	{

	return iCpuTime - aStart.iCpuTime;

	}

class TCpuUsage

	{

public:

	enum {EMaxCpus=8};

public:

	void Sample();

	TInt64 ElapsedTimeDelta(const TCpuUsage& aStart) const;

	TInt64 CpuTimeDelta(const TCpuUsage& aStart, TInt aCpu) const;

	static TInt N() { return NumberOfCpus; }

public:

	static void Init();

private:

	static void SampleIdleTimes(TAny* aPtr);

private:

	TTimestamp	iElapsedTime;

	TInt64		iIdleTime[EMaxCpus];

private:

	static TInt NumberOfCpus;

	static RThread IdleThread[EMaxCpus];

	};

TInt TCpuUsage::NumberOfCpus = -1;

RThread TCpuUsage::IdleThread[TCpuUsage::EMaxCpus];

void TCpuUsage::Init()

	{

	TTimestamp::Init();

	NumberOfCpus = UserSvr::HalFunction(EHalGroupKernel, EKernelHalNumLogicalCpus, 0, 0);

	test.Printf(_L("NumberOfCpus = %d\n"), NumberOfCpus);

	assert(NumberOfCpus > 0);

	assert(NumberOfCpus <= EMaxCpus);

	TTimeIntervalMicroSeconds ms;

	TInt r;

	r = RThread().GetCpuTime(ms);

	if (r != KErrNone)

		{

		test.Printf(_L("RThread::GetCpuTime() returned %d\n"), r);

		test.Printf(_L("This test requires a working RThread::GetCpuTime() to run\n"));

		test(0);

		}

	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<NumberOfCpus; ++i)

		{

		TFullName tname(kname);

		TFullName tname2;

		if (i>0)

			tname.AppendNum(i);

		TFindThread ft(tname);

		test_KErrNone(ft.Next(tname2));

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

		test_KErrNone(r);

		IdleThread[i].FullName(tname2);

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

		}

	}

void TCpuUsage::Sample()

	{

	iElapsedTime.Sample(&SampleIdleTimes, this);

	}

void TCpuUsage::SampleIdleTimes(TAny* aPtr)

	{

	TCpuUsage& me = *(TCpuUsage*)aPtr;

	assert(NumberOfCpus > 0);

	TInt i;

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

		assert(IdleThread[i].GetCpuTime((TTimeIntervalMicroSeconds&)me.iIdleTime[i]) == KErrNone);

	}

TInt64 TCpuUsage::ElapsedTimeDelta(const TCpuUsage& aStart) const

	{

	return iElapsedTime - aStart.iElapsedTime;

	}

TInt64 TCpuUsage::CpuTimeDelta(const TCpuUsage& aStart, TInt aCpu) const

	{

	assert(TUint(aCpu) < TUint(EMaxCpus));

	if (aCpu >= NumberOfCpus)

		return 0;

	TInt64 idle_time = iIdleTime[aCpu] - aStart.iIdleTime[aCpu];

	TInt64 elapsed_time = iElapsedTime - aStart.iElapsedTime;

	return elapsed_time - idle_time;

	}

/******************************************************************************

 * Generic CPU Consumer

 ******************************************************************************/

enum TCpuEaterType

	{

	EEaterStd				=0,		// do CPU-intensive work with few memory references

	EEaterMemoryLocalS		=1,		// do loads of memory references with reasonable locality, shared

	EEaterMemoryNonLocalS	=2,		// do loads of memory references with poor locality, shared

	EEaterMemoryLocalU		=3,		// do loads of memory references with reasonable locality, unshared

	EEaterMemoryNonLocalU	=4,		// do loads of memory references with poor locality, unshared

	EEaterMemoryAtomic		=5,		// do loads of atomic memory references

	EEaterMemoryAtomic2		=6,		// do loads of atomic memory references

	EEaterAmdahl			=7,		// do CPU-intensive work interspersed with serialized sections

	};

class CDefaultCpuEater;

class REaterArray;

class MCpuEater

	{

public:

	MCpuEater();

	virtual ~MCpuEater();

	virtual void Eat(TInt aTime, TUint32* aWorkDone)=0;

	virtual void Calibrate();

	inline TBool IsCalibrated() { return iCalibration!=0; }

protected:

	TUint32 WorkValue(TInt aTime);

	TUint32	iCalibration;	// work value for 2^16 microseconds

	TUint16	iInstance;

	TUint16	iType;

	friend class REaterArray;

	};

MCpuEater::MCpuEater()

	{

	iCalibration = 0;			// uncalibrated

	iInstance = KMaxTUint16;	// dummy value

	iType = KMaxTUint16;		// dummy value

	}

MCpuEater::~MCpuEater()

	{

	}

// Calibration is for 2^KLog2CalibrateTime microseconds

const TInt KLog2CalibrateTime = 13;

TUint32 MCpuEater::WorkValue(TInt aTime)

	{

	if (iCalibration == 0)

		return aTime;

	TUint64 x = TUint64(aTime) * TUint64(iCalibration);

	x >>= (KLog2CalibrateTime + 2);	// Factor of 4 margin for slowdowns

	TUint32 r = I64LOW(x);

	if (I64HIGH(x))

		r = KMaxTUint32;

	if (r == 0)

		return 1;

	if (r > iCalibration)

		return iCalibration;

	return r;

	}

void MCpuEater::Calibrate()

	{

	iCalibration = 0;

	TUint32 work = 1;

	TUint64 used = 1;

	TUint64 threshold = 1;

	threshold <<= KLog2CalibrateTime;

	while (work)

		{

		TThreadCpuUsageSample initial;

		TThreadCpuUsageSample final;

		initial.Sample(RThread());

		Eat(work, 0);

		final.Sample(RThread());

		used = final.CpuTimeDelta(initial);

		if (used >= threshold)

			break;

		work <<= 1;

		}

	assert(work > 0);

	TUint64 c(work);

	c <<= KLog2CalibrateTime;

	c /= used;

	if (I64HIGH(c))

		iCalibration = KMaxTUint32;

	else if (I64LOW(c))

		iCalibration = I64LOW(c);

	else

		iCalibration = 1;

	test.Printf(_L("MCpuEater::Calibrate() %u\n"), iCalibration);

	}

class REaterArray : public RPointerArray<MCpuEater>

	{

public:

	REaterArray();

	void Close();

	MCpuEater* Find(TInt aType, TInt aInstance);

	MCpuEater* FindOrCreateL(TInt aType, TInt aInstance);

private:

	MCpuEater* CreateLC(TInt aType);

private:

	class MDummy : public MCpuEater

		{

	public:

		MDummy(TInt aType, TInt aInstance)

			{ iType=TUint16(aType); iInstance=TUint16(aInstance); }

		virtual ~MDummy()

			{}

		virtual void Eat(TInt, TUint32*)