// 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\mmu\t_mmustress.cpp

 // Stress test for memory management services performed by the kernel's memory model.

 // 

 //

 /**

  @file

 */

 #define __E32TEST_EXTENSION__

 #include <e32test.h>

 #include "u32std.h"

 #include <u32hal.h>

 #include <e32svr.h>

 #include <dptest.h>

 #include <e32def.h>

 #include <e32def_private.h>

 #include "d_memorytest.h"

 #include "..\defrag\d_pagemove.h"

 TBool TRACE = 0;

 LOCAL_D RTest test(_L("T_MMUSTRESS"));

 TUint32 MemModelAttributes;

 TUint32 MemModel;

 TInt PageSize;

 TInt PageMask;

 #if !defined(__WINS__) && !defined(__X86__)

 const TPtrC KMoveLddFileName=_L("D_PAGEMOVE.LDD");

 RPageMove MoveLdd;

 #endif

 RMemoryTestLdd Ldd;

 const TUint KNumTestChunks = 6;

 RChunk Chunks[KNumTestChunks];

 TInt Committed[KNumTestChunks] = {0}; // for each chunk, is the 'owned' region uncommited(0), commited(1) or mixed(-1)

 class TNicePtr8 : public TPtr8 { public: TNicePtr8() : TPtr8(0,0) {} } ChunkPtr[KNumTestChunks];

 const TUint KNumSlaveProcesses = 4;

 RProcess Slaves[KNumSlaveProcesses];

 TRequestStatus SlaveLogons[KNumSlaveProcesses];

 TRequestStatus SlaveRendezvous[KNumSlaveProcesses];

 TInt SlaveNumber = -1; // master process is slave -1

 const TInt KLocalIpcBufferSize = 0x10000;

 TUint8* LocalIpcBuffer = 0;

 RSemaphore StartSemaphore;

 //

 // Random number generation

 //

 TUint32 RandomSeed;

 TUint32 Random()

 	{

 	RandomSeed = RandomSeed*69069+1;

 	return RandomSeed;

 	}

 TUint32 Random(TUint32 aRange)

 	{

 	return (TUint32)((TUint64(Random())*TUint64(aRange))>>32);

 	}

 void RandomInit(TUint32 aSeed)

 	{

 	RandomSeed = aSeed+(aSeed<<8)+(aSeed<<16)+(aSeed<<24);

 	Random();

 	Random();

 	}

 //

 // Chunk utils

 //

 TBuf<KMaxKernelName> ChunkName(TInt aChunkNumber)

 	{

 	TBuf<KMaxKernelName> name;

 	name.Format(_L("T_MMUSTRESS-Chunk%d"),aChunkNumber);

 	return name;

 	}

 #ifdef __WINS__

 TInt KChunkShift = 16;

 #elif defined(__X86__)

 TInt KChunkShift = 22;

 #else

 TInt KChunkShift = 20;

 #endif

 TInt ChunkSize(TInt aChunkNumber)

 	{

 	// biggest chunk (number 0) is big enough for each slave to own a region which is

 	// 2 page tables ('chunks') in size...

 	return (2*KNumSlaveProcesses)<<(KChunkShift-aChunkNumber);

 	}

 // check smallest chunk is less than 'chunk' size...

 __ASSERT_COMPILE((2*KNumSlaveProcesses>>(KNumTestChunks-1))==0);

 /* Memory region 'owned' by this slave process */

 void ChunkOwnedRegion(TInt aChunkNumber,TInt& aOffset,TInt& aSize)

 	{

 	TInt size = ChunkSize(aChunkNumber)/KNumSlaveProcesses;

 	aSize = size;

 	aOffset = SlaveNumber*size;

 	test_Equal(0,size&PageMask);

 	}

 void ChunkMarkRegion(TInt aChunkNumber,TInt aOffset,TInt aSize)

 	{

 	TInt pageSize = PageSize;

 	TUint32 mark = aOffset|aChunkNumber|(SlaveNumber<<4);

 	TUint8* ptr = Chunks[aChunkNumber].Base()+aOffset;

 	TUint8* ptrEnd = ptr+aSize;

 	while(ptr<ptrEnd)

 		{

 		((TUint32*)ptr)[0] = mark;

 		((TUint32*)ptr)[1] = ~mark;

 		mark += pageSize;

 		ptr += pageSize;

 		}

 	}

 void ChunkCheckRegion(TInt aChunkNumber,TInt aOffset,TInt aSize)

 	{

 	TInt pageSize = PageSize;

 	TUint32 mark = aOffset|aChunkNumber|(SlaveNumber<<4);

 	TUint8* ptr = Chunks[aChunkNumber].Base()+aOffset;

 	TUint8* ptrEnd = ptr+aSize;

 	while(ptr<ptrEnd)

 		{

 		test_Equal(mark,((TUint32*)ptr)[0]);

 		test_Equal(~mark,((TUint32*)ptr)[1]);

 		mark += pageSize;

 		ptr += pageSize;

 		}

 	}

 TInt ChunkOpen(TInt aChunkNumber)

 	{

 	RChunk& chunk = Chunks[aChunkNumber];

 	if(chunk.Handle()!=0)

 		return KErrNone;

 	if(TRACE) RDebug::Printf("%d %d Open",SlaveNumber,aChunkNumber);

 	TInt r = chunk.OpenGlobal(ChunkName(aChunkNumber),false);

 	if(r!=KErrNoMemory)

 		test_KErrNone(r);

 	return r;

 	}

 //

 // Server utils

 //

 TBuf<KMaxKernelName> ServerName(TInt aSlaveNumber)

 	{

 	TBuf<KMaxKernelName> name;

 	name.Format(_L("T_MMUSTRESS-Server%d"),aSlaveNumber);

 	return name;

 	}

 RServer2 Server;

 RMessage2 ServerMessage;

 TRequestStatus ServerStatus;

 class RTestSession : public RSessionBase

 	{

 public:

 	TInt Connect(TInt aServerNumber)

 		{

 		return CreateSession(ServerName(aServerNumber),TVersion(),1,EIpcSession_Unsharable,0,&iStatus);

 		}

 	TInt Send(TInt aChunkNumber)

 		{

 		return RSessionBase::Send(0,TIpcArgs(SlaveNumber,aChunkNumber,&ChunkPtr[aChunkNumber]));

 		}

 	TRequestStatus iStatus;

 	};

 RTestSession Sessions[KNumSlaveProcesses];

 //

 //

 //

 void SlaveInit()

 	{

 	RDebug::Printf("Slave %d initialising",SlaveNumber);

 	TBuf<KMaxKernelName> name;

 	name.Format(_L("T_MMUSTRESS-Slave%d"),SlaveNumber);

 	User::RenameThread(name);

 	test_KErrNone(StartSemaphore.Open(2));

 	TInt r;

 #if !defined(__WINS__) && !defined(__X86__)

 	// Move ldd may not be in the ROM so needs to be loaded.

 	r=User::LoadLogicalDevice(KMoveLddFileName);

 	test_Value(r, r==KErrNone || r==KErrAlreadyExists);

 	test_KErrNone(MoveLdd.Open());

 #endif

 	test_KErrNone(Ldd.Open());

 	test_KErrNone(Ldd.CreateVirtualPinObject());

 	LocalIpcBuffer = (TUint8*)User::Alloc(KLocalIpcBufferSize);

 	test(LocalIpcBuffer!=0);

 	test_KErrNone(Server.CreateGlobal(ServerName(SlaveNumber)));

 	TUint i;

 	// create sessions with other slaves...

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

 		{

 		for(;;)

 			{

 			r = Sessions[i].Connect(i);

 //			RDebug::Printf("%d Session %d = %d,%d",SlaveNumber,i,r,Sessions[i].iStatus.Int());

 			if(r==KErrNotFound)

 				{

 				// give other slaves time to create their servers...

 				User::After(10000);

 				continue;

 				}

 			test_KErrNone(r);

 			break;

 			}

 		}

 	// process session connect messages...

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

 		{

 		RMessage2 m;

 //		RDebug::Printf("%d Server waiting for connect message",SlaveNumber);

 		Server.Receive(m);

 		test_Equal(RMessage2::EConnect,m.Function())

 		m.Complete(KErrNone);

 		}

 	// wait for our session connections...

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

 		{

 //		RDebug::Printf("%d Session wait %d",SlaveNumber,i);

 		User::WaitForRequest(Sessions[i].iStatus);

 		}

 	// prime server for receiving mesages...

 	Server.Receive(ServerMessage,ServerStatus);

 	// synchronise with other processes...

 	RDebug::Printf("Slave %d waiting for trigger",SlaveNumber);

 	RProcess::Rendezvous(KErrNone);

 	StartSemaphore.Wait();

 	RDebug::Printf("Slave %d started",SlaveNumber);

 	}

 //

 // Test by random operations...

 //

 void DoTest()

 	{

 	RandomInit(SlaveNumber);

 	TInt r;

 	for(;;)

 		{

 		// select random chunk...

 		TInt chunkNumber = Random(KNumTestChunks);

 		RChunk& chunk = Chunks[chunkNumber];

 		// get the region of this chunk which this process 'owns'...

 		TInt offset;

 		TInt size;

 		ChunkOwnedRegion(chunkNumber,offset,size);

 		// calculate a random region in the owned part...

 		TInt randomOffset = offset+(Random(size)&~PageMask);

 		TInt randomSize = (Random(size-(randomOffset-offset))+PageMask)&~PageMask;

 		if(!randomSize)

 			continue; // try again

 		// pick a random slave...

 		TInt randomSlave = Random(KNumSlaveProcesses);

 		// open chunk if it isn't already...

 		r = ChunkOpen(chunkNumber);

 		if(r==KErrNoMemory)

 			continue; // can't do anything with chunk if we can't open it

 		// check our contents of chunk...

 		if(Committed[chunkNumber]==1)

 			{

 			if(TRACE) RDebug::Printf("%d %d Check %08x+%08x",SlaveNumber,chunkNumber,offset,size);

 			ChunkCheckRegion(chunkNumber,offset,size);

 			}

 		// perform random operation...

 		switch(Random(12))

 			{

 		case 0:

 		case 1:

 			// close chunk...

 			if(TRACE) RDebug::Printf("%d %d Close",SlaveNumber,chunkNumber);

 			chunk.Close();

 			break;

 		case 2:

 			// commit all...

 			if(TRACE) RDebug::Printf("%d %d Commit all %08x+%08x",SlaveNumber,chunkNumber,offset,size);

 			if(Committed[chunkNumber]!=0)

 				{

 				r = chunk.Decommit(offset,size);

 				test_KErrNone(r);

 				Committed[chunkNumber] = 0;

 				}

 			r = chunk.Commit(offset,size);

 			if(r!=KErrNoMemory)

 				{

 				test_KErrNone(r);

 				Committed[chunkNumber] = 1;

 				ChunkMarkRegion(chunkNumber,offset,size);

 				}

 			break;

 		case 3:

 			// decommit all...

 			if(TRACE) RDebug::Printf("%d %d Decommit all %08x+%08x",SlaveNumber,chunkNumber,offset,size);

 			r = chunk.Decommit(offset,size);

 			test_KErrNone(r);

 			Committed[chunkNumber] = 0;

 			break;

 		case 4:

 		case 5:

 			// commit random...

 			if(TRACE) RDebug::Printf("%d %d Commit %08x+%08x",SlaveNumber,chunkNumber,randomOffset,randomSize);

 			r = chunk.Commit(randomOffset,randomSize);

 			if(r!=KErrNoMemory)

 				{

 				if(Committed[chunkNumber]==0)

 					{

 					test_KErrNone(r);

 					Committed[chunkNumber] = -1;

 					}

 				else if(Committed[chunkNumber]==1)

 					{

 					test_Equal(KErrAlreadyExists,r);

 					}

 				else

 					{

 					if(r!=KErrAlreadyExists)

 						test_KErrNone(r);

 					}

 				}

 			break;

 		case 6:

 		case 7:

 			// decommit random...

 			if(TRACE) RDebug::Printf("%d %d Decommit %08x+%08x",SlaveNumber,chunkNumber,randomOffset,randomSize);

 			r = chunk.Decommit(randomOffset,randomSize);

 			test_KErrNone(r);

 			if(Committed[chunkNumber]==1)

 				Committed[chunkNumber] = -1;

 			break;

 		case 8:

 			if(TRACE) RDebug::Printf("%d %d IPC Send->%d",SlaveNumber,chunkNumber,randomSlave);

 //			ChunkPtr[chunkNumber].Set(chunk.Base(),ChunkSize(chunkNumber),ChunkSize(chunkNumber));

 			ChunkPtr[chunkNumber].Set(chunk.Base()+offset,size,size);

 			Sessions[randomSlave].Send(chunkNumber);

 			break;

 		case 9:

 			// process IPC messages...

 			if(ServerStatus.Int()==KRequestPending)

 				continue;

 			User::WaitForRequest(ServerStatus);

 			{

 			TInt sourceSlave = ServerMessage.Int0();

 			chunkNumber = ServerMessage.Int1();

 			if(TRACE) RDebug::Printf("%d %d IPC Receive<-%d",SlaveNumber,chunkNumber,sourceSlave);

 			test_Equal(0,ServerMessage.Function());

 			// get local descriptor for owned region in chunk...

 			size = ServerMessage.GetDesMaxLength(2);

 			test_NotNegative(size);

 			if(size>KLocalIpcBufferSize)

 				size = KLocalIpcBufferSize;

 			TPtr8 local(LocalIpcBuffer,size,size);

 //			if(Random(2))

 				{

 				// IPC read from other slave...

 				if(TRACE) RDebug::Printf("%d %d IPC Read<-%d",SlaveNumber,chunkNumber,sourceSlave);

 				TInt panicTrace = Ldd.SetPanicTrace(EFalse);

 				r = ServerMessage.Read(2,local);

 				Ldd.SetPanicTrace(panicTrace);

 				if(r!=KErrBadDescriptor)

 					test_KErrNone(r);

 				}

 //			else

 //				{

 //				// IPC write to other slave...

 //				if(TRACE) RDebug::Printf("%d %d IPC Write->%d",SlaveNumber,chunkNumber,sourceSlave);

 //				r = ServerMessage.Write(2,local,offset);

 //				if(r!=KErrBadDescriptor)

 //					test_KErrNone(r);

 //				if(Committed[chunkNumber]==1)

 //					ChunkMarkRegion(chunkNumber,offset,size);

 //				}

 			}

 			ServerMessage.Complete(KErrNone);

 			Server.Receive(ServerMessage,ServerStatus);

 			break;

 		case 10:

 		case 11:

 			// pin memory...

 			{

 			test_KErrNone(Ldd.UnpinVirtualMemory());

 			for(TInt tries=10; tries>0; --tries)

 				{

 				TInt chunkSize = ChunkSize(chunkNumber);

 				offset = Random(chunkSize);

 				TInt maxSize = chunkSize-offset;

 				if(maxSize>0x1000)

 					maxSize = 0x1000;

 				size = Random(maxSize);

 				r = Ldd.PinVirtualMemory((TLinAddr)chunk.Base()+offset, size);

 				if(r!=KErrNotFound && r!=KErrNoMemory)

 					{

 					test_KErrNone(r);

 					break;

 					}

 				}

 			}

 			break;

 		case 12:

 		case 13:

 			// Move any page in the chunk, not just the owned region.

 			{

 #if !defined(__WINS__) && !defined(__X86__)

 			for(TInt tries=10; tries>0; --tries)

 				{

 				TInt chunkSize = ChunkSize(chunkNumber);

 				offset = Random(chunkSize);

 				MoveLdd.TryMovingUserPage((TAny*)(chunk.Base()+offset), ETrue);

 				// Allow the move to fail for any reason as the page of the chunk

 				// may or may not be currently committed, pinned, or accessed.

 				}

 #endif

 			}

 			break;

 		default:

 			test(false); // can't happen

 			break;

 			}

 		}

 	}

 TInt E32Main()

 	{

 	// get system info...

 	MemModelAttributes = UserSvr::HalFunction(EHalGroupKernel, EKernelHalMemModelInfo, NULL, NULL);

 	MemModel = MemModelAttributes&EMemModelTypeMask;

 	UserHal::PageSizeInBytes(PageSize);

 	PageMask = PageSize-1;

 	// see if we are a slave process...

 	if(User::GetTIntParameter(1,SlaveNumber)==KErrNone)

 		{

 		// do testing...

 		SlaveInit();

 		DoTest();

 		return KErrGeneral; // shouldn't have returned from testing

 		}

 	// master process...

 	TBool pass = true; // final test result

 	test.Title();

 	if((MemModelAttributes&EMemModelAttrVA)==false)

 		{

 		test.Start(_L("TESTS NOT RUN - Not relevent for the memory model"));

 		test.End();

 		return KErrNone;

 		}

 	// get time to run tests for...

 	TInt timeout = 10; // time in seconds

 	TInt cmdLineLen = User::CommandLineLength();

 	if(cmdLineLen)

 		{

 		// get timeout value from command line

 		RBuf cmdLine;

 		test_KErrNone(cmdLine.Create(cmdLineLen));

 		User::CommandLine(cmdLine);

 		test_KErrNone(TLex(cmdLine).Val(timeout));

 		if(timeout==0)

 			timeout = KMaxTInt;

 		}

 	TTimeIntervalMicroSeconds32 tickTime;

 	test_KErrNone(UserHal::TickPeriod(tickTime));

 	TInt ticksPerSecond = 1000000/tickTime.Int();

 	TInt timeoutTicks;

 	if(timeout<KMaxTInt/ticksPerSecond)

 		timeoutTicks = timeout*ticksPerSecond;

 	else

 		{

 		timeoutTicks = KMaxTInt;

 		timeout = timeoutTicks/ticksPerSecond;

 		}

 	// master process runs at higher priority than slaves so it can timeout and kill them...

 	RThread().SetPriority(EPriorityMore);

 	test.Start(_L("Creating test chunks"));

 	TUint i;

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

 		{

 		test.Printf(_L("Size %dkB\r\n"),ChunkSize(i)>>10);

 		test_KErrNone(Chunks[i].CreateDisconnectedGlobal(ChunkName(i),0,0,ChunkSize(i)));

 		}

 	test.Next(_L("Spawning slave processes"));

 	test_KErrNone(StartSemaphore.CreateGlobal(KNullDesC,0));

 	TFileName processFile(RProcess().FileName());

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

 		{

 		test.Printf(_L("Slave %d\r\n"),i);

 		RProcess& slave = Slaves[i];

 		test_KErrNone(slave.Create(processFile,KNullDesC));

 		test_KErrNone(slave.SetParameter(1,i));

 		test_KErrNone(slave.SetParameter(2,StartSemaphore));

 		slave.Logon(SlaveLogons[i]);

 		test_Equal(KRequestPending,SlaveLogons[i].Int());

 		slave.Rendezvous(SlaveRendezvous[i]);

 		test_Equal(KRequestPending,SlaveRendezvous[i].Int());

 		}

 	test.Next(_L("Create timer"));

 	RTimer timer;

 	test_KErrNone(timer.CreateLocal());

 	test.Next(_L("Resuming slave processes"));

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

 		Slaves[i].Resume();

 	// this test must now take care not to die (e.g. panic due to assert fail)

 	// until it has killed the slave processes

 	test.Next(_L("Change paging cache size"));

 	TUint cacheOriginalMin = 0;

 	TUint cacheOriginalMax = 0;

 	TUint cacheCurrentSize = 0;

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

 	DPTest::SetCacheSize(1, 2*ChunkSize(0)); // big enough for all the test chunks

 	test.Next(_L("Wait for slaves to initialise"));

 	TRequestStatus timeoutStatus;

 	timer.After(timeoutStatus,10*1000000); // allow short time for slaves to initialise

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

 		{

 		User::WaitForAnyRequest(); // wait for a rendexvous

 		if(timeoutStatus.Int()!=KRequestPending)

 			{

 			test.Printf(_L("Timeout waiting for slaves to initialise\r\n"));

 			pass = false;

 			break;

 			}

 		}

 	test.Next(_L("Restore paging cache size"));

 	DPTest::SetCacheSize(cacheOriginalMin, cacheOriginalMax);

 	if(pass)

 		{

 		timer.Cancel();

 		User::WaitForAnyRequest(); // swallow timer signal

 		test.Next(_L("Check slaves are ready"));

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

 			{

 			if(SlaveRendezvous[i].Int()!=KErrNone || Slaves[i].ExitType()!=EExitPending)

 				{

 				test.Printf(_L("Slaves not ready or died!\r\n"));

 				pass = false;

 				break;

 				}

 			}

 		}

 	if(pass)

 		{

 		test.Next(_L("Setup simulated kernel heap failure"));

 		__KHEAP_SETFAIL(RAllocator::EDeterministic,100);

 		TBuf<80> text;

 		text.Format(_L("Stressing for %d seconds..."),timeout);

 		test.Next(text);

 		timer.AfterTicks(timeoutStatus,timeoutTicks);

 		StartSemaphore.Signal(KNumSlaveProcesses); // release slaves to start testing

 		User::WaitForAnyRequest(); // wait for timeout or slave death via logon completion

 		pass = timeoutStatus.Int()==KErrNone; // timeout means slaves are still running OK

 		test.Next(_L("Check slaves still running"));

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

 			if(Slaves[i].ExitType()!=EExitPending)

 				pass = false;

 		test.Next(_L("Clear kernel heap failure"));

 		TUint kheapFails = __KHEAP_CHECKFAILURE;

 		__KHEAP_RESET;

 		test.Printf(_L("Number of simulated memory failures = %d\r\n"),kheapFails);

 		}

 	test.Next(_L("Killing slave processes"));

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

 		Slaves[i].Kill(0);

 	test.Next(_L("Assert test passed"));

 	test(pass);

 	test.End();

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

 		Slaves[i].Close();

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

 		Chunks[i].Close();

 	timer.Close();

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

 		User::WaitForRequest(SlaveLogons[i]);

 	UserSvr::HalFunction(EHalGroupKernel, EKernelHalSupervisorBarrier, (TAny*)5000, 0);

 	return KErrNone;

 	}