// Copyright (c) 2008-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\t_ramdefrag.cpp

// RAM Defragmentation Functional Tests

// 

//

//#define RUN_ALL_TESTS			// Uncomment to ensure that all tests are run regardless of test failures

//#define DEBUG_VER				// Uncomment for information output from tests

#define __E32TEST_EXTENSION__

#include <e32test.h>

RTest test(_L("T_RAMDEFRAG"));

#include <e32rom.h>

#include <u32hal.h>

#include <f32file.h>

#include <f32dbg.h>

#include <e32svr.h>

#include <e32msgqueue.h>

#include <e32math.h>

#include <hal.h>

#include "testdefs.h"

#include <dptest.h>

#include "t_ramdefrag.h"

#define READ(a) ReadByte((volatile TUint8*)(a))

#ifdef RUN_ALL_TESTS

#define TEST_FAIL {gTestStepFailed++;}

#define CLEANUP(a) {}

#else

#define TEST_FAIL {TestCleanup(); test(EFalse);}

#define CLEANUP(a) {if (!gFailPrintPageInfo) \

						{ \

						PrintPageInfo(); \

						gFailPrintPageInfo = ETrue; \

						} \

					a;}

#endif

#define TEST_DRIVER_OPEN		1

#define TEST_DRIVER_CLOSE		0

#define BEST_MOVABLE			1

#define BEST_DISCARDABLE		2

#define BEST_FIXED				3

#define Z_ALLOC_CONTIG			1

#define Z_ALLOC_DISC			2

LOCAL_D TUint gTestStarted = EFalse;								// Used to ensure matching TestStart() and TestEnd().

LOCAL_D TBool gPagedRom = ETrue;									// Stores whether or not is a paged ROM

LOCAL_D TInt gTestStepFailed = 0;									// Stores the number of test steps failed

LOCAL_D TBool gFailPrintPageInfo = EFalse;							// Set to ETrue once CLEANUP has been invoked once.

LOCAL_D TBool gFileCacheRun = EFalse;								// Set to ETrue whe FSCaching tests have been run

LOCAL_D TInt gRamSize;												// The total RAM size in bytes

LOCAL_D TInt gFreeRam;												// The amount of free RAM available in bytes

LOCAL_D TInt gPageSize;												// The number of bytes per page

LOCAL_D TUint gPageShift;

#ifdef DEBUG_VER

LOCAL_D TInt gRamUsed; 												// The amount of RAM used in bytes

#endif

LOCAL_D TInt gInitialRam;											// The initial free RAM before a test starts

LOCAL_D TInt gEndRam;												// The end free RAM when a test finishes

LOCAL_D TUint gOriginalMinCacheSize;									// The original DP minSize

LOCAL_D TUint gOriginalMaxCacheSize;									// The original DP maxSize

LOCAL_D TInt gTotalRamLost;											// The total amount of RAM lost during the test

LOCAL_D TUint gZoneCount = 0;										// Number of zones

LOCAL_D const TUint KInvalidZoneID = 0xffffffff;					// Invalid value for a zone ID

LOCAL_D STestPageCount gTotalPageCount;

LOCAL_D struct SRamZoneConfig*	gZoneConfigArray;					// Contains the configurations of all the zones

LOCAL_D struct SRamZoneUtilisation*	gZoneUtilArray;					// Contains the utilisations of all the zones

LOCAL_D struct SRamZoneUtilisation* gOriginalPageCountArray;		// Contains the original utilisations of the zones

LOCAL_D TInt* gPrefArray;											// Contains the preference order of the zones 

LOCAL_D TUint8* gOrigFlagArray;										// Contains the orignal values for the zone flags

LOCAL_D TInt gDefragMaxPages = 0;

const TInt KFillAllMovable = -1;

LOCAL_D RChunk* gChunkArray1 = NULL;								// Stores reference to all the chunks that have been created

LOCAL_D RChunk* gChunkArray2 = NULL;								// Stores reference to all the chunks that have been created

LOCAL_D TUint gChunkArraySize1 = 0;									// The size of the array gChunkArray

LOCAL_D TUint gChunkArraySize2 = 0;									// The size of the array gChunkArray

const TUint KChunkDefaultSize = 0x300000;	

const TUint KMaxChunks = 14;

LOCAL_D const TUint KNumAllocChunks = 10;							// The number of chunks to be allocd for some tests.

LOCAL_D RRamDefragFuncTestLdd Ldd;									// Main Ldd used to call into device driver

LOCAL_D TBuf<20> gTestThreadName =_L("TestThread");	

LOCAL_D RThread gTestThread;

LOCAL_D TRequestStatus status;

