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

 	}