// 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\loader\t_pageldrtst.cpp

// Demand Paging Loader Stress Tests

// Demand Paging Loader stress tests attempt to cause as much paging as possible

// whilst putting the system various types of load.

// t_pageldrtst.exe is the root of the tests, it in turn will start copies of 

// itself stored in various types of media (t_pageldrtst_rom.exe for example).

// It also loads DLLs from various media, each DLL containing simple functions 

// that are aligned on page boundaries, so each function call is likely to 

// cause a page fault.

// Usage:

// t_pageldrtst and t_pageldrtst_rom

// Common command lines:

// t_pageldrtst - run the auto test suite

// t_pageldrtst lowmem - run the low memory tests

// t_pageldrtst chunks - run the chunk tests

// t_pageldrtst chunks+ - run the chunk tests (same as used in autotest)

// t_pageldrtst echunks - run the really stressful chunk tests

// t_pageldrtst auto debug - run the autotest but with debug output to the serial port

// t_pageldrtst d_exc - run the d_exc tests

// Arguments:

// single - run the tests in a single thread

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

// auto - dummy param to trick the tests into running the auto test suite with extra params

// fullauto - param to make the tests perform the full automatic stress test

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

// mmc - only use the mmc media for media access to test file caching

// min - min cache size in pages

// max - max cache size in pages

// chunks - simple chunk stress tests

// chunks+ - the chunk auto tests

// echunks - extremem chunks tests

// nochunkdata - don't check the integrity of the data in the chunks

// lowmem - low memory tests

// dll - only load dll's

// exe - only start exe's (t_pagestress)

// self - only start copies of self (t_pageldrtst from various media)

// complete - dll, exe and self.

// rom - only load from ROM

// base - only load the base DLL and exe's (from code)

// mixed - rom and base.

// all_media - load dlls and exes from all media

// debug - switch on debugging information

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

// noclean - don't delete copied files on exit

// d_exc - run the d_exc tests

// global - load dlls once globally

// thread - load dlls once per thread

// func - load dlls in the test function (default and most stressful)

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

// reaper - test the reaper.

// btrace - test the btrace code.

// defrag - test the ram defrag code.

// stressfree - set the page cache to stress free size and run tests.

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

// functions from multiple DLLs which include 64 functions which have 

// been aligned on page boundaries from multiple threads, whilst causing 

// background paging by spawning copies of itself and t_pagestress.

// The test also endeavours to stress the loader by loading and unloading

// DLLs from multiple threads from various types of media at the same 

// time as stressing the media, testing chunks, the reaper and changing

// thread priorities.

// 002 Load thrashing, test rapid loading and unloading of DLLs from 

// multiple threads (DEF100158)

// 003 Multiple threads loading DLLs in random pattern

// 004 Multiple threads loading EXE, SELF and DLLs in random pattern with

// all media, loaded in thread with prio change

// 005 Multiple threads loading EXE, SELF and DLLs in random pattern with

// all media, loaded globally with prio change

// 006 Multiple threads loading EXE, SELF and DLLs in random pattern with

// all media, loaded in func with process interleaving

// 007 Multiple threads loading EXE, SELF and DLLs in random pattern with

// all media, loaded in func with process interleaving, prio change

// and media access

// 008 Low Memory setup test

// 009 Low Memory, Multiple threads loading EXE, SELF and DLLs in random 

// pattern, loaded in func.

// 010 Low Memory setup test

// 011 Low Memory, Multiple threads loading EXE, SELF and DLLs in random 

// pattern, loaded in func with process interleaving, 

// prio change and media access

// 012 Close test driver

// 013 Chunk tests, Multiple threads loading EXE, SELF and DLLs in random 

// pattern with ROM / ROFS media, loaded in func with prio change 

// 014 Reaper tests with Multiple threads loading EXE, SELF and DLLs in random 

// pattern with all media 

// 015 Reaper tests with Multiple threads loading EXE, SELF and DLLs in random 

// pattern with all media, prio change and process interleaving

// 016 d_exc check test

// 

//

//! @SYMTestCaseID			KBASE-T_PAGELDRTST-0326

//! @SYMTestType			UT

//! @SYMPREQ				PREQ1110

//! @SYMTestCaseDesc		Demand Paging Loader Stress Tests

//! @SYMTestActions			001 Demand Paging loader stress tests...

//! @SYMTestExpectedResults All tests should pass.

//! @SYMTestPriority        High

//! @SYMTestStatus          Implemented

#include <e32test.h>

#include <e32rom.h>

#include <e32svr.h>

#include <u32hal.h>

#include <f32file.h>

#include <f32dbg.h>

#include <e32msgqueue.h>

#include <e32math.h>

#include <e32btrace.h>

#include <d32btrace.h>

#include <d32locd.h>