LOCAL_D TInt gDrive;												// The removable media drive

LOCAL_D RFs gTheFs;									

LOCAL_D TFileName gSessionPath;

const TInt KNoRemovableDrive = -1;									// gDrive is set to this when no suitable drive can be found.

const TInt KDefaultCacheSize = (128 + 12) * 1024;					// The default file system cache size 

const TUint KNumFilesOrig = (32 * 1024 * 1024) / KDefaultCacheSize;	// The number of files that are needed to fill the file system cache

LOCAL_D TInt gFilesNeededToFillCache = KNumFilesOrig ;				// Not constant as can change depending on the size of the disk

LOCAL_D RFile gFile[KNumFilesOrig];

LOCAL_D TInt* gCandList1;											// Array of zones that have the same preference and the same

LOCAL_D TInt* gCandList2;											// amount of free pages

const TInt KInvalidCandIndex = -1;

//

// GetDrive

//

// Gets the removable drive number

//

TInt GetDrive()

	{

	RFs theFs;

	TInt r = theFs.Connect();

	test_KErrNone(r);

	TInt driveLet = KNoRemovableDrive;

	TInt i = EDriveA;

	for (; i <= EDriveZ; i++)

		{

		TVolumeInfo volInfo;

		r = theFs.Volume(volInfo, i);

		if (r == KErrNone)

			{// This drive no. exists so determine if it is removable and 

			//  formattable media.

			if ((volInfo.iDrive.iDriveAtt & KDriveAttRemovable) &&

				(volInfo.iDrive.iMediaAtt & KMediaAttFormattable))	

				{

				driveLet = i;

				break;

				}

			}

		}

	theFs.Close();

	return driveLet;

	}

//

// DeviceDriver

//

// Opens or closes the device driver used

//

TInt DeviceDriver(TInt aFunctionNum)

	{

	TInt r = 0;

	switch (aFunctionNum)

		{

		case TEST_DRIVER_OPEN:

			{

			r = User::LoadLogicalDevice(KRamDefragFuncTestLddName);

			test(r==KErrNone || r==KErrAlreadyExists);

			r = Ldd.Open();

			test_KErrNone(r);

			}

		break;

		case TEST_DRIVER_CLOSE:

			{

			Ldd.Close();

			r = User::FreeLogicalDevice(KRamDefragFuncTestLddName);

			test_KErrNone(r);

			}

		break;

		default:

		break;

		}

	return r;

	}

//

// GetOriginalPageCount

//

// Obtains the orginal types of pages in each of the zones

//

void GetOriginalPageCount()

	{

	TUint index;

	TInt ret = 0;

	TESTDEBUG(test.Printf(_L("ram defrag : Get info about the zones\n")));

	for (index = 0; index < gZoneCount; index ++)

		{

		ret = UserSvr::HalFunction(EHalGroupRam,ERamHalGetZoneUtilisation,(TAny*)index, (TAny*)&gOriginalPageCountArray[index]);

		test(ret == KErrNone);

		}

	}

//

// PrintPageInfo

//

// Prints various page information to the screen

//

void PrintPageInfo()

	{

	test.Printf(_L("\nZONE CONFIGURATIONS:\n"));

	for (TUint index = 0; index < gZoneCount; index ++)

		{

		TInt ret = UserSvr::HalFunction(EHalGroupRam,ERamHalGetZoneConfig,(TAny*)index, (TAny*)&gZoneConfigArray[index]);

		test(ret == KErrNone);

		test.Printf(_L("config : id=0x%08x  index=%-2d  base=0x%08x  end=0x%08x  pages=0x%08x  pref=%-2d  flags=0x%x\n"),

					gZoneConfigArray[index].iZoneId,gZoneConfigArray[index].iZoneIndex,

					gZoneConfigArray[index].iPhysBase,gZoneConfigArray[index].iPhysEnd,

					gZoneConfigArray[index].iPhysPages,gZoneConfigArray[index].iPref,gZoneConfigArray[index].iFlags);

		}

	test.Printf(_L("\nZONE UTILISATIONS:\n"));

	for (TUint index = 0; index < gZoneCount; index ++)

		{

		TInt ret = UserSvr::HalFunction(EHalGroupRam,ERamHalGetZoneUtilisation,(TAny*)index, (TAny*)&gZoneUtilArray[index]);

		test(ret == KErrNone);

		test.Printf(_L("usage  : id=0x%08x  index=%-2d  pref=%d  pages=0x%08x free=0x%08x  unknown=0x%08x  fixed=0x%08x  move=0x%08x  discard=0x%08x  other=0x%08x\n"),

					gZoneUtilArray[index].iZoneId,gZoneUtilArray[index].iZoneIndex,gZoneConfigArray[index].iPref, 

					gZoneUtilArray[index].iPhysPages,gZoneUtilArray[index].iFreePages,

					gZoneUtilArray[index].iAllocUnknown,gZoneUtilArray[index].iAllocFixed,gZoneUtilArray[index].iAllocMovable,

					gZoneUtilArray[index].iAllocDiscardable,gZoneUtilArray[index].iAllocOther);

		}

	}

