#include <hal.h>

class TPRNG 

	TPRNG();

	TUint32 IntRand();

	TReal FloatRand();

TPRNG::TPRNG()

TUint32 TPRNG::IntRand()

TReal TPRNG::FloatRand()

	{

	return (TReal)IntRand() / KMaxTUint32;

	}

class TRandom

	{

public:

	virtual ~TRandom() { }

	virtual TUint32 Next() = 0;

	};

 class TUniformRandom : public TRandom

	{

public:

	void SetParams(TUint aMax) { iMax = aMax; }

	virtual TUint32 Next();

private:

	TPRNG iRand;

	TUint iMax;

	};

TUint32 TUniformRandom::Next()

	{

	return iRand.IntRand() % iMax;

	}

class TNormalRandom : public TRandom

	{

public:

	void SetParams(TInt aMax, TInt aSd);

	virtual TUint32 Next();

private:

	TUint32 GetNext();

private:

	TPRNG iRand;

	TInt iMax;

	TInt iExpectation;

	TInt iSd;

	TUint32 iCached;

	};

void TNormalRandom::SetParams(TInt aMax, TInt aSd)

	{

	iMax = aMax;

	iExpectation = aMax / 2;

	iSd = aSd;

	iCached = KMaxTUint32;

	}

TUint32 TNormalRandom::Next()

	{

	TUint32 r;

	do

		{

		r = GetNext();

		}

	while (r > (TUint)iMax);

	return r;

	}

TUint32 TNormalRandom::GetNext()

	{

	if (iCached != KMaxTUint32)

		{

		TUint32 r = iCached;

		iCached = KMaxTUint32;

		return r;

		}

	// box-muller transform

	// from http://www.taygeta.com/random/gaussian.html

	TReal x1, x2, w, ln_w, y1, y2;

	do

		{

		x1 = 2.0 * iRand.FloatRand() - 1.0;

		x2 = 2.0 * iRand.FloatRand() - 1.0;

		w = x1 * x1 + x2 * x2;

		}

	while ( w >= 1.0 );

	TInt r = Math::Ln(ln_w, w);

	__ASSERT_ALWAYS(r == KErrNone, User::Invariant());

	w = (-2.0 * ln_w ) / w;

	TReal w2;

	r = Math::Sqrt(w2, w);

	__ASSERT_ALWAYS(r == KErrNone, User::Invariant());

	y1 = x1 * w2;

	y2 = x2 * w2;

	y1 = y1 * iSd + iExpectation;

	y2 = y2 * iSd + iExpectation;

	iCached = (TUint32)y2;

	return (TUint32)y1;

	}

static TBool BenchmarksSupported = EFalse;

static TReal BenchmarkMultiplier;

static TInt InitBenchmarks()

	{

	BenchmarksSupported = UserSvr::HalFunction(EHalGroupVM, EVMHalResetPagingBenchmark, (TAny*)EPagingBmReadRomPage, NULL) == KErrNone;

	if (!BenchmarksSupported)

		return KErrNone;

	TInt freq = 0;

	TInt r = HAL::Get(HAL::EFastCounterFrequency, freq);

	if (r != KErrNone)

		return r;

	BenchmarkMultiplier = 1000000.0 / freq;

	return KErrNone;

	}

static void ResetBenchmarks()

	{

	if (!BenchmarksSupported)

		return;	

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

		{

		TInt r = UserSvr::HalFunction(EHalGroupVM, EVMHalResetPagingBenchmark, (TAny*)i, NULL);

		if (r != KErrNone)

			test.Printf(_L("Error resetting benchmark %d\n"), i);

		test_KErrNone(r);

		}

	}

static TInt GetBenchmark(TPagingBenchmark aBenchmark, TInt& aCountOut, TInt& aTotalTimeInMicrosOut)

	{

	SPagingBenchmarkInfo info;

	TInt r = UserSvr::HalFunction(EHalGroupVM, EVMHalGetPagingBenchmark, (TAny*)aBenchmark, &info);

	if (r!=KErrNone)

		return r;

	aCountOut = info.iCount;

	aTotalTimeInMicrosOut = (TInt)(info.iTotalTime * BenchmarkMultiplier);

	return KErrNone;

	}

static TInt GetAllBenchmarks(TInt aTestLengthInSeconds, TInt aCountOut[EMaxPagingBm], TInt aTimeOut[EMaxPagingBm])

	{

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

		{

		TInt count = 0;

		TInt timeInMicros = 0;

		TInt r = GetBenchmark((TPagingBenchmark)i, count, timeInMicros);

		if (r != KErrNone)

			return r;

		aCountOut[i] = count / aTestLengthInSeconds;

		aTimeOut[i] = timeInMicros / aTestLengthInSeconds;

		}

	return KErrNone;	

	}

