// Copyright (c) 2006-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:

// f32test\demandpaging\t_pagestress.cpp

// Demand Paging Stress Tests

// t_pagestress.exe basically attempts to cause large ammounts of paging by calling

// functions (256) which are alligned on a page boundary from multiple threads.

// There are mulitple versions of t_pagestress installed on a test system to test rom

// and code paging from various media types.

// Usage:

// t_pagestress and t_pagestress_rom

// Common command lines:

// t_pagestress lowmem

// debug - switch on debugging information

// silent - no output to the screen or serial port

// check - check the allignments

// single - run the tests in a single thread

// multiple <numThreads> - run the tests in multiple threads where <numThreads>

// interleave - force thread interleaving

// prio - each thread reschedules in between each function call, causes lots of context changes

// media - perform media access during the tests, very stressful

// lowmem - low memory tests

// forward - patern in which to execute function calls 

// backward - patern in which to execute function calls 			

// random - patern in which to execute function calls 			

// all - patern in which to execute function calls (forward, backward and random)

// inst - for debugging a parameter passed to a spawned exe to give it an id.

// iters <count> - the number of times to loop (a '-' means run forever)

// t_pagestress causes a large ammount of paging by repeatedly calling 

// 256 functions which have been aligned on page boundaries from 

// multiple threads.

// 1  - a single thread calling all functions

// 2  - Multiple threads calling all functions

// 3  - Multiple threads calling all functions with a priority change 

// after each function call

// 4  - Multiple threads calling all functions with background 

// media activity

// 5  - Multiple threads calling all functions with media activity and 

// a priority change after each function call

// 6  - Multiple threads calling all functions with process interleave

// 7  - Multiple threads calling all functions with process interleave 

// and a priority change after each function call

// 8  - Multiple threads calling all functions with process interleave 

// media acess and a priority change after each function call

// 9  - Multiple threads calling all functions with low available memory

// 10 - Multiple threads calling all functions with low available memory,

// starting with initial free ram.

// 

//

//! @SYMTestCaseID			KBASE-T_PAGESTRESS-0327

//! @SYMTestType			UT

//! @SYMPREQ				PREQ1110

//! @SYMTestCaseDesc		Demand Paging Stress Tests

//! @SYMTestActions			0  - Check the alignment of all functions

//! @SYMTestExpectedResults All tests should pass.

//! @SYMTestPriority        High

//! @SYMTestStatus          Implemented

#include <e32test.h>

RTest test(_L("T_PAGESTRESS"));

#include <e32rom.h>

#include <e32svr.h>

#include <u32hal.h>

#include <f32file.h>

#include <f32dbg.h>

#include <e32msgqueue.h>

#include <e32math.h>

#include "testdefs.h"

#ifdef __X86__

#define TEST_ON_UNPAGED

#endif

/* The following line will cause t_pagestress.h to declare an array of function

 * pointers to  page boundary aligned functions that we can use in this test...

 */

#define TPS_DECLARE_ARRAY

#include "t_pagestress.h"

TBool   	TestDebug					= EFalse;

TBool		TestSilent					= EFalse;

TBool		TestExit					= EFalse;

TBool   	TestCheck					= EFalse;

TBool   	TestSingle					= EFalse;

TBool   	TestMultiple				= EFalse;

TBool   	TestForever					= EFalse;

TInt		TestMaxLoops				= 20;

TInt		TestMultipleThreadCount		= 50;

TInt		TestInstanceId				= 0;

#define TEST_INTERLEAVE_PRIO		EPriorityMore//EPriorityRealTime //23 // KNandThreadPriority - 1

TBool		TestInterleave				= EFalse;

TBool		TestWeAreTheTestBase		= EFalse;

TBool		TestBootedFromMmc			= EFalse;

TInt		DriveNumber=-1;   // Parameter - Which drive?  -1 = autodetect.

#define TEST_NONE		0x0

#define TEST_FORWARD	0x2

#define TEST_BACKWARD	0x4

#define TEST_RANDOM		0x8

#define TEST_ALL		(TEST_RANDOM | TEST_BACKWARD | TEST_FORWARD)

TUint32		TestWhichTests				= TEST_ALL;

TBuf<32>	TestNameBuffer;

TBool		TestPrioChange				= ETrue;

TBool		TestStopMedia				= EFalse;