//

// GetAllPageInfo

//

// Get various different page information for all zones

// Also updates the total page count

//

void GetAllPageInfo()

	{

	TInt ret = 0;

	gTotalPageCount.iFreePages = 0;

	gTotalPageCount.iUnknownPages = 0;

	gTotalPageCount.iFixedPages = 0;

	gTotalPageCount.iMovablePages = 0;

	gTotalPageCount.iDiscardablePages = 0;

	gTotalPageCount.iOtherPages = 0;

	// now get the config of each of the zones.

	TUint	index;

	TESTDEBUG(test.Printf(_L("ram defrag : Get info about the zones\n")));

	for (index = 0; index < gZoneCount; index ++)

		{

		ret = UserSvr::HalFunction(EHalGroupRam,ERamHalGetZoneConfig,(TAny*)index, (TAny*)&gZoneConfigArray[index]);

		test(ret == KErrNone);

		ret = UserSvr::HalFunction(EHalGroupRam,ERamHalGetZoneUtilisation,(TAny*)index, (TAny*)&gZoneUtilArray[index]);

		test(ret == KErrNone);

		gTotalPageCount.iFreePages += gZoneUtilArray[index].iFreePages;

		gTotalPageCount.iUnknownPages += gZoneUtilArray[index].iAllocUnknown;

		gTotalPageCount.iFixedPages += gZoneUtilArray[index].iAllocFixed;

		gTotalPageCount.iMovablePages += gZoneUtilArray[index].iAllocMovable;

		gTotalPageCount.iDiscardablePages += gZoneUtilArray[index].iAllocDiscardable;

		gTotalPageCount.iOtherPages += gZoneUtilArray[index].iAllocOther;

		}

	TESTDEBUG(test.Printf(_L("free=0x%x unknown=0x%x fixed=0x%x move=0x%x discard=0x%x other=0x%x\n"),

					gTotalPageCount.iFreePages, gTotalPageCount.iUnknownPages, gTotalPageCount.iFixedPages, 

					gTotalPageCount.iMovablePages, gTotalPageCount.iDiscardablePages,gTotalPageCount.iOtherPages));

	TESTDEBUG(PrintPageInfo());

	}

void RestoreRamZoneFlags()

	{

	GetAllPageInfo(); // Update the current set of RAM zone flag data.

	for (TUint index=0; index < gZoneCount; index++)

		{

		TUint zoneDefragID = gZoneConfigArray[index].iZoneId;

		Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, ORIG_FLAG, gOrigFlagArray[index]);

		}

	}

void ResetRamZoneFlags()

	{

	GetAllPageInfo(); // Update the current set of RAM zone flag data.

	for (TUint index=0; index < gZoneCount; index++)

		{

		TUint zoneDefragID = gZoneConfigArray[index].iZoneId;

		Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, RESET_FLAG);

		}

	}

void RemoveChunkAlloc(RChunk*& aChunkArray, TUint& aChunkArraySize);

void ResetDPCache();

void FSCachCleanUp()

	{

	// If the File System Caching tests have been run, 

	// ensure that they are cleaned up

	if (gFileCacheRun)

		{

		TUint i = 0;

		// First close all the open handles to the RFile objects open

		for (i = 0; i < KNumFilesOrig; i++) 

			{

			gFile[i].Close();

			}

		// Now call EmptyRamZone on every zone to ensure that 

		// discardable pages are cleaned up

		GetAllPageInfo();

		for (i = 0; i < gZoneCount; i++)

			{

			TUint zoneID = gZoneConfigArray[i].iZoneId;

			Ldd.CallDefrag(DEFRAG_TYPE_EMPTY, DEFRAG_VER_SYNC, zoneID);

			}

		gFileCacheRun = EFalse;

		}

	}

//

// TestCleanup

//

// Cleans up all the allocations made at the beginning of the test

//