TInt EnsureSystemIdleThread(TAny*)

	{

	RThread::Rendezvous(KErrNone);

	for (;;)

		{

		// Spin

		}

	}

void EnsureSystemIdle()

	{

	const TInt KMaxWait = 60 * 1000000;

	const TInt KSampleTime = 1 * 1000000;

	const TInt KWaitTime = 5 * 1000000;

	test.Printf(_L("Waiting for system to become idle\n"));

	TInt totalTime = 0;

	TBool idle;

	do

		{	

		RThread thread;

		test_KErrNone(thread.Create(_L("EnsureSystemIdleThread"), EnsureSystemIdleThread, 1024, NULL, NULL));		

		thread.SetPriority(EPriorityLess);

		thread.Resume();

		TRequestStatus status;

		thread.Rendezvous(status);

		User::WaitForRequest(status);

		test_KErrNone(status.Int());

		User::After(KSampleTime);

		thread.Suspend();

		TTimeIntervalMicroSeconds time;

		test_KErrNone(thread.GetCpuTime(time));

		TReal error = (100.0 * Abs(time.Int64() - KSampleTime)) / KSampleTime;

		test.Printf(_L("    time == %ld, error == %f%%\n"), time.Int64(), error);

		idle = error < 2.0;		

		thread.Kill(KErrNone);

		thread.Logon(status);

		User::WaitForRequest(status);

		test_KErrNone(status.Int());

		CLOSE_AND_WAIT(thread);

		if (!idle)

			User::After(KWaitTime);		// Allow system to finish whatever it's doing

		totalTime += KSampleTime + KWaitTime;

		test(totalTime < KMaxWait);

		}

	while(!idle);

	}

	EWorkloadUniformRandom,

	EWorkloadNormalRandom1,

	EWorkloadNormalRandom2,

	EWorkloadShuffle,

	EMaxWorkloads

	TPRNG random;

	TUniformRandom uniformRand;

	TNormalRandom normalRand;

				for (TUint i = 0 ;

					 gRunThrashTest && i < (args->iPageCount * gPageSize) / sizeof(TInt)  ;

					 ++i)

					ptr[i] = 1;

		case EWorkloadUniformRandom:

		case EWorkloadNormalRandom1:

		case EWorkloadNormalRandom2:

			TInt oldSize = -1;

			TUint32 writeMask = 0;

			switch (args->iWorkload)

				{

				case EWorkloadUniformRandom:

				case EWorkloadNormalRandom1:

					writeMask = 0x80000000; break;

				case EWorkloadNormalRandom2:

					writeMask = 0xc0000000; break;

				default: test(EFalse); break;

				}

				TInt size = args->iPageCount;

				if (size != oldSize)

					switch (args->iWorkload)

						{

						case EWorkloadUniformRandom:

							uniformRand.SetParams(size); break;

						case EWorkloadNormalRandom1:

						case EWorkloadNormalRandom2:

							normalRand.SetParams(size, size / 8); break;

						default: test(EFalse); break;

						}

					oldSize = size;

				TInt page = args->iWorkload == EWorkloadUniformRandom ?

					uniformRand.Next() : normalRand.Next();

				TInt index = page * (gPageSize / sizeof(TInt));

				TBool write = (random.IntRand() & writeMask) == 0;

				if (write)

					ptr[index] = acc;

				else

					acc += ptr[index];

				__e32_atomic_add_ord64(&args->iAccesses, 1);

			TInt i = 0;

				Mem::Swap(&ptr[i], &ptr[i + random.IntRand() % (size - i - 1) + 1], sizeof(TInt));

				__e32_atomic_add_ord64(&args->iAccesses, 2);

				++i;

				if (i >= size - 1)

					i = 0;

void ThrashTest(const TDesC& aTestName,	// name and description

				TInt aThreads,			// number of threads to run

	const TInt KTestLengthInSeconds = 2;

	test.Next(_L("Thrash test"));

	DPTest::FlushCache();

	EnsureSystemIdle();

	TInt i;

	test.Printf(_L("Table: %S\n"), &aTestName);

	test.Printf(_L("totalPages, totalAccesses, thrashLevel"));

	if (BenchmarksSupported)

		test.Printf(_L(", rejuveCount, rejuveTime, codePageInCount, codePageInTime, initCount, initTime, readCount, readTime, writePages, writeCount, writeTime"));

	if (aThreads > 1)

		{

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

			test.Printf(_L(", Thread%dPages, Thread%dAccesses"), i, i);

		}

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

	TInt pageCount = aBeginPages - 5 * step; // first run ignored