TBool		TestMediaAccess				= EFalse;

#define TEST_LM_NUM_FREE	0

#define TEST_LM_BLOCKSIZE	1

#define TEST_LM_BLOCKS_FREE	4

TBool		TestLowMem					= EFalse;

RPageStressTestLdd Ldd;

TInt		TestPageSize				= 4096;

RSemaphore	TestMultiSem;

RMsgQueue<TBuf <64> >	TestMsgQueue;

TBool		TestIsDemandPaged = ETrue;

#define TEST_NEXT(__args) \

	if (!TestSilent)\

		test.Next __args;

#define DBGS_PRINT(__args)\

	if (!TestSilent)\

		test.Printf __args ;

#define DBGD_PRINT(__args)\

	if (TestDebug)\

		test.Printf __args ;\

#define DEBUG_PRINT(__args)\

if (!TestSilent)\

	{\

	if (aMsgQueue && aBuffer && aTheSem)\

		{\

		aBuffer->Zero();\

		aBuffer->Format __args ;\

		aTheSem->Wait();\

		aMsgQueue->SendBlocking(*aBuffer);\

		aTheSem->Signal();\

		}\

	else\

		{\

		test.Printf __args ;\

		}\

	}

#define RUNTEST(__test, __error)\

	if (!TestSilent)\

		test(__test == __error);\

	else\

		__test;

#define RUNTEST1(__test)\

	if (!TestSilent)\

		test(__test);

#define DEBUG_PRINT1(__args)\

if (TestDebug)\

	{\

	DEBUG_PRINT(__args)\

	}

//

// CheckAlignments

//

// The following functions wanders through the function pointer array

// declared in t_pagestress.h and ensures that the alignment has worked, 

// (a good start!) and then calls each of the functions in turn to 

// ensure that they work, simple first sanity check test.

//

TInt CheckAlignments()

	{

	// now it's time to play with the array of function pointers...

	TInt  seed = 1;

	TUint32 index = 0;

	TInt ret = KErrNone;

	while (index < (PAGESTRESS_FUNC_COUNT - 1))

		{

		DBGD_PRINT((_L("\nAddress (%u) 0x%x difference to next %u\n"), index, (TUint32)PagestressFuncPtrs[index], (TUint32)PagestressFuncPtrs[index + 1] - (TUint32)PagestressFuncPtrs[index]));	

		if ((((TUint32)PagestressFuncPtrs[index + 1] - (TUint32)PagestressFuncPtrs[0]) % 4096) != 0)

			{

			DBGS_PRINT((_L("\nError! Allignment for %u is not offset of 4096 from index 0 0x%x 0x%x\n"), index, (TUint32)PagestressFuncPtrs[index + 1], (TUint32)PagestressFuncPtrs[0]));	

			ret = KErrGeneral;

			}

		//seed = PagestressFuncPtrs[index](seed, index);

		seed = CallTestFunc(seed, index, index);

		index ++;

		}

	return ret;

	}

//

// RunThreadForward

//

// Walk through the function pointer array (forwards) calling each function

//

void RunThreadForward()

	{

	TInt	seed = 1;

	TUint32 index = 0;

	RThread thisThread;

	while (index < PAGESTRESS_FUNC_COUNT)

		{

		if (TestPrioChange)

			{

			TThreadPriority originalThreadPriority = thisThread.Priority();

			thisThread.SetPriority(EPriorityLess);

			User::AfterHighRes(0);

			thisThread.SetPriority(originalThreadPriority);

			}

		//seed = PagestressFuncPtrs[index](seed, index);

		seed = CallTestFunc(seed, index, index);

		index ++;

		}

	}

//

// RunThreadBackward

//

// Walk through the function pointer array (backwards) calling each function

//

void RunThreadBackward()

	{

	TInt	seed = 1;

	TInt	index = PAGESTRESS_FUNC_COUNT;

	RThread thisThread;

	while (index > 0)

		{

		if (TestPrioChange)

			{

			TThreadPriority originalThreadPriority = thisThread.Priority();

			thisThread.SetPriority(EPriorityLess);

			User::AfterHighRes(0);

			thisThread.SetPriority(originalThreadPriority);

			}

		index --;

		//seed = PagestressFuncPtrs[index](seed, index);

		seed = CallTestFunc(seed, index, index);

		}

	}

//

// RunThreadRandom

