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

// f32test\demandpaging\t_wdpstress.cpp

// Data Paging Stress Tests

// Common command lines:

// t_wdpstress lowmem

// debug - switch on debugging information

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

// single - run the tests in a single thread

// multiple <numThreads> - run the tests in multiple threads where <numThreads> (max 50 simultaneous threads)

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

// stack - perform autotest only with stack paging tests

// chunk - perform autotest only with chunk paging tests 			

// commit - perform autotest only with committing and decommitting paging tests 

// ipc - perform autotest only with ipc pinning tests 			

// all - perform autotest with all paging tests(ipc, stack, chunk and commit)

// badserver - perform ipc pinning tests with dead server

// iters <count> - the number of times to loop 

// 

//

//! @SYMTestCaseID			KBASE-T_WDPSTRESS-xxx

//! @SYMTestType			UT

//! @SYMPREQ				PREQ1954

//! @SYMTestCaseDesc		Writable Data Paging Stress Tests

//! @SYMTestActions			

//! @SYMTestExpectedResults All tests should pass.

//! @SYMTestPriority        High

//! @SYMTestStatus          Implemented

//----------------------------------------------------------------------------------------------

//

#define __E32TEST_EXTENSION__

#include <e32test.h>

RTest test(_L("T_WDPSTRESS"));

#include <e32rom.h>

#include <u32hal.h>

#include <f32file.h>

#include <f32dbg.h>

#include <e32msgqueue.h>

#include <e32math.h>

#include <dptest.h>

#include <hal.h>

#include "testdefs.h"

#ifdef __X86__

#define TEST_ON_UNPAGED

#endif

#include "t_pagestress.h"

TBool   	TestDebug					= EFalse;

TBool		TestSilent					= EFalse;

TBool		TestExit					= EFalse;

TInt		gPerformTestLoop			= 10;					// Number of times to perform test on a thread

const TUint KMaxTestThreads				= 20;					// The maximum number of threads allowed to run simultaniously

TInt		gNumTestThreads				= KMaxTestThreads;		// The number of threads to run simultaneously

#define TEST_INTERLEAVE_PRIO			EPriorityMore

TBool		TestWeAreTheTestBase		= EFalse;

#define TEST_NONE		0x0

#define TEST_IPC		0x1

#define TEST_STACK		0x2

#define TEST_CHUNK		0x4

#define TEST_COMMIT		0x8

#define TEST_ALL		(TEST_COMMIT | TEST_CHUNK | TEST_STACK | TEST_IPC)

TUint32		gSetTests					= TEST_ALL;

TUint32		gTestWhichTests				= gSetTests;

TBuf<32>	gTestNameBuffer;

TBool		gTestPrioChange				= EFalse;				

TBool		gTestStopMedia				= EFalse;

TBool		gTestMediaAccess			= EFalse;

TBool		gTestInterleave				= EFalse;

TBool		gTestBadServer				= EFalse;

#define TEST_LM_NUM_FREE	0

#define TEST_LM_BLOCKSIZE	1

#define TEST_LM_BLOCKS_FREE	4

RPageStressTestLdd Ldd;

RSemaphore	TestMultiSem;

RMsgQueue<TBuf <64> >	TestMsgQueue;

TBool		gIsDemandPaged			= ETrue;

TBool		gTestRunning				= EFalse;				// To control when to stop flushing

TBool		gMaxChunksReached			= EFalse;				// On moving memory model, the number of chunks per process is capped

TInt		gPageSize;											// The number of bytes per page

TUint		gPageShift;

TUint		gChunksAllocd				= 0;					// The total number of chunks that have been allocated

TUint		gMaxChunks					= 0;					// The max amount of chunks after which KErrOverflow will be returned

RHeap*		gThreadHeap					= NULL;					

RHeap*		gStackHeap					= NULL;

TInt		gTestType					= -1;					// The type of test that is to be performed

#define TEST_NEXT(__args) \

	if (!TestSilent)\

		test.Next __args;

#define RDBGD_PRINT(__args)\

	if (TestDebug)\

	RDebug::Printf __args ;\

#define RDBGS_PRINT(__args)\

	if (!TestSilent)\

	RDebug::Printf __args ;\

#define DEBUG_PRINT(__args)\

if (!TestSilent)\

	{\

	if (aTestArguments.iMsgQueue && aTestArguments.iBuffer && aTestArguments.iTheSem)\

		{\

		aTestArguments.iBuffer->Zero();\

		aTestArguments.iBuffer->Format __args ;\

		aTestArguments.iTheSem->Wait();\

		aTestArguments.iMsgQueue->SendBlocking(*aTestArguments.iBuffer);\

		aTestArguments.iTheSem->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)\

	}

#define DOTEST(__operation, __condition)\

	if (aLowMem) \

		{\

		__operation;\

		while (!__condition)\

			{\

			Ldd.DoReleaseSomeRam(TEST_LM_BLOCKS_FREE);\

			__operation;\

			}\

		RUNTEST1(__condition);\

		}\

	else\

		{\

		__operation;\

		RUNTEST1(__condition);\

		}