void TestCleanup()

	{

	Ldd.ResetDriver();

	// Revert the cleared flags to their original values before the tests were carried out

	RestoreRamZoneFlags();

	// Reset the DP cache and remove any allocated chunks and fixed pages.

	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);

	RemoveChunkAlloc(gChunkArray2, gChunkArraySize2);

	ResetDPCache();

	Ldd.FreeAllFixedPages();

	Ldd.FreeFromAllZones();

	FSCachCleanUp();

	User::Free(gPrefArray);

	gPrefArray = NULL;

	User::Free(gOrigFlagArray);

	gOrigFlagArray = NULL;

	User::Free(gCandList1);

	gCandList1 = NULL;

	User::Free(gCandList2);

	gCandList2 = NULL;

	User::Free(gOriginalPageCountArray);

	gOriginalPageCountArray = NULL;

	// Output the last possible state of memory

	if (!gFailPrintPageInfo)

		PrintPageInfo();

	User::Free(gZoneConfigArray);

	gZoneConfigArray = NULL;

	User::Free(gZoneUtilArray);

	gZoneUtilArray = NULL;

	}

// TestSetup

//

// Get the necessary information needed to carry out the tests

//

TInt TestSetup()

	{

	// Get the MMC drive

	gDrive = GetDrive();

	// first get the number of zones

	TInt ret = UserSvr::HalFunction(EHalGroupRam,ERamHalGetZoneCount,&gZoneCount,0);

	if (ret != KErrNone)

		{

		test.Printf(_L("Cannot obtain the number of zones\n"));

		return ret;

		}

	test.Printf(_L("RAM Zones (count=%u)\n"),gZoneCount);

	// Obtain the size of the RAM and the size of a page	

	ret = HAL::Get(HAL::EMemoryRAM, gRamSize);

	if (ret != KErrNone)

		{

		test.Printf(_L("Cannot obtain the size of RAM\n"));

		return ret;

		}

	// Retrieve the page size and use it to detemine the page shift (assumes 32-bit system).

	ret = HAL::Get(HAL::EMemoryPageSize, gPageSize);

	if (ret != KErrNone)

		{

		test.Printf(_L("Cannot obtain the page size\n"));

		return ret;

		}

	TUint32 pageMask = gPageSize;

	TUint i = 0;

	for (; i < 32; i++)

		{

		if (pageMask & 1)

			{

			if (pageMask & ~1u)

				{

				test.Printf(_L("ERROR - page size not a power of 2"));

				return KErrNotSupported;

				}

			gPageShift = i;

			break;

			}

		pageMask >>= 1;

		}

	gZoneConfigArray = (SRamZoneConfig *)User::AllocZ(sizeof(SRamZoneConfig) * gZoneCount);

	if (gZoneConfigArray == NULL)

		return KErrNoMemory;

	gZoneUtilArray = (SRamZoneUtilisation *)User::AllocZ(sizeof(SRamZoneUtilisation) * gZoneCount);

	if (gZoneUtilArray == NULL)

		return KErrNoMemory;

	gPrefArray = (TInt *)User::AllocZ(sizeof(TInt) * gZoneCount);

	if (gPrefArray == NULL)

		return KErrNoMemory;

	gOrigFlagArray = (TUint8 *)User::AllocZ(sizeof(TUint8) * gZoneCount);

	if (gOrigFlagArray == NULL)

		return KErrNoMemory;

	gOriginalPageCountArray = (SRamZoneUtilisation *)User::AllocZ(sizeof(SRamZoneUtilisation) * gZoneCount);

	if (gOriginalPageCountArray == NULL)

		return KErrNoMemory;

	gCandList1 = (TInt *)User::AllocZ(sizeof(TInt) * gZoneCount);

	if (gCandList1 == NULL)

		return KErrNoMemory;

	gCandList2 = (TInt *)User::AllocZ(sizeof(TInt) * gZoneCount);

	if (gCandList2 == NULL)

		return KErrNoMemory;

	GetAllPageInfo();

	PrintPageInfo();

	// Store the original flags

	for (i=0; i < gZoneCount; i++)

		gOrigFlagArray[i] = gZoneConfigArray[i].iFlags;

	// Now clear the flags for carrying out tests

	Ldd.ResetDriver();

	ResetRamZoneFlags();

	// Check whether the ROM is paged or not

	TRomHeader* romHeader = (TRomHeader*)UserSvr::RomHeaderAddress();

	if(!romHeader->iPageableRomStart)

		{

		test.Printf(_L("Not a Paged ROM - Skipping all discardable page tests.\n"));

		gPagedRom = EFalse;

		}

	else

		{// Save the current state of the DP cache so it can be restored when required and

		// after the test has finished.

		TUint currentCacheSize;

		DPTest::CacheSize(gOriginalMinCacheSize, gOriginalMaxCacheSize, currentCacheSize);

		TESTDEBUG(test.Printf(_L("Original CacheSize: minCacheSize = 0x%x, maxCacheSize = 0x%x, currentCacheSize = 0x%x\n"), 

									gOriginalMinCacheSize >> gPageShift, gOriginalMaxCacheSize >> gPageShift, 

									currentCacheSize >> gPageShift));

		}

	return KErrNone;

	}

