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

	}