#include <hal.h>

#include "t_hash.h"

#include "paging_info.h"

#ifndef TEST_AUTOTEST

#define TEST_RUN_REAPERTEST

#define TEST_RUN_LOWMEMTEST

#define TEST_RUN_DEFRAGTEST

#define TEST_RUN_D_EXCTEST

#define TEST_RUN_CHUNKTEST

#define TEST_RUN_AUTOTEST

RTest test(_L("T_PAGELDRTST"));

#else

#ifdef TEST_RUN_REAPERTEST

RTest test(_L("T_PAGELDRTST_REAPER"));

#endif

#ifdef TEST_RUN_LOWMEMTEST

RTest test(_L("T_PAGELDRTST_LOWMEM"));

#endif

#ifdef TEST_RUN_DEFRAGTEST

RTest test(_L("T_PAGELDRTST_DEFRAG"));

#endif

#ifdef TEST_RUN_D_EXCTEST

RTest test(_L("T_PAGELDRTST_D_EXC"));

#endif

#ifdef TEST_RUN_CHUNKTEST

RTest test(_L("T_PAGELDRTST_CHUNK"));

#endif

#ifdef TEST_RUN_AUTOTEST

RTest test(_L("T_PAGELDRTST_AUTO"));

#endif

#endif //TEST_AUTOTEST

const TInt KMessageBufSize = 80;

typedef TBuf<KMessageBufSize> TMessageBuf;

//#define TEST_SHORT_TEST

//#define TEST_THRASHING_TEST

//#define TEST_ADD_FAT_MEDIA

#define TEST_DONT_RESET_STATS

#define TEST_MINIMAL_STATS

//#define TEST_KERN_HEAP

#define TEST_ADD_FRAGD_MEDIA

#ifdef TEST_ADD_FRAGD_MEDIA

#endif

#if defined(_DEBUG) || defined(_DEBUG_RELEASE)

//#define WANT_FS_CACHE_STATS 

#endif

#ifdef __X86__

#define TEST_ON_UNPAGED

#define TEST_NO_DEXC_IN_AUTO

#endif

#include "t_pagestress.h"

#include "t_pageldrtstdll.h"

#include "t_ramstress.h"

TBool		TestDebug					= EFalse;

TBool		TestSilent					= EFalse;

TBool		TestExit					= EFalse;

#define TEST_EXE			0x01

#define TEST_DLL			0x02

#define TEST_SELF			0x04

#define TEST_EXE_SELF		(TEST_EXE | TEST_SELF)

#define TEST_EXE_SELF_DLL	(TEST_EXE | TEST_SELF | TEST_DLL)

TInt		TestLoading				    = TEST_EXE_SELF_DLL;

#define TEST_MEDIA_BASE			(1 << KTestMediaBase)

#define TEST_MEDIA_ROM			(1 << KTestMediaRom)

#define TEST_MEDIA_ROFS			(1 << KTestMediaRofs)

#define TEST_MEDIA_EXT			(1 << KTestMediaExt)

#define TEST_MEDIA_FAT			(1 << KTestMediaFat)

#define TEST_MEDIA_MMC			(1 << KTestMediaMmc)

#define TEST_MEDIA_ROM_BASE		(TEST_MEDIA_ROM | TEST_MEDIA_BASE)

#define TEST_MEDIA_ALL		(TEST_MEDIA_ROM | TEST_MEDIA_BASE | TEST_MEDIA_ROFS | TEST_MEDIA_EXT | TEST_MEDIA_MMC)

typedef enum

{

	KTestMediaBase = 0,

	KTestMediaRom,

	KTestMediaExt,

	KTestMediaRofs,

#ifdef TEST_ADD_FAT_MEDIA

	KTestMediaFat,  // this is the last one that is always present.

#endif

	KTestMediaMmc,

#ifdef TEST_ADD_FRAGD_MEDIA

	KTestMediaNandFrag,

	KTestMediaMmcFrag,

#endif

	KTestMediaCOUNT,

}ETestMediaType;

#ifdef TEST_ADD_FAT_MEDIA

#define TEST_MEDIA_COUNT_HACK   (KTestMediaFat + 1)

#else

#define TEST_MEDIA_COUNT_HACK   (KTestMediaRofs + 1)

#endif

typedef enum

{

	KTestMediaAccessNone = 0,

	KTestMediaAccessBasic,

	KTestMediaAccessMultipleThreads,

	KTestMediaAccessMultiplePattern,

	KTestMediaAccessMixed,

	KTestMediaAccessCOUNT,

}ETestMediaAccess;

TInt		TestWhichMedia			    = TEST_MEDIA_ROM_BASE;

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

TBool		TestSingle					= EFalse;

TBool		TestMultiple				= EFalse;