// 

// UpdateRamInfo

//

// Updating the various RAM information

//

void UpdateRamInfo()

	{

	HAL::Get(HAL::EMemoryRAMFree, gFreeRam);

	TESTDEBUG(gRamUsed = gRamSize - gFreeRam);

	}

// 

// CheckRamDifference

//

// Checks the difference between the initial free RAM and the end free RAM

//

void CheckRamDifference()

	{

	if (gInitialRam == gEndRam)

		{

		TESTDEBUG(test.Printf(_L("No RAM was lost during this test\n")));

		}

	else

		{

		TInt diff = gInitialRam - gEndRam;

		gTotalRamLost = gTotalRamLost + diff;

		}

	}

TInt VerifyMovDisAlloc();

//

// TestStart

//

// Updates the RAM information at the beginning of a test step	

//

void TestStart()

	{

	test(!gTestStarted);

	gTestStarted = ETrue;

	Ldd.ResetDriver();

	Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);

	if (VerifyMovDisAlloc() != KErrNone)

		{

		CLEANUP(;);

		TEST_FAIL;

		}

	UpdateRamInfo();

	gInitialRam = gFreeRam;

	TESTDEBUG(test.Printf(_L("Initial Free RAM = 0x%x, Initial RAM Used = 0x%x\n"), gFreeRam, gRamUsed));

	}

void RemoveChunkAlloc(RChunk*& aChunkArray, TUint& aChunkArraySize);

//

// TestEnd

//

// Updates RAM information at end of test step and checks the RAM delta

//

void TestEnd()

	{

	test(gTestStarted);

	gTestStarted = EFalse;

	gDefragMaxPages = 0;

	// Clean up anything that may need to be cleaned.

	ResetRamZoneFlags();

	RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);

	RemoveChunkAlloc(gChunkArray2, gChunkArraySize2);

	ResetDPCache();

	Ldd.FreeAllFixedPages();

	FSCachCleanUp();

	UpdateRamInfo();

	gEndRam = gFreeRam;

	TESTDEBUG(test.Printf(_L("End RAM Free = 0x%x, End RAM Used = 0x%x\n"), gEndRam, gRamUsed));

	CheckRamDifference();

	test.Printf(_L(" \n"));

	}

//

// CheckZonesSwitchedOff

//

// Checks that zones have been switched off

//

TBool CheckZonesSwitchedOff()

	{

	GetAllPageInfo();

	for (TUint i = 0; i < gZoneCount; i++)

		{

		if (gOriginalPageCountArray[i].iFreePages != gOriginalPageCountArray[i].iPhysPages &&

			gZoneUtilArray[i].iFreePages == gZoneUtilArray[i].iPhysPages)

			{

			return ETrue;

			}

		}

	return EFalse;

	}

//

// CheckZoneIsOff

//

// Checks if a particular zone is empty 

//

TBool CheckZoneIsOff(TUint aZoneIndex)

	{

	GetAllPageInfo();

	if (gZoneUtilArray[aZoneIndex].iFreePages == gZoneUtilArray[aZoneIndex].iPhysPages)

		{

		TESTDEBUG(test.Printf(_L("Zone index %d is Empty\n"), aZoneIndex));

		return ETrue;

		}

	else

		{

		TESTDEBUG(test.Printf(_L("Zone index %d is Not empty\n"), aZoneIndex));

		return EFalse;

		}

	}

//

// GetPrefOrder

//

// Go through each zone ordering them in preference order

//

void GetPrefOrder()

	{

	GetAllPageInfo();

	TESTDEBUG(PrintPageInfo());

	for (TUint i=0; i < (TUint)gZoneCount; i++)

		gPrefArray[i] = KErrNotFound;

	for (TUint curIndex = 0; curIndex < gZoneCount; curIndex++)

		{

		TBool currentEmpty = gZoneUtilArray[curIndex].iPhysPages == gZoneUtilArray[curIndex].iFreePages;

		TUint currentPref = gZoneConfigArray[curIndex].iPref;

		TUint currentImmovPages = 	gZoneUtilArray[curIndex].iAllocFixed + 

									gZoneUtilArray[curIndex].iAllocUnknown;

		TUint morePrefCnt = 0;

		for (TUint index = 0; index < gZoneCount; index++)

			{// A RAM zone with the same iPref is more preferable if it has 

			// more immovable pages.

			if (gZoneConfigArray[index].iPref < currentPref || 

				(gZoneConfigArray[index].iPref == currentPref && 

				(currentImmovPages < gZoneUtilArray[index].iAllocFixed + gZoneUtilArray[index].iAllocUnknown ||

				(currentEmpty &&

				gZoneUtilArray[index].iFreePages != gZoneUtilArray[index].iPhysPages))))

				{

				morePrefCnt++;

				}

			}

		while (gPrefArray[morePrefCnt] != KErrNotFound)

			{// Zone(s) of this preference and size already exist so 

			 // place this one after it/them

			morePrefCnt++;

			}

		gPrefArray[morePrefCnt] = curIndex;

		}

	}

