// 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 "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 TRandom

 	{

 public:

 	TRandom();

 	TUint32 Next();

 private:

 	enum

 		{

 		KA = 1664525,

 		KB = 1013904223

 		};

 	TUint32 iV;

 	};

 TRandom::TRandom()

 	{

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

 	}

 TUint32 TRandom::Next()

 	{

 	iV = KA * iV + KB;

 	return iV;

 	}

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

 	}

 enum TWorkload

 	{

 	EWorkloadSequential,

 	EWorkloadRandom,

 	EWorkloadShuffle

 	};

 struct SThrashTestArgs

 	{

 	TInt iThreadGroup;

 	TInt iGroupSize;

 	TWorkload iWorkload;

 	TUint8* iBasePtr;

 	volatile TInt iPageCount;

 	volatile TInt64 iAccesses;

 	};

 TInt ThrashTestFunc(TAny* aArg)

 	{

 	SThrashTestArgs* args = (SThrashTestArgs*)aArg;

 	TRandom random;

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

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

 	switch (args->iWorkload)

 		{

 		case EWorkloadSequential:

 			while (gRunThrashTest)

 				{

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

 				for (TInt i = 0 ; i < size && gRunThrashTest ; ++i)

 					{

 					ptr[i] = random.Next();

 					__e32_atomic_add_ord64(&args->iAccesses, 1);

 					}

 				}

 			break;

 		case EWorkloadRandom:

 			{

 			TInt acc = 0;

 			while (gRunThrashTest)

 				{

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

 				for (TInt i = 0 ; i < size && gRunThrashTest ; ++i)

 					{

 					TUint32 rand = random.Next();

 					TInt action = rand >> 31;

 					TInt r = rand % size;

 					if (action == 0)

 						acc += ptr[r];

 					else

 						ptr[r] = acc;

 					__e32_atomic_add_ord64(&args->iAccesses, 1);

 					}

 				}

 			}

 			break;

 		case EWorkloadShuffle:

 			{

 			TInt i;

 			while (gRunThrashTest)

 				{

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

 				for (i = 0 ; gRunThrashTest && i < (size - 1) ; ++i)

 					{

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

 					__e32_atomic_add_ord64(&args->iAccesses, 2);

 					}

 				}

 			}

 			break;

 		default:

 			test(EFalse);

 		}

 	return KErrNone;;

 	}

 struct SThrashThreadData

 	{

 	RThread iThread;

 	TRequestStatus iStatus;

 	SThrashTestArgs iArgs;

 	};

 void ThrashTest(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

 	{

 	RDebug::Printf("\nPages Accesses     ThL");

 	DPTest::FlushCache();

 	User::After(1000000);

 	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;

 	TInt pageCount = aBeginPages;

 	const TInt maxSteps = 30;

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

 	TInt i;

 	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

 			{

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

 				threads[i].iArgs.iPageCount = pageCount;

 			}

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

 			__e32_atomic_store_ord64(&threads[i].iArgs.iAccesses, 0);

 		User::After(2000000);		

 		TInt thrashLevel = UserSvr::HalFunction(EHalGroupVM, EVMHalGetThrashLevel, 0, 0);

 		test(thrashLevel >= 0 && thrashLevel <= 255);

 		TInt64 totalAccesses = 0;

 		TInt totalPages = 0;

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

 			{

 			totalAccesses += __e32_atomic_load_acq64(&threads[i].iArgs.iAccesses);

 			if (aSharedData)

 				totalPages = Max(totalPages, threads[i].iArgs.iPageCount);

 			else

 				totalPages += threads[i].iArgs.iPageCount;

 			}

 		test.Printf(_L("%5d %12ld %3d"), totalPages, totalAccesses, thrashLevel);

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

 			{

 			test.Printf(_L(" %5d %12ld"),

 						threads[i].iArgs.iPageCount,

 						__e32_atomic_load_acq64(&threads[i].iArgs.iAccesses));

 			test_Equal(KRequestPending, threads[i].iStatus.Int());

 			}

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

 		if (aEndPages >= aBeginPages ? pageCount >= aEndPages : pageCount < aEndPages)

 			break;

 		pageCount += step;

 		}

 	gRunThrashTest = EFalse;

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

 		{

 		SThrashThreadData& thread = threads[i];

 		User::WaitForRequest(thread.iStatus);

 		test_Equal(EExitKill, thread.iThread.ExitType());

 		test_KErrNone(thread.iStatus.Int());

 		thread.iThread.Close();

 		}

 	gChunk.Close();	

 	RDebug::Printf("\n");

 	}

 void TestThrashing()

 	{

 	TInt minPages = (3 * gMaxCacheSize) / 4 - 4;

 	TInt maxPages = (5 * gMaxCacheSize) / 4;

 	TInt minPages2 = (3 * gMaxCacheSize) / 8 - 4;

 	TInt maxPages2 = (5 * gMaxCacheSize) / 8;

 	TInt minPages4 = (3 * gMaxCacheSize) / 16 - 4;

 	TInt maxPages4 = (5 * gMaxCacheSize) / 16;

 	// Single thread increasing in size

 	test.Next(_L("Thrash test: single thread, sequential workload"));

 	ThrashTest(1, ETrue, EWorkloadSequential, minPages, maxPages, 0);

 	test.Next(_L("Thrash test: single thread, random workload"));

 	ThrashTest(1, ETrue, EWorkloadRandom, minPages, maxPages, 0);

 	test.Next(_L("Thrash test: single thread, shuffle workload"));

 	ThrashTest(1, ETrue, EWorkloadShuffle, minPages, maxPages, 0);

 	// Multiple threads with shared data, one thread incresing in size

 	test.Next(_L("Thrash test: two threads with shared data, one thread increasing, random workload"));

 	ThrashTest(2, ETrue, EWorkloadRandom, minPages, maxPages, minPages);

 	test.Next(_L("Thrash test: four threads with shared data, one thread increasing, random workload"));

 	ThrashTest(4, ETrue, EWorkloadRandom, minPages, maxPages, minPages);

 	// Multiple threads with shared data, all threads incresing in size

 	test.Next(_L("Thrash test: two threads with shared data, all threads increasing, random workload"));

 	ThrashTest(2, ETrue, EWorkloadRandom, minPages, maxPages, 0);

 	test.Next(_L("Thrash test: four threads with shared data, all threads increasing, random workload"));

 	ThrashTest(4, ETrue, EWorkloadRandom, minPages, maxPages, 0);

 	// Multiple threads with independent data, one thread incresing in size

 	test.Next(_L("Thrash test: two threads with independent data, one thread increasing, random workload"));

 	ThrashTest(2, EFalse, EWorkloadRandom, minPages2, maxPages2, gMaxCacheSize / 2);

 	test.Next(_L("Thrash test: four threads with independent data, one thread increasing, random workload"));

 	ThrashTest(4, EFalse, EWorkloadRandom, minPages4, maxPages4, gMaxCacheSize / 4);

 	// Multiple threads with independant data, all threads incresing in size

 	test.Next(_L("Thrash test: two threads with independent data, all threads increasing, random workload"));

 	ThrashTest(2, EFalse, EWorkloadRandom, minPages2, maxPages2, 0);

 	test.Next(_L("Thrash test: four threads with independent data, all threads increasing, random workload"));

 	ThrashTest(4, EFalse, EWorkloadRandom, minPages4, maxPages4, 0);

 	// Attempt to create thrash state where there is sufficient cache

 	test.Next(_L("Thrash test: two threads with independent data, one threads decreasing, random workload"));

 	TInt halfCacheSize = gMaxCacheSize / 2;

 	ThrashTest(2, EFalse, EWorkloadRandom, halfCacheSize + 10, halfCacheSize - 30, halfCacheSize);

 	}

 void TestThrashHal()

 	{			 

 	test.Next(_L("Test EVMHalSetThrashThresholds"));

 	test_Equal(KErrArgument, UserSvr::HalFunction(EHalGroupVM, EVMHalSetThrashThresholds, (TAny*)256, 0));

 	test_Equal(KErrArgument, UserSvr::HalFunction(EHalGroupVM, EVMHalSetThrashThresholds, (TAny*)0, (TAny*)1));

 	test_KErrNone(UserSvr::HalFunction(EHalGroupVM, EVMHalSetThrashThresholds, 0, 0));

 	test_KErrNone(UserSvr::HalFunction(EHalGroupVM, EVMHalSetThrashThresholds, (TAny*)255, 0));

 	test_KErrNone(UserSvr::HalFunction(EHalGroupVM, EVMHalSetThrashThresholds, (TAny*)200, (TAny*)150));

 	test.Next(_L("Test EVMHalGetThrashLevel"));

 	User::After(2000000);

 	TInt r = UserSvr::HalFunction(EHalGroupVM, EVMHalGetThrashLevel, 0, 0);

 	test(r >= 0 && r <= 255);

 	test.Printf(_L("Thrash level == %d\n"), r);

 	test(r <= 10);  // should indicate lightly loaded system

 	if (!gDataPagingSupported)

 		return;  // rest of this test relies on data paging

 	// set up thrashing notification

 	RChangeNotifier notifier;

 	test_KErrNone(notifier.Create());

 	TRequestStatus status;

 	test_KErrNone(notifier.Logon(status));

 	test_KErrNone(notifier.Logon(status));  // first logon completes immediately

 	test_Equal(KRequestPending, status.Int());

 	// stress system and check thrash level and notification

 	ThrashTest(1, ETrue, EWorkloadRandom, gMaxCacheSize * 2, gMaxCacheSize * 2 + 5, 0);

 	r = UserSvr::HalFunction(EHalGroupVM, EVMHalGetThrashLevel, 0, 0);

 	test(r >= 0 && r <= 255);

 	test.Printf(_L("Thrash level == %d\n"), r);

 	test(r > 200);  // should indicate thrashing

 	test_Equal(EChangesThrashLevel, status.Int());

 	User::WaitForAnyRequest();

 	// wait for system to calm down and check notification again

 	test_KErrNone(notifier.Logon(status));

 	User::WaitForAnyRequest();

 	test_Equal(EChangesThreadDeath, status.Int());

 	test_KErrNone(notifier.Logon(status));

 	User::After(2000000);

 	r = UserSvr::HalFunction(EHalGroupVM, EVMHalGetThrashLevel, 0, 0);

 	test(r >= 0 && r <= 255);

 	test.Printf(_L("Thrash level == %d\n"), r);

 	test(r <= 10);  // should indicate lightly loaded system

 	test_Equal(EChangesThrashLevel, status.Int());	

 	User::WaitForAnyRequest();

 	}

 void TestThrashHalNotSupported()

 	{

 	test_Equal(KErrNotSupported, UserSvr::HalFunction(EHalGroupVM, EVMHalGetThrashLevel, 0, 0));

 	test_Equal(KErrNotSupported, UserSvr::HalFunction(EHalGroupVM, EVMHalSetThrashThresholds, 0, 0));

 	}

 TInt E32Main()

 	{

 	test.Title();

 	test.Start(_L("Test thrashing monitor"));

 	test_KErrNone(GetGlobalPolicies());

 	TUint cacheOriginalMin = 0;

 	TUint cacheOriginalMax = 0;

 	TUint cacheCurrentSize = 0;

 	if (gDataPagingSupported)

 		{

 		test.Next(_L("Thrash test: change maximum cache size to minimal"));

 		//store original values

 		DPTest::CacheSize(cacheOriginalMin, cacheOriginalMax, cacheCurrentSize);

 		gMaxCacheSize = 256;

 		gMinCacheSize = 64;

 		test_KErrNone(DPTest::SetCacheSize(gMinCacheSize * gPageSize, gMaxCacheSize * gPageSize));

 		}

 	TBool flexibleMemoryModel = (MemModelAttributes() & EMemModelTypeMask) == EMemModelTypeFlexible;

 	if (flexibleMemoryModel)

 		TestThrashHal();

 	else

 		TestThrashHalNotSupported();

 	if (gDataPagingSupported && User::CommandLineLength() > 0)

 		{		

 		test.Next(_L("Extended thrashing tests"));

 		TestThrashing();

 		}

 	if (gDataPagingSupported)

 		{

 		//Reset the cache size to normal

 		test.Next(_L("Thrash test: Reset cache size to normal"));

 		test_KErrNone(DPTest::SetCacheSize(cacheOriginalMin, cacheOriginalMax));

 		}

 	test.End();

 	return 0;

 	}