//

// Walk through the function pointer array in a random order a number of times calling each function

//

void RunThreadRandom()

	{

	TInt	seed = 1;

	TInt	index = 0;

	TInt	randNum;

	RThread thisThread;

	while (index < (TInt)PAGESTRESS_FUNC_COUNT)

		{

		if (TestPrioChange)

			{

			TThreadPriority originalThreadPriority = thisThread.Priority();

			thisThread.SetPriority(EPriorityLess);

			User::AfterHighRes(0);

			thisThread.SetPriority(originalThreadPriority);

			}

		randNum = Math::Random();

		randNum %= PAGESTRESS_FUNC_COUNT;

		//seed = PagestressFuncPtrs[randNum](seed, randNum);

		seed = CallTestFunc(seed, randNum, randNum);

		index ++;

		}

	}

//

// PerformTestThread

//

// This is the function that actually does the work.

// It is complicated a little because test.Printf can only be called from the first thread that calls it 

// so if we are using multiple threads we need to use a message queue to pass the debug info from the

// child threads back to the parent for the parent to then call printf.

//

//

LOCAL_C void PerformTestThread(TInt					  aThreadIndex, 

							   RMsgQueue<TBuf <64> > *aMsgQueue = NULL, 

							   TBuf<64>				 *aBuffer = NULL,

							   RSemaphore			 *aTheSem = NULL)

	{

	TUint start = User::TickCount();

	DEBUG_PRINT1((_L("%S : thread Starting %d\n"), &TestNameBuffer, aThreadIndex));

	// now select how we do the test...

	TInt	iterIndex;

	if (TEST_ALL == (TestWhichTests & TEST_ALL))

		{

		#define LOCAL_ORDER_INDEX1	6

		#define LOCAL_ORDER_INDEX2	3

		TInt	order[LOCAL_ORDER_INDEX1][LOCAL_ORDER_INDEX2] = {	{TEST_FORWARD, TEST_BACKWARD,TEST_RANDOM},

																	{TEST_FORWARD, TEST_RANDOM,  TEST_BACKWARD},

																	{TEST_BACKWARD,TEST_FORWARD, TEST_RANDOM},

																	{TEST_BACKWARD,TEST_RANDOM,  TEST_FORWARD},

																	{TEST_RANDOM,  TEST_FORWARD, TEST_BACKWARD},

																	{TEST_RANDOM,  TEST_BACKWARD,TEST_FORWARD}};

		TInt	whichOrder = 0;

		for (iterIndex = 0; iterIndex < TestMaxLoops; iterIndex ++)

			{

			TInt    selOrder = ((aThreadIndex + 1) * (iterIndex + 1)) % LOCAL_ORDER_INDEX1;

			for (whichOrder = 0; whichOrder < LOCAL_ORDER_INDEX2; whichOrder ++)

				{

				switch (order[selOrder][whichOrder])

					{

						case TEST_FORWARD:

						DEBUG_PRINT1((_L("%S : %d Iter %d Forward\n"), &TestNameBuffer, aThreadIndex, iterIndex));

						RunThreadForward();

						break;

						case TEST_BACKWARD:

						DEBUG_PRINT1((_L("%S : %d Iter %d Backward\n"), &TestNameBuffer, aThreadIndex, iterIndex));

						RunThreadBackward();

						break;

						case TEST_RANDOM:

						DEBUG_PRINT1((_L("%S : %d Iter %d Random\n"), &TestNameBuffer, aThreadIndex, iterIndex));

						RunThreadRandom();

						break;

						default: // this is really an error.

						break;

					}

				}

			}

		}

	else

		{

		if (TestWhichTests & TEST_FORWARD)

			{

			for (iterIndex = 0; iterIndex < TestMaxLoops; iterIndex ++)

				{

				DEBUG_PRINT1((_L("%S : %d Iter %d Forward\n"), &TestNameBuffer, aThreadIndex, iterIndex));

				RunThreadForward();

				}

			}

		if (TestWhichTests & TEST_BACKWARD)

			{

			for (iterIndex = 0; iterIndex < TestMaxLoops; iterIndex ++)

				{

				DEBUG_PRINT1((_L("%S : %d Iter %d Backward\n"), &TestNameBuffer, aThreadIndex, iterIndex));

				RunThreadBackward();

				}

			}

		if (TestWhichTests & TEST_RANDOM)

			{

			for (iterIndex = 0; iterIndex < TestMaxLoops; iterIndex ++)

				{

				DEBUG_PRINT1((_L("%S : %d Iter %d Random\n"), &TestNameBuffer, aThreadIndex, iterIndex));

				RunThreadRandom();

				}

			}

		}

	DEBUG_PRINT1((_L("%S : thread Exiting %d (tickcount %u)\n"), &TestNameBuffer, aThreadIndex, User::TickCount() - start));

	}