#define DOTEST1(__operation, __condition)\

	if (aTestArguments.iLowMem) \

		{\

		__operation;\

		while (!__condition)\

			{\

			Ldd.DoReleaseSomeRam(TEST_LM_BLOCKS_FREE);\

			__operation;\

			}\

		RUNTEST1(__condition);\

		}\

	else\

		{\

		__operation;\

		RUNTEST1(__condition);\

		}

struct SThreadExitResults

	{

	TInt					iExitType;

	TInt					iExitReason;

	};

SThreadExitResults* gResultsArray;

const TInt KExitTypeReset = -1;

struct SPerformTestArgs

	{

	TInt					iThreadIndex;

	RMsgQueue<TBuf <64> >	*iMsgQueue; 

	TBuf<64>				*iBuffer;

	RSemaphore				*iTheSem;

	TBool					iLowMem;

	TInt					iTestType;

	};

TInt DoTest(TInt gTestType, TBool aLowMem = EFalse);

enum

	{

	ETestSingle, 

	ETestMultiple,

	ETestMedia,

	ETestLowMem,

	ETestInterleave,

	ETestCommit, 

	ETestTypes,

	// This is at the moment manual

	ETestBadServer, 

	ETestTypeEnd, 

	};

TInt FreeRam()

	{

	// wait for any async cleanup in the supervisor to finish first...

	UserSvr::HalFunction(EHalGroupKernel, EKernelHalSupervisorBarrier, 0, 0);

	TMemoryInfoV1Buf meminfo;

	TInt r = UserHal::MemoryInfo(meminfo);

	test_KErrNone(r);

	return meminfo().iFreeRamInBytes;

	}

const TUint KStackSize = 20 * 4096;

TUint stackLimit = 150;//*** NEED TO WORK OUT HOW MUCH STACK WE HAVE***

/**

Recursive function

*/

void CallRecFunc(TUint aNum, TInt aThreadIndex)

	{

	RDBGD_PRINT(("ThreadId %d CallRecFunc, aNum = %d\n", aThreadIndex, aNum));

	if (aNum >= stackLimit)

		{// To avoid a stack overflow

		return;

		}

	else

		{

		CallRecFunc(++aNum, aThreadIndex);

		User::After(0);

		}

	RDBGD_PRINT(("ThreadId %d CRF(%d)Returning...", aThreadIndex, aNum));

	return;

	}

/**

Thread that calls a recursive function

*/

TInt ThreadFunc(TAny* aThreadIndex)

	{

	for (TUint i=0; i<1; i++)

		{

		CallRecFunc(0, (TInt)aThreadIndex);

		}

	RDBGD_PRINT(("ThreadId %d ThreadFunc Returning...", (TInt)aThreadIndex));

	return KErrNone;

	}

/**

Thread continuously flushes the paging cache

*/

TInt FlushFunc(TAny* /*aPtr*/)

	{

	RThread().SetPriority(EPriorityMore);

	while(gTestRunning)

		{

		DPTest::FlushCache();	

		User::After((Math::Random()&0xfff)*10);

		}

	return KErrNone;

	}

//

// TestStackPaging

//

// Create a paged thread which calls a recursive function.

// Calls to function will be placed on the stack, which is data paged

//

TInt TestStackPaging(SPerformTestArgs& aTestArguments)

	{

	RDBGD_PRINT(("Creating test thread"));

	TBuf<16> runThreadName;

	runThreadName = _L("");

	TThreadCreateInfo threadCreateInfo(runThreadName, ThreadFunc, KStackSize, (TAny*) aTestArguments.iThreadIndex);

	threadCreateInfo.SetCreateHeap(KMinHeapSize, KMinHeapSize);

	//threadCreateInfo.SetUseHeap(NULL);

	threadCreateInfo.SetPaging(TThreadCreateInfo::EPaged);

	RThread testThread;

	TInt r;

	for(;;)

		{

		r = testThread.Create(threadCreateInfo);

		if(r != KErrNoMemory)

			break;

		if(!aTestArguments.iLowMem)

			break;

		if(Ldd.DoReleaseSomeRam(TEST_LM_BLOCKS_FREE) != KErrNone)

			break;

		RDBGD_PRINT(("TestStackPaging released some RAM\n"));

		}

	RDBGD_PRINT(("TID(%d) TestStackPaging create r = %d freeRam = %d\n", aTestArguments.iThreadIndex, r, FreeRam()));

	if (r != KErrNone)

		return r;

	TRequestStatus threadStatus;

	testThread.Logon(threadStatus);

	RDBGD_PRINT(("resuming test thread"));

	testThread.Resume();

	RDBGD_PRINT(("waiting for threadstatus"));

	User::WaitForRequest(threadStatus);

	RDBGD_PRINT(("Killing threads\n"));

	testThread.Close();

	return KErrNone;

	}