TInt		TestMaxLoops				= 20;

#define TEST_2MEDIA_THREADS		20

#define TEST_ALLMEDIA_THREADS	20

TInt		TestMultipleThreadCount		= TEST_2MEDIA_THREADS;

TInt		TestInstanceId				= 0;

TBool		TestWeAreTheTestBase        = EFalse;

TBool		TestBootedFromMmc			= EFalse;

TBool		TestOnlyFromMmc				= EFalse;

TBool		TestD_Exc					= EFalse;

TBool		TestNoClean					= EFalse;

TBool		TestFullAutoTest			= EFalse;

#define TEST_DLL_GLOBAL		0x01

#define TEST_DLL_THREAD		0x02

#define TEST_DLL_FUNC		0x04

TInt		TestLoadDllHow				= TEST_DLL_FUNC;

TBool		TestIsAutomated				= EFalse;

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

TBool		TestInterleave				= EFalse;

TFileName	TestNameBuffer;

TBool		TestPrioChange				= EFalse;

volatile TBool		TestStopMedia				= EFalse;

ETestMediaAccess TestMediaAccess        = KTestMediaAccessNone;

#define TEST_NUM_FILES		5

RSemaphore	TestMultiSem;

RMsgQueue<TMessageBuf> TestMsgQueue;

#define TEST_LM_NUM_FREE	0

#define TEST_LM_BLOCKSIZE	1

#define TEST_LM_BLOCKS_FREE	4

TBool		TestLowMem					= EFalse;

TBool		TestingLowMem				= EFalse;

RPageStressTestLdd PagestressLdd;

RRamStressTestLdd  RamstressLdd;

TBool		TestBtrace					= EFalse;

TBool		TestDefrag					= EFalse;

TBool		TestChunks					= EFalse;

TBool		TestChunksPlus				= EFalse;

TBool		TestExtremeChunks			= EFalse;

TBool		TestChunkData				= ETrue;

TBool		TestingChunks				= EFalse;

volatile TBool		TestDefragTestEnd			= EFalse;

TBool		TestingDefrag				= EFalse;

volatile TBool		TestThreadsExit				= EFalse;

TInt		TestPageSize				= 4096;

RChunk		TestChunk;

TInt		TestCommitEnd = 0;

TUint8*		TestChunkBase = NULL;

#define TEST_NUM_PAGES			64

#define TEST_NUM_CHUNK_PAGES	(TEST_NUM_PAGES * 2)

TBool		TestChunkPageState[TEST_NUM_CHUNK_PAGES];

TBool		TestReaper					= EFalse;

TBool		TestingReaper				= EFalse;

TBool		TestingReaperCleaningFiles  = EFalse;

#define TEST_REAPER_ITERS			20

#define TEST_DOT_PERIOD				30

TBool		TestStressFree				= EFalse;

TInt		TestMinCacheSize = 64 * 4096;

TInt		TestMaxCacheSize = 128 * 4096;

TBool		TestIsDemandPaged = ETrue;

#define TEST_MAX_ZONE_THREADS		8

TUint		TestZoneCount = 0;

TInt TickPeriod = 15625;

#define TEST_NONE		0x0

#define TEST_THRASH		0x1

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

_LIT(KRomPath, "z:\\sys\\bin\\");

_LIT(KMmcDefaultPath, "d:\\sys\\bin\\");

#define EXISTS(__val) ((__val == KErrNone) ? &KFileExists : &KFileMissing)

_LIT(KSysHash,"?:\\Sys\\Hash\\");

_LIT(KTestBlank, "");

_LIT(KFileExists, "Exists");

_LIT(KFileMissing, "Missing");

_LIT(KMultipleTest, "Multiple");

_LIT(KSingleTest,   "Single  ");

_LIT(KTestExe, "Exe ");

_LIT(KTestDll, "Dll ");

_LIT(KTestSelf, "Self ");

_LIT(KTestBase, "Base ");

_LIT(KTestRom, "ROM ");

_LIT(KTestAll, "All ");

_LIT(KTestGlobal, "Global");

_LIT(KTestThread, "Thread");

_LIT(KTestFunc,  "Func");

_LIT(KTestInter, "Interleave ");

_LIT(KTestPrio, "Prio ");

_LIT(KTestMedia, "Media ");

_LIT(KTestLowMem, "LowMem ");

_LIT(KTestChunking, "Chunks ");

_LIT(KTestEChunking, "EChunks ");

_LIT(KTestChunkingPlus, "Chunks+ ");

_LIT(KTestReaper, "Reaper ");

_LIT(KTestThrash, "Thrash ");

_LIT(KTestForward, "Forward ");

_LIT(KTestBackward, "Backward ");

_LIT(KTestRandom, "Random ");

