--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/mmu/t_mmubm.cpp	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,216 @@
+// Copyright (c) 1995-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_mmubm.cpp
+// Overview:
+// Time MMU allocation & deallocation
+// API Information:
+// RChunk
+// Details:
+// - Allocate and release a 1 MB chunk 100 times and time how long it takes.
+// - Allocate and release a 2 MB chunk 100 times and time how long it takes.
+// - Allocate and release a 7 MB chunk 100 times and time how long it takes.
+// - Allocate a 7 MB chunk once and time how long it takes.
+// - Deallocate a 7 MB chunk once and time how long it takes.
+// Platforms/Drives/Compatibility:
+// All.
+// Assumptions/Requirement/Pre-requisites:
+// Failures and causes:
+// Base Port information:
+// 
+//
+
+#define __E32TEST_EXTENSION__
+
+#include <e32test.h>
+#include "mmudetect.h"
+#include "d_gobble.h"
+#include "d_memorytest.h"
+#include "freeram.h"
+
+RTest test(_L("T_MMUBM"));
+
+typedef TInt (*TestFunction)(TUint32 aIters, TUint32 aSize);
+
+RMemoryTestLdd MemoryTest;
+RChunk TheChunk;
+
+LOCAL_C TInt AllocPhysical(TUint32 aIters, TUint32 aSize)
+	{
+	return MemoryTest.AllocPhysTest(aIters, aSize * 0x00100000);
+	}
+
+LOCAL_C TInt AllocPhysical1(TUint32 aIters, TUint32 aSize)
+	{
+	return MemoryTest.AllocPhysTest1(aIters, aSize * 0x00100000);
+	}
+
+LOCAL_C TInt AdjustChunk(TUint32 aIters, TUint32 aSize)
+	{
+	TUint32 i;
+	for (i=0; i<aIters; i++)
+		{
+		TInt r=TheChunk.Adjust(aSize * 0x00100000);
+		if (r!=KErrNone)
+			return r;
+		r=TheChunk.Adjust(0);
+		if (r!=KErrNone)
+			return r;
+		}
+	return KErrNone;
+	}
+
+LOCAL_C TInt AllocateChunk(TUint32 aIters, TUint32 aSize)
+	{
+	aIters = aSize;
+	return TheChunk.Adjust(aSize * 0x00100000);
+	}
+
+LOCAL_C TInt DeallocateChunk(TUint32 , TUint32 )
+	{
+	return TheChunk.Adjust(0);
+	}
+
+LOCAL_C TInt TimedCall(TestFunction aFunction, TUint32& aTime, TUint32 aIters, TUint32 aSize)
+	{
+	TUint32 before=User::NTickCount();
+	TInt r=(*aFunction)(aIters, aSize);
+	TUint32 after=User::NTickCount();
+	aTime=after-before;
+	return r;
+	}
+
+#define DO_TEST(__ret, __func, __time, __iters, __size)\
+	tempSize = __size;\
+	__ret=TimedCall(__func, __time, __iters, __size);\
+	if (__ret==KErrNone)\
+		{\
+		test.Printf(_L("  %dMb %d times ... %d ms\n"),__size, __iters,__time);\
+		}\
+	else if (tempSize < 7)\
+		{\
+		test(__ret==KErrNone);\
+		}
+
+#define DO_TEST_GOB(__ret, __func, __time, __iters, __size, __rem,__taken)\
+	tempSize = __size;\
+	__ret = gobbler.Open();\
+	test(__ret==KErrNone);\
+	/* gobble leaving x+1MB then test adjusting to x...*/\
+	__taken = gobbler.GobbleRAM(__rem*1024*1024);\
+	test.Printf(_L("Gobbled: %dK freeRam %dK\n"), __taken/1024, FreeRam()/1024);\
+	/* adjust to 1MB*/\
+	__ret=TimedCall(__func, __time, __iters, __size);\
+	if (__ret==KErrNone)\
+		{\
+		test.Printf(_L(" %dMb %d times ... %d ms\n"),__size, __iters,__time);\
+		}\
+	else if (tempSize < 7)\
+		{\
+		test(__ret==KErrNone);\
+		}\
+	gobbler.Close();
+	
+
+GLDEF_C TInt E32Main()
+	{
+
+	test.Title();
+	if (!HaveVirtMem())
+		{
+		test.Printf(_L("This test requires an MMU\n"));
+		return KErrNone;
+		}
+	test.Start(_L("Timing MMU allocation/deallocation..."));
+
+	test(KErrNone==MemoryTest.Open());
+
+	TInt r;
+	TUint32 t;
+	TUint32 tempSize;
+	r=TheChunk.CreateLocal(0,0x01000000);
+	test(r==KErrNone);
+
+	test.Printf(_L("Adjusting Chunks\n"));
+	DO_TEST(r, AdjustChunk, t, 100, 1);
+	DO_TEST(r, AdjustChunk, t, 100, 2);
+	DO_TEST(r, AdjustChunk, t, 100, 7);
+	r=TimedCall(AllocateChunk,t,1,7);
+	if (r==KErrNone)
+		{
+		test.Printf(_L("Allocate 7Mb once ... %d ms\n"),t);
+		r=TimedCall(DeallocateChunk,t, 1, 0);
+		test.Printf(_L("Deallocate 7Mb once ... %d ms\n"),t);
+		}
+	else
+		{
+		test.Printf(_L("Alloc chunk 7Mb failed! %d\n"), r);
+		}
+	
+	test.Next(_L("Test physical memory allocations...."));
+
+	DO_TEST(r, AllocPhysical, t, 100, 1);
+	DO_TEST(r, AllocPhysical1, t, 100, 1);
+	DO_TEST(r, AllocPhysical, t, 100, 2);
+	DO_TEST(r, AllocPhysical1, t, 100, 2);
+	DO_TEST(r, AllocPhysical, t, 100, 7);
+	DO_TEST(r, AllocPhysical1, t, 100, 7);
+
+	test.Next(_L("Now the test with low memory...."));
+
+	r = User::LoadLogicalDevice(KGobblerLddFileName);
+	test(r==KErrNone || r==KErrAlreadyExists);
+
+	RGobbler gobbler;
+	TUint32 taken = 0;
+
+	DO_TEST_GOB(r, AdjustChunk, t, 100, 1, 2, taken);
+	DO_TEST_GOB(r, AdjustChunk, t, 100, 2, 3, taken);
+	DO_TEST_GOB(r, AdjustChunk, t, 100, 7, 8, taken);
+
+	r=TimedCall(AllocateChunk,t,1,7);
+	if (r==KErrNone)
+		{
+		test.Printf(_L("Allocate 7Mb once ... %d ms\n"),t);
+		r=TimedCall(DeallocateChunk,t, 1, 0);
+		test.Printf(_L("Deallocate 7Mb once ... %d ms\n"),t);
+		}
+
+	// gobble leaving 8MB then test allocing 7...
+	r = gobbler.Open();
+	test(r==KErrNone);
+	taken = gobbler.GobbleRAM(8*1024*1024);
+	test.Printf(_L("Gobbled: %dK freeRam %dK\n"), taken/1024, FreeRam()/1024);
+	// allocate 7mb
+	r=TimedCall(AllocateChunk,t,1,7);
+	if (r==KErrNone)
+		{
+		test.Printf(_L("Allocate 7Mb once ... %d ms\n"),t);
+		r=TimedCall(DeallocateChunk,t, 1, 0);
+		test.Printf(_L("Deallocate 7Mb once ... %d ms\n"),t);
+		}
+	else
+		test.Printf(_L("Alloc chunk 7Mb failed! %d\n"), r);
+	gobbler.Close();
+
+	test.Next(_L("Test physical memory allocations with low memory...."));
+	DO_TEST_GOB(r, AllocPhysical, t, 100, 1, 2, taken);
+	DO_TEST_GOB(r, AllocPhysical1, t, 100, 1, 2, taken);
+	DO_TEST_GOB(r, AllocPhysical, t, 100, 2, 3, taken);
+	DO_TEST_GOB(r, AllocPhysical1, t, 100, 2, 3, taken);
+	DO_TEST_GOB(r, AllocPhysical, t, 100, 7, 8, taken);
+	DO_TEST_GOB(r, AllocPhysical1, t, 100, 7, 8, taken);
+
+	test.End();
+	return 0;
+	}