diff -r 000000000000 -r a41df078684a kerneltest/e32test/defrag/d_pagemove.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/defrag/d_pagemove.cpp	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,502 @@
+// 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:
+// e32test\defrag\d_pagemove.cpp
+// LDD for testing defrag page moving
+// 
+//
+
+#include <kernel/kern_priv.h>
+#include "platform.h"
+#include "d_pagemove.h"
+#include "nk_priv.h"
+
+// debug tracing for this test driver is very noisy - off by default
+#undef DEBUG_PAGEMOVE
+#ifdef DEBUG_PAGEMOVE
+#define DBG(a) a
+#else
+#define DBG(a)
+#endif
+
+const TInt KArbitraryNumber = 4;
+
+// This driver is ram loaded (see mmp file) so this function will do fine
+// as a test of RAM-loaded code.
+TInt RamLoadedFunction()
+	{
+	return KArbitraryNumber;
+	}
+
+const TInt KMajorVersionNumber=0;
+const TInt KMinorVersionNumber=1;
+const TInt KBuildVersionNumber=1;
+
+
+_LIT(KLddName,"PageMove");
+
+class DPageMove;
+
+class DPageMoveFactory : public DLogicalDevice
+//
+// Page move LDD factory
+//
+	{
+public:
+	DPageMoveFactory();
+	virtual TInt Install();						//overriding pure virtual
+	virtual void GetCaps(TDes8& aDes) const;	//overriding pure virtual
+	virtual TInt Create(DLogicalChannelBase*& aChannel);	//overriding pure virtual
+	};
+
+class DPageMove : public DLogicalChannelBase
+//
+// Page move logical channel
+//
+	{
+public:
+	DPageMove();
+	~DPageMove();
+protected:
+	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);
+	virtual TInt Request(TInt aFunction, TAny* a1, TAny* a2);
+	TInt DoPageMove(TLinAddr aAddr, TBool aEchoOff=EFalse);
+	TInt KernelDataMovePerformance(void);
+	TInt iPageSize;
+	};
+
+DECLARE_STANDARD_LDD()
+	{
+    return new DPageMoveFactory;
+    }
+
+DPageMoveFactory::DPageMoveFactory()
+//
+// Constructor
+//
+    {
+    iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);
+    //iParseMask=0;//No units, no info, no PDD
+    //iUnitsMask=0;//Only one thing
+    }
+
+TInt DPageMoveFactory::Create(DLogicalChannelBase*& aChannel)
+//
+// Create a new DPageMove on this logical device
+//
+    {
+	aChannel=new DPageMove;
+	return aChannel?KErrNone:KErrNoMemory;
+    }
+
+TInt DPageMoveFactory::Install()
+//
+// Install the LDD - overriding pure virtual
+//
+    {
+    return SetName(&KLddName);
+    }
+
+void DPageMoveFactory::GetCaps(TDes8& aDes) const
+//
+// Get capabilities - overriding pure virtual
+//
+    {
+    TCapsPageMoveV01 b;
+    b.iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);
+    Kern::InfoCopy(aDes,(TUint8*)&b,sizeof(b));
+    }
+
+DPageMove::DPageMove()
+//
+// Constructor
+//
+    {
+    }
+
+TInt DPageMove::DoCreate(TInt /*aUnit*/, const TDesC8* /*anInfo*/, const TVersion& aVer)
+//
+// Create channel
+//
+    {
+    if (!Kern::QueryVersionSupported(TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber),aVer))
+    	return KErrNotSupported;
+	iPageSize=Kern::RoundToPageSize(1);
+	return KErrNone;
+	}
+
+DPageMove::~DPageMove()
+//
+// Destructor
+//
+    {
+    }
+
+TInt DPageMove::Request(TInt aFunction, TAny* a1, TAny* a2)
+	{
+	TInt r=KErrNone;
+	DBG(Kern::Printf("DPageMove::Request func=%d a1=%08x a2=%08x", aFunction, a1, a2));
+	NKern::ThreadEnterCS();
+	switch (aFunction)
+		{
+		case RPageMove::EControlTryMovingKHeap:
+			// Allocate a large array on the kernel heap and try moving it around.
+			{
+			const TInt size=16384;
+			TUint8* array = new TUint8[size];
+			if (array == NULL)
+				r=KErrNoMemory;
+			else
+				{
+				for (TInt i=0; i<size; i++) array[i] = i*i;
+
+				TUint8* firstpage=(TUint8*)_ALIGN_DOWN((TLinAddr)array, iPageSize);
+				for (TUint8* page=firstpage; page<array+size; page+=iPageSize)
+					{
+					r=DoPageMove((TLinAddr)page);
+					if (r!=KErrNone)
+						{
+						Kern::Printf("Move returned %d", r);
+						break;
+						}
+					}
+
+				if (r==KErrNone)
+					{
+					for (TInt i=0; i<size; i++)
+						{
+						if (array[i] != (TUint8)(i*i))
+							{
+							r=KErrGeneral;
+							Kern::Printf("Data differs at index %d address %08x, expected %02x got %02x", i, &array[i], (TUint8)(i*i), array[i]);
+							}
+						}
+					}
+
+				Kern::ValidateHeap();
+
+				delete [] array;
+				}
+			}
+			break;
+
+		case RPageMove::EControlTryMovingKStack:
+			// Stick a not-too-large array on the current thread's kernel stack and try moving it around.
+			{
+			const TInt size=1024;
+			TUint8 array[size];
+			for (TInt i=0; i<size; i++) array[i] = i*i;
+
+			TUint8* firstpage=(TUint8*)_ALIGN_DOWN((TLinAddr)array, iPageSize);
+			for (TUint8* page=firstpage; page<array+size; page+=iPageSize)
+				{
+				r=DoPageMove((TLinAddr)page);
+				if (r!=KErrNone)
+					{
+					Kern::Printf("Move returned %d", r);
+					break;
+					}
+				}
+
+			if (r==KErrNone)
+				{
+				for (TInt i=0; i<size; i++)
+					{
+					if (array[i] != (TUint8)(i*i))
+						{
+						r=KErrGeneral;
+						Kern::Printf("Data differs at index %d address %08x, expected %02x got %02x", i, &array[i], (TUint8)(i*i), array[i]);
+						}
+					}
+				}
+			}
+			break;
+
+		case RPageMove::EControlTryMovingUserPage:
+		case RPageMove::EControlTryMovingLocale:
+			// Try moving the page that the user part of the test told us to.
+			r=DoPageMove((TLinAddr)a1, (TBool)a2);
+			if (r!=KErrNone && !a2)
+				Kern::Printf("Move returned %d", r);
+			break;
+
+		case RPageMove::EControlTryMovingKCode:
+			{
+			r=DoPageMove((TLinAddr)&RamLoadedFunction);
+			if (r==KErrNone)
+				{
+				if (RamLoadedFunction()!=KArbitraryNumber)
+					r=KErrGeneral;
+				}	
+			else
+				Kern::Printf("Move returned %d", r);
+			}
+			break;
+
+		case RPageMove::EControlPerfMovingKData:
+			r = KernelDataMovePerformance();
+			break;
+
+		case RPageMove::EControlGetPhysAddr:
+			TPhysAddr addr;
+			addr = (TUint)Epoc::LinearToPhysical((TLinAddr)a1);
+			Kern::ThreadRawWrite(&Kern::CurrentThread(),a2, &addr, sizeof(TPhysAddr));
+			break;
+
+		case RPageMove::EControlTryMovingPhysAddr:
+			{
+			TPhysAddr newAddr;
+			r = Epoc::MovePhysicalPage((TPhysAddr)a1, newAddr);
+			Kern::ThreadRawWrite(&Kern::CurrentThread(),a2, &newAddr, sizeof(TPhysAddr));
+			break;
+			}
+
+		case RPageMove::EControlTryMovingPageTable:
+			{
+			TPhysAddr newAddr;
+			r = Epoc::MovePhysicalPage((TPhysAddr) a1, newAddr, Epoc::ERamDefragPage_PageTable);
+			if (newAddr != KPhysAddrInvalid)
+				r = KErrGeneral;
+			break;
+			}
+
+		case RPageMove::EControlTryMovingPageTableInfo:
+			{
+			TPhysAddr newAddr;
+			r = Epoc::MovePhysicalPage((TPhysAddr) a1, newAddr, Epoc::ERamDefragPage_PageTableInfo);
+			if (newAddr != KPhysAddrInvalid)
+				r = KErrGeneral;
+			break;
+			}
+
+		case RPageMove::EControlNumberOfCpus:
+			r = NKern::NumberOfCpus();
+			break;
+		default:
+			r=KErrNotSupported;
+			break;
+		}
+	NKern::ThreadLeaveCS();
+	if (r!=KErrNone)
+		DBG(Kern::Printf("DPageMove::Request returns %d", r));
+	return r;
+	}
+
+TInt DPageMove::DoPageMove(TLinAddr aAddr, TBool aEchoOff)
+	{
+	DBG(Kern::Printf("DPageMove::DoPageMove() addr=%08x",aAddr));
+	aAddr = _ALIGN_DOWN(aAddr, iPageSize);
+
+	TPhysAddr aOld = Epoc::LinearToPhysical(aAddr);
+	TInt r;
+	if (aOld == KPhysAddrInvalid)
+		r=KErrArgument;
+	else
+		{
+		TPhysAddr aNew;
+		r=Epoc::MovePhysicalPage(aOld, aNew);
+		if (r==KErrNone)
+			{
+			TPhysAddr aNewCheck = Epoc::LinearToPhysical(aAddr);
+			if (aNewCheck != aNew)
+				{
+				if (!aEchoOff)
+					Kern::Printf("Address mismatch: expected %08x actual %08x\n",aNew,aNewCheck);
+				if (aNew != KPhysAddrInvalid && aNewCheck != KPhysAddrInvalid)
+					{// The page was not paged out by the moving so don't allow 
+					// addresses to differ.  If is was paged out then it may have 
+					// been paged back in again but to any free page so the addresses will differ.
+					r=KErrGeneral;
+					}
+				}
+			}
+		}
+	if (r!=KErrNone)
+		DBG(Kern::Printf("DPageMove::DoPageMove() returns %d", r));
+	return r;
+	}
+
+
+//#define EXTRA_TRACE
+#ifdef EXTRA_TRACE
+#define KERN_PRINTF(x...) Kern::Printf(x)
+#else
+#define KERN_PRINTF(x...)
+#endif
+
+TInt DPageMove::KernelDataMovePerformance(void)
+{
+	const TInt KHeapPagesToMove = 2000;
+	const TInt KMoveAttempts = 50;
+	const TInt KStackSize=1024;
+	enum TKMoveMode
+		{
+		EKMoveHeap,
+		EKMoveStack,
+		EKMoveModes,
+		};
+
+	TInt r = KErrNone;
+
+	// Create some kernel stack pages
+	TUint8 stackArray[KStackSize];
+
+	/// Create some kernel heap pages
+	TUint actualHeapPages = KHeapPagesToMove;
+	TInt heapArraySize = iPageSize * KHeapPagesToMove;
+	TUint8* heapArray = new TUint8[heapArraySize];
+	if (heapArray == NULL)
+		return KErrNoMemory;
+	
+	TInt i = 0;
+	for (; i < heapArraySize; i++)
+		{
+		heapArray[i] = i;
+		}
+
+	KERN_PRINTF("Testing Performance of Moving Kernel Data Pages");
+
+	TInt moveMode = EKMoveStack;
+	for (; moveMode < EKMoveModes; moveMode++)
+		{
+		TLinAddr pageAddr = NULL;
+		TLinAddr endAddr = NULL;
+		TLinAddr baseAddr = NULL;
+		switch (moveMode)
+			{
+			case EKMoveHeap:
+				pageAddr = _ALIGN_DOWN((TLinAddr)heapArray, iPageSize);
+				baseAddr = pageAddr;
+				endAddr = _ALIGN_UP((TLinAddr)heapArray + heapArraySize, iPageSize);
+				actualHeapPages = (endAddr - baseAddr) / iPageSize;
+				KERN_PRINTF("heap baseAddr %x endAddr %x", baseAddr, endAddr);
+				break;
+
+			case EKMoveStack:
+				pageAddr = _ALIGN_DOWN((TLinAddr)stackArray, iPageSize);
+				baseAddr = pageAddr;
+				endAddr = _ALIGN_UP((TLinAddr)stackArray + KStackSize, iPageSize);
+				KERN_PRINTF("stack baseAddr %x endAddr %x", baseAddr, endAddr);
+				break;
+			}
+
+		TUint32 minTime = KMaxTUint32;
+		TUint32 maxTime = 0; 
+		TUint32 cummulative = 0;
+		TInt iterations = KMoveAttempts;
+		TInt tot = iterations;
+		TUint pagesMoved = (endAddr - baseAddr) / iPageSize;
+		while (iterations--)
+			{
+			TUint32 diff;
+			TUint32 startTime=0;
+			TUint32 endTime=0;
+			switch (moveMode)
+				{
+				case EKMoveHeap:
+					startTime = NKern::FastCounter(); 
+				
+					while (pageAddr < endAddr) 
+						{
+						r = DoPageMove(pageAddr);
+
+						if (r != KErrNone)
+							{
+							goto exit;
+							}
+						pageAddr += iPageSize;
+						}
+					endTime = NKern::FastCounter();
+					break;
+			
+				case EKMoveStack:
+					// Normally will move same number of pages as heap to make comparison easier
+					TUint i = actualHeapPages;
+					startTime = NKern::FastCounter();
+					for (; i > 0; i--)
+						{
+						while (pageAddr < endAddr) 
+							{
+							r = DoPageMove(pageAddr);
+
+							if (r != KErrNone)
+								{
+								goto exit;
+								}
+							pageAddr += iPageSize;
+							}
+						pageAddr = baseAddr;
+						}
+					endTime = NKern::FastCounter();
+					break;
+				}
+			diff = endTime - startTime;
+			if (endTime < startTime) 
+				{
+				Kern::Printf("WARNING - fast counter overflowed. Assuming only once and continuing");
+				diff = (KMaxTUint32 - startTime) + endTime;
+				}
+
+			if (diff == 0)
+				{
+				Kern::Printf("difference 0!");
+				tot--;
+				}
+
+			if (diff > maxTime)
+				maxTime = diff;
+			if (diff < minTime)
+				minTime = diff;
+
+			if (cummulative + diff < cummulative)
+				{
+				Kern::Printf("OverFlow!!!");
+				r = KErrOverflow;
+				goto exit;
+				}
+			pageAddr = baseAddr;
+			cummulative += diff;
+			}
+		switch (moveMode)
+			{
+			case EKMoveHeap:				
+				if (tot != 0)
+					{
+					TUint average = (cummulative / tot);
+					Kern::Printf("Fast counter ticks to move %d kernel heap pages: Av %d Min %d Max %d (non zero iterations = %d out of %d)", pagesMoved, average, minTime, maxTime, tot, KMoveAttempts);
+					Kern::Printf("Average of %d ticks to move one page\n", average / pagesMoved);
+					}
+				else
+					Kern::Printf("WARNING - all kernel heap page moves took 0 fast counter ticks");
+				break;
+			
+			case EKMoveStack:
+				if (tot != 0)
+					{
+					TUint average = (cummulative / tot);
+					Kern::Printf("Fast counter ticks to move %d kernel stack pages %d times: Av %d Min %d Max %d (non zero iterations = %d out of %d)", pagesMoved, actualHeapPages, average, minTime, maxTime, tot, KMoveAttempts);
+					Kern::Printf("Average of %d ticks to move one page\n", average / (pagesMoved * actualHeapPages));
+					}
+				else
+					Kern::Printf("WARNING - all kernel stack page moves took 0 fast counter ticks");
+				break;
+			}
+		}
+
+	r = KErrNone;
+exit:
+	delete [] heapArray;
+	return r;
+	}
+	
+