//

// ZonesSamePref

//

// Return ETrue if the RAM zones are of the same preference.

//

// NOTE - This requires GetAllPageInfo() to have already been called.

//

TBool ZonesSamePref(TUint aZoneIndex1, TUint aZoneIndex2)

	{

	TBool zoneEmpty1 = gZoneUtilArray[aZoneIndex1].iFreePages == gZoneUtilArray[aZoneIndex1].iPhysPages;

	TBool zoneEmpty2 = gZoneUtilArray[aZoneIndex2].iFreePages == gZoneUtilArray[aZoneIndex2].iPhysPages;

	if (gZoneConfigArray[aZoneIndex1].iPref == gZoneConfigArray[aZoneIndex2].iPref &&

		(gZoneUtilArray[aZoneIndex1].iAllocFixed + gZoneUtilArray[aZoneIndex1].iAllocUnknown == 

		gZoneUtilArray[aZoneIndex2].iAllocFixed + gZoneUtilArray[aZoneIndex2].iAllocUnknown &&

		(zoneEmpty1 == zoneEmpty2)))

		{

		return ETrue;

		}

	return EFalse;	

	}

//

// FindMostPrefEmpty

//

// Checks all zones and returns the most preferable RAM zone which 

// is completely emtpy

//

// @param aZoneIndex On return this will contain the index into gZoneUtilArray of the most preferable empty RAM zone.

// @param aPrefIndex On return this will contain the index into gPrefArray of the most preferable empty RAM zone.

//

// @return KErrNotFound if a zone cannot be found, else KErrNone

//

TInt FindMostPrefEmpty(TUint& aZoneIndex, TUint* aPrefIndex = NULL)

	{

	// Get the most pref zone which is completely free to use as a test zone

	GetPrefOrder();

	TUint prefIndex = 0;

	for (; prefIndex < gZoneCount; prefIndex++)

		{

		TUint zoneIndex = gPrefArray[prefIndex];

		if (gZoneUtilArray[zoneIndex].iFreePages == gZoneUtilArray[zoneIndex].iPhysPages)

			{

			aZoneIndex = zoneIndex;

			if (aPrefIndex)

				{

				*aPrefIndex = prefIndex;

				}

			return KErrNone;

			}

		}

	return KErrNotFound;

	}

//

// FindLeastPrefEmpty

//

// Checks all zones and returns the least preferable RAM zone which 

// is completely emtpy

//

// @param aZoneIndex On return this will contain the index into gZoneUtilArray of the least preferable empty RAM zone.

// @param aPrefIndex On return this will contain the index into gPrefArray of the least preferable empty RAM zone.

//

// @return KErrNotFound if a zone cannot be found, else KErrNone

//

TInt FindLeastPrefEmpty(TUint& aZoneIndex, TUint* aPrefIndex = NULL)

	{

	// Get the most pref zone which is completely free to use as a test zone

	GetPrefOrder();

	TInt prefIndex = gZoneCount - 1;

	for (; prefIndex >= 0; prefIndex--)

		{

		TUint zoneIndex = gPrefArray[prefIndex];

		if (gZoneUtilArray[zoneIndex].iFreePages == gZoneUtilArray[zoneIndex].iPhysPages)

			{

			aZoneIndex = zoneIndex;

			if (aPrefIndex)

				{

				*aPrefIndex = (TUint)prefIndex;

				}

			return KErrNone;

			}

		}

	return KErrNotFound;

	}

//

// FindMostPrefWithFree

//

// Checks all zones and returns the most preferable RAM zone which 

// has at least 1 free page 

//

// @param aZoneIndex On return this will contain the index into gZoneUtilArray of the most preferable RAM zone with free pages.

// @param aPrefIndex On return this will contain the index into gPrefArray of the most preferable RAM zone with free pages.

//

// @return KErrNotFound if a zone cannot be found, else KErrNone

//