//--------------------------Server Pinning stuff-----------------------------------------------------

_LIT(KTestServer,"CTestServer");

const TUint KSemServer = 0;

class CTestServer : public CServer2

	{

public:

	CTestServer(TInt aPriority);

protected:

	//override the pure virtual functions:

	virtual CSession2* NewSessionL(const TVersion& aVersion,const RMessage2& aMessage) const;

	};

class CTestSession : public CSession2

	{

public:

	enum TTestMode

		{

		EStop,

		ERead,

		EWrite,

		EReadWrite,

		};

//Override pure virtual

	IMPORT_C virtual void ServiceL(const RMessage2& aMessage);

private:

	TInt ReadWrite(const RMessage2& aMessage, TBool aRead, TBool aWrite);

	TBool iClientDied;

	};

class CMyActiveScheduler : public CActiveScheduler

	{

public:

	virtual void Error(TInt anError) const; //override pure virtual error function

	};

class RSession : public RSessionBase

	{

public:

	TInt PublicSendReceive(TInt aFunction, const TIpcArgs &aPtr)

		{

		return (SendReceive(aFunction, aPtr));

		}

	TInt PublicCreateSession(const TDesC& aServer,TInt aMessageSlots)

		{

		return (CreateSession(aServer,User::Version(),aMessageSlots));

		}

	};

struct SServerArgs

	{

	TBool iBadServer;

	RSemaphore iSemArray;

	};

SServerArgs gServerArgsArray[KMaxTestThreads];

CTestServer::CTestServer(TInt aPriority)

//

// Constructor - sets name

//

	: CServer2(aPriority)

	{}

CSession2* CTestServer::NewSessionL(const TVersion& aVersion,const RMessage2& /*aMessage*/) const

//

// Virtual fn - checks version supported and creates a CTestSession

//

	{

	TVersion version(KE32MajorVersionNumber,KE32MinorVersionNumber,KE32BuildVersionNumber);

	if (User::QueryVersionSupported(version,aVersion)==EFalse)

		User::Leave(KErrNotSupported);

	CTestSession* newCTestSession = new CTestSession;

	if (newCTestSession==NULL)

		User::Panic(_L("NewSessionL failure"), KErrNoMemory);

	return(newCTestSession);

	}

TInt CTestSession::ReadWrite(const RMessage2& aMessage, TBool aRead, TBool aWrite)

	{

	TInt r = KErrNone;

	for (TUint argIndex = 0; argIndex < 4; argIndex++)

		{

		// Get the length of the descriptor and verify it is as expected.

		TInt length = aMessage.GetDesLength(argIndex);

		if (length < KErrNone)

			{

			RDebug::Printf("  Error getting descriptor length %d", length);

			return length;

			}

		if (aRead)

			{

			// Now read the descriptor

			HBufC8* des = HBufC8::New(length);

			if (!des)

				return KErrNoMemory;

			TPtr8 desPtr = des->Des();

			r = aMessage.Read(argIndex, desPtr);

			if (r != KErrNone)

				{

				delete des;

				return r;

				}

			//TODO: Verify the descriptor

			delete des;

			}

		if (aWrite)

			{

			// Now write to the maximum length of the descriptor.

			TInt max = length;

			HBufC8* argTmp = HBufC8::New(max);

			if (!argTmp)

				return KErrNoMemory;

			TPtr8 argPtr = argTmp->Des();

			argPtr.SetLength(max);

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

				argPtr[i] = (TUint8)argIndex;

			r = aMessage.Write(argIndex, argPtr);

			delete argTmp;

			if (r != KErrNone)

				return r;

			}

		}

	return KErrNone;

	}

void CTestSession::ServiceL(const RMessage2& aMessage)

//

// Virtual message-handler

//

	{

	TInt r = KErrNone;

	iClientDied = EFalse;

	switch (aMessage.Function())

		{

		case EStop:

			RDBGD_PRINT(("Stopping server"));

			CActiveScheduler::Stop();

			break;

		case ERead:

			r = ReadWrite(aMessage, ETrue, EFalse);

			break;

		case EWrite:

			r = ReadWrite(aMessage, EFalse, ETrue);

			break;

		case EReadWrite:

			r = ReadWrite(aMessage, ETrue, ETrue);

			break;

		default:

			r = KErrNotSupported;

		}

 	aMessage.Complete(r);

	// If descriptors aren't as expected then panic so the test will fail.

	if (r != KErrNone)

		User::Panic(_L("ServiceL failure"), r);

	}

// CTestSession funtions

void CMyActiveScheduler::Error(TInt anError) const

//

// Virtual error handler

//

	{

	User::Panic(_L("CMyActiveScheduer::Error"), anError);

	}

TInt ServerThread(TAny* aThreadIndex)

//

// Passed as the server thread in 2 tests - sets up and runs CTestServer

//

	{

	RDBGD_PRINT(("ServerThread"));

	TUint threadIndex = (TUint)aThreadIndex;