typedef struct 

	{

	TBool				testFullAutoOnly;

	TInt				testLoading;

	TInt				testWhichMedia;

	TBool				testMultiple;

	TInt				testMaxLoops;

	TInt				testMultipleThreadCount;

	TBool				testLoadDllHow;

	TBool				testInterleave;

	TBool				testPrioChange;

	ETestMediaAccess	testMediaAccess;

	TUint32				testWhichTests;

	TBool				testLowMem;

	TInt				testFreeRam;

	}TTheTests; 

typedef struct

	{

	TInt	ok;

	TInt	fail;

	}TChunkTestPair;

typedef struct

	{

	TChunkTestPair	lock;

	TChunkTestPair	unlock;

	TChunkTestPair	decommit;

	TChunkTestPair	commit;

	TChunkTestPair	check;

	}

TChunkTestStats;

TChunkTestStats	TestChunkStats[TEST_NUM_CHUNK_PAGES];

TPtrC TestPsExeNames[KTestMediaCOUNT] = {	_L("t_pagestress.exe"), 

											_L("t_pagestress_rom.exe"), 

											_L("t_pagestress_ext.exe"), 

											_L("t_pagestress_rofs.exe"), 

#ifdef TEST_ADD_FAT_MEDIA

											_L("t_pagestress_fat.exe"),

#endif

											_L("t_pagestress_mmc.exe"),

#ifdef TEST_ADD_FRAGD_MEDIA

											_L("t_pagestress_nfr.exe"),

											_L("t_pagestress_mfr.exe"),

#endif

											};

TPtrC TestPlExeNames[KTestMediaCOUNT] = {	_L("t_pageldrtst.exe"), 

											_L("t_pageldrtst_rom.exe"), 

											_L("t_pageldrtst_ext.exe"), 

											_L("t_pageldrtst_rofs.exe"), 

#ifdef TEST_ADD_FAT_MEDIA

											_L("t_pageldrtst_fat.exe"),

#endif

											_L("t_pageldrtst_mmc.exe"),

#ifdef TEST_ADD_FRAGD_MEDIA

											_L("t_pageldrtst_nfr.exe"),

											_L("t_pageldrtst_mfr.exe"),

#endif

											};

_LIT(KDllBaseName,   "t_pageldrtst");

TPtrC TestPlExtNames[KTestMediaCOUNT] = {	_L(".dll"),

											_L("_rom.dll"),

											_L("_ext.dll"),

											_L("_rofs.dll"),

#ifdef TEST_ADD_FAT_MEDIA

											_L("_fat.dll"),

#endif

											_L("_mmc.dll"),

#ifdef TEST_ADD_FRAGD_MEDIA

											_L("_nfr.dll"),

											_L("_mfr.dll"),

#endif

											};

TBool TestDllExesExist[KTestMediaCOUNT] = { EFalse, 

											EFalse,

											EFalse,

											EFalse,

#ifdef TEST_ADD_FAT_MEDIA

											EFalse,

#endif

											EFalse,

#ifdef TEST_ADD_FRAGD_MEDIA

											EFalse,

											EFalse,

#endif

											};

#define DBGS_PRINT(__args)\

	if (!TestSilent) test.Printf __args;

#define DBGD_PRINT(__args)\

	if (TestDebug) test.Printf __args;

void SendDebugMessage(RMsgQueue<TMessageBuf> *aMsgQueue = NULL, 

					  TMessageBuf            *aBuffer = NULL,

					  RSemaphore	 		 *aTheSem = NULL)

	{

	for (;;)

		{

		aTheSem->Wait();

		TInt r = aMsgQueue->Send(*aBuffer);

		aTheSem->Signal();

		if (r != KErrOverflow)

			return;

		User::After(0);

		}

	}

#define DEBUG_PRINT(__args)\

if (!TestSilent) \

	{\

	if (aMsgQueue && aBuffer && aTheSem)\

		{\

		aBuffer->Zero();\

		aBuffer->Format __args ;\

		SendDebugMessage(aMsgQueue, aBuffer, aTheSem);\

		}\

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

	}

#define DOTEST(__operation, __condition)\

	if (aLowMem) \

		{\

		__operation;\

		while (!__condition)\

			{\

			DBGD_PRINT((_L("Releasing some memory on line %d\n"), __LINE__));\

			if (pTheSem)\

				pTheSem->Wait();\

			PagestressLdd.DoReleaseSomeRam(TEST_LM_BLOCKS_FREE);\

			if (pTheSem)\

				pTheSem->Signal();\

			__operation;\

			}\

		RUNTEST1(__condition);\

		}\

	else\

		{\

		__operation;\

		RUNTEST1(__condition);\

		}

#define DOTEST1(__var, __func, __ok, __fail)\

	if (aLowMem) \

		{\

		__var = __func;\