TInt FindMostPrefWithFree(TUint& aZoneIndex, TUint* aPrefIndex = NULL)

	{

	// Get the most pref zone which has free pages

	GetPrefOrder();

	TUint prefIndex = 0;

	for (; prefIndex < gZoneCount; prefIndex++)

		{

		TUint zoneIndex = gPrefArray[prefIndex];

		if (gZoneUtilArray[zoneIndex].iFreePages)

			{

			aZoneIndex = zoneIndex;

			if (aPrefIndex)

				{

				*aPrefIndex = prefIndex;

				}

			return KErrNone;

			}

		}

	return KErrNotFound;

	}

//

// CanGenSucceed

//

// Check whether a call to TRamDefragRequest::DefragRam() would be able to 

// succeed or not. 

//

TBool CanGenSucceed()

	{

	GetPrefOrder();

	TBool genSucceed = EFalse;

	// Work out if general has anything to do

	for(TInt prefIndex = (TInt)gZoneCount-1; prefIndex >= 0; prefIndex--)

		{

		TUint zoneIndex = gPrefArray[prefIndex];

		TESTDEBUG(test.Printf(_L("prefIndex = %d zoneIndex = 0x%x\n"), prefIndex, zoneIndex));

		TUint samePrefCount = 1;

		TUint samePrefSucceed = 0;

		// The number of zones of this preference that will be skipped by the general defrag

		TUint samePrefEmptyImmovable = 0;

		// Determine how many zones have the same preference as this one

		TInt prevPrefIndex = (prefIndex != 0)? (prefIndex - 1) : -1;

		for (; prevPrefIndex >= 0; prevPrefIndex--)

			{

			TUint prevIndex = gPrefArray[prevPrefIndex];

			if (ZonesSamePref(zoneIndex, prevIndex))

				{

				samePrefCount++;

				}

			else // no more zones with this preference

				break;

			}

		TESTDEBUG(test.Printf(_L("samePrefCount = %d\n"), samePrefCount));

		for (TInt l = prefIndex - (samePrefCount-1); l <= prefIndex; l++)

			{

			TUint curPrefIndex = gPrefArray[l];

			TESTDEBUG(test.Printf(_L("curPrefIndex = %d\n"), curPrefIndex));

			if (gZoneUtilArray[curPrefIndex].iFreePages != gZoneConfigArray[curPrefIndex].iPhysPages)

				{

				TBool clearMovable = EFalse;

				TBool clearDiscardable = EFalse;

				if (gZoneUtilArray[curPrefIndex].iAllocUnknown || gZoneUtilArray[curPrefIndex].iAllocFixed)

					{

					TESTDEBUG(test.Printf(_L("unknown or fixed\n")));

					samePrefEmptyImmovable++;

					continue;

					}

				if (gZoneUtilArray[curPrefIndex].iAllocMovable)

					{// determine if movable can potentially be cleared from this zone

					TUint freeInLower = 0;

					for (TInt j=0; j <= prefIndex; j++)

						{

						TUint idx = gPrefArray[j];

						if (idx == curPrefIndex)

							continue;

						freeInLower += gZoneUtilArray[idx].iFreePages;

						}

					if (gZoneUtilArray[curPrefIndex].iAllocMovable <= freeInLower)

						{

						clearMovable = ETrue;

						TESTDEBUG(test.Printf(_L("Can clear movable, curPrefIndex = %d\n"), curPrefIndex));

						}

					}

				else

					{

					TESTDEBUG(test.Printf(_L("Can clear movable, curPrefIndex = %d\n"), curPrefIndex));

					clearMovable = ETrue;

					}

				if (gZoneUtilArray[curPrefIndex].iAllocDiscardable)

					{

					if (gPagedRom)

						{

						TUint minCacheSize = 0;

						TUint maxCacheSize = 0;

						TUint currentCacheSize = 0;

						DPTest::CacheSize(minCacheSize,maxCacheSize,currentCacheSize);

						TUint spareCache = currentCacheSize - minCacheSize;

						if (spareCache >= gZoneUtilArray[curPrefIndex].iAllocDiscardable )

							{

							clearDiscardable = ETrue;

							TESTDEBUG(test.Printf(_L("Paged: Can clear discardable\n")));

							}

						else

							{// determine space for discardable in more preferable zones

							TUint freeInLower = 0;

							for (TInt j=0; j <= prefIndex; j++)

								{

								TUint idx = gPrefArray[j];

								if (idx == curPrefIndex)

									continue;

								freeInLower += gZoneUtilArray[idx].iFreePages;

								}

							if (gZoneUtilArray[curPrefIndex].iAllocDiscardable - spareCache <= freeInLower)

								{

								clearDiscardable = ETrue;	

								TESTDEBUG(test.Printf(_L("Paged: Can clear discardable curPrefIndex = %d\n"), curPrefIndex));

								}

							}

						}

					else

						{//Should always be OK to discard as no min cache size on non-paged ROMS

						clearDiscardable = ETrue;

						test.Printf(_L("Can clear discardable curPrefIndex = %d\n"), curPrefIndex);

						}

					}

				else

					{

					clearDiscardable = ETrue;

					}

				if (clearDiscardable && clearMovable)

					{

					samePrefSucceed++;

					TESTDEBUG(test.Printf(_L("General should succeed ID=%x\n"), gZoneConfigArray[curPrefIndex].iZoneId));

					}

				}

			else

				{//zone already empty

				samePrefEmptyImmovable++;

				}

			}

		if (samePrefSucceed == 0 && samePrefEmptyImmovable == 0)

			{// no zones can be defragged and none are already empty/have immovable.

			break;

			}

		if (samePrefEmptyImmovable != samePrefCount)

			{// Have reached some zones with allocated pages in them.

			if (samePrefSucceed + samePrefEmptyImmovable == samePrefCount)

				{// general should definitely succeed as each of the zones of this preference 

				// can be emptied or are already empty/have immovable pages allocated.

				TESTDEBUG(test.Printf(_L("General should succeed \n")));

				genSucceed = ETrue;

				}

			break;

			}

		prefIndex -= samePrefCount - 1;

		}

	return genSucceed;

	}

