diff -r 000000000000 -r a41df078684a kerneltest/e32test/demandpaging/t_wdpsoak.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/demandpaging/t_wdpsoak.cpp	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,643 @@
+// Copyright (c) 2005-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_wdpsoak.cpp
+// 
+//
+
+#define __E32TEST_EXTENSION__
+#include <e32test.h>
+#include <dptest.h>
+#include <hal.h>
+#include "../mmu/mmudetect.h"
+#include "../mmu/freeram.h"
+
+#define MAX_CHUNKS	10
+#define PRINT(string) if (!gQuiet) test.Printf(string)
+#define PRINT1(string,param) if (!gQuiet) test.Printf(string,param)
+#define TESTNEXT(string) if (!gQuiet) test.Next(string)
+
+//------------globals---------------------
+LOCAL_D RTest test(_L("T_WDPSOAK"));
+LOCAL_D TInt gPageSize = 0;
+LOCAL_D TUint gChunkSize = 0;		// default chunk size
+LOCAL_D RChunk gChunk[MAX_CHUNKS];
+LOCAL_D TUint gNextChunk = 0;
+LOCAL_D TBool gQuiet = EFalse;
+LOCAL_D TUint gPeriod = 0;
+LOCAL_D TUint gMin = 0;
+LOCAL_D TUint gMax = 0;
+LOCAL_D TUint gMemScheme = 0;
+
+const TUint32 KFlushQuietLimit = 100000;
+
+TUint64 SwapFree()
+	{
+	SVMSwapInfo swapInfo;
+	test_KErrNone(UserSvr::HalFunction(EHalGroupVM, EVMHalGetSwapInfo, &swapInfo, 0));
+	
+	return swapInfo.iSwapFree;
+	}
+
+TUint64 SwapSize()
+	{
+	SVMSwapInfo swapInfo;
+	test_KErrNone(UserSvr::HalFunction(EHalGroupVM, EVMHalGetSwapInfo, &swapInfo, 0));
+	
+	return swapInfo.iSwapSize;
+	}
+
+void CacheSize(TUint aMin, TUint aMax)
+	{
+	SVMCacheInfo info;
+	if (UserSvr::HalFunction(EHalGroupVM,EVMHalGetCacheSize,&info,0) != KErrNone)
+		{
+		return;
+		}
+	
+	if (aMin > 0 || aMax > 0)
+		{
+		if (aMin > 0)
+			{
+			info.iMinSize = aMin;
+			}
+		if (aMax > 0)
+			{
+			info.iMaxSize = aMax;
+			}
+		UserSvr::HalFunction(EHalGroupVM,EVMHalSetCacheSize,(TAny*)info.iMinSize,(TAny*)info.iMaxSize);
+		if (UserSvr::HalFunction(EHalGroupVM,EVMHalGetCacheSize,&info,0) != KErrNone)
+			{
+			return;
+			}
+		}
+
+	PRINT1(_L("Paging Cache min size %d"),info.iMinSize);
+	PRINT1(_L("  max size %d"),info.iMaxSize);
+	PRINT1(_L("  current size %d\n"),info.iCurrentSize);
+	}
+
+void ShowMemoryUse()
+	{
+	PRINT1(_L("RAM free 0x%08X bytes"),FreeRam());
+	PRINT1(_L("  Swap free 0x%08X bytes\n"),SwapFree());
+
+	TPckgBuf<DPTest::TEventInfo> infoBuf;
+	TInt r = UserSvr::HalFunction(EHalGroupVM,EVMHalGetEventInfo,&infoBuf,0);
+	if (r!=KErrNone)
+		{
+		return;
+		}
+	PRINT1(_L("Page fault count %d"),infoBuf().iPageFaultCount);
+	PRINT1(_L("  Page IN count %d\n"),infoBuf().iPageInReadCount);
+
+	return;
+	}
+
+void ShowHelp()
+	{
+	PRINT(_L("***************************************\n"));
+	PRINT(_L("The following are immediate commands\n"));
+	PRINT(_L("F       flush the paging cache\n"));
+	PRINT(_L("I       show memory information\n"));
+	PRINT(_L("?       show this help\n"));
+	PRINT(_L("Rn      read all pages of chunk n\n"));
+	PRINT(_L("Wn      write all pages of chunk n\n"));
+	PRINT(_L("Mn      periodic memory scheme n\n"));
+	PRINT(_L("The following require a <CR> termination\n"));
+	PRINT(_L("C=nnnn  create a chunnk of size nnnn\n"));
+	PRINT(_L("L=nnnn  paging cache min size nnnn\n"));
+	PRINT(_L("H=nnnn  paging cache max size nnnn\n"));
+	PRINT(_L("P=nnnn  periodic flush/memory scheme nnnn microseconds\n"));
+	PRINT(_L("Esc     to exit\n"));
+	PRINT(_L("***************************************\n"));
+	}
+
+void CreateChunk(RChunk * aChunk, TUint aSize)
+	{
+	TESTNEXT(_L("Creating a paged chunk"));
+	TChunkCreateInfo createInfo;
+	PRINT1(_L("Creating chunk size 0x%08X bytes "),aSize);
+	PRINT1(_L("at index %d\n"),gNextChunk);
+	createInfo.SetPaging(TChunkCreateInfo::EPaged);
+	createInfo.SetNormal(aSize,aSize);
+	test_KErrNone(aChunk->Create(createInfo));
+	}
+
+void ReadChunk(RChunk * aChunk)
+	{
+	TESTNEXT(_L("Reading from each page of chunk"));
+	TUint8* chunkBase = aChunk->Base();
+	
+	TUint8 chunkVal = 0;
+	for (TInt i = 0; i < aChunk->Size(); i += gPageSize)
+		{
+		chunkVal = * (chunkBase + i);
+		}
+	
+	// only needed to remove compiler warning on unused variable
+	if (chunkVal)
+		chunkVal = 0;
+	
+	return;
+	}
+
+void WriteChunk(RChunk * aChunk, TUint8 aValue = 0)
+	{
+	static TUint8 lastWriteValue = 1;
+	TESTNEXT(_L("Writing to each page of chunk"));
+	TUint8* chunkBase = aChunk->Base();
+	
+	lastWriteValue = (TUint8)(aValue == 0 ? lastWriteValue + 1 : aValue);
+	for (TInt i = 0; i < aChunk->Size(); i += gPageSize)
+		{
+		* (chunkBase + i) = lastWriteValue;
+		}
+
+	return;
+	}
+
+void ParseCommandLine ()
+	{
+	TBuf<64> c;
+	
+	User::CommandLine(c);
+	c.LowerCase();
+
+	if (c != KNullDesC)
+		{
+		TLex lex(c);
+		TPtrC token;
+
+		while (token.Set(lex.NextToken()), token != KNullDesC)
+			{
+			if (token.Mid(0) == _L("quiet"))
+				{
+				gQuiet = ETrue;
+				continue;
+				}
+
+			if (token.Mid(0) == _L("verbose"))
+				{
+				gQuiet = EFalse;
+				continue;
+				}
+
+			if (token.Left(5) == _L("chunk"))
+				{
+				TInt equalPos;
+				equalPos = token.Locate('=');
+				if (equalPos > 0 && (equalPos+1) < token.Length())
+					{
+					TLex lexNum(token.Mid(equalPos+1));
+					lexNum.Val(gChunkSize,EDecimal);	
+					}
+				continue;
+				}
+
+			if (token.Left(3) == _L("low"))
+				{
+				TInt equalPos;
+				equalPos = token.Locate('=');
+				if (equalPos > 0 && (equalPos+1) < token.Length())
+					{
+					TLex lexNum(token.Mid(equalPos+1));
+					lexNum.Val(gMin,EDecimal);	
+					}
+				continue;
+				}
+
+			if (token.Left(5) == _L("high"))
+				{
+				TInt equalPos;
+				equalPos = token.Locate('=');
+				if (equalPos > 0 && (equalPos+1) < token.Length())
+					{
+					TLex lexNum(token.Mid(equalPos+1));
+					lexNum.Val(gMax,EDecimal);	
+					}
+				continue;
+				}
+
+			if (token.Left(6) == _L("period"))
+				{
+				TInt equalPos;
+				equalPos = token.Locate('=');
+				if (equalPos > 0 && (equalPos+1) < token.Length())
+					{
+					TLex lexNum(token.Mid(equalPos+1));
+					lexNum.Val(gPeriod,EDecimal);	
+					}
+				continue;
+				}
+
+			if (token.Left(3) == _L("mem"))
+				{
+				TInt equalPos;
+				equalPos = token.Locate('=');
+				if (equalPos > 0 && (equalPos+1) < token.Length())
+					{
+					TLex lexNum(token.Mid(equalPos+1));
+					lexNum.Val(gMemScheme,EDecimal);	
+					}
+				continue;
+				}
+
+			}
+		}
+	}
+
+enum TimerActions
+	{
+	ENoaction = 0,
+	EFlush = 1,
+	EFlushQuiet = 2,
+	EMemScheme1 = 1 << 4,
+	EMemScheme2 = 2 << 4,
+	EMemScheme3 = 3 << 4,
+	EMemScheme4 = 4 << 4,
+	};
+
+// CActive class to monitor KeyStrokes from User
+class CActiveConsole : public CActive
+	{
+public:
+	CActiveConsole();
+	~CActiveConsole();
+	void GetCharacter();
+	static TInt Callback(TAny* aCtrl);
+
+private:
+	CPeriodic*	iTimer;
+	TChar iCmdGetValue;
+	TBool iGetHexValue;
+	TBool iPrompt;
+	TChar iLastChar;
+	TUint iValue;
+	TUint16 iActions;
+	TUint32 iPeriod;
+	
+	// Defined as pure virtual by CActive;
+	// implementation provided by this class.
+	virtual void DoCancel();
+	// Defined as pure virtual by CActive;
+	// implementation provided by this class,
+	virtual void RunL();
+	void ProcessKeyPressL(TChar aChar);
+	void ProcessValue();
+	};
+
+// Class CActiveConsole
+CActiveConsole::CActiveConsole()
+	: CActive(EPriorityHigh)
+	{
+	CActiveScheduler::Add(this);
+
+    iTimer = CPeriodic::NewL(EPriorityNormal);
+    iActions = ENoaction;
+    iPrompt = ETrue;
+    iPeriod = 0;
+ 	if (gPeriod > 0)
+		{
+		if (gMemScheme > 0)
+			{
+			iActions = (TUint16)(gMemScheme << 4);			
+			}
+		else
+			{
+			iActions = (TUint16)(gPeriod < KFlushQuietLimit ? EFlushQuiet : EFlush);
+			}
+		iPeriod = gPeriod;
+	    iTimer->Start(0,gPeriod,TCallBack(Callback,this));
+		}
+	}
+
+CActiveConsole::~CActiveConsole()
+	{
+    iTimer->Cancel();
+    delete iTimer;
+
+    Cancel();
+	}
+
+// Callback function for timer expiry
+TInt CActiveConsole::Callback(TAny* aControl)
+	{
+	switch (((CActiveConsole*)aControl)->iActions & 0x0F)
+		{
+		case ENoaction :
+			break;
+
+		case EFlush :
+			PRINT(_L("Flush\n"));
+			// drop through to quiet 
+			
+		case EFlushQuiet :
+			test_KErrNone(DPTest::FlushCache());
+			break;
+			
+		default	:
+			break;
+		}
+
+	switch (((CActiveConsole*)aControl)->iActions & 0xF0)
+		{
+		TUint i;
+		case EMemScheme1 :
+			for (i = 0; i < gNextChunk; i++)
+				ReadChunk (&gChunk[i]);						
+			break;
+
+		case EMemScheme2 :
+			for (i = 0; i < gNextChunk; i++)
+				WriteChunk (&gChunk[i]);						
+			break;
+
+		default	:
+			break;
+		}
+	
+	return KErrNone;
+	}
+
+void CActiveConsole::GetCharacter()
+	{
+	if (iPrompt)
+		{
+		PRINT(_L("***Command (F,I,Q,V,?,Rn,Wn,Mn,C=nnnnn,H=nnnn,L=nnnn,P=nnnn) or Esc to exit ***\n"));
+		iPrompt = EFalse;
+		}
+	test.Console()->Read(iStatus);
+	SetActive();
+	}
+
+void CActiveConsole::DoCancel()
+	{
+	PRINT(_L("CActiveConsole::DoCancel\n"));
+	test.Console()->ReadCancel();
+	}
+
+void CActiveConsole::ProcessKeyPressL(TChar aChar)
+	{
+	if (aChar == EKeyEscape)
+		{
+		PRINT(_L("CActiveConsole: ESC key pressed -> stopping active scheduler...\n"));
+		CActiveScheduler::Stop();
+		return;
+		}
+	aChar.UpperCase();
+	if (iCmdGetValue != 0 && aChar == '\r')
+		{
+		if (iLastChar == 'K')
+			{
+			iValue *= iGetHexValue ? 0x400 : 1000;
+			}
+		if (iLastChar == 'M')
+			{
+			iValue *= iGetHexValue ? 0x10000 : 1000000;
+			}
+		PRINT1(_L("CActiveConsole: Value %d\n"),iValue);
+		ProcessValue();
+		}
+	if (iCmdGetValue != 0 )
+		{
+		if (iGetHexValue)
+			{
+			if (aChar.IsDigit())
+				{
+				iValue = iValue * 16 + aChar.GetNumericValue();
+			}
+			else
+				{
+				if (aChar.IsHexDigit())
+					{
+					iValue = iValue * 16 + (TUint)aChar - 'A' + 10;
+					}
+				else
+					{
+						if (aChar != 'K' && aChar != 'M')
+						{
+						PRINT(_L("Illegal hexadecimal character - Enter command\n"));
+						iCmdGetValue = 0;
+						}
+					}
+				}
+			}
+		else
+			{
+			if (aChar.IsDigit())
+				{
+				iValue = iValue * 10 + aChar.GetNumericValue();
+				}
+			else
+				{
+				if ((aChar == 'X') && (iLastChar == '0') && (iValue == 0))
+					iGetHexValue = ETrue;
+				else
+					{
+					if (aChar != 'K' && aChar != 'M')
+						{
+						test.Printf(_L("Illegal decimal character - Enter command\n"));
+						iCmdGetValue = 0;							
+						}
+					}
+				}
+			}
+		}
+	else
+		{
+		switch (aChar)
+			{
+			case 'F' :
+				TESTNEXT(_L("Flushing Cache"));
+				test_KErrNone(DPTest::FlushCache());
+				ShowMemoryUse();
+				iPrompt = ETrue;
+				break;
+				
+			case 'I' :
+				CacheSize(0,0);
+				ShowMemoryUse();
+				iPrompt = ETrue;
+				break;
+	
+			case 'Q' :
+				gQuiet = ETrue;
+				iPrompt = ETrue;
+				break;
+
+			case 'V' :
+				gQuiet = EFalse;
+				iPrompt = ETrue;
+				break;
+				
+			case '?' :
+				ShowHelp();
+				break;
+
+			case '=' :
+				iCmdGetValue = iLastChar;
+				iGetHexValue = EFalse;
+				iValue = 0;
+				break;
+						
+			default :
+				if (aChar.IsDigit())
+					{
+					if (iLastChar == 'R')
+						{
+						if (aChar.GetNumericValue() < (TInt)gNextChunk)
+							{
+							ReadChunk (&gChunk[aChar.GetNumericValue()]);			
+							}
+						else
+							{
+							for (TUint i = 0; i < gNextChunk; i++)
+								ReadChunk (&gChunk[i]);			
+							}
+						iPrompt = ETrue;
+						}				
+					if (iLastChar == 'W')
+						{
+						if (aChar.GetNumericValue() < (TInt)gNextChunk)
+							{
+							WriteChunk (&gChunk[aChar.GetNumericValue()]);			
+							}
+						else
+							{
+							for (TUint i = 0; i < gNextChunk; i++)
+								WriteChunk (&gChunk[i]);			
+							}
+						iPrompt = ETrue;
+						}
+					if (iLastChar == 'M')
+						{
+						if (aChar.GetNumericValue() == 0)
+							{
+							iActions = (TUint16)(iPeriod < KFlushQuietLimit ? EFlushQuiet : EFlush);							
+							}
+						else
+							{
+							iActions = (TUint16)(aChar.GetNumericValue() << 4);							
+							}
+						iPrompt = ETrue;
+						}
+					}
+				break;
+			}
+		}
+	iLastChar = aChar;
+	GetCharacter();
+	return;
+	}
+
+void CActiveConsole::ProcessValue()
+	{
+	switch (iCmdGetValue)
+		{
+		case 'C' :
+			if (iValue > 0 && gNextChunk < MAX_CHUNKS)
+				{
+				CreateChunk (&gChunk[gNextChunk], iValue);
+				ReadChunk (&gChunk[gNextChunk]);
+				ShowMemoryUse();				
+				gNextChunk++;
+				}
+			break;
+
+		case 'H' :
+			CacheSize (0,iValue);
+			break;
+			
+		case 'L' :
+			CacheSize (iValue,0);
+			break;
+
+		case 'P' :
+			iPeriod = iValue;
+			iActions = (TUint16)(iValue < KFlushQuietLimit ? EFlushQuiet : EFlush);
+			iTimer->Cancel();
+			if (iValue > 0)
+				{
+				iTimer->Start(0,iValue,TCallBack(Callback,this));
+				}
+			break;	
+
+		default :
+			break;
+		}
+	iCmdGetValue = 0;
+	iPrompt = ETrue;
+	}
+
+void CActiveConsole::RunL()
+	{
+	ProcessKeyPressL(static_cast<TChar>(test.Console()->KeyCode()));
+	}
+
+TInt E32Main()
+	{
+	test.Title();
+	test.Start(_L("Writable Data Paging Soak Test"));
+
+	ParseCommandLine();
+	
+	if (DPTest::Attributes() & DPTest::ERomPaging)
+		test.Printf(_L("Rom paging supported\n"));
+	if (DPTest::Attributes() & DPTest::ECodePaging)
+		test.Printf(_L("Code paging supported\n"));
+	if (DPTest::Attributes() & DPTest::EDataPaging)
+		test.Printf(_L("Data paging supported\n"));
+
+	TInt totalRamSize;
+	HAL::Get(HAL::EMemoryRAM,totalRamSize);
+	HAL::Get(HAL::EMemoryPageSize,gPageSize);
+	test.Printf(_L("Total RAM size 0x%08X bytes"),totalRamSize);
+	test.Printf(_L("  Swap size 0x%08X bytes"),SwapSize());
+	test.Printf(_L("  Page size 0x%08X bytes\n"),gPageSize);
+	CacheSize(gMin,gMax);
+
+	if ((DPTest::Attributes() & DPTest::EDataPaging) == 0)
+		{
+		test.Printf(_L("Writable Demand Paging not supported\n"));
+		test.End();
+		return 0;
+		}
+
+	ShowMemoryUse();
+
+	//User::SetDebugMask(0x00000008);		//KMMU
+	//User::SetDebugMask(0x00000080);		//KEXEC
+	//User::SetDebugMask(0x90000000);		//KPANIC KMMU2
+	//User::SetDebugMask(0x40000000, 1);	//KPAGING
+
+	if (gChunkSize)
+		{
+		CreateChunk (&gChunk[gNextChunk], gChunkSize);
+		ReadChunk (&gChunk[gNextChunk]);
+		ShowMemoryUse();				
+		gNextChunk++;
+		}
+	
+	CActiveScheduler* myScheduler = new (ELeave) CActiveScheduler();
+	CActiveScheduler::Install(myScheduler);
+
+	CActiveConsole* myActiveConsole = new CActiveConsole();
+	myActiveConsole->GetCharacter();
+
+	CActiveScheduler::Start();
+	
+	test.End();
+
+	return 0;
+	}