//

// MultipleTestThread

//

// Thread function, one created for each thread in a multiple thread test.

//

LOCAL_C TInt MultipleTestThread(TAny* aUseTb)

	{

	TBuf<64>					localBuffer;

	if (TestInterleave)	

		{

		RThread				thisThread;

		thisThread.SetPriority((TThreadPriority) TEST_INTERLEAVE_PRIO);

		}

	PerformTestThread((TInt) aUseTb, &TestMsgQueue, &localBuffer, &TestMultiSem);

	return KErrNone;

	}

//

// DoSingleTest

// 

// Perform the single thread test, spawning a number of threads.

//

LOCAL_C void DoSingleTest()

	{

	PerformTestThread((TInt) TestInstanceId);

	}

//

// FindDriveNumber

// 

// Find the first read write drive.

//

TInt FindDriveNumber(RFs fs)

	{

	TDriveInfo driveInfo;

	for (TInt drvNum=0; drvNum<KMaxDrives; ++drvNum)

		{

		TInt r = fs.Drive(driveInfo, drvNum);

		if (r >= 0)

			{

			if (driveInfo.iType == EMediaHardDisk)

				return (drvNum);

			}

		}

	return -1;

	}

//

// FindFsNANDDrive

//

// Find the NAND drive

//

static TInt FindFsNANDDrive(RFs& aFs)

	{

	TDriveList driveList;

	TDriveInfo driveInfo;

	TInt r=aFs.DriveList(driveList);

    if (r == KErrNone)

		{

		for (TInt drvNum= (DriveNumber<0)?0:DriveNumber; drvNum<KMaxDrives; ++drvNum)

			{

			if(!driveList[drvNum])

				continue;   //-- skip unexisting drive

			if (aFs.Drive(driveInfo, drvNum) == KErrNone)

				{

				if(driveInfo.iMediaAtt&KMediaAttPageable)

					{

					TBool readOnly = driveInfo.iMediaAtt & KMediaAttWriteProtected;		// skip ROFS partitions

					if(!readOnly)

						{

						if ((drvNum==DriveNumber) || (DriveNumber<0))		// only test if running on this drive

							{

							return (drvNum);

							}

						}

					}

				}

			}

		}

	return -1;

	}

//

// FindMMCDriveNumber

// 

// Find the first read write drive.

//

TInt FindMMCDriveNumber(RFs& aFs)

	{

	TDriveInfo driveInfo;

	for (TInt drvNum=0; drvNum<KMaxDrives; ++drvNum)

		{

		TInt r = aFs.Drive(driveInfo, drvNum);

		if (r >= 0)

			{

			if (driveInfo.iType == EMediaHardDisk)

				return (drvNum);

			}

		}

	return -1; 

	}

//

// PerformRomAndFileSystemAccess

// 

// Access the rom and dump it out to one of the writeable partitions...

// really just to make the media server a little busy during the test.

//

TInt PerformRomAndFileSystemAccessThread(RMsgQueue<TBuf <64> > *aMsgQueue = NULL, 

										 TBuf<64>			   *aBuffer = NULL,

										 RSemaphore			   *aTheSem = NULL)

	{

	TUint maxBytes = KMaxTUint;

	TInt startTime = User::TickCount();

	RFs fs;

	RFile file;

	if (KErrNone != fs.Connect())

		{

		DEBUG_PRINT(_L("PerformRomAndFileSystemAccessThread : Can't connect to the FS\n"));

		return KErrGeneral;

		}

	// get info about the ROM...

	TRomHeader* romHeader = (TRomHeader*)UserSvr::RomHeaderAddress();

	TUint8* start;

	TUint8* end;

	if(romHeader->iPageableRomStart)

		{

		start = (TUint8*)romHeader + romHeader->iPageableRomStart;

		end = start + romHeader->iPageableRomSize;