//

// ReadByte

//

// Read a particular byte 

//

TUint8 ReadByte(volatile TUint8* aPtr)

	{

	return *aPtr;

	}

//

// AllocDiscardable

//

// Allocate Discardable pages in the form of demand paged pages

//

// @param aNumDiscardableBytes On return this will contain the number of discardable bytes above the min cache size.

// @param aMaxBytes The new limit for maximum number of bytes in the DP cache, set to KMaxTUInt64 to fill RAM.

// @param aMinOffsetBytes When not set to KMaxTUint64, this sets the min cache size to be the max cache size - aMinOffsetBytes.

//

TInt AllocDiscardable(TInt& aNumDiscardableBytes, TUint64 aMaxBytes = KMaxTUint64, TUint64 aMinOffsetBytes = KMaxTUint64)

	{

	TUint minCacheSize = 0;

	TUint maxCacheSize = 0;

	TUint currentCacheSize = 0;

	DPTest::CacheSize(minCacheSize,maxCacheSize,currentCacheSize);

	TESTDEBUG(test.Printf(_L("Original CacheSize: minCacheSize = 0x%x, maxCacheSize = 0x%x, currentCacheSize = 0x%x\n"), 

								minCacheSize >> gPageShift, maxCacheSize >> gPageShift, currentCacheSize >> gPageShift));

	TESTDEBUG(test.Printf(_L("SetCacheSize: minCacheSize = 0x%x, maxCacheSize = 0x%x\n"), minCacheSize >> gPageShift, aMaxBytes >> gPageShift));

	if (aMaxBytes == KMaxTUint64)

		{// Need to fill all of free memory with discardable pages

		UpdateRamInfo();

		maxCacheSize = minCacheSize + gFreeRam;

		if (aMinOffsetBytes != KMaxTUint64)

			{// Set the min cache size relative to the max cache size.

			minCacheSize = maxCacheSize - aMinOffsetBytes;

			}

		TESTDEBUG(test.Printf(_L("free 0x%x max 0x%x min 0x%x\n"), gFreeRam, maxCacheSize, minCacheSize));

		}

	else

		{

		maxCacheSize = aMaxBytes;

		}

	TInt r = DPTest::SetCacheSize(maxCacheSize, maxCacheSize);

	if (r != KErrNone)

		return r;

	r = DPTest::SetCacheSize(minCacheSize, maxCacheSize);

	if (r != KErrNone)

		return r;

	DPTest::CacheSize(minCacheSize,maxCacheSize,currentCacheSize);

	TESTDEBUG(test.Printf(_L("After CacheSize: minCacheSize = 0x%x, maxCacheSize = 0x%x, currentCacheSize = 0x%x\n"), 

					minCacheSize >> gPageShift, maxCacheSize >> gPageShift, currentCacheSize >> gPageShift));

	aNumDiscardableBytes = currentCacheSize - minCacheSize;

	TESTDEBUG(test.Printf(_L("Number of discardable bytes 0x%x\n"), aNumDiscardableBytes));

	if (aMaxBytes == KMaxTUint64)

		{

		UpdateRamInfo();

		if (gFreeRam != aNumDiscardableBytes)

			{// The only free RAM should be that of the DP cache.

			test.Printf(_L("gFreeRam 0x%x aNumDiscardableBytes 0x%x\n"), gFreeRam, aNumDiscardableBytes);

			return KErrGeneral;

			}

		}