// Copyright (c) 2008-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\demandpaging\t_thrash.cpp

// todo: test combinations of rom / code / data paging

//

#define __E32TEST_EXTENSION__

#include <e32test.h>

#include <dptest.h>

#include <e32hal.h>

#include <u32hal.h>

#include <u32exec.h>

#include <e32svr.h>

#include <e32panic.h>

#include "u32std.h"

#include <e32msgqueue.h>

#include <e32atomics.h>

#include <e32math.h>

#include <hal.h>

#include "t_dpcmn.h"

#include "../mmu/mmudetect.h"

#include "../mmu/d_memorytest.h"

#include "../mmu/t_codepaging_dll.h"

RTest test(_L("T_THRASH"));

volatile TBool gRunThrashTest = EFalse;

_LIT(KChunkName, "t_thrash chunk");

class TPRNG 

	{

public:

	TPRNG();

	TUint32 IntRand();

	TReal FloatRand();

private:

	enum

		{

		KA = 1664525,

		KB = 1013904223

		};

	TUint32 iV;

	};

TPRNG::TPRNG()

	{

	iV = (TUint32)this + RThread().Id() + User::FastCounter() + 23;

	}

TUint32 TPRNG::IntRand()

	{

	iV = KA * iV + KB;

	return iV;

	}

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;	

	}

void CreatePagedChunk(TInt aSizeInPages)

	{

	test_Equal(0,gChunk.Handle());

	TChunkCreateInfo createInfo;

	TInt size = aSizeInPages * gPageSize;

	createInfo.SetNormal(size, size);

	createInfo.SetPaging(TChunkCreateInfo::EPaged);

	createInfo.SetOwner(EOwnerProcess);

	createInfo.SetGlobal(KChunkName);

	test_KErrNone(gChunk.Create(createInfo));

	test(gChunk.IsPaged()); // this is only ever called if data paging is supported

	}

TUint32* PageBasePtr(TInt aPage)

	{

	return (TUint32*)(gChunk.Base() + (gPageSize * aPage));

	}

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();

		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);

	}

enum TWorkload

	{

	EWorkloadSequential,

	EWorkloadUniformRandom,

	EWorkloadNormalRandom1,

	EWorkloadNormalRandom2,

	EWorkloadShuffle,

	EMaxWorkloads

	};

struct SThrashTestArgs

	{

	TInt iThreadGroup;

	TInt iGroupSize;

	TWorkload iWorkload;

	TUint8* iBasePtr;

	volatile TInt iPageCount;

	volatile TInt64 iAccesses;

	};

TInt ThrashTestFunc(TAny* aArg)

	{

	SThrashTestArgs* args = (SThrashTestArgs*)aArg;

	TPRNG random;

	TUniformRandom uniformRand;

	TNormalRandom normalRand;

	TInt startPage = args->iThreadGroup * args->iGroupSize;

	TInt* ptr = (TInt*)(args->iBasePtr + startPage * gPageSize);

	switch (args->iWorkload)

		{

		case EWorkloadSequential:

			while (gRunThrashTest)

				{

				for (TUint i = 0 ;

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

					 ++i)

					{

					ptr[i] = 1;

					__e32_atomic_add_ord64(&args->iAccesses, 1);

					}

				}

			break;

		case EWorkloadUniformRandom:

		case EWorkloadNormalRandom1:

		case EWorkloadNormalRandom2:

			{

			TInt acc = 0;

			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;

				}

			while (gRunThrashTest)

				{

				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);

				}

			}

			break;

		case EWorkloadShuffle:

			{

			TInt i = 0;

			while (gRunThrashTest)

				{

				TInt size = (args->iPageCount * gPageSize) / sizeof(TInt);

				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;

				}

			}

			break;

		default:

			test(EFalse);

		}

	return KErrNone;;

	}

struct SThrashThreadData

	{

	RThread iThread;

	TRequestStatus iStatus;

	SThrashTestArgs iArgs;

	};

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

				TInt aThreads,			// number of threads to run

				TBool aSharedData,		// whether all threads share the same data

				TWorkload aWorkload,

				TInt aBeginPages,		// number of pages to start with for last/all threads

				TInt aEndPages,			// number of pages to end with for last/all threads

				TInt aOtherPages)		// num of pages for other threads, or zero to use same value for all

	{

	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 pagesNeeded;

	TInt maxPages = Max(aBeginPages, aEndPages);

	TInt groupSize = 0;

	if (aSharedData)

		pagesNeeded = Max(maxPages, aOtherPages);

	else

		{

		if (aOtherPages)

			{

			groupSize = aOtherPages;

			pagesNeeded = (aThreads - 1) * aOtherPages + maxPages;

			}

		else

			{

			groupSize = maxPages;

			pagesNeeded = aThreads * maxPages;

			}

		}

	CreatePagedChunk(pagesNeeded);

	SThrashThreadData* threads = new SThrashThreadData[aThreads];

	test_NotNull(threads);

	gRunThrashTest = ETrue;

	const TInt maxSteps = 30;

	TInt step = aEndPages >= aBeginPages ? Max((aEndPages - aBeginPages) / maxSteps, 1) : Min((aEndPages - aBeginPages) / maxSteps, -1);

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

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

		{

		SThrashThreadData& thread = threads[i];

		thread.iArgs.iThreadGroup = aSharedData ? 0 : i;

		thread.iArgs.iGroupSize = groupSize;

		thread.iArgs.iWorkload = aWorkload;

		thread.iArgs.iBasePtr = gChunk.Base();

		if (aOtherPages)

			thread.iArgs.iPageCount = (i == aThreads - 1) ? pageCount : aOtherPages;

		else

			thread.iArgs.iPageCount = pageCount;

		test_KErrNone(thread.iThread.Create(KNullDesC, ThrashTestFunc, gPageSize, NULL, &thread.iArgs));

		thread.iThread.Logon(thread.iStatus);

		thread.iThread.SetPriority(EPriorityLess);

		threads[i].iThread.Resume();

		}

	for (;;)

		{

		if (aOtherPages)

			threads[aThreads - 1].iArgs.iPageCount = pageCount;

		else

			{