// 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 "..\mmu\mmudetect.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;
LOCAL_D TUint gMemModel;
//
// 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));
}
// Get the memory model of the kernel that this test is running on.
gMemModel = MemModelType();
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);
TInt r;
r = VerifyMovDisAlloc();
if (r == KErrGeneral)
{
// A rare set of circumstances may cause some of the movable pages to be in
// use during the defrag and thus not be moved to the correct RAM zone. Run
// the defrag once more to give it a chance to move these pages. We ensure
// that there is no pending asynchronous clean up operation before doing so.
UserSvr::HalFunction(EHalGroupKernel, EKernelHalSupervisorBarrier, 0, 0);
Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
r = VerifyMovDisAlloc();
}
if (r != 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));
// Ensure any asynchronous clean up operations complete before we move on
// to the next test.
UserSvr::HalFunction(EHalGroupKernel, EKernelHalSupervisorBarrier, 0, 0);
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;
}
}
return KErrNone;
}
//
// ResetDPCache
//
// Flush the cache and set the boundaries back to their original values
//
void ResetDPCache()
{
if (gPagedRom)
{
TUint minCacheSize = 0;
TUint maxCacheSize = 0;
TUint currentCacheSize = 0;
TESTDEBUG(test.Printf(_L("FlushCache\n")));
TInt r = DPTest::FlushCache();
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));
r = DPTest::SetCacheSize(gOriginalMinCacheSize, gOriginalMinCacheSize);
r = DPTest::SetCacheSize(gOriginalMinCacheSize, gOriginalMaxCacheSize);
TESTDEBUG(test.Printf(_L("SetCacheSize returns r = %d\n"), 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));
}
}
//
// WriteToChunk
//
// Write to a number of chunks
//
TInt WriteToChunk(RChunk* aChunkArray, TUint aChunkArraySize, TInt aChunk, TUint8 aStart=0)
{
for (TUint i=0; i<10; i++) // Write to all chunks 10 times
{
for (TUint j=0; j < aChunkArraySize; j++) //Write to all open chunks except aChunk.
{
if (aChunkArray[j].Handle() != NULL)
{
if ((TInt)j == aChunk) // Don't write to specified chunk
{
continue;
}
TUint8* base = aChunkArray[j].Base();
for (TUint8 k = aStart; k < aStart + 10; k++)
{
*base++ = k; // write 0 - 9 to the chunk
}
}
}
}
return KErrNone;
}
//
// ReadChunk
//
// Read chunks - If a chunk is specified, that particular chunk is not read
//
TInt ReadChunk(RChunk* aChunkArray, TUint aChunkArraySize, TInt aChunk=-1)
{
for (TUint j=0; j < aChunkArraySize; j++) //Read all open chunks
{
if (aChunkArray[j].Handle() != NULL)
{
if ((TInt)j == aChunk) // Don't read specified chunk
{
continue;
}
TUint8* base = aChunkArray[j].Base();
while ((aChunkArray[j].Base() + aChunkArray[j].Size()) != base)
{
READ(base++);
}
}
}
return KErrNone;
}
//
// RemoveChunkAlloc
//
// Remove ALL chunks allocated
//
// @param aChunkArray The array that stores a reference to the chunks created.
// @param aChunkArraySize The size of aChunkArray.
//
void RemoveChunkAlloc(RChunk*& aChunkArray, TUint& aChunkArraySize)
{
TInt closedChunks = 0;
if (aChunkArray == NULL)
{// The chunk array has already been deleted.
return;
}
for (TUint i = 0; i < aChunkArraySize; i++)
{
if (aChunkArray[i].Handle() != NULL)
{
aChunkArray[i].Close();
closedChunks ++;
}
}
delete[] aChunkArray;
aChunkArray = NULL;
aChunkArraySize = 0;
UpdateRamInfo();
test.Printf(_L("Free RAM after closing %d chunks = 0x%x\n"),closedChunks,gFreeRam);
}
TBool SpaceAvailForPageTables(TUint aZoneIndex, TInt aNumPages)
{
// Every 1MB allocated needs a new page table
const TUint KDataBytesPerPageTable = 1024 * 1024;
// 1 Page can fit 4 page tables
const TUint KPageTablesPerPage = 4;
GetAllPageInfo();
if (aNumPages == KFillAllMovable)
{
aNumPages = gTotalPageCount.iFreePages;
}
TUint allocBytes = aNumPages << gPageShift;
// Add 1 as you always require at least 1 page table
TUint pageTablesRequired = (allocBytes / KDataBytesPerPageTable) + 1;
// Add 1 as the first 1-3 page tables may require a new page.
TUint pageTablePagesRequired = (pageTablesRequired / KPageTablesPerPage) + 1;
// Determine the number of free pages in the other zones
TUint freeInOther = 0;
for (TUint index = 0; index < gZoneCount; index++)
{
if (index != aZoneIndex)
{
freeInOther += gZoneUtilArray[index].iFreePages;
}
}
// Need an overhead for the heap to grow (5 pages)
const TUint KOverhead = 5;
if (freeInOther < pageTablePagesRequired + KOverhead)
{// Not enough space in other zones to fit all page tables
test.Printf(_L("No space in other zones for page table pages\n"));
return EFalse;
}
// There is space available in the other zones to fit all the page tables
return ETrue;
}
//
// AllocMovable
//
// Allocate movable memory in the form of chunks
//
// @param aChunkArray The array to store a reference to the chunks created.
// @param aChunkArraySize The size of aChunkArray.
// @param aNumChunks The number of chunks to create.
// @param aNumPages The size of each chunk.
//
TInt AllocMovable(RChunk*& aChunkArray, TUint& aChunkArraySize, TInt aNumChunks, TUint aChunkSize=KChunkDefaultSize, TBool aForceFill = ETrue)
{
TUint i = 0;
TInt r = 0;
TUint chunksAllocd = 0;
TBool fillAll = EFalse;
TInt numChunks = aNumChunks;
UpdateRamInfo();
// Allocate chunks to take up all of memory with the maximum number of chunks
if (aNumChunks == KFillAllMovable)
{
fillAll = ETrue;
if (aChunkSize == KChunkDefaultSize)
{
numChunks = KMaxChunks;
aChunkSize = gFreeRam / numChunks;
}
else
{
numChunks = gFreeRam / aChunkSize;
}
}
test.Printf(_L("gFreeRam = 0x%x, aChunkSize = 0x%x, numChunks = %d\n"), gFreeRam, aChunkSize, numChunks);
// Allocate as many chunks as is specified, either with the default chunk size or a specified chunk size
if (aChunkArray == NULL)
{
aChunkArraySize = numChunks;
aChunkArray = new RChunk[aChunkArraySize];
if (aChunkArray == NULL)
return KErrNoMemory;
}
// Create chunks for each RChunk with a NULL handle.
for (i = 0; i < aChunkArraySize; i++)
{
if (aChunkArray[i].Handle() == NULL)
{
// Keep going even if a chunk creation fails as the flag tests rely
// on this.
r = aChunkArray[i].CreateLocal(aChunkSize, aChunkSize);
if (r != KErrNone && fillAll && aForceFill)
{
while (aChunkArray[i].CreateLocal(aChunkSize, aChunkSize) != KErrNone)
{
aChunkSize -= gPageSize;
}
}
if (r == KErrNone)
{
chunksAllocd++;
}
}
User::After(10); // Wait so that the next chunk gets allocated in the next time slice
}
test.Printf(_L("Number of chunks allocd = %d\n"),chunksAllocd);
return r;
}
//
// ZoneAllocMovable
//
// Allocate the specified number of movable pages to a specific zone
// If the number of pages is not specified, then fill the specified zone with
// movable pages
//
// @param aChunkArray The array to store a reference to the chunks created.
// @param aChunkArraySize The size of aChunkArray.
// @param aZoneIndex The zone index to allocate movable pages to.
// @param aNumPages The number of movable pages to allocate.
//
TInt ZoneAllocMovable(RChunk*& aChunkArray, TUint& aChunkArraySize, TUint aZoneIndex, TUint aNumPages = KMaxTUint)
{
ResetRamZoneFlags();
TInt r = KErrNone;
TUint allocBytes = 0;
if (aNumPages == KMaxTUint)
{
aNumPages = gZoneUtilArray[aZoneIndex].iFreePages;
}
allocBytes = aNumPages << gPageShift;
if (!SpaceAvailForPageTables(aZoneIndex, aNumPages))
{
return KErrGeneral;
}
// Block all other zones from allocation
for(TUint index = 0; index < gZoneCount; index++)
{
if (index == aZoneIndex)
{
r = Ldd.SetZoneFlag(gZoneConfigArray[index].iZoneId, gZoneConfigArray[index].iFlags, NO_FIXED_FLAG);
}
else
{
r = Ldd.SetZoneFlag(gZoneConfigArray[index].iZoneId, gZoneConfigArray[index].iFlags, NO_MOVE_FLAG);
}
if (r != KErrNone)
{
test.Printf(_L("Failed to set RAM zone flag on zone %d r = %d\n"), index, r);
return r;
}
}
// Allocate the movable pages
r = AllocMovable(aChunkArray, aChunkArraySize, 1, allocBytes);
ResetRamZoneFlags();
return r;
}
//
// ZoneAllocDiscard
//
// Allocate the specified number of discardable pages to a specific zone
//
// @param aZoneIndex The zone index to allocate discardable pages to.
// @param aNumPages The number of discardable pages to allocate.
// @param aDisPages On return this will contain the number of discardable pages allocated
//
TInt ZoneAllocDiscard(TUint aZoneIndex, TUint aNumPages, TInt& aDisPages)
{
TInt r = KErrNone;
ResetRamZoneFlags();
for (TUint index = 0; index < gZoneCount; index++)
{
TUint zoneID = gZoneConfigArray[index].iZoneId;
if (index == aZoneIndex)
{
r = Ldd.SetZoneFlag(zoneID, gZoneConfigArray[index].iFlags, ONLY_DISCARD_FLAG);
}
else
{
r = Ldd.SetZoneFlag(zoneID, gZoneConfigArray[index].iFlags, NO_DISCARD_FLAG);
}
if (r != KErrNone)
{
test.Printf(_L("Failed to set flag r = %d\n"), r);
return r;
}
}
TUint disBytes = gTotalPageCount.iDiscardablePages + aNumPages << gPageShift;
r = AllocDiscardable(aDisPages, disBytes);
aDisPages = aDisPages >> gPageShift;
if (r != KErrNone)
{
test.Printf(_L("Discardable pages not allocated r = %d\n"), r);
}
ResetRamZoneFlags();
return r;
}
//
// FreeMovable
//
// Free movable pages by closing chunks.
// The function will close every other chunk so that the movable pages are scattered in every zone
//
// @param aChunkArray The array that stores reference to the chunks created.
// @param aChunkArraySize The size of aChunkArray.
//
TInt FreeMovable(RChunk* aChunkArray, TUint aChunkArraySize)
{
TUint i;
TInt closedChunks = 0;
for (i=0; i < aChunkArraySize; i+=2) // Close every other chunk
{
if (aChunkArray[i].Handle() != NULL)
{
aChunkArray[i].Close();
closedChunks ++;
}
}
UpdateRamInfo();
test.Printf(_L("Free RAM after closing %d chunks = 0x%x\n"),closedChunks,gFreeRam);
return KErrNone;
}
//
// GetBestZone
//
// Obtains the most preferable zone for allocating a specific type of page
//
// @param aPageType The page type that we are interested in
// @param aBestPrefIndex The index into the preference array for the zone.
//
// @return KErrNotFound if a zone cannot be found, else the zone index into gZoneUtilArray
//
TInt GetBestZone(TInt aPageType, TUint* aBestPrefIndex = NULL)
{
GetPrefOrder();
switch (aPageType)
{
case BEST_MOVABLE:
case BEST_DISCARDABLE:
{
TInt bestIndex = KErrNotFound;
TUint bestPrefIndex = 0;
TUint curIndex = 0;
TInt startIndex = KErrNotFound;
TBool zoneFound = EFalse;
// Find the least preferable zone that has movable or discardable pages
for (TInt prefIndex = gZoneCount - 1; prefIndex >= 0; prefIndex--)
{
curIndex = gPrefArray[prefIndex];
if (gZoneUtilArray[curIndex].iAllocMovable || gZoneUtilArray[curIndex].iAllocDiscardable)
{
startIndex = prefIndex;
break;
}
}
if (startIndex == KErrNotFound)
return startIndex;
// Work up the preference list to look for the best zone
for (TInt prefIndex = startIndex; prefIndex >= 0; prefIndex--)
{
curIndex = gPrefArray[prefIndex];
if (gZoneUtilArray[curIndex].iFreePages)
{
bestIndex = curIndex;
bestPrefIndex = prefIndex;
zoneFound = ETrue;
break;
}
}
// If the zone still isn't found, look down the preference list
if (!zoneFound)
{
for (TUint prefIndex = startIndex; prefIndex < gZoneCount; prefIndex++)
{
curIndex = gPrefArray[prefIndex];
if (gZoneUtilArray[curIndex].iFreePages)
{
bestIndex = curIndex;
bestPrefIndex = prefIndex;
zoneFound = ETrue;
break;
}
}
}
test.Printf(_L("leastPref = %d\n"), bestIndex);
if (aBestPrefIndex)
*aBestPrefIndex = bestPrefIndex;
return bestIndex;
}
case BEST_FIXED:
for (TUint prefIndex = 0; prefIndex < gZoneCount; prefIndex++)
{
TUint mostPref = gPrefArray[prefIndex];
if (gZoneUtilArray[mostPref].iFreePages != 0 ||
gZoneUtilArray[mostPref].iAllocMovable != 0 ||
gZoneUtilArray[mostPref].iAllocDiscardable != 0)
{
test.Printf(_L("mostPref = %d\n"), mostPref);
if (aBestPrefIndex)
*aBestPrefIndex = prefIndex;
return mostPref;
}
}
break;
}
test.Printf(_L("Cannot find zone\n"));
return KErrNotFound;
}
void GetCandList1(TInt aIndex);
//
// VerifyMovDisAlloc
//
// Checks that all movable and discardable pages are in the correct RAM zones.
// Should only be invoked after a general defragmentation or a general
// defragmentation followed by an allocation.
//
// NOTE - This shouldn't be used to verify RAM if a RAM specific allocation or
// zone claim operation has been performed.
//
// @return KErrNone if RAM layout is good, KErrGeneral if not, KErrNotFound if no
// movable or discardable pages are allocated.
//
TInt VerifyMovDisAlloc()
{
GetPrefOrder();
TInt leastInUse = KErrNotFound;
TUint requiredMovDis = 0;
TUint totalMorePrefInUse = 0;
TBool verifySpread = ETrue;
TBool prevZoneNotFull = EFalse;
// Determine which is the least prefable RAM zone in use and how many pages
// are allocated of each type.
for (TInt prefIndex = gZoneCount - 1; prefIndex >= 0; prefIndex--)
{
TUint index = gPrefArray[prefIndex];
TUint allocMov = gZoneUtilArray[index].iAllocMovable;
TUint allocDis = gZoneUtilArray[index].iAllocDiscardable;
TUint allocFixed = gZoneUtilArray[index].iAllocFixed;
TESTDEBUG(test.Printf(_L("pref ID 0x%x\n"), gZoneConfigArray[index].iZoneId));
if (allocMov || allocDis || allocFixed)
{
TBool zoneNotFull = EFalse;
GetCandList1(index);
TUint candIndex = 0;
for (; candIndex < gZoneCount; candIndex++)
{
TInt zoneIndexCand = gCandList1[candIndex];
if (zoneIndexCand == KInvalidCandIndex)
{
break;
}
allocMov += gZoneUtilArray[zoneIndexCand].iAllocMovable;
allocDis += gZoneUtilArray[zoneIndexCand].iAllocDiscardable;
if (gZoneUtilArray[zoneIndexCand].iFreePages)
{
zoneNotFull = ETrue;
}
}
prefIndex -= candIndex - 1;
if (leastInUse == KErrNotFound)
{// Have found least preferable RAM zone that is in use.
leastInUse = index;
if (allocFixed)
{// The least preferable RAM zone has fixed pages in it so
// RAM may be more spread out than is necessary.
verifySpread = EFalse;
}
}
else
{
if (verifySpread && (allocMov || allocDis) && prevZoneNotFull)
{// The previous least preferable RAM zones were not full so shouldn't
// be any movable or discardable pages in the RAM zones of this preference.
test.Printf(_L("Movable or discardable pages in more preferable RAM zones unnecessarily\n"));
return KErrGeneral;
}
prevZoneNotFull = zoneNotFull;
// Not the least preferable RAM zone so add to total allocatable.
totalMorePrefInUse += allocMov + allocDis + gZoneUtilArray[index].iFreePages;
}
requiredMovDis += allocMov + allocDis;
}
}
if (leastInUse == KErrNotFound)
{// No movable or discardable pages are allocated.
test.Printf(_L("No in use RAM zones found????\n"));
return KErrNotFound;
}
if (totalMorePrefInUse > requiredMovDis)
{// There are enough allocatable pages in the RAM zones below the currently
// least preferable RAM in use.
test.Printf(_L("Memory is spread out totalMorePref 0x%x required 0x%x\n"), totalMorePrefInUse, requiredMovDis);
if (verifySpread)
return KErrGeneral;
}
return KErrNone;
}
//
// GetCandList1
//
// Populates a list of all zones that have the same preference and the same amount
// of immovable pages
//
void GetCandList1(TInt aIndex)
{
for (TUint i=0; i<gZoneCount; i++)
{
gCandList1[i] = KInvalidCandIndex;
}
TInt candListIndex = 0;
GetAllPageInfo();
for (TUint i=0; i<gZoneCount; i++)
{
if (ZonesSamePref(aIndex, i))
{
gCandList1[candListIndex] = i;
candListIndex ++;
}
}
}
//
// GetCandList2
//
// Populates a list of all zones that have the same preference and the same amount
// of immovable pages
//
void GetCandList2(TInt aIndex)
{
for (TUint i=0; i<gZoneCount; i++)
{
gCandList2[i] = KInvalidCandIndex;
}
TInt candListIndex = 0;
GetAllPageInfo();
for (TUint i=0; i<gZoneCount; i++)
{
if (ZonesSamePref(aIndex, i))
{
gCandList2[candListIndex] = i;
candListIndex ++;
}
}
}
//
// GetCandListFixed1
//
// Populates a list of all zones that have the same preference and the same
// amount of immovable pages, it will ignore RAM zones that are full of
// immovable pages as these are the only RAM zones that fixed pages can't be
// allocated into.
//
void GetCandListFixed1(TInt aIndex)
{
for (TUint i=0; i<gZoneCount; i++)
{
gCandList1[i] = KInvalidCandIndex;
}
TInt candListIndex = 0;
GetAllPageInfo();
for (TUint i=0; i<gZoneCount; i++)
{
if (ZonesSamePref(aIndex, i) &&
gZoneUtilArray[i].iAllocFixed + gZoneUtilArray[i].iAllocUnknown !=
gZoneConfigArray[i].iPhysPages)
{
gCandList1[candListIndex] = i;
candListIndex ++;
}
}
}
//
// MultiGenDefragThreadFunc
//
// Called when a general defrag is called to run at the same time as another operation
//
TInt MultiGenDefragThreadFunc(TAny* /*aPtr*/)
{
RRamDefragFuncTestLdd Ldd2;
TInt r = Ldd2.Open();
if (r != KErrNone)
{
RDebug::Printf("Unable to open Ldd2 in MultiGenDefragThreadFunc, r = %d\n", r);
return r;
}
RThread thisThread = RThread();
thisThread.SetPriority(EPriorityLess);
r = Ldd2.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
Ldd2.Close();
thisThread.Close();
return r;
}
TBool gTestLoop = EFalse;
//
// MultiLoopGenDefragThreadFunc
//
// Called when a general defrag is called to run at the same time as another operation
//
TInt MultiLoopGenDefragThreadFunc(TAny* /*aPtr*/)
{
RRamDefragFuncTestLdd Ldd2;
TInt r = Ldd2.Open();
if (r != KErrNone)
{
RDebug::Printf("Unable to open Ldd2 in MultiLoopGenDefragThreadFunc, r = %d\n", r);
return r;
}
RThread thisThread = RThread();
thisThread.SetPriority(EPriorityLess);
while (gTestLoop)
{
r = Ldd2.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
if (r != KErrNone)
goto threadExit;
}
threadExit:
Ldd2.Close();
thisThread.Close();
return r;
}
//
// MultiEmptyZoneThreadFunc
//
// Called when a zone defrag is called to run at the same time as another operation
//
TInt MultiEmptyZoneThreadFunc(TAny* zoneID)
{
RRamDefragFuncTestLdd Ldd2;
TInt r = Ldd2.Open();
if (r != KErrNone)
{
RDebug::Printf("Unable to open Ldd2 in MultiEmptyZoneThreadFunc, r = %d\n", r);
return r;
}
RThread thisThread = RThread();
thisThread.SetPriority(EPriorityLess);
r = Ldd2.CallDefrag(DEFRAG_TYPE_EMPTY, DEFRAG_VER_SYNC, (TUint)zoneID);
Ldd2.Close();
thisThread.Close();
return r;
}
//
// MultiClaimZoneThreadFunc
//
// Called when a ClaimRamZone is called to run at the same time as another operation
//
TInt MultiClaimZoneThreadFunc(TAny* zoneID)
{
RRamDefragFuncTestLdd Ldd2;
TInt r = Ldd2.Open();
if (r != KErrNone)
{
RDebug::Printf("Unable to open Ldd2 in MultiClaimZoneThreadFunc, r = %d\n", r);
return r;
}
RThread thisThread = RThread();
thisThread.SetPriority(EPriorityLess);
r = Ldd2.CallDefrag(DEFRAG_TYPE_CLAIM, DEFRAG_VER_SYNC, (TUint)zoneID);
Ldd2.Close();
thisThread.Close();
return r;
}
//
// TestAllocStrategies
//
// Verifying that pages are allocated correctly. All tests rely on a general defragmentation occuring
// in TestStart() so that memory is in a defragmented state before the allocations.
//
//---------------------------------------------------------------------------------------------------------------------
//! @SYMTestCaseID KBASE-t_ramdefrag-0525
//! @SYMTestCaseDesc Verifying that pages are allocated correctly
//! @SYMTestType CIT
//! @SYMPREQ PREQ308
//! @SYMTestPriority High
//! @SYMTestActions
//! 1. Allocate one chunk to memory.
//! Check which zone the chunk has been allocated to by checking the
//! number of movable pages before and after the allocation has taken place.
//! 2. Allocate one chunk to memory that is large enough to cause an empty RAM
//! zone to be used.
//! 3. Allocate a certain number of fixed pages to memory.
//! Check which zone the chunk has been allocated to by checking the
//! number of fixed pages before and after the allocation has taken place.
//! 4. Allocate fixed pages when it is known that discardable pages will need
//! to be discarded for the allocation to succeed.
//! 5. Allocate fixed pages when it is known that movable pages will need
//! to be moved for the allocation to succeed.
//! 6. Allocate fixed pages when it is known that movable pages will need
//! to be moved for the allocation to succeed, Determine the "best" zone for fixed pages and allocate 1 more
//! than that.
//! 7. Allocate discardable pages by loading pages that are demand paged.
//! Check which zone the memory has been allocated to by checking the number of
//! discardable pages before and after the allocation has taken place.
//! 8. Allocate a contiguous fixed page into a zone which is full of movable or discardable pages.
//! 9. Allocate a large 1MB aligned chunk with as few pages as possible availiable for page tables,
//! then clear to every page in the chunk. This is attempting to ensure that the chunk pages
//! that have page tables associated to them are remapped correctly if the chunk pages have to be
//! moved so page table pages to map other pages in the chunk are allocated in the most preferable
//! ram zones.
//!
//! @SYMTestExpectedResults
//! 1. The memory has been allocated to the most preferred zone with the least amount of
//! space accounting for the zone threshold for movable pages.
//! 2. The new RAM zone is used and the movable page are allocated into it first then the other
//! more preferable RAM zones.
//! 3. The fixed pages are allocated to the most preferred zone
//! 4. The fixed pages are allocatted to the most preferred zone with free, movable or discardable pages in it.
//! 5. The fixed pages are allocatted to the most preferred zone with free, movable or discardable pages in it.
//! 6. Extra page is placed in the next preferable to the "best"zone
//! 7. Memory is allocated to the most preferred zone with the least amount of
//! space accounting for the zone threshold for discardable pages.
//! 8. The fixed page is allocated as it has moved or discarded a page.
//! 9. The chunk is cleared succesfully.
//!
//---------------------------------------------------------------------------------------------------------------------
TInt TestAllocStrategies()
{
test.Start(_L("Test1: Check which zone a movable page has been allocated to "));
TestStart(); //This will perform a general defrag which should tidy up RAM for us
gChunkArray1 = new RChunk;
gChunkArraySize1 = 1;
TBool zoneFound = EFalse;
// Determine if suitable RAM zone exists for testing
TInt best = GetBestZone(BEST_MOVABLE);
if (best == KErrNotFound)
{
test.Printf(_L("Cannot find zone to perform test - Skipping...\n"));
}
else
{
test.Printf(_L("best = %d\n"), best);
// Populate the candidate list
GetCandList2(best);
// Allocate 1 movable page
GetOriginalPageCount();
if (AllocMovable(gChunkArray1, gChunkArraySize1, 1, gPageSize) != KErrNone)
{
test.Printf(_L("Not enough free RAM for test - Skipping...\n"));
}
else
{
GetAllPageInfo();
TInt r = VerifyMovDisAlloc();
// Need to check all candidates to see if page has gone into any one of them
for (TUint i=0; i < gZoneCount; i++)
{
if (gCandList2[i] == KInvalidCandIndex)
{
break;
}
TUint zoneIndex = gCandList2[i];
if (gOriginalPageCountArray[zoneIndex].iAllocMovable < gZoneUtilArray[zoneIndex].iAllocMovable)
{
zoneFound = ETrue;
break;
}
}
if (r == KErrNone && zoneFound)
{
test.Printf(_L("Pass: Movable allocated to the zone expected\n"));
}
else
{
test.Printf(_L("Fail: Movable allocated to a zone that was not expected, r %d\n"), r);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
}
}
TestEnd();
test.Next(_L("Test2: Check that movable pages allocated from least preferable RAM zone to be used\n"));
TestStart();
gChunkArray1 = new RChunk;
gChunkArraySize1 = 1;
// Determine if suitable RAM zone exists for testing.
TUint bestPrefIndex;
best = GetBestZone(BEST_MOVABLE, &bestPrefIndex);
TUint morePrefIndex = bestPrefIndex - 1;
TUint nextLeastPrefIndex = bestPrefIndex + 1;
// Check number of free pages in the more preferable zones
TUint freeInMorePref = 0;
for (TUint i = 0; i < bestPrefIndex; i++)
{
freeInMorePref += gZoneUtilArray[gPrefArray[i]].iFreePages;
}
test.Printf(_L("freeInMorePref = 0x%x\n"), freeInMorePref);
const TUint KHeapOverhead = 5; // Room for kernel heap allocations so they don't affect the page count
if (best == KErrNotFound || nextLeastPrefIndex >= gZoneCount ||
(gZoneUtilArray[gPrefArray[nextLeastPrefIndex]].iFreePages < KHeapOverhead &&
freeInMorePref < KHeapOverhead)||
gZoneConfigArray[gPrefArray[nextLeastPrefIndex]].iPref == gZoneConfigArray[best].iPref ||
gZoneConfigArray[gPrefArray[morePrefIndex]].iPref == gZoneConfigArray[best].iPref)
{// No less preferable RAM zone or there are more or less preferable of
// same preference so re-ordering potential makes verification too complex.
test.Printf(_L("Cannot find zone to perform test - Skipping...\n"));
}
else
{
// Ensure the zone is almost full as chunks will get allocated in blocks
// by almost filling the best zone with fixed pages, leaving a space (e.g. 20 pages)
const TUint KSpaceNeeded = 20;
if (gZoneUtilArray[best].iFreePages > KSpaceNeeded)
{
TUint zoneID = gZoneUtilArray[best].iZoneId;
TUint diffAlloc = gZoneUtilArray[best].iFreePages - KSpaceNeeded;
TInt r = Ldd.ZoneAllocDiscontiguous(zoneID, diffAlloc);
if (r != KErrNone)
{
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
}
GetAllPageInfo();
// Update the number of free pages in the more preferable zones
freeInMorePref = 0;
for (TUint i = 0; i < bestPrefIndex; i++)
{
freeInMorePref += gZoneUtilArray[gPrefArray[i]].iFreePages;
}
TUint origFixed = gTotalPageCount.iFixedPages;
GetOriginalPageCount();
// Allocate enough movable pages that the next least preferable RAM zone
// will need to be used.
TUint movPages = gZoneUtilArray[best].iFreePages + 1;
TUint movBytes = movPages << gPageShift;
TInt r = AllocMovable(gChunkArray1, gChunkArraySize1, 1, movBytes);
if (r != KErrNone)
{
CLEANUP(Ldd.FreeAllFixedPages());
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
GetAllPageInfo();
TUint curFixed = gTotalPageCount.iFixedPages;
TInt difFixed = curFixed - origFixed;
// If there is space in the more preferable zones then they should be allocated starting from
// the "best" zone to the more preferable zones, else from the next least preferable zone to the more preferable zones
TUint prefIndex;
if ((TInt)freeInMorePref > difFixed)
{//No new zones should be turned on, allocation should have gone into bestPrefIndex then down towards most preferred zones
TUint nextIndex = gPrefArray[nextLeastPrefIndex];
if (gOriginalPageCountArray[best].iAllocMovable >= gZoneUtilArray[best].iAllocMovable ||
gOriginalPageCountArray[nextIndex].iAllocMovable < gZoneUtilArray[nextIndex].iAllocMovable)
{
test.Printf(_L("Movable page allocated incorrectly origFree 0x%x curFree 0x%x nxtPrefFree 0x%x\n"),
gOriginalPageCountArray[best].iFreePages, gZoneUtilArray[best].iFreePages,
gZoneUtilArray[nextLeastPrefIndex].iFreePages);
CLEANUP(Ldd.FreeAllFixedPages());
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
prefIndex = morePrefIndex;
}
else
{// If there are enough free pages in "nextIndex" to fit all movable pages allocated then the movable
// page count in "best" should stay the same, else they should be allocated between "nextIndex" and "best".
TUint nextIndex = gPrefArray[nextLeastPrefIndex];
test.Printf(_L("nextIndex = %d\n"), nextIndex);
if (gOriginalPageCountArray[nextIndex].iAllocMovable >= gZoneUtilArray[nextIndex].iAllocMovable ||
(gOriginalPageCountArray[nextIndex].iFreePages >= movPages &&
gOriginalPageCountArray[best].iAllocMovable != gZoneUtilArray[best].iAllocMovable) ||
(gOriginalPageCountArray[nextIndex].iFreePages < movPages &&
gOriginalPageCountArray[best].iAllocMovable == gZoneUtilArray[best].iAllocMovable))
{
test.Printf(_L("Movable page allocated incorrectly origFree 0x%x curFree 0x%x nxtPrefFree 0x%x\n"),
gOriginalPageCountArray[nextIndex].iFreePages, gZoneUtilArray[nextIndex].iFreePages,
gZoneUtilArray[nextIndex].iFreePages);
CLEANUP(Ldd.FreeAllFixedPages());
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
prefIndex = bestPrefIndex;
}
// Check that movable pages have only been allocated into the more
// preferable RAM zones if the less preferable ram zones in use are full.
prefIndex++;
do
{
prefIndex--;
TUint indexCurrent = gPrefArray[prefIndex];
TUint indexLessPref = gPrefArray[prefIndex+1];
if (gOriginalPageCountArray[indexCurrent].iAllocMovable < gZoneUtilArray[indexCurrent].iAllocMovable &&
gZoneUtilArray[indexLessPref].iFreePages)
{// Current in use zone or less preferable than current has free pages so fail
test.Printf(_L("Movable page allocated incorrectly origFree 0x%x curFree 0x%x nxtPrefFree 0x%x\n"),
gOriginalPageCountArray[best].iFreePages, gZoneUtilArray[best].iFreePages,
gZoneUtilArray[nextLeastPrefIndex].iFreePages);
CLEANUP(Ldd.FreeAllFixedPages());
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
}
while(prefIndex);
test.Printf(_L("Pass: Pages allocated to the zone expected\n"));
}
TestEnd();
test.Next(_L("Test3: Check which zone a fixed page has been allocated to "));
for (TUint testStep = 0; testStep < 2; testStep++)
{
switch (testStep)
{
case 0:
test.Printf(_L("Testing discontiguous allocations\n"));
break;
case 1:
test.Printf(_L("Testing contiguous allocations\n"));
break;
}
TestStart();
zoneFound = EFalse;
GetOriginalPageCount();
best = GetBestZone(BEST_FIXED);
TESTDEBUG(test.Printf(_L("best = %d\n"), best));
if (best == KErrNotFound)
{
test.Printf(_L("Cannot find zone to perform test - Skipping...\n"));
}
else
{
GetCandList1(best);
TInt allocFixedPages = 1; // Try and allocate just 1 fixed page
switch (testStep)
{
case 0:
Ldd.AllocateFixed(allocFixedPages);
break;
case 1:
TUint allocFixedBytes = allocFixedPages << gPageShift;
Ldd.AllocContiguous(allocFixedBytes);
break;
}
GetAllPageInfo();
for (TUint i=0; i<gZoneCount; i++)
{
if (gCandList1[i] == KInvalidCandIndex)
{
break;
}
TUint zoneIndex = gCandList1[i];
if (gOriginalPageCountArray[zoneIndex].iAllocFixed + allocFixedPages <= gZoneUtilArray[zoneIndex].iAllocFixed)
{
zoneFound = ETrue;
break;
}
}
if (zoneFound)
{
test.Printf(_L("Pass: Chunk has been allocated to the zone expected\n"));
}
else
{
test.Printf(_L("Fail: Fixed been allocated to a zone that was not expected\n"));
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
Ldd.FreeAllFixedPages();
}
TestEnd();
}
test.Next(_L("Test4: Check fixed page allocations will discard pages"));
for (TUint testStep = 0; testStep < 2; testStep++)
{
switch (testStep)
{
case 0:
test.Printf(_L("Testing discontiguous allocations\n"));
break;
case 1:
test.Printf(_L("Testing contiguous allocations\n"));
break;
}
TestStart();
TInt discardBytes;
TInt r;
if (!gPagedRom)
{
test.Printf(_L("Not a paged ROM - Skipping test step\n"));
goto SkipTest4;
}
best = GetBestZone(BEST_FIXED);
TESTDEBUG(test.Printf(_L("best = %d\n"), best));
if (best == KErrNotFound)
{
test.Printf(_L("Cannot find zone to perform test - Skipping...\n"));
goto SkipTest4;
}
// Ensure discardable pages in the preferred RAM zone.
r = AllocDiscardable(discardBytes);
if (r != KErrNone)
{
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
TEST_FAIL;
}
if (discardBytes < gPageSize)
{// Can't discard any pages so test can't run.
test.Printf(_L("Memory too full to perform test - Skipping...\n"));
goto SkipTest4;
}
// Make sure all RAM zones that the fixed page allocation could potentially
// go to have discardable pages allocated in it.
GetOriginalPageCount();
GetCandListFixed1(best);
for (TUint i = 0; i < gZoneCount; i++)
{
if (gCandList1[i] == KInvalidCandIndex)
{
break;
}
TUint zoneIndex = gCandList1[i];
if (gOriginalPageCountArray[zoneIndex].iAllocDiscardable == 0)
{
test.Printf(_L("No dicardable pages in one of the candidates RAM zones - Skipping...\n"));
goto SkipTest4;
}
if (gOriginalPageCountArray[zoneIndex].iFreePages != 0)
{
test.Printf(_L("Some free pages in candidate RAM zone ID%x\n"),
gZoneConfigArray[zoneIndex].iZoneId);
CLEANUP(ResetDPCache());
TEST_FAIL;
}
}
// Allocate 1 fixed page and ensure that it discards a page.
switch (testStep)
{
case 0:
r = Ldd.AllocateFixed(1);
break;
case 1:
r = Ldd.AllocContiguous(gPageSize);
break;
}
// Find RAM zone the fixed page was allocated into.
GetAllPageInfo();
zoneFound = EFalse;
for (TUint i = 0; i < gZoneCount; i++)
{
if (gCandList1[i] == KInvalidCandIndex)
{
break;
}
TUint zoneIndex = gCandList1[i];
if (gOriginalPageCountArray[zoneIndex].iAllocFixed < gZoneUtilArray[zoneIndex].iAllocFixed)
{
zoneFound = ETrue;
if (gOriginalPageCountArray[zoneIndex].iAllocDiscardable <= gZoneUtilArray[zoneIndex].iAllocDiscardable &&
gOriginalPageCountArray[zoneIndex].iAllocMovable <= gZoneUtilArray[zoneIndex].iAllocMovable)
{
test.Printf(_L("Fixed pages allocated but no pages discarded in RAM zone ID 0x%x\n"),
gZoneConfigArray[zoneIndex].iZoneId);
CLEANUP(ResetDPCache());
TEST_FAIL;
}
}
}
if (!zoneFound || r != KErrNone)
{
test.Printf(_L("No fixed pages were allocated r = %d\n"), r);
CLEANUP(ResetDPCache());
TEST_FAIL;
}
else
{
test.Printf(_L("Pass: Pages been allocated to the zone expected\n"));
}
SkipTest4 :
// This will free any DP cache pages and fixed pages allocated.
TestEnd();
}
for (TUint testIndex = 0; testIndex < 2; testIndex++)
{
switch (testIndex)
{
case 0:
test.Next(_L("Test5: Check fixed page allocations (discontiguous) will move pages"));
break;
case 1:
test.Next(_L("Test6: Check fixed page will only go into a new zone if all other fix page zones are full of fix"));
break;
}
TestStart();
gChunkArray1 = new RChunk;
gChunkArraySize1 = 1;
TInt r = KErrNone;
TUint freeInOtherZones = 0;
TUint allocatablePages;
TUint allocImmovPages;
TUint bestPrefIndex;
TUint nextBestIndex = 0;
const TUint KMovAllocOverhead = 5; // need pages for page tables and kernel heap expansion.
best = GetBestZone(BEST_FIXED, &bestPrefIndex);
TESTDEBUG(test.Printf(_L("best = %d\n"), best));
GetCandListFixed1(best);
TUint candidates = 0;
for (TUint i = 0; i < gZoneCount; i++)
{
if (gCandList1[i] == KInvalidCandIndex)
{
break;
}
candidates++;
}
if (best == KErrNotFound ||
(gZoneUtilArray[best].iAllocMovable == 0 && gZoneUtilArray[best].iFreePages < KMovAllocOverhead) ||
candidates != 1)
{
test.Printf(_L("Cannot find zone or too many equal pref zones to perform test - Skipping...\n"));
goto SkipTest5;
}
if (testIndex == 1)
{// need to work out what the next best zone would be
GetPrefOrder();
if (bestPrefIndex + 1 >= gZoneCount)
{
test.Printf(_L("Cannot find next best zone - Skipping...\n"));
goto SkipTest5;
}
nextBestIndex = gPrefArray[bestPrefIndex + 1];
test.Printf(_L("nextBestIndex= %d\n"), nextBestIndex);
GetCandListFixed1(nextBestIndex);
candidates = 0;
for (TUint i = 0; i < gZoneCount; i++)
{
if (gCandList1[i] == KInvalidCandIndex)
{
break;
}
candidates++;
}
if (gZoneUtilArray[nextBestIndex].iPhysPages == gZoneUtilArray[nextBestIndex].iAllocFixed +
gZoneUtilArray[nextBestIndex].iAllocUnknown ||
candidates != 1)
{
test.Printf(_L("Cannot find zone or too many equal pref zones to perform test - Skipping...\n"));
goto SkipTest5;
}
}
for (TUint i = 0; i < gZoneCount; i++)
{
if (i != (TUint)best)
{
freeInOtherZones += gZoneUtilArray[i].iFreePages;
}
}
allocatablePages = gZoneUtilArray[best].iFreePages +
gZoneUtilArray[best].iAllocMovable +
gZoneUtilArray[best].iAllocDiscardable;
if (allocatablePages > freeInOtherZones)
{
test.Printf(_L("Not enough free RAM for test - Skipping...\n"));
goto SkipTest5;
}
// Allocate the fixed array before getting any page counts
r = Ldd.AllocFixedArray(allocatablePages + 1);
if (r != KErrNone)
{
test.Printf(_L("Failed to allocate fixed array r = %d - Skipping...\n"), r);
goto SkipTest5;
}
// Fill the RAM zone with movable pages if none already in it.
GetAllPageInfo();
if (gZoneUtilArray[best].iAllocMovable == 0)
{
if (!gZoneUtilArray[best].iFreePages)
{
test.Printf(_L("RAM zone ID %x too full for test - Skipping...\n"), gZoneConfigArray[best].iZoneId);
goto SkipTest5;
}
// Fill the zone with movable pages
r = ZoneAllocMovable(gChunkArray1, gChunkArraySize1, best);
if (r != KErrNone)
{
test.Printf(_L("Failed to fill zone index %d with movable r = %d\n"), best, r);
CLEANUP(ResetRamZoneFlags());
TEST_FAIL;
}
if (GetBestZone(BEST_FIXED) != best)
{
test.Printf(_L("Unable to complete test; RAM zone reordering - Skipping...\n"));
goto SkipTest5;
}
}
// Allocate fixed pages after reseting the allocation flags.
GetAllPageInfo();
ResetRamZoneFlags();
allocatablePages = gZoneUtilArray[best].iFreePages +
gZoneUtilArray[best].iAllocMovable +
gZoneUtilArray[best].iAllocDiscardable;
switch (testIndex)
{
case 0:
r = Ldd.AllocateFixed2(allocatablePages);
GetAllPageInfo();
allocImmovPages = gZoneUtilArray[best].iAllocFixed + gZoneUtilArray[best].iAllocUnknown;
if (r != KErrNone || gZoneConfigArray[best].iPhysPages != allocImmovPages)
{
test.Printf(_L("RAM zone ID 0x%x not full of immovable pages\n"), gZoneConfigArray[best].iZoneId);
CLEANUP(ResetRamZoneFlags());
TEST_FAIL;
}
else
{
test.Printf(_L("Pass: Pages allocated to the zone expected\n"));
}
break;
case 1:
GetOriginalPageCount();
r = Ldd.AllocateFixed2(allocatablePages + 1);
GetAllPageInfo();
allocImmovPages = gZoneUtilArray[best].iAllocFixed + gZoneUtilArray[best].iAllocUnknown;
if (r != KErrNone || gZoneUtilArray[best].iPhysPages != allocImmovPages ||
gZoneUtilArray[nextBestIndex].iAllocFixed <= gOriginalPageCountArray[nextBestIndex].iAllocFixed)
{
test.Printf(_L("RAM zone ID 0x%x not full of immovable pages or next best ID 0x%x no fix pages\n"),
gZoneConfigArray[best].iZoneId, gZoneConfigArray[nextBestIndex].iZoneId);
test.Printf(_L("nextBest %d origFix 0x%x curFix 0x%x\n"),
nextBestIndex, gOriginalPageCountArray[nextBestIndex].iAllocFixed,
gZoneUtilArray[nextBestIndex].iAllocFixed);
CLEANUP(ResetRamZoneFlags());
TEST_FAIL;
}
// Go through every other zone and check that fixed pages haven't increased
for (TUint i = 0; i < gZoneCount; i++)
{
if (i != (TUint)best && i != (TUint)nextBestIndex &&
gZoneUtilArray[i].iAllocFixed > gOriginalPageCountArray[i].iAllocFixed)
{
test.Printf(_L("FAIL: Fix page count increased zoneIndex %d orig 0x%x current 0x%x\n"),
i, gOriginalPageCountArray[i].iAllocFixed, gZoneUtilArray[i].iAllocFixed);
CLEANUP(ResetRamZoneFlags());
TEST_FAIL;
}
}
test.Printf(_L("Pass: Pages allocated to the zone expected\n"));
break;
}
SkipTest5 :
// This will perform any required clean up.
ResetRamZoneFlags();
TestEnd();
}
test.Next(_L("Test7: Check which zone a discardable page has been allocated to"));
TestStart();
if (gPagedRom)
{
GetAllPageInfo();
// Try to allocate just one more discardable page
TUint allocBytes = (gTotalPageCount.iDiscardablePages + 1) << gPageShift;
TInt discardablePages;
best = GetBestZone(BEST_DISCARDABLE);
if (best == KErrNotFound)
{
test.Printf(_L("Cannot find zone to perform test - Skipping...\n"));
}
else
{
// Populate the candidate list
GetCandList2(best);
zoneFound = EFalse;
GetOriginalPageCount();
TInt r = AllocDiscardable(discardablePages, allocBytes);
if (r != KErrNone)
{
test.Printf(_L("Fail: r %d\n"), r);
CLEANUP(ResetDPCache());
TEST_FAIL;
}
r = VerifyMovDisAlloc();
// Need to check all candidates to see if page has gone into any one of them
for (TUint i=0; i < gZoneCount; i++)
{
if (gCandList2[i] == KInvalidCandIndex)
{
break;
}
TUint zoneIndex = gCandList2[i];
if (gOriginalPageCountArray[zoneIndex].iAllocDiscardable < gZoneUtilArray[zoneIndex].iAllocDiscardable)
{
zoneFound = ETrue;
break;
}
}
if (r == KErrNone && zoneFound)
{
test.Printf(_L("Pass: Discardable allocated to the zone expected\n"));
}
else
{
test.Printf(_L("Fail: Discardable been allocated to a zone that was not expected r %d\n"), r);
CLEANUP(ResetDPCache());
TEST_FAIL;
}
}
}
else
{
test.Printf(_L("Not a paged ROM - Skipping test step\n"));
}
TestEnd();
test.Next(_L("Test8: Check fixed page allocations (contiguous) will move pages"));
TestStart();
gChunkArray1 = new RChunk;
gChunkArraySize1 = 1;
TInt r = KErrNone;
TUint testZoneIndex = 0;
// Get the most pref zone which is completely free to use as a test zone
r = FindMostPrefEmpty(testZoneIndex);
if (r != KErrNone)
{
test.Printf(_L("Cannot find empty zone - Skipping...\n"));
goto skipTest8;
}
// fill the test zone with movable pages
r = ZoneAllocMovable(gChunkArray1, gChunkArraySize1, testZoneIndex);
GetAllPageInfo();
if (r != KErrNone ||
gZoneUtilArray[testZoneIndex].iAllocMovable != gZoneUtilArray[testZoneIndex].iPhysPages)
{
test.Printf(_L("Failed to allocate movable r = %d - Skipping...\n"), r);
goto skipTest8;
}
if (gTotalPageCount.iFreePages < 1)
{
test.Printf(_L("Insufficient memory - totalFreePages = 0x%x - Skipping...\n"), gTotalPageCount.iFreePages);
goto skipTest8;
}
for (TUint zoneIndex = 0; zoneIndex < gZoneCount; zoneIndex++)
{
TUint zoneId = gZoneConfigArray[zoneIndex].iZoneId;
if (zoneIndex != testZoneIndex)
{
r = Ldd.SetZoneFlag(zoneId, gZoneConfigArray[zoneIndex].iFlags, NO_FIXED_FLAG);
if (r != KErrNone)
{
test.Printf(_L("Failed to set flag on zone index %d r = %d- Skipping...\n"), zoneIndex, r);
goto skipTest8;
}
}
}
//attempt to alloc 1 contiguous fixed page
r = Ldd.AllocContiguous(gPageSize);
GetAllPageInfo();
if (r != KErrNone ||
!gZoneUtilArray[testZoneIndex].iAllocFixed)
{
test.Printf(_L("FAIL: no fixed pages in testZoneIndex(%d) r = %d\n"), testZoneIndex, r);
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
skipTest8:
TestEnd();
test.Next(_L("Test9: Allocate a large 1MB aligned chunk and touch all its pages"));
TestStart();
gChunkArray1 = new RChunk;
gChunkArraySize1 = 1;
GetAllPageInfo();
const TUint KChunkBytes = 0x100000;
const TUint KChunkMask = KChunkBytes - 1;
TUint freeBytes = gTotalPageCount.iFreePages << gPageShift;
TUint chunkSize = freeBytes & ~KChunkMask;
// Fill as much memory as possible with fixed pages while still allowing the movable allocation to succeed.
// This should help force the page table allocation for the chunk to need to move pages.
TUint fixedSize = freeBytes - chunkSize;
r = KErrNoMemory;
while (r != KErrNone && fixedSize)
{
Ldd.FreeAllFixedPages();
fixedSize -= gPageSize;
test.Printf(_L("fixedSize 0x%x\n"), fixedSize);
r = Ldd.AllocateFixed(fixedSize >> gPageShift);
if (r != KErrNone)
break;
r = AllocMovable(gChunkArray1, gChunkArraySize1, gChunkArraySize1, chunkSize);
}
if (r == KErrNone)
{
// Touch every page in the chunk.
memclr(gChunkArray1->Base(), chunkSize);
}
TestEnd(); // This will free any chunk and fixed pages.
test.End();
return KErrNone;
}
//
// TestMovingPages
//
//---------------------------------------------------------------------------------------------------------------------
//! @SYMTestCaseID KBASE-t_ramdefrag-0526
//! @SYMTestType CIT
//! @SYMTestCaseDesc Verifying that pages are moved correctly
//! @SYMPREQ PREQ308
//! @SYMTestPriority High
//! @SYMTestActions
//! 1. Fragment the memory. Write to all chunks apart from chunk 9.
//! Following this start a RAM defrag and whilst defrag is running write to chunk 9.
//! 2. Fragment the memory. Start a RAM defrag and whilst defrag is running
//! continuously write different values to the chunks.
//! 3. Fragment the memory. Following this start a RAM defrag and whilst this
//! is happening, continuously read from all chunks.
//! 4. Allocate some movable pages. Call a device driver that will allocate fixed
//! pages and write values to these fixed pages.
//! Close every other chunk so that only 5 chunks are now still open.
//! Following this perform a RAM defrag.
//! Read from the fixed pages that were originally written to, ensuring
//! that they have not changed.
//! 5. Without starting any processes, allocate discardable pages by loading
//! pages that are demand paged.
//! Read each of the constants from beginning to end.
//! Following this perform a RAM defrag.
//!
//! @SYMTestExpectedResults
//! 1. Zones are emptied
//! 2. Zones are emptied
//! 3. Zones are emptied
//! 4. The values written to the fixed pages have not changed.
//! 5. Zones are emptied
//---------------------------------------------------------------------------------------------------------------------
TInt TestMovingPages()
{
const TInt KAllChunks = -1; // Specifies that all chunks should be written to
test.Start(_L("Test1: Whilst moving page, change the usage "));
TestStart();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks, KChunkDefaultSize);
FreeMovable(gChunkArray1, gChunkArraySize1);
// Find a chunk that exists
TInt chunkIndex = gChunkArraySize1 - 1;
for (; chunkIndex >= 0 && gChunkArray1[chunkIndex].Handle() == NULL; chunkIndex--);
if (chunkIndex < 0)
{
test.Printf(_L("No chunks were allocated\n"));
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
WriteToChunk(gChunkArray1, gChunkArraySize1, chunkIndex);
TInt r = gTestThread.Create(gTestThreadName,MultiGenDefragThreadFunc,KDefaultStackSize,0x1000,0x1000,NULL);
if (r != KErrNone)
{
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
gTestThread.Logon(status);
gTestThread.Resume();
TUint8* base = gChunkArray1[chunkIndex].Base();
while (status.Int() == KRequestPending)
{
User::After(10000);
for (TInt8 k = 0; k < 10; k ++)
{
if (base == gChunkArray1[chunkIndex].Base() + gChunkArray1[chunkIndex].Size())
{
base = gChunkArray1[chunkIndex].Base();
}
*base++ = k; // write 0 - 9 to the chunk
}
}
User::WaitForRequest(status);
r = status.Int();
TESTDEBUG(test.Printf(_L("defrag running on another thread returns %d\n"), r));
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
if (r == KErrNone)
{
test.Printf(_L("Correct return value\n"));
test.Printf(_L("Passed...\n"));
}
else
{
test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrNone);
TEST_FAIL;
}
gTestThread.Close();
TestEnd();
test.Next(_L("Test2: Whilst moving page, change the contents of the page"));
TestStart();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks, KChunkDefaultSize);
FreeMovable(gChunkArray1, gChunkArraySize1);
WriteToChunk(gChunkArray1, gChunkArraySize1, KAllChunks);
r = gTestThread.Create(gTestThreadName,MultiGenDefragThreadFunc,KDefaultStackSize,0x1000,0x1000,NULL);
if (r != KErrNone)
{
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
gTestThread.Logon(status);
gTestThread.Resume();
TUint8 startValue = 0;
while (status.Int() == KRequestPending)
{
User::After(10000);
WriteToChunk(gChunkArray1, gChunkArraySize1, KAllChunks, startValue);
if (++startValue > 245)
{
startValue = 0;
}
}
User::WaitForRequest(status);
r = status.Int();
TESTDEBUG(test.Printf(_L("defrag running on another thread returns %d\n"), r));
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
if (r == KErrNone)
{
test.Printf(_L("Correct return value\n"));
test.Printf(_L("Passed...\n"));
}
else
{
test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrNone);
TEST_FAIL;
}
gTestThread.Close();
TestEnd();
test.Next(_L("Test3: Whilst moving page, read pages"));
TestStart();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks, KChunkDefaultSize);
FreeMovable(gChunkArray1, gChunkArraySize1);
WriteToChunk(gChunkArray1, gChunkArraySize1, KAllChunks);
r = gTestThread.Create(gTestThreadName,MultiGenDefragThreadFunc,KDefaultStackSize,0x1000,0x1000,NULL);
if (r != KErrNone)
{
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
gTestThread.Logon(status);
gTestThread.Resume();
while (status.Int() == KRequestPending)
{
User::After(100000000);
ReadChunk(gChunkArray1, gChunkArraySize1);
}
User::WaitForRequest(status);
r = status.Int();
TESTDEBUG(test.Printf(_L("defrag running on another thread returns %d\n"), r));
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
if (r == KErrNone)
{
test.Printf(_L("Correct return value\n"));
test.Printf(_L("Passed...\n"));
}
else
{
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
TEST_FAIL;
}
gTestThread.Close();
TestEnd();
test.Next(_L("Test4: Allocate fixed pages and then perform a defrag"));
TestStart();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
Ldd.AllocateFixedWrite(FILL_ALL_FIXED);
GetOriginalPageCount();
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
test.Printf(_L("defrag returns %d\n"), r);
if (CheckZonesSwitchedOff() != EFalse)
{
test.Printf(_L("Fail: Zones were switched off when they shouldn't have been\n"));
CLEANUP(r = Ldd.FreeAllFixedPagesRead());
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
r = Ldd.FreeAllFixedPagesRead();
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
TestEnd();
test.Next(_L("Test5: Allocate discardable pages and then perform a defrag"));
TestStart();
if (gPagedRom)
{
TInt discardablePages;
UpdateRamInfo();
r = AllocDiscardable(discardablePages);
if (r != KErrNone)
{
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
TEST_FAIL;
}
TESTDEBUG(test.Printf(_L("Number of discardable pages = 0x%x\n"), discardablePages >> gPageShift));
GetOriginalPageCount();
TBool genSucceed = CanGenSucceed();
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
TESTDEBUG(test.Printf(_L("defrag returns %d\n"), r));
if (genSucceed && CheckZonesSwitchedOff() == EFalse)
{
test.Printf(_L("Fail: Zones were not switched off when they should have been\n"));
CLEANUP(ResetDPCache());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
ResetDPCache();
}
else
{
test.Printf(_L("Not a paged ROM - Skipping test step\n"));
}
TestEnd();
test.End();
return 0;
}
//
// TestMovPgsDefrag
//
//---------------------------------------------------------------------------------------------------------------------
//! @SYMTestCaseID KBASE-t_ramdefrag-0527
//! @SYMTestType CIT
//! @SYMTestCaseDesc Verifying the moving of pages in the defrag implmentation
//! @SYMPREQ PREQ308
//! @SYMTestPriority High
//! @SYMTestActions
//! 1. Fragment the memory. Following this perform a RAM defrag.
//! Now that all movable memory has now been moved and the relevant source
//! zones have been switched off, again attempt to perform a RAM defrag.
//! 2. Fragment the memory. Following this perform a RAM defrag and whilst
//! this is happening, continuously create more chunks.
//! 3. Set up memory so that there are a mix of movable and free pages in a low preference zone, with there
//! being movable pages in the higher preference zones. Following this call a general defrag
//! 4. Set up memory so that there are a mix of movable and free pages and a couple of free pages
//! in a low preference zone, with there being enough free pages in the higher preference zones for the
//! pages to be moved to. Following this call a general defrag
//! 5. Set up memory so that there is a fixed page and a movable page in an empty zone (testZone). Also ensure that
//! there are movable and free pages in more preferable zones than the test zone. Following this call a general
//! defrag
//! 6. Set up memory so that the mostPrefZone contains movable and free pages. Allocate 1 movable and 1 fixed
//! page into an empty zone (testZone). Following this call a general defrag.
//!
//! @SYMTestExpectedResults
//! 1. Second defrag does not empty any zones
//! 2. No zones have been emptied
//! 3. Zones are emptied if the general defrag can succeed
//! 4. Defrag fills up the less preferable zones first
//! 5. movable pages are moved from the testZone
//! 6. testZone is not emptied
//---------------------------------------------------------------------------------------------------------------------
TInt TestMovPgsDefrag()
{
TInt r = KErrNone;
test.Start(_L("Test1: Performing a defrag twice"));
TestStart();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
TESTDEBUG(test.Printf(_L("After calling general defrag r = %d\n"), r));
r = VerifyMovDisAlloc();
// The first defrag should empty zones if the general can succeed
if (r != KErrNone)
{
test.Printf(_L("Fail: r = %d, memory is not laid out as expected\n"), r);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
GetOriginalPageCount();
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
TESTDEBUG(test.Printf(_L("After calling general defrag again r = %d\n"), r));
// The second call to general defrag should have nothing further to do
if (r != KErrNone || CheckZonesSwitchedOff() != EFalse)
{
test.Printf(_L("Fail: r = %d, expected = %d, or zones have been switched off \n"),
r, KErrNone);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
TestEnd();
test.Next(_L("Test2: Ensure new memory allocations can occur successfully during a general defrag"));
TestStart();
// Create a thread to call Defrag continuously and resume it
r = gTestThread.Create(gTestThreadName,MultiLoopGenDefragThreadFunc,KDefaultStackSize,0x1000,0x1000,NULL);
if (r != KErrNone)
{
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
TEST_FAIL;
}
gTestThread.Logon(status);
gTestLoop = ETrue;
gTestThread.Resume();
// Whilst the defrag loop is taking place, continuously allocate and free memory
for (TInt i = 0; i < 100; i++)
{
r = AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
if (r != KErrNone)
break;
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
}
gTestLoop = EFalse;
User::WaitForRequest(status);
TESTDEBUG(test.Printf(_L("defrag running on another thread returns %d\n"), r));
if (r != KErrNone || status.Int() != KErrNone)
{
test.Printf(_L("Fail: r = %d, status.Int() = %d\n"), r, status.Int());
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
RemoveChunkAlloc(gChunkArray2, gChunkArraySize2);
gTestThread.Close();
TestEnd();
test.Next(_L("Test3: Check whether RAM defrag switches off any zones"));
TestStart();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
GetOriginalPageCount();
TBool genSucceed = CanGenSucceed();
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
TESTDEBUG(test.Printf(_L("After calling zone defrag r = %d\n"), r));
if (r != KErrNone || (genSucceed && CheckZonesSwitchedOff() == EFalse))
{
test.Printf(_L("Fail: No zones were switched off or r = %d, expected = %d\n"), r, KErrNone);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
TestEnd();
test.Next(_L("Test4: Verify that a general defrag moves pages to the least preferable RAM zone in use"));
TestStart();
gChunkArray1 = new RChunk;
gChunkArraySize1 = 1;
// Get the preference order
GetPrefOrder();
TUint mostPrefIndex = 0;
TUint mostPrefArrayIndex = 0;
TUint totMov = 0;
TUint lastPrefIndex = 0;
TUint lastPrefArrayIndex = 0;
TUint movPages = 0;
TUint movBytes = 0;
TUint totFreeInTestZones = 0;
TBool zoneNotEmptyOrFull = EFalse;
// Find the first most pref zone that has free pages in it
r = FindMostPrefWithFree(mostPrefIndex, &mostPrefArrayIndex);
if (r != KErrNone)
{
test.Printf(_L("Cannot find zone to perform test - Skipping...\n"));
goto skipTest4;
}
// Find the next most preferable free zone
lastPrefArrayIndex = mostPrefArrayIndex + 1;
while (lastPrefArrayIndex < gZoneCount &&
gZoneUtilArray[gPrefArray[lastPrefArrayIndex]].iFreePages != gZoneUtilArray[gPrefArray[lastPrefArrayIndex]].iPhysPages)
{
lastPrefArrayIndex++;
}
if (lastPrefArrayIndex >= gZoneCount)
{
test.Printf(_L("Skipping...\n"));
goto skipTest4;
}
// Block all other zones
for (TUint prefIndex = lastPrefArrayIndex + 1; prefIndex < gZoneCount; prefIndex++)
{
TUint zoneIndex = gPrefArray[prefIndex];
Ldd.SetZoneFlag(gZoneConfigArray[zoneIndex].iZoneId, gZoneConfigArray[zoneIndex].iFlags, NO_ALLOC_FLAG);
}
// Zone alloc to fill half of the last zone under test
GetAllPageInfo();
lastPrefIndex = gPrefArray[lastPrefArrayIndex];
r = Ldd.ZoneAllocDiscontiguous(gZoneConfigArray[lastPrefIndex].iZoneId, gZoneUtilArray[lastPrefIndex].iFreePages >> 1);
if (r != KErrNone)
{
test.Printf(_L("Failed to allocate fixed pages r = %d - Skipping...\n"), r);
goto skipTest4;
}
// Go through the zones under test and determine the number of free pages
GetAllPageInfo();
for(TUint prefIndex = mostPrefArrayIndex; prefIndex <= lastPrefArrayIndex; prefIndex++)
{
TUint zoneIndex = gPrefArray[prefIndex];
totFreeInTestZones += gZoneUtilArray[zoneIndex].iFreePages;
}
// Allocate movable pages to almost fill zones under test
movPages = totFreeInTestZones;
movBytes = movPages << gPageShift;
while (movBytes && AllocMovable(gChunkArray1, gChunkArraySize1, 1, movBytes) != KErrNone)
{
movBytes -= gPageSize;
movPages--;
}
if (!movBytes)
{
test.Printf(_L("Failed to allocate 0x%x movable pages - Skipping...\n"), movPages);
goto skipTest4;
}
// Free the allocated fixed pages
Ldd.FreeAllFixedPages();
// Reset all the flags
ResetRamZoneFlags();
// Check that the most preferable zone still has movable pages in it
// and also check that the last zone under test has free pages in it
GetAllPageInfo();
if (gTotalPageCount.iMovablePages < movPages ||
gZoneUtilArray[mostPrefIndex].iAllocMovable == 0 ||
gZoneUtilArray[lastPrefIndex].iFreePages == 0)
{
test.Printf(_L("Setup failed - Skipping...\n"));
goto skipTest4;
}
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
// Check that defrag allocated the movable from the less preferable to the more preferable
GetPrefOrder();
totMov = gTotalPageCount.iMovablePages;
for(TInt prefIndex = gZoneCount - 1; prefIndex >= 0 ; prefIndex--)
{
TUint zoneIndex = gPrefArray[prefIndex];
GetCandList1(zoneIndex);
TUint candIndex = 0;
for (; candIndex < gZoneCount; candIndex++)
{// Check all the zones of this preference
TInt zoneIndexCand = gCandList1[candIndex];
if (zoneIndexCand == KInvalidCandIndex)
{
break;
}
totMov -= gZoneUtilArray[zoneIndexCand].iAllocMovable;
if (gZoneUtilArray[zoneIndexCand].iFreePages &&
(gZoneUtilArray[zoneIndexCand].iAllocMovable ||
gZoneUtilArray[zoneIndexCand].iAllocDiscardable))
{
zoneNotEmptyOrFull = ETrue;
}
}
prefIndex -= candIndex - 1 ;
if (zoneNotEmptyOrFull && totMov != 0)
{
test.Printf(_L("FAIL: index = %d free = 0x%x totMov = 0x%x\n"),
zoneIndex, gZoneUtilArray[zoneIndex].iFreePages, totMov);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
CLEANUP(RemoveChunkAlloc(gChunkArray2, gChunkArraySize2));
TEST_FAIL;
}
}
skipTest4:
TestEnd();
test.Next(_L("Test5: Verify that a general defrag tidies up if RAM zone to be emptied contains fixed pages"));
TestStart();
gChunkArray1 = new RChunk;
gChunkArraySize1 = 1;
gChunkArray2 = new RChunk;
gChunkArraySize2 = 1;
// find 2 empty zones - put 1 movable in 1 of them and 1 movable and 1 fixed in the other
TUint testZoneIndex1;
TUint testZoneIndex2;
TUint testZoneID2;
TUint numFreeInUse = 0;
r = FindMostPrefEmpty(testZoneIndex1);
if (r != KErrNone)
{
test.Printf(_L("Skipping...\n"));
goto skipTest5;
}
// Allocate 1 movable page to the test zone
r = ZoneAllocMovable(gChunkArray1, gChunkArraySize1, testZoneIndex1, 1);
if (r != KErrNone)
{
test.Printf(_L("Failed to allocate 1 movable page to zone index %d, r = %d - Skipping...\n"), testZoneIndex1, r);
goto skipTest5;
}
r = FindMostPrefEmpty(testZoneIndex2);
if (r != KErrNone)
{
test.Printf(_L("Skipping...\n"));
goto skipTest5;
}
// Allocate 1 movable page to the test zone
r = ZoneAllocMovable(gChunkArray2, gChunkArraySize2, testZoneIndex2, 1);
if (r != KErrNone)
{
test.Printf(_L("Failed to allocate 1 movable page to zone index %d, r = %d - Skipping...\n"), testZoneIndex2, r);
goto skipTest5;
}
// Zone alloc to put 1 fixed page last zone under test
testZoneID2 = gZoneConfigArray[testZoneIndex2].iZoneId;
r = Ldd.ZoneAllocContiguous(testZoneID2, gPageSize);
if (r != KErrNone)
{
test.Printf(_L("Failed to allocate 1 fixed page to zone %d index, r = %d - Skipping...\n"), testZoneIndex2, r);
goto skipTest5;
}
// Allocate 2 fixed (as there is 1 in our test zone) to prevent reordering
GetAllPageInfo();
for (TUint index = 0; index < gZoneCount; index++)
{
TUint totImmovable = gZoneUtilArray[index].iAllocFixed + gZoneUtilArray[index].iAllocUnknown ;
if (index != testZoneIndex1 &&
index != testZoneIndex2 &&
gZoneUtilArray[index].iFreePages != gZoneUtilArray[index].iPhysPages &&
totImmovable < 2)
{
r = Ldd.ZoneAllocToMany(index, 2 - totImmovable);
if (r != KErrNone)
{
test.Printf(_L("Failed to alloc 0x%x fixed to zone index %d r = %d - Skipping...\n"),
2, index, r);
goto skipTest5;
}
}
}
// Check that the number of free pages in the other in-use zones >= movable pages in test zone
GetAllPageInfo();
for (TUint index = 0; index < gZoneCount; index++)
{
if (index != testZoneIndex1 &&
index != testZoneIndex2 &&
gZoneUtilArray[index].iFreePages != gZoneUtilArray[index].iPhysPages)
{
numFreeInUse += gZoneUtilArray[index].iFreePages;
}
}
if (gZoneUtilArray[testZoneIndex1].iAllocMovable + gZoneUtilArray[testZoneIndex1].iAllocDiscardable +
gZoneUtilArray[testZoneIndex2].iAllocMovable + gZoneUtilArray[testZoneIndex2].iAllocDiscardable > numFreeInUse ||
gZoneUtilArray[testZoneIndex2].iAllocFixed == 0)
{
test.Printf(_L("Setup failed - Skipping...\n"));
goto skipTest5;
}
// Added extra tracing to debug random failures
PrintPageInfo();
// Call a general defrag
GetOriginalPageCount();
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
// Check that the defrag tidies up
GetAllPageInfo();
if(gZoneUtilArray[testZoneIndex1].iAllocMovable ||
gZoneUtilArray[testZoneIndex2].iAllocMovable)
{
test.Printf(_L("FAIL: testZoneIndex1(%d): mov orig 0x%x cur 0x%x, testZoneIndex2(%d) mov orig 0x%x cur 0x%x \n"),
testZoneIndex1, gOriginalPageCountArray[testZoneIndex1].iAllocMovable, gZoneUtilArray[testZoneIndex1].iAllocMovable,
testZoneIndex2, gOriginalPageCountArray[testZoneIndex2].iAllocMovable, gZoneUtilArray[testZoneIndex2].iAllocMovable);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
CLEANUP(RemoveChunkAlloc(gChunkArray2, gChunkArraySize2));
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
skipTest5:
TestEnd();
test.Next(_L("Test6: Verify that a general defrag will not move pages if RAM zone to be emptied contains fixed pages"));
TestStart();
gChunkArray1 = new RChunk;
gChunkArraySize1 = 1;
// Find the first most pref zone that has free pages in it
r = FindMostPrefWithFree(mostPrefIndex, &mostPrefArrayIndex);
if (r != KErrNone)
{
test.Printf(_L("Cannot find zone to perform test - Skipping...\n"));
goto skipTest6;
}
// Find the next most preferable free zone
lastPrefArrayIndex = mostPrefArrayIndex + 1;
while (lastPrefArrayIndex < gZoneCount &&
gZoneUtilArray[gPrefArray[lastPrefArrayIndex]].iFreePages != gZoneUtilArray[gPrefArray[lastPrefArrayIndex]].iPhysPages)
{
lastPrefArrayIndex++;
}
if (lastPrefArrayIndex >= gZoneCount)
{
test.Printf(_L("Skipping...\n"));
goto skipTest6;
}
// Zone alloc to put 1 fixed page last zone under test
lastPrefIndex = gPrefArray[lastPrefArrayIndex];
r = Ldd.ZoneAllocDiscontiguous(gZoneConfigArray[lastPrefIndex].iZoneId, 1);
if (r != KErrNone)
{
test.Printf(_L("Failed to allocate 1 fixed page to zone index %d r = %d - Skipping...\n"), lastPrefIndex, r);
goto skipTest6;
}
GetAllPageInfo();
if (!gZoneUtilArray[mostPrefIndex].iFreePages)
{
test.Printf(_L("Not enough space in zone under test mostPrefIndex = %d - Skipping...\n"), mostPrefIndex);
goto skipTest6;
}
// Block all zones apart from the last zone under test from allocation
for (TUint prefIndex = 0; prefIndex < gZoneCount; prefIndex++)
{
TUint zoneIndex = gPrefArray[prefIndex];
if (zoneIndex != lastPrefIndex)
{
Ldd.SetZoneFlag(gZoneConfigArray[zoneIndex].iZoneId, gZoneConfigArray[zoneIndex].iFlags, NO_ALLOC_FLAG);
}
}
TESTDEBUG(test.Printf(_L("mostPrefIndex = %d lastPrefIndex = %d\n"), mostPrefIndex, lastPrefIndex));
// Allocate movable pages to the lastPrefZone that will fit into the most pref zone
movPages = gZoneUtilArray[mostPrefIndex].iFreePages;
movBytes = movPages << gPageShift;
while (movBytes && AllocMovable(gChunkArray1, gChunkArraySize1, 1, movBytes) != KErrNone)
{
movBytes -= gPageSize;
}
if (!movBytes)
{
test.Printf(_L("Failed to allocate 0x%x movable pages r = %d - Skipping...\n"), movPages, r);
goto skipTest6;
}
// Reset all the flags
ResetRamZoneFlags();
// Check that the number of movable pages in the least pref will fit
// into the most preferable zone
GetAllPageInfo();
if (gZoneUtilArray[lastPrefIndex].iAllocMovable > gZoneUtilArray[mostPrefIndex].iFreePages)
{
test.Printf(_L("Setup failed - Skipping...\n"));
PrintPageInfo();
goto skipTest6;
}
// Added extra tracing to debug random failures
PrintPageInfo();
// Call a general defrag
GetOriginalPageCount();
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
// Check that the defrag didn't move any pages from the least pref zone
GetAllPageInfo();
if(gOriginalPageCountArray[lastPrefIndex].iAllocMovable > gZoneUtilArray[lastPrefIndex].iAllocMovable)
{
test.Printf(_L("FAIL: mostPref(index %d): origMov = 0x%x curMov = 0x%x, lastPref(index %d): origMov = 0x%x curMov = 0x%x \n"),
mostPrefIndex, gOriginalPageCountArray[mostPrefIndex].iAllocMovable, gZoneUtilArray[mostPrefIndex].iAllocMovable,
lastPrefIndex, gOriginalPageCountArray[lastPrefIndex].iAllocMovable, gZoneUtilArray[lastPrefIndex].iAllocMovable);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
CLEANUP(RemoveChunkAlloc(gChunkArray2, gChunkArraySize2));
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
skipTest6:
TestEnd();
test.End();
return KErrNone;
}
//
// GenDefragTest123Setup
//
// Used to set up the memory ready for testing in TestGenDefrag, Test Steps 1, 2, 3 and 4
//
// @param aMovAlloc The number of movable pages to allocate.
// @param aFixAlloc The number of fixed pages to allocate.
// @param aDisAlloc The number of discardable pages to allocate.
// @param aMovIndex On return contains the test zone index.
// @param aNumFreeInUse On return contains the number of free pages in the inuse zones.
// @param aTestNo The test number that is using this setup.
//
TInt GenDefragTest123Setup(TUint aMovAlloc, TUint aFixAlloc, TUint aDisAlloc, TUint& aMovIndex, TUint& aNumFreeInUse, TUint aTestNo)
{
TInt r = KErrNone;
aNumFreeInUse = 0;
const TUint KFillUpTo = 5; // Rough estimate of how full the in-use zones should be
const TUint KSpaceNeeded = 2;
TUint movPrefIndex = 0;
if (aTestNo == 4)
{// Test 4 we need to look for the LEAST preferable RAM zone which is empty
TUint mostPrefIndex;
r = FindLeastPrefEmpty(aMovIndex, &movPrefIndex);
TInt r2 = FindMostPrefEmpty(mostPrefIndex);
if (r != KErrNone || r2 != KErrNone || !gPagedRom ||
gZoneConfigArray[aMovIndex].iPref == gZoneConfigArray[mostPrefIndex].iPref)
{
test.Printf(_L("r %d r2 %d or not a paged ROM or Equal zone preferences- Skipping test step...\n"),
r, r2);
return KErrGeneral;
}
}
else
{// All other tests look the MOST preferable RAM zone which is empty
r = FindMostPrefEmpty(aMovIndex, &movPrefIndex);
if (r != KErrNone || !gPagedRom)
{
test.Printf(_L("No suitable RAM zone found or not a paged ROM - Skipping test step...\n"));
return KErrGeneral;
}
}
// Go through all the in-use zones and check how many free pages there are
// Allocate fixed so there is only KFillUpTo pages in each in-use zone to
// ensure that the total number of free pages in the in-use zones can fit into
// the zone under test
GetAllPageInfo();
for (TUint index = 0; index < gZoneCount; index++)
{
if (gZoneUtilArray[index].iFreePages != gZoneUtilArray[index].iPhysPages &&
gZoneUtilArray[index].iFreePages > KFillUpTo)
{
r = Ldd.ZoneAllocToMany(index, gZoneUtilArray[index].iFreePages - KFillUpTo);
if (r != KErrNone)
{
test.Printf(_L("Failed to alloc 0x%x fixed to zone index %d r = %d - Ending setup...\n"),
gZoneUtilArray[index].iFreePages - KFillUpTo, index, r);
return KErrGeneral;
}
}
}
GetAllPageInfo();
// If any of the in-use zones doesn't contain any fixed and unknown pages allocate one fixed
for (TUint index = 0; index < gZoneCount; index++)
{
if (gZoneUtilArray[index].iFreePages != gZoneUtilArray[index].iPhysPages &&
!gZoneUtilArray[index].iAllocFixed && !gZoneUtilArray[index].iAllocUnknown)
{
r = Ldd.ZoneAllocToMany(index, 1);
if (r != KErrNone)
{
test.Printf(_L("Failed to alloc 0x%x fixed to zone index %d r = %d - Ending setup...\n"),
1, index, r);
return KErrGeneral;
}
}
}
GetAllPageInfo();
// Check the total number of free pages in the in-use zones
for (TUint index = 0; index < gZoneCount; index++)
{
if (gZoneUtilArray[index].iFreePages != gZoneUtilArray[index].iPhysPages)
{
aNumFreeInUse += gZoneUtilArray[index].iFreePages;
}
}
TESTDEBUG(test.Printf(_L("aNumFreeInUse = 0x%x\n"), aNumFreeInUse));
test.Printf(_L("aMovIndex = %d\n"), aMovIndex);
if (aNumFreeInUse < KSpaceNeeded)
{
test.Printf(_L("RAM zone to be tested is too full - Skipping test step...\n"));
return KErrGeneral;
}
// Ensure that there are movable pages in the zone under test
// ensuring that there is also room for discardable pages
GetAllPageInfo();
if (aMovAlloc != 0 && gZoneUtilArray[aMovIndex].iAllocMovable == 0)
{
// Allocate just aMovAlloc movable pages
TUint movPagesAlloc = aMovAlloc;
if (aTestNo == 2 || aTestNo == 4)
{// Tests 2 and 4 require that movable pages can't be moved from zone
movPagesAlloc = aNumFreeInUse + 1;
if (movPagesAlloc > gZoneUtilArray[aMovIndex].iFreePages)
{
test.Printf(_L("Insufficiant space in zone %d to allocate 0x%x pages - Ending setup...\n"),
aMovIndex, movPagesAlloc);
return KErrGeneral;
}
}
r = ZoneAllocMovable(gChunkArray1, gChunkArraySize1, aMovIndex, movPagesAlloc);
if (gZoneUtilArray[aMovIndex].iAllocMovable != movPagesAlloc ||
gZoneUtilArray[aMovIndex].iFreePages == 0 ||
r != KErrNone)
{// Movable page didn't go into RAM, or RAM zone is full.
test.Printf(_L("Can't complete test with current RAM layout. - Skipping...\n"));
test.Printf(_L("zone mov 0x%x free 0x%x r=%d\n"),
gZoneUtilArray[aMovIndex].iAllocMovable,
gZoneUtilArray[aMovIndex].iFreePages, r);
return KErrGeneral;
}
}
// Block all other zones from allocation
for(TUint i = 0; i < gZoneCount; i++)
{
if (i != aMovIndex)
{
r = Ldd.SetZoneFlag(gZoneConfigArray[i].iZoneId, gZoneConfigArray[i].iFlags, NO_ALLOC_FLAG);
if (r != KErrNone)
{
test.Printf(_L("Failed to set flag on zone index %d r = %d- Ending setup...\n"), i, r);
return KErrGeneral;
}
}
}
// Now ensure that there are fixed pages in the zone under test
// ensuring that there is also room for discardable pages
GetAllPageInfo();
if (aFixAlloc != 0 && gZoneUtilArray[aMovIndex].iAllocFixed == 0)
{//Allocate just aFixAlloc fixed pages
r = Ldd.ZoneAllocToMany(aMovIndex, aFixAlloc);
GetAllPageInfo();
if (gZoneUtilArray[aMovIndex].iAllocMovable == 0 ||
gZoneUtilArray[aMovIndex].iFreePages == 0 ||
gZoneUtilArray[aMovIndex].iAllocFixed == 0 ||
r != KErrNone)
{// Fixed page didn't go into RAM or RAM zone is full.
test.Printf(_L("Can't complete test with current RAM layout. - Skipping...\n"));
test.Printf(_L("zone mov 0x%x fixed 0x%x free 0x%x r=%d\n"),
gZoneUtilArray[aMovIndex].iAllocMovable,
gZoneUtilArray[aMovIndex].iAllocFixed,
gZoneUtilArray[aMovIndex].iFreePages, r);
return KErrGeneral;
}
}
// Allocate aDisAlloc number of discardable pages
if (aDisAlloc != 0 && gZoneUtilArray[aMovIndex].iAllocDiscardable == 0)
{//Allocate just aDisAlloc discardable pages
TInt discard;
r = ZoneAllocDiscard(aMovIndex, aDisAlloc, discard);
GetAllPageInfo();
if (r != KErrNone || gZoneUtilArray[aMovIndex].iAllocDiscardable == 0)
{// Discardable page didn't go into RAM or RAM zone is full.
test.Printf(_L("Can't complete test with current RAM layout. - Skipping...\n"));
test.Printf(_L("zone mov 0x%x discardable 0x%x free 0x%x r=%d\n"),
gZoneUtilArray[aMovIndex].iAllocDiscardable,
gZoneUtilArray[aMovIndex].iAllocFixed,
gZoneUtilArray[aMovIndex].iFreePages, r);
return KErrGeneral;
}
}
// Update the total number of free pages in the in-use zones
aNumFreeInUse = 0;
for (TUint index = 0; index < gZoneCount; index++)
{
if (gZoneUtilArray[index].iFreePages != gZoneUtilArray[index].iPhysPages &&
index != aMovIndex)
{
aNumFreeInUse += gZoneUtilArray[index].iFreePages;
}
}
TESTDEBUG(test.Printf(_L("aNumFreeInUse = 0x%x\n"), aNumFreeInUse));
// now reset all the flags
ResetRamZoneFlags();
return KErrNone;
}
//
// TestGenDefrag
//
//---------------------------------------------------------------------------------------------------------------------
//! @SYMTestCaseID KBASE-t_ramdefrag-0528
//! @SYMTestType CIT
//! @SYMTestCaseDesc Verifying general scenarios when RAM defrag would take place
//! @SYMPREQ PREQ308
//! @SYMTestPriority High
//! @SYMTestActions
//! 1. Allocate 1 movable, 1 fixed and 1 discardable pages into the most preferable empty RAM zone
//! ensuring that there is enough free space in the more preferable RAM zones for the
//! movable pages in the RAM zone under test. Following this call a general defrag.
//! 2. Allocate 1 movable and 1 discardable page into into the most preferable empty RAM zone
//! ensuring that there is not enough free space in the more preferable RAM zones for the
//! movable pages in the RAM zone under test. Following this call a general defrag.
//! 3. Allocate 1 movable and 1 discardable and 1 fixed page into the most preferable empty RAM zone(a).
//! Following this, place 1 movable page in an empty zone(b) ensuring that there is enough free space in
//! the more preferable RAM zones for the movable pages in both zones (a) and (b).
//! Following this call a general defrag.
//! 4. Allocate 1 movable and 1 discardable page into the least preferable empty RAM zone
//! ensuring that there is not enough free space in the more preferable RAM zones for the
//! movable pages in the RAM zone under test. Following this call a general defrag.
//! 5. Fragment the memory.
//! Following this allocate discardable pages by loading pages that are demand paged.
//! Read each of the constants from beginning to end.
//! Following this perform a RAM defrag.
//! 6. Call a device driver that will continuously allocate fixed pages to the
//! memory until it reports out of memory. Following this perform a RAM defrag.
//! 7. Defrag memory filled with discardable pages when the min cache size is reached
//! 8. Fragment the memory. Following this, continuously call a general defrag, each time
//! reducing the size of the chunks that are allocated
//!
//! @SYMTestExpectedResults
//! 1. The RAM zone under test is not emptied and all the discardable pages contained in it
//! have not been discarded.
//! 2. The RAM zone under test is not emptied and all the discardable pages contained in it
//! have not been discarded.
//! 3. RAM zones (a) and (b) have been emptied and all the discardable pages contained in them
//! have not been discarded.
//! 4. The RAM zone under test is emptied
//! 5. Pages are discarded
//! 6. No zones are emptied
//! 7. The least preferable zone is skipped but the other zones are defragmented as required.
//! 8. Zones are emptied if the general defrag can succeed
//---------------------------------------------------------------------------------------------------------------------
TInt TestGenDefrag()
{
TInt r = KErrNone;
test.Start(_L("Test1: Test General Defrag doesn't discard pages when fixed page in zone to be emptied"));
TestStart();
gChunkArray1 = new RChunk;
gChunkArraySize1 = 1;
TUint numFreeInUse = 0;
TUint testNo = 1;
// We just need 1 movable, 1 discardable and 1 fixed in the zone to ensure it cannot be emptied
// as the fixed should block the defrag
TInt movAllocPages = 1;
TInt fixAllocPages = 1;
TInt disAllocPages = 1;
TUint zoneIndex;
if (GenDefragTest123Setup(movAllocPages, fixAllocPages, disAllocPages, zoneIndex, numFreeInUse, testNo) != KErrNone)
{
test.Printf(_L("Setup failed - Skipping..\n"));
goto skipTest1;
}
// Call a general defrag and check that no discardable pages were freed.
GetOriginalPageCount();
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
GetAllPageInfo();
if (r != KErrNone ||
gZoneUtilArray[zoneIndex].iAllocMovable < gOriginalPageCountArray[zoneIndex].iAllocMovable ||
gOriginalPageCountArray[zoneIndex].iAllocDiscardable > gZoneUtilArray[zoneIndex].iAllocDiscardable)
{
test.Printf(_L("Fail: r = %d zoneIndex %d origMov 0x%x curMov 0x%x origDis 0x%x curDis 0x%x\n"), r, zoneIndex,
gOriginalPageCountArray[zoneIndex].iAllocMovable, gZoneUtilArray[zoneIndex].iAllocMovable,
gOriginalPageCountArray[zoneIndex].iAllocDiscardable, gZoneUtilArray[zoneIndex].iAllocDiscardable);
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
skipTest1:
// TestEnd() will perform any required clean up.
TestEnd();
test.Next(_L("Test2: Test General Defrag doesn't discard pages when zone can't be emptied"));
TestStart();
gChunkArray1 = new RChunk;
gChunkArraySize1 = 1;
testNo++;
// No fixed, but there should be no space for the movable to go to
// GenDefragTest123Setup(), will ensure that this is the case
// by allocating 1 more movable page than there is free in the in-use zones
movAllocPages = 1;
fixAllocPages = 0;
disAllocPages = 1;
if (GenDefragTest123Setup(movAllocPages, fixAllocPages, disAllocPages, zoneIndex, numFreeInUse, testNo) != KErrNone)
{
test.Printf(_L("Setup failed - Skipping..\n"));
goto skipTest2;
}
// Call a general defrag and check that no discardable pages were freed.
GetOriginalPageCount();
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
GetAllPageInfo();
if (r != KErrNone ||
gZoneUtilArray[zoneIndex].iAllocMovable < gOriginalPageCountArray[zoneIndex].iAllocMovable ||
gOriginalPageCountArray[zoneIndex].iAllocDiscardable > gZoneUtilArray[zoneIndex].iAllocDiscardable)
{
test.Printf(_L("Fail: r = %d zoneIndex %d origMov 0x%x curMov 0x%x origDis 0x%x curDis 0x%x\n"), r, zoneIndex,
gOriginalPageCountArray[zoneIndex].iAllocMovable, gZoneUtilArray[zoneIndex].iAllocMovable,
gOriginalPageCountArray[zoneIndex].iAllocDiscardable, gZoneUtilArray[zoneIndex].iAllocDiscardable);
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
skipTest2:
// TestEnd() will perform any required clean up.
TestEnd();
test.Next(_L("Test3: Test General Defrag tidies when fixed page in zone to be emptied but other can be emptied"));
TestStart();
gChunkArray1 = new RChunk;
gChunkArraySize1 = 1;
gChunkArray2 = new RChunk;
gChunkArraySize2 = 1;
TUint totalToMove;
testNo++;
// First use GenDefragTest123Setup() to ensure we place 1 fixed, 1 movable and 1 discardable
// in the least preferable zone
movAllocPages = 1;
fixAllocPages = 1;
disAllocPages = 1;
TBool zoneFound = EFalse;
TUint emptyZoneIndex = 0;
if (GenDefragTest123Setup(movAllocPages, fixAllocPages, disAllocPages, zoneIndex, numFreeInUse, testNo) != KErrNone)
{
test.Printf(_L("Setup failed - Skipping..\n"));
goto skipTest3;
}
// Find an empty zone and place a movable page in it
GetAllPageInfo();
for (TUint i = 0; i < gZoneCount; i++)
{
if (gZoneUtilArray[i].iFreePages == gZoneUtilArray[i].iPhysPages)
{
zoneFound = ETrue;
emptyZoneIndex = i;
break;
}
}
if (!zoneFound)
{
test.Printf(_L("Can't find empty zone - Skipping..\n"));
goto skipTest3;
}
// Allocate 1 movable page into the empty zone
r = ZoneAllocMovable(gChunkArray2, gChunkArraySize2, emptyZoneIndex, 1);
GetAllPageInfo();
if (r != KErrNone ||
gZoneUtilArray[emptyZoneIndex].iAllocMovable == 0 ||
gZoneUtilArray[emptyZoneIndex].iAllocFixed != 0)
{
test.Printf(_L("Movable pages not allocated or fixed pages allocated. - Skipping...\n"));
test.Printf(_L("zone mov 0x%x free 0x%x r =% d\n"),
gZoneUtilArray[emptyZoneIndex].iAllocMovable,
gZoneUtilArray[emptyZoneIndex].iFreePages, r);
goto skipTest3;
}
// Check that the amount we are allocating can actually be moved into the in-use zones
totalToMove = gZoneUtilArray[zoneIndex].iAllocMovable + gZoneUtilArray[zoneIndex].iAllocDiscardable +
gZoneUtilArray[emptyZoneIndex].iAllocMovable + gZoneUtilArray[emptyZoneIndex].iAllocDiscardable;
// Check the total number of free pages in the in-use zones
numFreeInUse = 0;
for (TUint index = 0; index < gZoneCount; index++)
{
if (gZoneUtilArray[index].iFreePages != gZoneUtilArray[index].iPhysPages &&
index != zoneIndex && index != emptyZoneIndex)
{
numFreeInUse += gZoneUtilArray[index].iFreePages;
}
}
if(numFreeInUse < totalToMove)
{
test.Printf(_L("No space to move pages numFreeInUse = 0x%x totalToMove = 0x%x - Skipping..\n"),
numFreeInUse, totalToMove);
goto skipTest3;
}
// Call a general defrag and check that zone is emptied.
GetOriginalPageCount();
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
GetAllPageInfo();
if (r != KErrNone ||
gZoneUtilArray[zoneIndex].iAllocMovable ||
gZoneUtilArray[zoneIndex].iAllocDiscardable ||
gZoneUtilArray[emptyZoneIndex].iAllocMovable)
{
test.Printf(_L("Fail: r = %d zoneIndex %d origMov 0x%x curMov 0x%x origDis 0x%x curDis 0x%x\n"), r, zoneIndex,
gOriginalPageCountArray[zoneIndex].iAllocMovable, gZoneUtilArray[zoneIndex].iAllocMovable,
gOriginalPageCountArray[zoneIndex].iAllocDiscardable, gZoneUtilArray[zoneIndex].iAllocDiscardable);
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
skipTest3:
// TestEnd() will perform any required clean up.
TestEnd();
test.Next(_L("Test4: Test General Defrag moves pages into the next most pref if they don't fit into the most pref"));
TestStart();
gChunkArray1 = new RChunk;
gChunkArraySize1 = 1;
testNo++;
// No fixed, but there should be no space for the movable to go to
// GenDefragTest123Setup(), will ensure that this is the case
// by allocating 1 more movable page than there is free in the in-use zones
movAllocPages = 1;
fixAllocPages = 0;
disAllocPages = 1;
if (GenDefragTest123Setup(movAllocPages, fixAllocPages, disAllocPages, zoneIndex, numFreeInUse, testNo) != KErrNone)
{
test.Printf(_L("Setup failed - Skipping..\n"));
goto skipTest4;
}
// Call a general defrag and check that the test zone is emptied.
GetOriginalPageCount();
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
GetAllPageInfo();
if (r != KErrNone ||
gZoneUtilArray[zoneIndex].iFreePages != gZoneUtilArray[zoneIndex].iPhysPages)
{
test.Printf(_L("Fail: r = %d zoneIndex %d origMov 0x%x curMov 0x%x origDis 0x%x curDis 0x%x\n"), r, zoneIndex,
gOriginalPageCountArray[zoneIndex].iAllocMovable, gZoneUtilArray[zoneIndex].iAllocMovable,
gOriginalPageCountArray[zoneIndex].iAllocDiscardable, gZoneUtilArray[zoneIndex].iAllocDiscardable);
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
skipTest4:
// TestEnd() will perform any required clean up.
TestEnd();
test.Next(_L("Test5: Defrag memory filled with discardable pages\n"));
TestStart();
if (gPagedRom)
{
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
GetAllPageInfo();
TInt discardablePages;
UpdateRamInfo();
r = AllocDiscardable(discardablePages);
if (r != KErrNone)
{
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
TESTDEBUG(test.Printf(_L("Number of discardable pages = 0x%x\n"), discardablePages >> gPageShift));
GetOriginalPageCount();
TBool genSucceed = CanGenSucceed();
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
TESTDEBUG(test.Printf(_L("After calling defrag r = %d\n"), r));
if (r != KErrNone)
{
test.Printf(_L("Fail: r = %d, expected = %d\n"),r,KErrNone);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else if (genSucceed && CheckZonesSwitchedOff() == EFalse)
{
test.Printf(_L("No Zones Switched off and should have been\n"));
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
ResetDPCache();
}
else
{
test.Printf(_L("Not a paged ROM - Skipping test step\n"));
}
TestEnd();
test.Next(_L("Test6: Defrag memory filled with fixed pages"));
TestStart();
TESTDEBUG(test.Printf(_L("Filling memory with fixed pages, r = %d\n")));
r = Ldd.AllocateFixed(FILL_ALL_FIXED);
GetOriginalPageCount();
TBool genSucceed = CanGenSucceed();
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
TESTDEBUG(test.Printf(_L("After calling defrag r = %d\n"), r));
// The zones should be full of fixed pages so the general should do nothing.
if (r != KErrNone ||
genSucceed ||
CheckZonesSwitchedOff())
{
test.Printf(_L("Fail: r = %d, expected = %d, or zone have been emptied\n"), r, KErrNone);
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
Ldd.FreeAllFixedPages();
TestEnd();
PrintPageInfo();
test.Next(_L("Test7: Defrag memory filled with discardable pages when the min cache size is reached\n"));
TestStart();
if (gPagedRom)
{
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
GetAllPageInfo();
TInt discardablePages;
UpdateRamInfo();
r = AllocDiscardable(discardablePages);
if (r != KErrNone)
{
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
TESTDEBUG(test.Printf(_L("Number of discardable pages = 0x%x\n"), discardablePages >> gPageShift));
TUint minCacheSize = 0;
TUint maxCacheSize = 0;
TUint currentCacheSize = 0;
DPTest::CacheSize(minCacheSize,maxCacheSize,currentCacheSize);
TUint setMin = maxCacheSize;
TUint64 setMax = maxCacheSize;
TInt r = DPTest::SetCacheSize(setMin, setMax);
if (r != KErrNone)
{
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
CLEANUP(ResetDPCache());
TEST_FAIL;
}
TESTDEBUG(test.Printf(_L("After SetCacheSize: minCacheSize = 0x%x, maxCacheSize = 0x%x\n"),
setMin >> gPageShift, setMax >> gPageShift));
GetOriginalPageCount();
genSucceed = CanGenSucceed();
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
TESTDEBUG(test.Printf(_L("After calling defrag r = %d\n"), r));
if (r != KErrNone)
{
test.Printf(_L("Fail: r = %d, expected = %d\n"),r,KErrNone);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
CLEANUP(ResetDPCache());
TEST_FAIL;
}
else if (genSucceed && CheckZonesSwitchedOff() == EFalse)
{
test.Printf(_L("No Zones Switched off and should have been\n"));
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
CLEANUP(ResetDPCache());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
ResetDPCache();
}
else
{
test.Printf(_L("Not a paged ROM - Skipping test step\n"));
}
TestEnd();
test.Next(_L("Test8: Defrag fragmented memory for various smaller chunk sizes"));
TInt chunkSize = 0x80000;
while (chunkSize >= 0x4000)
{
test.Printf(_L("chunkSize = %dKB\n"), chunkSize/1024);
TestStart();
r = AllocMovable(gChunkArray1, gChunkArraySize1, KFillAllMovable, chunkSize, EFalse);
r = FreeMovable(gChunkArray1, gChunkArraySize1);
GetOriginalPageCount();
TBool genSucceed = CanGenSucceed();
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
TESTDEBUG(test.Printf(_L("After calling defrag r = %d\n"), r));
if (r != KErrNone)
{
test.Printf(_L("Fail: r = %d, expected = %d\n"),r,KErrNone);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else if (genSucceed && CheckZonesSwitchedOff() == EFalse)
{
test.Printf(_L("No Zones Switched off and should have been\n"));
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
TestEnd();
chunkSize = chunkSize>>1;
}
test.Next(_L("Test9: Defrag fragmented memory "));
TestStart();
r = AllocMovable(gChunkArray1, gChunkArraySize1, KFillAllMovable);
r = FreeMovable(gChunkArray1, gChunkArraySize1);
GetOriginalPageCount();
genSucceed = CanGenSucceed();
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
TESTDEBUG(test.Printf(_L("After calling defrag r = %d\n"), r));
if (r != KErrNone)
{
test.Printf(_L("Fail: r = %d, expected = %d\n"),r,KErrNone);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else if (genSucceed && CheckZonesSwitchedOff() == EFalse)
{
test.Printf(_L("No Zones Switched off and should have been\n"));
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
TestEnd();
test.End();
return KErrNone;
}
//
// TestGetRamZonePageCount
//
//---------------------------------------------------------------------------------------------------------------------
//! @SYMTestCaseID KBASE-t_ramdefrag-0529
//! @SYMTestType CIT
//! @SYMTestCaseDesc Verifying the implementation of the function GetRamZonePageCount()
//! @SYMPREQ PREQ308
//! @SYMTestPriority High
//! @SYMTestActions
//! 1. Fragment the memory. Following this, call GetRamZonePageCount() on every zone and verify
//! the values with the test HAL functions.
//! 2. Fragment the memory. Following this, call function with an valid aID
//!
//! @SYMTestExpectedResults
//! 1. KErrNone
//! 2. KErrArgument
//---------------------------------------------------------------------------------------------------------------------
TInt TestGetRamZonePageCount()
{
test.Start(_L("Test1: Call GetRamZonePageCount() on every zone one after the other"));
TestStart();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
for (TUint index = 0; index < gZoneCount; index++)
{
GetAllPageInfo();
TUint zoneID = gZoneConfigArray[index].iZoneId;
STestUserSidePageCount pageData;
TInt r = Ldd.PageCount(zoneID, &pageData);
TESTDEBUG(test.Printf(_L("Page count function r = %d\n"), r));
if (r != KErrNone)
{
test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrNone);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
if (pageData.iFreePages != gZoneUtilArray[index].iFreePages ||
pageData.iFixedPages != gZoneUtilArray[index].iAllocFixed ||
pageData.iMovablePages != gZoneUtilArray[index].iAllocMovable ||
pageData.iDiscardablePages != gZoneUtilArray[index].iAllocDiscardable)
{
test.Printf(_L("RAM zone page count does not match test HAL page count, Zone %d\n"), zoneID);
test.Printf(_L("PgCnt: free = 0x%x, fixed = 0x%x, movable= 0x%x, discard = 0x%x\n"),
pageData.iFreePages, pageData.iFixedPages, pageData.iMovablePages, pageData.iDiscardablePages);
test.Printf(_L("HalFunc: free = 0x%x, fixed = 0x%x, movable= 0x%x, discard = 0x%x\n"),
gZoneUtilArray[index].iFreePages, gZoneUtilArray[index].iAllocFixed,
gZoneUtilArray[index].iAllocMovable, gZoneUtilArray[index].iAllocDiscardable);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Zone %d Passed...\n"), zoneID);
}
TESTDEBUG(test.Printf(_L("iFreePages = 0x%x, iFixedPages = 0x%x, iMovablePages = 0x%x, iDiscardablePages = 0x%x\n"),
pageData.iFreePages, pageData.iFixedPages, pageData.iMovablePages, pageData.iDiscardablePages));
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
TestEnd();
test.Next(_L("Test2: Call GetRamZonePageCount() with an invalid aID "));
TestStart();
TUint zoneID = KInvalidZoneID;
STestUserSidePageCount pageData;
TInt r = Ldd.PageCount(zoneID, &pageData);
TESTDEBUG(test.Printf(_L("Page count function r = %d\n"), r));
if (r != KErrArgument)
{
test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrArgument);
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
TestEnd();
test.End();
return 0;
}
const TUint KIndex2Alloc = 10;
const TUint KTestMaxPages = 6;
//
// DefragMaxPagesSetup
//
// Arranges the memory layout in preparation for TestDefragRamMaxPages()
//
// WARNING THIS WILL BE UNRELIABLE IF aMaxPages > KIndex2Alloc
//
TInt DefragMaxPagesSetup(TInt aPageType, TUint aMaxPages, TUint& aIndex, TUint& aIndex2)
{
TInt r = KErrNoMemory;
// Get the preference order and determine the 2 most preferable zones
// that are currently not in use.
GetPrefOrder();
TUint freeInUsePages = 0;
TBool zonesFound = EFalse;
for (TUint i = 1; i < gZoneCount; i++)
{
aIndex = gPrefArray[i];
aIndex2 = gPrefArray[i-1];
TUint indexFree = gZoneUtilArray[aIndex].iFreePages;
TUint index2Free = gZoneUtilArray[aIndex2].iFreePages;
if (indexFree == gZoneUtilArray[aIndex].iPhysPages &&
index2Free == gZoneUtilArray[aIndex2].iPhysPages &&
indexFree >= aMaxPages && index2Free >= KIndex2Alloc &&
freeInUsePages >= KIndex2Alloc + aMaxPages)
{
zonesFound = ETrue;
break;
}
freeInUsePages += index2Free;
}
// Could suitable RAM zones be found.
if (!zonesFound)
{
test.Printf(_L("Insufficient memory - Skipping test...\n"));
return KErrNoMemory;
}
if (aPageType == BEST_MOVABLE)
{
// Allocate KIndex2Alloc movable pages to aIndex2
r = ZoneAllocMovable(gChunkArray1, gChunkArraySize1, aIndex2, KIndex2Alloc);
if (r != KErrNone)
{
test.Printf(_L("Insufficient memory - Skipping test...\n"));
r = KErrNoMemory;
goto error;
}
// Now allow movable pages to be allocated into the least preferable RAM zone under test only.
GetAllPageInfo();
if (aMaxPages >= gZoneUtilArray[aIndex].iFreePages)
{
test.Printf(_L("Insufficient memory available - Skipping test...\n"));
r = KErrNoMemory;
goto error;
}
// Allocate aMaxPages movable pages to aIndex
r = ZoneAllocMovable(gChunkArray2, gChunkArraySize2, aIndex, aMaxPages);
if (r != KErrNone)
{
test.Printf(_L("Insufficient memory - Skipping test...\n"));
r = KErrNoMemory;
goto error;
}
// Determine how many free pages there are in the RAM zones more preferable
// than the RAM zones under test.
GetPrefOrder();
freeInUsePages = 0;
for (TUint i = 0; i < gZoneCount; i++)
{
TUint tmpIndex = gPrefArray[i];
if (tmpIndex == aIndex2)
break;
freeInUsePages += gZoneUtilArray[tmpIndex].iFreePages;
}
// Verify that the RAM layout is still suitable for the test.
if (gZoneUtilArray[aIndex].iAllocMovable != aMaxPages ||
gZoneUtilArray[aIndex2].iAllocMovable != KIndex2Alloc ||
gZoneUtilArray[aIndex].iAllocDiscardable || gZoneUtilArray[aIndex].iAllocFixed ||
gZoneUtilArray[aIndex2].iAllocDiscardable || gZoneUtilArray[aIndex2].iAllocFixed ||
freeInUsePages < KIndex2Alloc + aMaxPages)
{
test.Printf(_L("Insufficient memory - Skipping test...\n"));
r = KErrNoMemory;
goto error;
}
// now reset all the flags
ResetRamZoneFlags();
// Perform a general defrag
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC, 0, KTestMaxPages);
goto exit;
}
if (aPageType == BEST_DISCARDABLE)
{
TUint minCacheSize = 0;
TUint maxCacheSize = 0;
TUint currentCacheSize = 0;
DPTest::CacheSize(minCacheSize,maxCacheSize,currentCacheSize);
test.Printf(_L("Original CacheSize: minCacheSize = 0x%x, maxCacheSize = 0x%x, currentCacheSize = 0x%x\n"),
minCacheSize >> gPageShift, maxCacheSize >> gPageShift, currentCacheSize >> gPageShift);
// Allocate a number of discardable pages to the 2nd least preferable zone under test
TInt disPages;
r = ZoneAllocDiscard(aIndex2, KIndex2Alloc, disPages);
if (r != KErrNone)
{
test.Printf(_L("ZoneAllocDiscard() r = %d KIndex2Alloc = 0x%x disPages = 0x%x aIndex2 = %d - Skipping test...\n"),
r, KIndex2Alloc, disPages, aIndex2);
GetAllPageInfo();
PrintPageInfo();
r = KErrNoMemory;
goto error;
}
TUint discFillBytes = KIndex2Alloc << gPageShift;
r = DPTest::SetCacheSize(currentCacheSize + discFillBytes, currentCacheSize + discFillBytes);
if (r != KErrNone)
{
test.Printf(_L("SetCacheSize r = 0x%x currentCacheSize + discFillBytes = 0x%x - Skipping test...\n"),
r, currentCacheSize + discFillBytes);
GetAllPageInfo();
PrintPageInfo();
r = KErrNoMemory;
goto error;
}
// Allocate a discardable pages equal to aMaxPages to the least preferable zone under test
GetAllPageInfo();
if(aMaxPages >= gTotalPageCount.iFreePages)
{
test.Printf(_L("Insufficient memory available - Skipping test...\n"));
r = KErrNoMemory;
goto error;
}
TUint allocPages = aMaxPages + KIndex2Alloc;
r = ZoneAllocDiscard(aIndex, aMaxPages, disPages);
if (r != KErrNone)
{
test.Printf(_L("ZoneAllocDiscard() r = %d aMaxPages = 0x%x disPages = 0x%x aIndex = %d - Skipping test...\n"),
r, aMaxPages, disPages, aIndex);
GetAllPageInfo();
PrintPageInfo();
r = KErrNoMemory;
goto error;
}
discFillBytes = allocPages << gPageShift;
r = DPTest::SetCacheSize(currentCacheSize + discFillBytes, currentCacheSize + discFillBytes);
if (r != KErrNone)
{
test.Printf(_L("SetCacheSize r = %d currentCacheSize + discFillBytes = 0x%x - Skipping test...\n"),
r, currentCacheSize + discFillBytes);
GetAllPageInfo();
PrintPageInfo();
r = KErrNoMemory;
goto error;
}
// Determine how many free pages there are in the RAM zones more preferable
// than the RAM zones under test.
GetPrefOrder();
freeInUsePages = 0;
for (TUint i = 0; i < gZoneCount; i++)
{
TUint tmpIndex = gPrefArray[i];
if (tmpIndex == aIndex2)
break;
freeInUsePages += gZoneUtilArray[tmpIndex].iFreePages;
}
// Verify that the RAM layout is still suitable for the test.
if (r != KErrNone || gZoneUtilArray[aIndex].iAllocDiscardable != aMaxPages ||
gZoneUtilArray[aIndex2].iAllocDiscardable != KIndex2Alloc ||
gZoneUtilArray[aIndex].iAllocMovable || gZoneUtilArray[aIndex].iAllocFixed ||
gZoneUtilArray[aIndex2].iAllocMovable || gZoneUtilArray[aIndex2].iAllocFixed ||
freeInUsePages < KIndex2Alloc + aMaxPages)
{
test.Printf(_L("Insufficient memory - Skipping test...\n"));
r = KErrNoMemory;
goto error;
}
// now reset all the flags
ResetRamZoneFlags();
// Perform a general defrag with maxPages = KTestMaxPages
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC, 0, KTestMaxPages);
goto exit;
}
error:
// Reset all the flags
ResetRamZoneFlags();
exit:
return r;
}
//
// TestDefragRamMaxPages
//
//---------------------------------------------------------------------------------------------------------------------
//! @SYMTestCaseID KBASE-t_ramdefrag-0530
//! @SYMTestType CIT
//! @SYMTestCaseDesc Verifying the implementation of the function TRamDefragRequest::DefragRam()
//! @SYMPREQ PREQ308
//! @SYMTestPriority High
//! @SYMTestActions
//! 1. Call function with invalid aMaxPages
//! 2. Call DefragRam when aMaxPages < number of movable pages in least preferable zone
//! 3. Call DefragRam when aMaxPages > number of movable pages in least preferable zone
//! 4. Call DefragRam when aMaxPages = number of movable pages in least preferable zone
//! 5. Call DefragRam when aMaxPages < number of discardable pages in least preferable zone
//! 6. Call DefragRam when aMaxPages > number of discardable pages in least preferable zone
//! 7. Call DefragRam when aMaxPages = number of discardable pages in least preferable zone
//!
//! @SYMTestExpectedResults
//! 1. KErrArgument
//! 2. Least preferable zone and 2nd least preferable zone have not been emptied
//! 3. Least preferable zone has been emptied and 2nd least preferable zone has not been emptied
//! 4. Least preferable zone has been emptied and 2nd least preferable zone not not been emptied
//! 5. Least preferable zone and 2nd least preferable zone have not been emptied
//! 6. Least preferable zone has been emptied and 2nd least preferable zone has not been emptied
//! 7. Least preferable zone has been emptied and 2nd least preferable zone not not been emptied
//---------------------------------------------------------------------------------------------------------------------
TInt TestDefragRamMaxPages()
{
test.Start(_L("Test1: Call DefragRam with invalid aMaxPages "));
TestStart();
gDefragMaxPages = -1;
TInt r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC, 0, gDefragMaxPages);
TESTDEBUG(test.Printf(_L("After calling defrag r = %d\n"), r));
if (r != KErrArgument)
{
test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrArgument);
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
TestEnd();
test.Next(_L("Test2: Call DefragRam aMaxPages < number of movable pages in least preferable zone "));
TestStart();
gChunkArray1 = new RChunk;
gChunkArraySize1 = 1;
gChunkArray2 = new RChunk;
gChunkArraySize2 = 1;
TUint index = 0;
TUint index2 = 0;
r = DefragMaxPagesSetup(BEST_MOVABLE, KTestMaxPages + 1, index, index2);
if (gZoneUtilArray[index].iAllocFixed > 0 || gZoneUtilArray[index2].iAllocFixed > 0)
{// Cannot perform test with fixed pages in least preferable zones
test.Printf(_L("Fixed pages in least preferable zone - Skipping...\n"));
}
else
{
if (r == KErrNone)
{
GetAllPageInfo();
if (gZoneUtilArray[index].iAllocMovable < KTestMaxPages + 1 ||
gZoneUtilArray[index2].iAllocMovable < KIndex2Alloc)
{
test.Printf(_L("Fail: index = %d, expected = 0x%x, index2 = %d, expected = 0x%x\n"),
index, KTestMaxPages + 1, index2, KIndex2Alloc);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
CLEANUP(RemoveChunkAlloc(gChunkArray2, gChunkArraySize2));
CLEANUP(Ldd.FreeFromAllZones());
TEST_FAIL;
}
// Double check that if DefragRam is called with maxPages = 0, these zones are emptied
// if there is free space elsewhere
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC, 0, gDefragMaxPages);
GetAllPageInfo();
if (gTotalPageCount.iFreePages > KIndex2Alloc + KTestMaxPages + 1 &&
(gZoneUtilArray[index].iAllocMovable != 0 || gZoneUtilArray[index2].iAllocMovable != 0))
{
test.Printf(_L("Fail: index = %d, expected = 0x%x, index2 = %d, expected = 0x%x\n"),
index, 0, index2, 0);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
CLEANUP(RemoveChunkAlloc(gChunkArray2, gChunkArraySize2));
CLEANUP(Ldd.FreeFromAllZones());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
else
{
test.Printf(_L("DefragMaxPagesSetup failed r = %d\n"), r);
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
RemoveChunkAlloc(gChunkArray2, gChunkArraySize2);
}
Ldd.FreeFromAllZones();
TestEnd();
test.Next(_L("Test3: Call DefragRam aMaxPages > number of movable pages in least preferable zone "));
TestStart();
gChunkArray1 = new RChunk;
gChunkArraySize1 = 1;
gChunkArray2 = new RChunk;
gChunkArraySize2 = 1;
r = DefragMaxPagesSetup(BEST_MOVABLE, KTestMaxPages - 1, index, index2);
if (gZoneUtilArray[index].iAllocFixed > 0 || gZoneUtilArray[index2].iAllocFixed > 0)
{// Cannot perform test with fixed pages in least preferable zones
test.Printf(_L("Fixed pages in least preferable zone - Skipping...\n"));
}
else
{
if (r == KErrNone)
{
GetAllPageInfo();
if (gZoneUtilArray[index].iAllocMovable != 0)
{
test.Printf(_L("Fail: index = %d, expected = 0x%x, index2 = %d, expected = 0x%x\n"),
index, 0, index2, KIndex2Alloc);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
CLEANUP(RemoveChunkAlloc(gChunkArray2, gChunkArraySize2));
CLEANUP(Ldd.FreeFromAllZones());
TEST_FAIL;
}
// Double check that if DefragRam is called with maxPages = 0, these zones are emptied
// if there is free space elsewhere
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC, 0, gDefragMaxPages);
GetAllPageInfo();
if (gTotalPageCount.iFreePages > KIndex2Alloc + KTestMaxPages - 1 &&
(gZoneUtilArray[index].iAllocMovable != 0 || gZoneUtilArray[index2].iAllocMovable != 0))
{
test.Printf(_L("Fail: index = %d, expected = 0x%x, index2 = %d, expected = 0x%x\n"),
index, 0, index2, 0);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
CLEANUP(RemoveChunkAlloc(gChunkArray2, gChunkArraySize2));
CLEANUP(Ldd.FreeFromAllZones());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
else
{
test.Printf(_L("DefragMaxPagesSetup failed r = %d\n"), r);
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
RemoveChunkAlloc(gChunkArray2, gChunkArraySize2);
}
Ldd.FreeFromAllZones();
TestEnd();
test.Next(_L("Test4: Call DefragRam aMaxPages = number of movable pages in least preferable zone "));
TestStart();
gChunkArray1 = new RChunk;
gChunkArraySize1 = 1;
gChunkArray2 = new RChunk;
gChunkArraySize2 = 1;
r = DefragMaxPagesSetup(BEST_MOVABLE, KTestMaxPages, index, index2);
if (gZoneUtilArray[index].iAllocFixed > 0 || gZoneUtilArray[index2].iAllocFixed > 0)
{// Cannot perform test with fixed pages in least preferable zones
test.Printf(_L("Fixed pages in least preferable zone - Skipping...\n"));
}
else
{
if (r == KErrNone)
{
GetAllPageInfo();
if (gZoneUtilArray[index].iAllocMovable != 0)
{
test.Printf(_L("Fail: index = %d, expected = 0x%x, index2 = %d, expected = 0x%x\n"),
index, 0, index2, KIndex2Alloc);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
CLEANUP(RemoveChunkAlloc(gChunkArray2, gChunkArraySize2));
CLEANUP(Ldd.FreeFromAllZones());
TEST_FAIL;
}
// Double check that if DefragRam is called with maxPages = 0, these zones are emptied
// if there is free space elsewhere
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC, 0, gDefragMaxPages);
GetAllPageInfo();
if (gTotalPageCount.iFreePages > KIndex2Alloc + KTestMaxPages &&
(gZoneUtilArray[index].iAllocMovable != 0 || gZoneUtilArray[index2].iAllocMovable != 0))
{
test.Printf(_L("Fail: index = %d, expected = 0x%x, index2 = %d, expected = 0x%x\n"),
index, 0, index2, 0);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
CLEANUP(RemoveChunkAlloc(gChunkArray2, gChunkArraySize2));
CLEANUP(Ldd.FreeFromAllZones());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
else
{
test.Printf(_L("DefragMaxPagesSetup failed r = %d\n"), r);
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
RemoveChunkAlloc(gChunkArray2, gChunkArraySize2);
}
Ldd.FreeFromAllZones();
TestEnd();
test.Next(_L("Test5: Call DefragRam aMaxPages < number of discardable pages in least preferable zone "));
TestStart();
if (gPagedRom)
{
r = DefragMaxPagesSetup(BEST_DISCARDABLE, KTestMaxPages + 1, index, index2);
if (gZoneUtilArray[index].iAllocFixed > 0 || gZoneUtilArray[index2].iAllocFixed > 0)
{// Cannot perform test with fixed pages in least preferable zones
test.Printf(_L("Fixed pages in least preferable zone - Skipping...\n"));
}
else
{
if (r == KErrNone)
{
GetAllPageInfo();
if (gZoneUtilArray[index].iAllocDiscardable < KTestMaxPages + 1 ||
gZoneUtilArray[index2].iAllocDiscardable < KIndex2Alloc)
{
test.Printf(_L("Fail: index = %d, expected = 0x%x, index2 = %d, expected = 0x%x\n"),
index, KTestMaxPages + 1, index2, KIndex2Alloc);
CLEANUP(ResetDPCache());
CLEANUP(Ldd.FreeFromAllZones());
TEST_FAIL;
}
// Double check that if DefragRam is called with maxPages = 0, these zones are emptied
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC, 0, gDefragMaxPages);
GetAllPageInfo();
if (gZoneUtilArray[index].iAllocDiscardable != 0 ||
gZoneUtilArray[index2].iAllocDiscardable != 0)
{
test.Printf(_L("Fail: index = %d, expected = 0x%x, index2 = %d, expected = 0x%x\n"),
index, 0, index2, 0);
CLEANUP(ResetDPCache());
CLEANUP(Ldd.FreeFromAllZones());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
else
{
test.Printf(_L("DefragMaxPagesSetup failed r = %d\n"), r);
}
ResetDPCache();
}
Ldd.FreeFromAllZones();
}
else
{
test.Printf(_L("Not a Paged Rom - Skipping...\n"));
}
TestEnd();
test.Next(_L("Test6: Call DefragRam aMaxPages > number of discardable pages in least preferable zone "));
TestStart();
if (gPagedRom)
{
r = DefragMaxPagesSetup(BEST_DISCARDABLE, KTestMaxPages - 1, index, index2);
if (gZoneUtilArray[index].iAllocFixed > 0 || gZoneUtilArray[index2].iAllocFixed > 0)
{// Cannot perform test with fixed pages in least preferable zones
test.Printf(_L("Fixed pages in least preferable zone - Skipping...\n"));
}
else
{
if (r == KErrNone)
{
GetAllPageInfo();
if (gZoneUtilArray[index].iAllocDiscardable != 0||
gZoneUtilArray[index2].iAllocDiscardable != KIndex2Alloc)
{
test.Printf(_L("Fail: index = %d, expected = 0x%x, index2 = %d, expected = 0x%x\n"),
index, 0, index2, KIndex2Alloc);
CLEANUP(ResetDPCache());
CLEANUP(Ldd.FreeFromAllZones());
TEST_FAIL;
}
// Double check that if DefragRam is called with maxPages = 0, these zones are emptied
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC, 0, gDefragMaxPages);
GetAllPageInfo();
if (gZoneUtilArray[index].iAllocDiscardable != 0||
gZoneUtilArray[index2].iAllocDiscardable != 0)
{
test.Printf(_L("Fail: index = %d, expected = 0x%x, index2 = %d, expected = 0x%x\n"),
index, 0, index2, 0);
CLEANUP(ResetDPCache());
CLEANUP(Ldd.FreeFromAllZones());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
else
{
test.Printf(_L("DefragMaxPagesSetup failed r = %d\n"), r);
}
ResetDPCache();
}
Ldd.FreeFromAllZones();
}
else
{
test.Printf(_L("Not a Paged Rom - Skipping...\n"));
}
TestEnd();
test.Next(_L("Test4: Call DefragRam aMaxPages = number of discardable pages in least preferable zone "));
TestStart();
if(gPagedRom)
{
r = DefragMaxPagesSetup(BEST_DISCARDABLE, KTestMaxPages, index, index2);
if (gZoneUtilArray[index].iAllocFixed > 0 || gZoneUtilArray[index2].iAllocFixed > 0)
{// Cannot perform test with fixed pages in least preferable zones
test.Printf(_L("Fixed pages in least preferable zone - Skipping...\n"));
}
else
{
if (r == KErrNone)
{
GetAllPageInfo();
if (gZoneUtilArray[index].iAllocDiscardable != 0||
gZoneUtilArray[index2].iAllocDiscardable != KIndex2Alloc)
{
test.Printf(_L("Fail: index = %d, expected = 0x%x, index2 = %d, expected = 0x%x\n"),
index, 0, index2, KIndex2Alloc);
CLEANUP(ResetDPCache());
CLEANUP(Ldd.FreeFromAllZones());
TEST_FAIL;
}
// Double check that if DefragRam is called with maxPages = 0, these zones are emptied
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC, 0, gDefragMaxPages);
GetAllPageInfo();
if (gZoneUtilArray[index].iAllocDiscardable != 0||
gZoneUtilArray[index2].iAllocDiscardable != 0)
{
test.Printf(_L("Fail: index = %d, expected = 0x%x, index2 = %d, expected = 0x%x\n"),
index, 0, index2, 0);
CLEANUP(ResetDPCache());
CLEANUP(Ldd.FreeFromAllZones());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
else
{
test.Printf(_L("DefragMaxPagesSetup failed r = %d\n"), r);
}
ResetDPCache();
}
Ldd.FreeFromAllZones();
}
else
{
test.Printf(_L("Not a Paged Rom - Skipping...\n"));
}
TestEnd();
test.End();
return KErrNone;
}
//
// TestEmptyRamZone
//
//---------------------------------------------------------------------------------------------------------------------
//! @SYMTestCaseID KBASE-t_ramdefrag-0531
//! @SYMTestType CIT
//! @SYMTestCaseDesc Verifying the implementation of the function TRamDefragRequest::EmptyRamZone()
//! @SYMPREQ PREQ308
//! @SYMTestPriority High
//! @SYMTestActions
//! 1. Fragment the memory. Call function with a valid aID,
//! i.e. a zone which lies within the range of zones.
//! 2. Fragment the memory. Call function with an invalid aID
//! i.e. a zone which does not exist within the range of zones.
//! 3. Fragment the memory. Following this, call a zone specific defrag on a particular zone.
//! Call the zone specific defrag again on the same zone whilst the other defrag is still
//! running on that zone.
//! 4. Fragment the memory. Following this, call the TRamDefragRequest::DefragRam() to perform general defrag.
//! Following this call zone specific defrag whilst the general defrag is still running.
//! 5. Fragment the memory. Following this, call a zone specific defrag on a particular zone.
//! Whilst the zone defrag is running, call a general defrag
//! 6: Fragment the memory. Following this, call the function on specifc zone and
//! at the same time allocate pages to the zone
//! 7. Fragment the memory. Call EmptyRamZone() on every zone one after the other.
//! 8. Fragment the memory. Allocate a couple of fixed pages to a zone that contains movable pages.
//! Following this, Call EmptyRamZone() on that zone.
//!
//! @SYMTestExpectedResults
//! 1. KErrNone
//! 2. KErrArgument
//! 3. KErrNone and the zone has been emptied
//! 4. Zone has not been emptied, as the general defrag has already placed pages in the zone
//! 5. Zone has been emptied
//! 6. KErrNone and pages have been allocated in the zone
//! 7. One of the following scenarios should occur:
//! a. If the cache has not reached its minimum size, then all the movable pages should
//! be moved from the zone if there are enough free pages in the other zones.
//! However, when demand paging is off, all movable pages should be moved from the zone, again if there
//! are enough free pages in the other zones.
//! b. If the current size of the cache minus the number of discardable pages in the zone being emptied is
//! not less than the minimum cache size, then all the discardable pages should be discarded of.
//! However, when demand paging is off, all discardable pages should be removed from
//! the zone.
//! 8. KErrNoMemory, however all movable and discardable pages have been moved from the zone
//---------------------------------------------------------------------------------------------------------------------
TInt TestEmptyRamZone()
{
TInt r = KErrNone;
TInt r2 = KErrNone;
test.Start(_L("Test1: Call EmptyRamZone with valid aID "));
TestStart();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
GetAllPageInfo();
TUint index = gZoneCount - 1;
while (index > 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
{
-- index;
}
TUint defragZoneID = gZoneConfigArray[index].iZoneId;
test.Printf(_L("Zone ID = %d\n"), defragZoneID);
if (index == 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
{
test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
}
else
{
r = Ldd.CallDefrag(DEFRAG_TYPE_EMPTY, DEFRAG_VER_SYNC, defragZoneID);
GetAllPageInfo();
TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
if (freeInOthers && (r != KErrNone || !CheckZoneIsOff(index)))
{
test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrNone);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
TestEnd();
test.Next(_L("Test2: Call EmptyRamZone with invalid aID "));
TestStart();
gChunkArray1 = new RChunk;
gChunkArraySize1 = 1;
defragZoneID = KInvalidZoneID;
r = Ldd.CallDefrag(DEFRAG_TYPE_EMPTY, DEFRAG_VER_SYNC, defragZoneID);
if (r != KErrArgument)
{
test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrArgument);
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
TestEnd();
test.Next(_L("Test3: Call EmptyRamZone twice at the same time "));
TestStart();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
GetAllPageInfo();
index = gZoneCount - 1;
while (index > 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
{
-- index;
}
defragZoneID = gZoneConfigArray[index].iZoneId;
if (index == 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
{
test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
}
else
{
r = gTestThread.Create(gTestThreadName,MultiEmptyZoneThreadFunc,KDefaultStackSize,0x1000,0x1000,(TAny *)defragZoneID);
if (r != KErrNone)
{
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
gTestThread.Logon(status);
gTestThread.Resume();
User::After(10);
r = Ldd.CallDefrag(DEFRAG_TYPE_EMPTY, DEFRAG_VER_SYNC, defragZoneID);
User::WaitForRequest(status);
r2 = status.Int();
GetAllPageInfo();
TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
if (r != r2 ||
(freeInOthers && (r != KErrNone || r2 != KErrNone || !CheckZoneIsOff(index))))
{
test.Printf(_L("Fail: r = %d, r2 = %d, expected = %d, or zone %d has not been emptied\n"),
r, r2, KErrNone, defragZoneID);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
gTestThread.Close();
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
TestEnd();
test.Next(_L("Test4: Call general defrag and zone defrag at the same time "));
TestStart();
TInt waitTime = 10000;
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
GetAllPageInfo();
index = gZoneCount - 1;
while (index > 0 && gZoneUtilArray[index].iAllocFixed > 0)
{
index--;
}
defragZoneID = gZoneConfigArray[index].iZoneId;
if (index == 0 && gZoneUtilArray[index].iAllocFixed > 0)
{
test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
}
else
{
r = gTestThread.Create(gTestThreadName,MultiGenDefragThreadFunc,KDefaultStackSize,0x1000,0x1000,NULL);
if (r != KErrNone)
{
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
gTestThread.Logon(status);
gTestThread.Resume();
User::After(waitTime);
TESTDEBUG(test.Printf(_L("Zone defrag running on main thread\n")));
r = Ldd.CallDefrag(DEFRAG_TYPE_EMPTY, DEFRAG_VER_SYNC, defragZoneID);
User::WaitForRequest(status);
r2 = status.Int();
GetAllPageInfo();
TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
if (r2 != KErrNone ||
(freeInOthers && (r != KErrNone || !CheckZoneIsOff(index))))
{
test.Printf(_L("Fail: r = %d, r2 = %d, expected = %d, or zone %d is on unexpectedly\n"),
r, r2, KErrNone, defragZoneID);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
gTestThread.Close();
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
TestEnd();
test.Next(_L("Test5: Call zone defrag and general defrag at the same time "));
TestStart();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
GetAllPageInfo();
index = gZoneCount - 1;
while (index > 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
{
-- index;
}
defragZoneID = gZoneConfigArray[index].iZoneId;
if (index == 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
{
test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
}
else
{
r = gTestThread.Create(gTestThreadName,MultiEmptyZoneThreadFunc,KDefaultStackSize,0x1000,0x1000,(TAny*)defragZoneID);
if (r != KErrNone)
{
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
gTestThread.Logon(status);
gTestThread.Resume();
User::After(0);
TESTDEBUG(test.Printf(_L("Zone defrag running on main thread\n")));
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC, 0, gDefragMaxPages);
User::WaitForRequest(status);
r2 = status.Int();
GetAllPageInfo();
TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
if (r != KErrNone ||
(freeInOthers && (r2 != KErrNone || !CheckZoneIsOff(index))))
{
test.Printf(_L("Fail: r = %d, r2 = %d, expected = %d, or zone 0x%x is on unexpectedly\n"),
r, r2, KErrNone, defragZoneID);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
gTestThread.Close();
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
TestEnd();
test.Next(_L("Test6: Call function TRamDefragRequest::EmptyRamZone on specifc zone and at the same time allocate pages to the zone"));
TestStart();
TInt pagesAlloc = 1; // Try and allocate just one page whilst trying to empty the zone.
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
GetAllPageInfo();
index = gZoneCount - 1;
while (index > 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
{
-- index;
}
defragZoneID = gZoneConfigArray[index].iZoneId;
if (index == 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
{
test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
}
else
{
TInt numPassed = 0;
for (waitTime = 1000; waitTime > 0; waitTime-=10)
{
r = gTestThread.Create(gTestThreadName,MultiEmptyZoneThreadFunc,KDefaultStackSize,0x1000,0x1000,(TAny*)defragZoneID);
if (r != KErrNone)
{
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
gTestThread.Logon(status);
gTestThread.Resume();
User::After(waitTime);
r = Ldd.ZoneAllocDiscontiguous(defragZoneID, pagesAlloc);
User::WaitForRequest(status);
r2 = status.Int();
if (r2 != KErrNone)
{
test.Printf(_L("Empty was unsuccsessful: r2 = %d, expected = %d\n"), r2, KErrNone);
}
else if (r != KErrNone)
{
test.Printf(_L("Fail: r = %d, expected = %d, r2 = %d, expected = %d, zone = 0x%x\n"),
r, KErrNone, r2, KErrNone, defragZoneID);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
else
{
numPassed ++;
}
Ldd.FreeAllFixedPages();
gTestThread.Close();
}
if (numPassed > 0)
{
test.Printf(_L("Passed...\n"));
}
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
TestEnd();
test.Next(_L("Test7: Call function TRamDefragRequest::EmptyRamZone on every zone one after the other"));
TestStart();
Ldd.ResetDriver();
for (index = 0; index < gZoneCount; index ++)
{
// Variables for DP ROM cache sizes
TUint minCacheSize = 0;
TUint maxCacheSize = 0;
TUint currentCacheSize = 0;
if (gPagedRom)
{
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));
// Calculate the maximum size available for the DP cache.
TUint minZoneFree = KMaxTUint;
TUint maxDisFillBytes = 0;
GetAllPageInfo();
for (TUint i = 0; i < gZoneCount; i++)
{
maxDisFillBytes += gZoneUtilArray[i].iFreePages;
maxDisFillBytes += gZoneUtilArray[i].iAllocDiscardable;
if (minZoneFree > gZoneUtilArray[i].iFreePages)
minZoneFree = gZoneUtilArray[i].iFreePages;
}
test.Printf(_L("Free pages 0x%x maxDisFillBytes 0x%x\n"), gTotalPageCount.iFreePages, maxDisFillBytes);
maxDisFillBytes <<= gPageShift;
r = DPTest::SetCacheSize(maxDisFillBytes, maxDisFillBytes);
if (r != KErrNone)
{
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
CLEANUP(ResetDPCache());
TEST_FAIL;
}
DPTest::CacheSize(minCacheSize,maxCacheSize,currentCacheSize);
TESTDEBUG(test.Printf(_L("CacheSize2: minCacheSize = 0x%x, maxCacheSize = 0x%x, currentCacheSize = 0x%x\n"),
minCacheSize >> gPageShift, maxCacheSize >> gPageShift, currentCacheSize >> gPageShift));
if (currentCacheSize != maxDisFillBytes)
{
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
CLEANUP(ResetDPCache());
TEST_FAIL;
}
GetAllPageInfo();
test.Printf(_L("Free pages after alloc discardable1 = 0x%x\n"), gTotalPageCount.iFreePages);
r = DPTest::SetCacheSize(minZoneFree << gPageShift, maxDisFillBytes);
if (r != KErrNone)
{
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
CLEANUP(ResetDPCache());
TEST_FAIL;
}
// Check all zones have no free pages.
GetAllPageInfo();
for (TUint i = 0; i < gZoneCount; i++)
{
if (gZoneUtilArray[i].iFreePages != 0)
{
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
CLEANUP(ResetDPCache());
TEST_FAIL;
}
}
}
else
{
// Fragment the RAM with some movable pages
AllocMovable(gChunkArray1, gChunkArraySize1, KFillAllMovable);
FreeMovable(gChunkArray1, gChunkArraySize1);
}
TUint zoneID = gZoneConfigArray[index].iZoneId;
GetAllPageInfo();
TUint origUnknownInZone = gZoneUtilArray[index].iAllocUnknown;
TUint origMovInZone = gZoneUtilArray[index].iAllocMovable;
TUint origFreeInZone = gZoneUtilArray[index].iFreePages;
test.Printf(_L("Zone ID 0x%x - fixedPages = 0x%x, unknownPages = 0x%x, discardablePages = 0x%x movable = 0x%x free = 0x%x\n"),
zoneID, gZoneUtilArray[index].iAllocFixed, origUnknownInZone, gZoneUtilArray[index].iAllocDiscardable,
origMovInZone, origFreeInZone);
r = Ldd.CallDefrag(DEFRAG_TYPE_EMPTY, DEFRAG_VER_SYNC, zoneID);
GetAllPageInfo();
TUint unknownPages = gZoneUtilArray[index].iAllocUnknown;
TUint discPages = gZoneUtilArray[index].iAllocDiscardable;
TUint movablePages = gZoneUtilArray[index].iAllocMovable;
TUint freeInOtherZones = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
if(movablePages && freeInOtherZones)
{
test.Printf(_L("Fail: Zone ID %x all the movable pages haven't been moved\n"), zoneID);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
CLEANUP(ResetDPCache());
TEST_FAIL;
}
if (origUnknownInZone != unknownPages)
{
test.Printf(_L("Fail: Zone ID %x unknown pages before and after are not equal\n"), zoneID);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
CLEANUP(ResetDPCache());
TEST_FAIL;
}
if (!gPagedRom)
{
if (discPages && freeInOtherZones)
{
test.Printf(_L("Fail: Zone ID %x all the discardable pages haven't been moved\n"), zoneID);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
CLEANUP(ResetDPCache());
TEST_FAIL;
}
}
else
{
DPTest::CacheSize(minCacheSize, maxCacheSize, currentCacheSize);
TESTDEBUG(test.Printf(_L("CacheSize3: minCacheSize = 0x%x, maxCacheSize = 0x%x, currentCacheSize = 0x%x\n"),
minCacheSize >> gPageShift, maxCacheSize >> gPageShift, currentCacheSize >> gPageShift));
// The the discardable pages should have been discarded or moved unless
// there is no room in the other zones and the cache size is already at its minimum
if (discPages && (freeInOtherZones || currentCacheSize != minCacheSize))
{
test.Printf(_L("Fail: Zone 0x%x all the discardable pages haven't been moved\n"), zoneID);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
CLEANUP(ResetDPCache());
TEST_FAIL;
}
}
test.Printf(_L("Passed...\n"));
}
// TestEnd() willl cleanup what's required
TestEnd();
test.Next(_L("Test8: Call function TRamDefragRequest::EmptyRamZone on a zone that contains fixed and movable pages"));
TestStart();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
GetAllPageInfo();
index = gZoneCount - 1;
while (index > 0 && (gZoneUtilArray[index].iAllocMovable < 10 || gZoneUtilArray[index].iFreePages < 3))
{
-- index;
}
defragZoneID = gZoneConfigArray[index].iZoneId;
if (index == 0 && (gZoneUtilArray[index].iAllocMovable < 10 || gZoneUtilArray[index].iFreePages < 3))
{
test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
}
else
{
test.Printf(_L("defragZoneID = 0x%x\n"), defragZoneID);
test.Printf(_L("movable = 0x%x discardable = 0x%x\n"),
gZoneUtilArray[index].iAllocMovable, gZoneUtilArray[index].iAllocDiscardable);
Ldd.ZoneAllocDiscontiguous(defragZoneID, 2); // Allocated 2 fixed pages to ensure that zone cannot be emptied
r = Ldd.CallDefrag(DEFRAG_TYPE_EMPTY, DEFRAG_VER_SYNC, defragZoneID);
GetAllPageInfo();
TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
if (r != KErrNoMemory ||
(freeInOthers &&
(gZoneUtilArray[index].iAllocMovable ||
gZoneUtilArray[index].iAllocDiscardable)))
{
test.Printf(_L("r = %d, expected = %d, or all movable/discardable pages have not been moved"),
r, KErrNoMemory);
CLEANUP(Ldd.FreeAllFixedPages());
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed..."));
}
Ldd.FreeAllFixedPages();
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
TestEnd();
test.End();
return r;
}
//
// TestClaimRamZone
//
//---------------------------------------------------------------------------------------------------------------------
//! @SYMTestCaseID KBASE-t_ramdefrag-0532
//! @SYMTestType CIT
//! @SYMTestCaseDesc Verifying the implemntation of the function TRamDefragRequest::ClaimRamZone()
//! @SYMPREQ PREQ308
//! @SYMTestPriority High
//! @SYMTestActions
//! 1. Fragment the memory. Following this, call function with a valid aID
//! 2. Fragment the memory. Following this, call function with an invalid aID
//! 3. Fragment the memory. Following this, start a zone defrag and whilst this
//! is running, call function on the same zone.
//! 4. Fragment the memory. Following this, start a general defrag and whilst this
//! is running, call function on the same zone.
//! 5. Fragment the memory. Following this, call ClaimRamZone() on a specific zone, whilst at the
//! same time calling ClaimRamZone() on another zone.
//! 6: Fragment the memory. Call function TRamDefragRequest::ClaimRamZone on specifc zone and at the
//! same time allocate pages to the zone
//! 7. Fragment the memory. Following this allocate fixed pages to a zone and attempt to claim
//! the zone.
//! 8. Fragment the memory. Following this call ClaimRamZone() on every zone, one after the other
//!
//! @SYMTestExpectedResults
//! 1. KErrNone
//! 2. KErrArgument
//! 3. KErrNone and the zone has been claimed
//! 4. KErrNone and the zone has been claimed
//! 5. KErrNone and both zones have been claimed
//! 6. KErrNoMemory
//! 7. KErrNoMemory, all movable and discardable pages have been moved
//! 8. One of the following scenarios should occur:
//! a. If the cache has not reached its minimum size and there are no unknown pages in
//! the zone, then all the movable pages should be moved from the zone if there are enough free pages
//! in the other zones.
//! However, when demand paging is off, all movable pages should be moved from the zone, again if there
//! are enough free pages in the other zones and if there are no unknown pages in the zone.
//! b. If the current size of the cache minus the number of discardable pages in the zone being emptied is not
//! less than the minimum cache size and there are no unknown pages in the zone,
//! then all the discardable pages should be discarded of.
//! However, when demand paging is off, all discardable pages should be removed from
//! the zone if there are no unknown pages in the zone.
//---------------------------------------------------------------------------------------------------------------------
TInt TestClaimRamZone()
{
TInt r = 0;
TInt r2 = 0;
TUint32 addr = 0;
TInt waitTime = 1000;
test.Start(_L("Test1: Call function TRamDefragRequest::ClaimRamZone with a valid aID"));
TestStart();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
GetAllPageInfo();
TUint index = gZoneCount - 1;
while (index > 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
{
-- index;
}
TUint defragZoneID = gZoneConfigArray[index].iZoneId;
if (index == 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
{
test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
}
else
{
r = Ldd.CallDefrag(DEFRAG_TYPE_CLAIM, DEFRAG_VER_SYNC, defragZoneID);
GetAllPageInfo();
TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
if (freeInOthers && r != KErrNone &&
gZoneUtilArray[index].iAllocFixed != gZoneUtilArray[index].iPhysPages)
{
test.Printf(_L("Fail: Zone 0x%x has not been claimed r %d expected %d\n"), defragZoneID, r, KErrNone);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
addr = gZoneConfigArray[index].iPhysBase;
if (r == KErrNone)
{
r = Ldd.FreeAllFixedPages();
}
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
TestEnd();
test.Next(_L("Test2: Call function TRamDefragRequest::ClaimRamZone with an invalid aID"));
TestStart();
gChunkArray1 = new RChunk;
gChunkArraySize1 = 1;
defragZoneID = KInvalidZoneID;
r = Ldd.CallDefrag(DEFRAG_TYPE_CLAIM, DEFRAG_VER_SYNC, defragZoneID);
if (r != KErrArgument)
{
test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrArgument);
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
TestEnd();
test.Next(_L("Test3: Call function TRamDefragRequest::ClaimRamZone when a EmptyRamZone is already running"));
TestStart();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
GetAllPageInfo();
index = gZoneCount - 1;
while (index > 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
{
-- index;
}
defragZoneID = gZoneConfigArray[index].iZoneId;
if (index == 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
{
test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
}
else
{
TInt numPassed = 0;
for (waitTime = 1000; waitTime > 0; waitTime-=10)
{
r = gTestThread.Create(gTestThreadName,MultiEmptyZoneThreadFunc,KDefaultStackSize,0x1000,0x1000,(TAny*)defragZoneID);
if (r != KErrNone)
{
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
gTestThread.Logon(status);
gTestThread.Resume();
User::After(waitTime);
r = Ldd.CallDefrag(DEFRAG_TYPE_CLAIM, DEFRAG_VER_SYNC, defragZoneID);
User::WaitForRequest(status);
r2 = status.Int();
GetAllPageInfo();
TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
if (freeInOthers && r != KErrNone && r2 != KErrNone)
{
test.Printf(_L("Fail: r = %d, r2 = %d, expected = %d, or zone ID 0x%x has not been claimed\n"),
r, r2, KErrNone, defragZoneID);
if (r == KErrNone)
{
CLEANUP(r = Ldd.FreeAllFixedPages());
}
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
numPassed ++;
}
if (r == KErrNone)
{
r = Ldd.FreeAllFixedPages();
}
gTestThread.Close();
}
if (numPassed > 0)
{
test.Printf(_L("Passed...\n"));
}
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
TestEnd();
test.Next(_L("Test4: Call function TRamDefragRequest::ClaimRamZone when a general defrag is already running"));
TestStart();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
GetAllPageInfo();
index = gZoneCount - 1;
while (index > 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
{
-- index;
}
if (index == 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
{
test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
}
else
{
defragZoneID = gZoneConfigArray[index].iZoneId;
r = gTestThread.Create(gTestThreadName,MultiGenDefragThreadFunc,KDefaultStackSize,0x1000,0x1000,NULL);
if (r != KErrNone)
{
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
gTestThread.Logon(status);
gTestThread.Resume();
User::After(waitTime);
r = Ldd.CallDefrag(DEFRAG_TYPE_CLAIM, DEFRAG_VER_SYNC, defragZoneID);
User::WaitForRequest(status);
r2 = status.Int();
if (r != KErrNone)
{
test.Printf(_L("ClaimZone: r = %d, expected = %d\n"), r, KErrNone);
}
if (r2 != KErrNone)
{
test.Printf(_L("General: r2 = %d, expected = %d\n"), r, KErrNone);
}
GetAllPageInfo();
TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
if (freeInOthers && gZoneUtilArray[index].iAllocFixed != gZoneUtilArray[index].iPhysPages)
{
test.Printf(_L("Fail: Zone ID 0x%x has not been claimed, r = %d, r2 = %d, expected = %d\n"),
defragZoneID, r, r2, KErrNone);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
if (r == KErrNone)
{
r = Ldd.FreeAllFixedPages();
}
gTestThread.Close();
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
TestEnd();
test.Next(_L("Test5: Call function TRamDefragRequest::ClaimRamZone on specifc zone at the same time as calling on another zone"));
TestStart();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
GetAllPageInfo();
index = gZoneCount - 1;
while (index > 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
{
-- index;
}
defragZoneID = gZoneConfigArray[index].iZoneId;
test.Printf(_L("index = 0x%x "), index);
TUint index2 = gZoneCount - 1;
while ( index2 > 0 &&
(index == index2 || gZoneUtilArray[index2].iAllocFixed != 0 || gZoneUtilArray[index2].iAllocUnknown != 0))
{
-- index2;
}
TUint defragZoneID2 = gZoneConfigArray[index2].iZoneId;
test.Printf(_L("index2 = %d\n"), index2);
if ((index == 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0)) ||
(index2 == 0 && (index == index2 || gZoneUtilArray[index2].iAllocFixed != 0 || gZoneUtilArray[index2].iAllocUnknown != 0)))
{
test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
}
else
{
r = gTestThread.Create(gTestThreadName,MultiClaimZoneThreadFunc,KDefaultStackSize,0x1000,0x1000,(TAny*)(defragZoneID2));
if (r != KErrNone)
{
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
gTestThread.Logon(status);
gTestThread.Resume();
User::After(waitTime);
r = Ldd.CallDefrag(DEFRAG_TYPE_CLAIM, DEFRAG_VER_SYNC, defragZoneID);
TESTDEBUG(test.Printf(_L("r = %d\n"), r));
User::WaitForRequest(status);
r2 = status.Int();
GetAllPageInfo();
TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
TUint freeInOthers2 = gTotalPageCount.iFreePages - gZoneUtilArray[index2].iFreePages;
if ((freeInOthers && r != KErrNone &&
gZoneUtilArray[index].iAllocFixed != gZoneUtilArray[index].iPhysPages) ||
(freeInOthers2 && r != KErrNone &&
gZoneUtilArray[index2].iAllocFixed != gZoneUtilArray[index2].iPhysPages))
{
test.Printf(_L("Fail: Zone ID 0x%x or Zone ID 0x%x has not been claimed, r = %d, r2 = %d, expected = %d\n"),
defragZoneID, defragZoneID2, r, r2, KErrNone);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
if (r == KErrNone)
{
r = Ldd.FreeAllFixedPages();
}
if (r2 == KErrNone)
{// Have to free from specific address as RAM zone claimed by other channel.
addr = gZoneConfigArray[index2].iPhysBase;
r = Ldd.FreeFromAddr(gZoneUtilArray[index2].iAllocFixed, addr);
}
gTestThread.Close();
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
TestEnd();
test.Next(_L("Test6: Call function TRamDefragRequest::ClaimRamZone on specifc zone and at the same time allocate pages to the zone"));
TestStart();
TInt pagesAlloc = 1; // Try and allocate just one page whilst attempting to claim the zone
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
GetAllPageInfo();
index = gZoneCount - 1;
while (index > 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
{
-- index;
}
if (index == 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
{
test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
}
else
{
GetAllPageInfo();
defragZoneID = gZoneConfigArray[index].iZoneId;
TInt numPassed = 0;
for (waitTime = 1000; waitTime > 0; waitTime-=10)
{
r = gTestThread.Create(gTestThreadName,MultiClaimZoneThreadFunc,KDefaultStackSize,0x1000,0x1000,(TAny*)defragZoneID);
if (r != KErrNone)
{
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
gTestThread.Logon(status);
gTestThread.Resume();
test(status.Int() == KRequestPending);
User::After(waitTime);
r = Ldd.ZoneAllocDiscontiguous(defragZoneID, pagesAlloc);
TESTDEBUG(test.Printf(_L("r = %d\n"), r));
User::WaitForRequest(status);
r2 = status.Int();
GetAllPageInfo();
TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
if (freeInOthers && r2 != KErrNone)
{
test.Printf(_L("Claim was unsuccsessful: r2 = %d, expected = %d\n"), r2, KErrNone);
}
else if (r2 == KErrNone && r != KErrNoMemory)
{
test.Printf(_L("Fail: r = %d, expected = %d, r2 = %d, expected = %d, zone ID = 0x%x\n"),
r, KErrNoMemory, r2, KErrNone, defragZoneID);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
CLEANUP(Ldd.FreeAllFixedPages());
// Free from address as a different channel claimed the RAM zone.
addr = gZoneConfigArray[index].iPhysBase;
CLEANUP(Ldd.FreeFromAddr(gZoneUtilArray[index].iAllocFixed, addr));
TEST_FAIL;
}
else
{
numPassed ++;
}
Ldd.FreeAllFixedPages();
GetAllPageInfo();
if (r2 == KErrNone)
{// Free from address as a different channel claimed the RAM zone.
addr = gZoneConfigArray[index].iPhysBase;
r = Ldd.FreeFromAddr(gZoneUtilArray[index].iAllocFixed, addr);
}
gTestThread.Close();
}
if (numPassed > 0)
{
test.Printf(_L("Passed...\n"));
}
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
TestEnd();
test.Next(_L("Test7: Call function TRamDefragRequest::ClaimRamZone on a zone that contains fixed and movable pages"));
TestStart();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
GetAllPageInfo();
index = gZoneCount - 1;
while (index > 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0) &&
(gZoneUtilArray[index].iAllocMovable < 10 || gZoneUtilArray[index].iFreePages < 3))
{
-- index;
}
if (index == 0 && ((gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0) &&
(gZoneUtilArray[index].iAllocMovable < 10 || gZoneUtilArray[index].iFreePages < 3)))
{
test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
}
else
{
defragZoneID = gZoneConfigArray[index].iZoneId;
TESTDEBUG(test.Printf(_L("defragZoneID = 0x%x\n"), defragZoneID));
TESTDEBUG(test.Printf(_L("movable = 0x%x discardable = 0x%x\n"),
gZoneUtilArray[index].iAllocMovable, gZoneUtilArray[index].iAllocDiscardable));
Ldd.ZoneAllocDiscontiguous(defragZoneID, 2); // Allocated 2 fixed pages to ensure that zone cannot be emptied
r = Ldd.CallDefrag(DEFRAG_TYPE_CLAIM, DEFRAG_VER_SYNC, defragZoneID);
GetAllPageInfo();
TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
if (r != KErrNoMemory ||
(freeInOthers &&
(gZoneUtilArray[index].iAllocMovable ||
gZoneUtilArray[index].iAllocDiscardable)))
{
test.Printf(_L("r = %d, expected = %d, or all movable/discardable pages have not been moved"),
r, KErrNoMemory);
CLEANUP(Ldd.FreeAllFixedPages());
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
Ldd.FreeAllFixedPages();
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
TestEnd();
test.Next(_L("Test8: Call function TRamDefragRequest::ClaimRamZone on every zone one after the other"));
TestStart();
Ldd.ResetDriver();
for (index = 0; index < gZoneCount; index ++)
{
// Variables for DP ROM cache sizes
TUint minCacheSize = 0;
TUint maxCacheSize = 0;
TUint currentCacheSize = 0;
if (gPagedRom)
{
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));
// Calculate the maximum size of the DP cache
TUint minZoneFree = KMaxTUint;
TUint maxDisFillBytes = 0;
GetAllPageInfo();
for (TUint i = 0; i < gZoneCount; i++)
{
maxDisFillBytes += gZoneUtilArray[i].iFreePages;
maxDisFillBytes += gZoneUtilArray[i].iAllocDiscardable;
if (minZoneFree > gZoneUtilArray[i].iFreePages)
minZoneFree = gZoneUtilArray[i].iFreePages;
}
test.Printf(_L("Free pages 0x%x maxDisFillBytes 0x%x\n"), gTotalPageCount.iFreePages, maxDisFillBytes);
maxDisFillBytes <<= gPageShift;
r = DPTest::SetCacheSize(maxDisFillBytes, maxDisFillBytes);
if (r != KErrNone)
{
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
CLEANUP(ResetDPCache());
TEST_FAIL;
}
DPTest::CacheSize(minCacheSize,maxCacheSize,currentCacheSize);
TESTDEBUG(test.Printf(_L("CacheSize2: minCacheSize = 0x%x, maxCacheSize = 0x%x, currentCacheSize = 0x%x\n"),
minCacheSize >> gPageShift, maxCacheSize >> gPageShift, currentCacheSize >> gPageShift));
if (currentCacheSize != maxDisFillBytes)
{
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
CLEANUP(ResetDPCache());
TEST_FAIL;
}
GetAllPageInfo();
test.Printf(_L("Free pages after alloc discardable1 = 0x%x\n"), gTotalPageCount.iFreePages);
r = DPTest::SetCacheSize(minZoneFree << gPageShift, maxDisFillBytes);
if (r != KErrNone)
{
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
CLEANUP(ResetDPCache());
TEST_FAIL;
}
// Check all zones have no free pages.
GetAllPageInfo();
for (TUint i = 0; i < gZoneCount; i++)
{
if (gZoneUtilArray[i].iFreePages != 0)
{
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
CLEANUP(ResetDPCache());
TEST_FAIL;
}
}
}
else
{
// Fragment the RAM with some movable pages
AllocMovable(gChunkArray1, gChunkArraySize1, KFillAllMovable);
FreeMovable(gChunkArray1, gChunkArraySize1);
}
TUint zoneID = gZoneConfigArray[index].iZoneId;
GetAllPageInfo();
TUint origUnknownInZone = gZoneUtilArray[index].iAllocUnknown;
TUint origMovInZone = gZoneUtilArray[index].iAllocMovable;
TUint origFreeInZone = gZoneUtilArray[index].iFreePages;
test.Printf(_L("Zone ID 0x%x - fixedPages = 0x%x, unknownPages = 0x%x, discardablePages = 0x%x movable = 0x%x free = 0x%x\n"),
zoneID, gZoneUtilArray[index].iAllocFixed, origUnknownInZone, gZoneUtilArray[index].iAllocDiscardable,
origMovInZone, origFreeInZone);
r = Ldd.CallDefrag(DEFRAG_TYPE_CLAIM, DEFRAG_VER_SYNC, zoneID);
GetAllPageInfo();
TUint unknownPages = gZoneUtilArray[index].iAllocUnknown;
TUint discPages = gZoneUtilArray[index].iAllocDiscardable;
TUint movablePages = gZoneUtilArray[index].iAllocMovable;
if (r == KErrNone)
{
r = Ldd.FreeAllFixedPages();
}
TUint freeInOtherZones = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
if (!unknownPages && movablePages && freeInOtherZones)
{
test.Printf(_L("Fail: Zone ID %x all the movable pages haven't been moved\n"), zoneID);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
CLEANUP(ResetDPCache());
TEST_FAIL;
}
if (origUnknownInZone != unknownPages)
{
test.Printf(_L("Fail: Zone ID %x unknown pages before and after are not equal\n"), zoneID);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
CLEANUP(ResetDPCache());
TEST_FAIL;
}
if (!gPagedRom)
{
if (!unknownPages && freeInOtherZones && discPages)
{
test.Printf(_L("Fail: Zone ID %x all the discardable pages haven't been moved\n"), zoneID);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
CLEANUP(ResetDPCache());
TEST_FAIL;
}
}
else
{
DPTest::CacheSize(minCacheSize, maxCacheSize, currentCacheSize);
TESTDEBUG(test.Printf(_L("CacheSize3: minCacheSize = 0x%x, maxCacheSize = 0x%x, currentCacheSize = 0x%x\n"),
minCacheSize >> gPageShift, maxCacheSize >> gPageShift, currentCacheSize >> gPageShift));
// The the discardable pages should have been discarded or moved unless
// there is no room in the other zones and the cache size is already at its minimum
if (!unknownPages && discPages && (freeInOtherZones || currentCacheSize != minCacheSize))
{
test.Printf(_L("Fail: Zone ID 0x%x all the discardable pages haven't been moved\n"), zoneID);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
CLEANUP(ResetDPCache());
TEST_FAIL;
}
}
test.Printf(_L("Passed...\n"));
}
// TestEnd() will cleanup what's required.
TestEnd();
test.End();
return 0;
}
//
// TestCancelDefrag
//
//-----------------------------------------------------------------------------------------------------------------------------------------
//! @SYMTestCaseID KBASE-t_ramdefrag-0533
//! @SYMTestType CIT
//! @SYMTestCaseDesc Verifying the implementation of the function TRamDefragRequest::CancelDefrag()
//! @SYMPREQ PREQ308
//! @SYMTestPriority High
//! @SYMTestActions
//! 1. Fragment the memory. Following this, start a general defrag and cancel it
//! 2. Fragment the memory. Following this, start a zone defrag and cancel it
//! 3. Fragment the memory. Following this, start a claim zone and cancel it
//!
//! @SYMTestExpectedResults
//! 1. KErrCancel
//! 2. KErrCancel
//! 3. KErrCancel
//-----------------------------------------------------------------------------------------------------------------------------------------
TInt TestCancelDefrag()
{
TInt r = 0;
TUint defragZoneID = 0;
test.Start(_L("Test1: Call general defrag and cancel it"));
TestStart();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
r = Ldd.CheckCancel(DEFRAG_TYPE_GEN);
TESTDEBUG(test.Printf(_L("r = %d\n"), r));
if (r != KErrCancel)
{
test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrCancel);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
TestEnd();
test.Next(_L("Test2: Call zone defrag and cancel it"));
TestStart();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
GetAllPageInfo();
TUint index = gZoneCount - 1;
while (index > 0 &&
(gZoneUtilArray[index].iFreePages == gZoneUtilArray[index].iPhysPages ||
gZoneUtilArray[index].iAllocFixed !=0 ||
gZoneUtilArray[index].iAllocUnknown !=0))
{
-- index;
}
if (index == 0 &&
(gZoneUtilArray[index].iFreePages == gZoneUtilArray[index].iPhysPages ||
gZoneUtilArray[index].iAllocFixed !=0 ||
gZoneUtilArray[index].iAllocUnknown !=0))
{
test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
}
else
{
defragZoneID = gZoneConfigArray[index].iZoneId;
TESTDEBUG(test.Printf(_L("defragZoneID = 0x%x\n"),defragZoneID));
r = Ldd.CheckCancel(DEFRAG_TYPE_EMPTY, defragZoneID);
TESTDEBUG(test.Printf(_L("r = %d\n"), r));
if (r != KErrCancel)
{
test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrCancel);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
TestEnd();
test.Next(_L("Test3: Call Claim RAM Zone and cancel it"));
TestStart();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
GetAllPageInfo();
index = gZoneCount - 1;
while (index > 0 &&
(gZoneUtilArray[index].iFreePages == gZoneUtilArray[index].iPhysPages ||
gZoneUtilArray[index].iAllocFixed !=0 ||
gZoneUtilArray[index].iAllocUnknown !=0))
{
-- index;
}
defragZoneID = gZoneConfigArray[index].iZoneId;
TESTDEBUG(test.Printf(_L("defragZoneID = 0x%x\n"),defragZoneID));
if (index == 0 &&
(gZoneUtilArray[index].iFreePages == gZoneUtilArray[index].iPhysPages ||
gZoneUtilArray[index].iAllocFixed !=0 ||
gZoneUtilArray[index].iAllocUnknown !=0))
{
test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
}
else
{
r = Ldd.CheckCancel(DEFRAG_TYPE_CLAIM, defragZoneID);
TESTDEBUG(test.Printf(_L("r = %d\n"), r));
if (r != KErrCancel)
{
test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrCancel);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
TestEnd();
test.End();
return 0;
}
//
// TestZoneAllocNoAffect
//
// Ensures that fixed page allocations do not affect the movable
// or discardable page allocations
//
TInt TestZoneAllocNoAffect(TInt aZoneAllocType, TInt aPageType)
{
TInt retVal = KErrNone;
TInt r = KErrNone;
TInt mostPrefIndex = 0;
TUint leastPrefIndex = 0;
TUint leastPrefZoneID = 0;
TestStart();
gChunkArray1 = new RChunk;
gChunkArraySize1 = 1;
switch(aPageType)
{
case BEST_MOVABLE:
test.Printf(_L("Test Epoc::ZoneAllocPhysicalRam() doesn't affect the allocation of movable pages\n"));
break;
case BEST_DISCARDABLE:
test.Printf(_L("Test Epoc::ZoneAllocPhysicalRam() doesn't affect the allocation of discardable pages\n"));
if (!gPagedRom)
{
test.Printf(_L("Not a paged ROM - Skipping...\n"));
goto skipSetup;
}
break;
}
// Fist find the zone that movable page allocations should go into
// Getting the best movable will be the same for discardable as well
mostPrefIndex = GetBestZone(aPageType);
if (mostPrefIndex == KErrNotFound)
{
test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
goto skipSetup;
}
// Get the least pref zone to zone alloc into and ensure it has free pages
GetPrefOrder();
leastPrefIndex = gPrefArray[gZoneCount - 1];
if (gZoneConfigArray[mostPrefIndex].iPref == gZoneConfigArray[leastPrefIndex].iPref)
{
test.Printf(_L("Zones with same preference - Skipping...\n"));
goto skipSetup;
}
if (leastPrefIndex == (TUint)mostPrefIndex ||
gZoneUtilArray[leastPrefIndex].iFreePages == 0)
{
test.Printf(_L("leastPrefIndex = mostPrefIndex or leastPrefIndex(%d) / mostPrefIndex(%d) has 0 free - Skipping test step...\n"),
leastPrefIndex, mostPrefIndex);
goto skipSetup;
}
// Zone alloc 1 fixed page into the least preferable zone
leastPrefZoneID = gZoneConfigArray[leastPrefIndex].iZoneId;
GetOriginalPageCount();
switch(aZoneAllocType)
{
case Z_ALLOC_DISC:
{
r = Ldd.ZoneAllocDiscontiguous(leastPrefZoneID, 1);
break;
}
case Z_ALLOC_CONTIG:
{
r = Ldd.ZoneAllocContiguous(leastPrefZoneID, gPageSize);
break;
}
}
GetAllPageInfo();
if (r != KErrNone ||
gZoneUtilArray[leastPrefIndex].iAllocFixed <= gOriginalPageCountArray[leastPrefIndex].iAllocFixed)
{
test.Printf(_L("Failed to allocate 1 fixed page to zone index %d r = %d\n"), leastPrefIndex, r);
goto skipSetup;
}
test.Printf(_L("leastPrefIndex = %d mostPrefIndex = %d\n"), leastPrefIndex, mostPrefIndex);
switch(aPageType)
{
case BEST_MOVABLE:
// now allocate 1 movable page
r = AllocMovable(gChunkArray1, gChunkArraySize1, 1, gPageSize);
if (r != KErrNone)
{
test.Printf(_L("Failed to allocate 1 movable page r = %d\n"), r);
goto skipSetup;
}
break;
case BEST_DISCARDABLE:
// now allocate 1 discardable page
TInt disPages;
TUint disBytes = (gTotalPageCount.iDiscardablePages + 1) << gPageShift;
r = AllocDiscardable(disPages, disBytes);
if (r != KErrNone)
{
test.Printf(_L("Failed to allocate 1 discardable page r = %d\n"), r);
goto skipSetup;
}
break;
}
GetAllPageInfo();
switch(aPageType)
{
case BEST_MOVABLE:
if (gOriginalPageCountArray[mostPrefIndex].iAllocMovable >= gZoneUtilArray[mostPrefIndex].iAllocMovable ||
gOriginalPageCountArray[leastPrefIndex].iAllocMovable < gZoneUtilArray[leastPrefIndex].iAllocMovable)
{
test.Printf(_L("FAIL: mostPrefIndex(%d) origMov 0x%x curMov 0x%x leastPrefIndex(%d) origMov 0x%x curMov 0x%x\n"),
mostPrefIndex, gOriginalPageCountArray[mostPrefIndex].iAllocMovable, gZoneUtilArray[mostPrefIndex].iAllocMovable,
leastPrefIndex, gOriginalPageCountArray[leastPrefIndex].iAllocMovable, gZoneUtilArray[leastPrefIndex].iAllocMovable);
CLEANUP(Ldd.FreeAllFixedPages());
retVal = KErrGeneral;
}
else
{
test.Printf(_L("Passed...\n"));
}
break;
case BEST_DISCARDABLE:
if (gOriginalPageCountArray[mostPrefIndex].iAllocDiscardable >= gZoneUtilArray[mostPrefIndex].iAllocDiscardable ||
gOriginalPageCountArray[leastPrefIndex].iAllocDiscardable < gZoneUtilArray[leastPrefIndex].iAllocDiscardable)
{
test.Printf(_L("FAIL: mostPrefIndex(%d) origDis 0x%x curDis 0x%x leastPrefIndex(%d) origDis 0x%x curDis 0x%x\n"),
mostPrefIndex, gOriginalPageCountArray[mostPrefIndex].iAllocDiscardable, gZoneUtilArray[mostPrefIndex].iAllocDiscardable,
leastPrefIndex, gOriginalPageCountArray[leastPrefIndex].iAllocDiscardable, gZoneUtilArray[leastPrefIndex].iAllocDiscardable);
CLEANUP(Ldd.FreeAllFixedPages());
retVal = KErrGeneral;
}
else
{
test.Printf(_L("Passed...\n"));
}
break;
}
// This will clean up any fixed pages allocated.
skipSetup:
TestEnd();
return retVal;
}
//
// TestZoneAllocContiguous
//
//---------------------------------------------------------------------------------------------------------------------
//! @SYMTestCaseID KBASE-t_ramdefrag-0535
//! @SYMTestType CIT
//! @SYMTestCaseDesc Verifying the contiguous overload of Epoc::ZoneAllocPhysicalRam().
//! @SYMPREQ PREQ308
//! @SYMTestPriority High
//! @SYMTestActions
//! 1. Call function with a valid aZoneID.
//! 2. Call function with an invalid aZoneID
//! 3. Call function with aSize > zone size
//! 4. Call multiple RAM zone overload of the function with a mix of valid and invalid IDs.
//! 5. Call multiple RAM zone overload of the function with contiguous RAM zones and attempt
//! to allocate over both RAM zones.
//! 6. Call function on a RAM zone that has some non-DP pages allocated into it and ask
//! for the whole RAM zone to be filled with fixed pages.
//! 7. Get the most preferable zone for movable page allocations (mostPref). Allocate 1 contiguous fixed page
//! in the least preferable zone. Following this allocate 1 movable page
//! 8. Get the most preferable zone for discardable page allocations (mostPref). Allocate 1 contiguous fixed
//! page in the least preferable zone. Following this allocate 1 discardable page
//!
//! @SYMTestExpectedResults
//! 1. KErrNone
//! 2. KErrArgument
//! 3. KErrArgument
//! 4. KErrArgument
//! 5. KErrNone
//! 6. KErrNoMemory
//! 7. Movable pages are allocated into zone mostPref.
//! 8. Discardable pages are allocated into zone mostPref
//---------------------------------------------------------------------------------------------------------------------
TInt TestZoneAllocContiguous()
{
TInt r = 0;
test.Start(_L("Test1: Call function Epoc::ZoneAllocPhysicalRam() with a valid aZoneID"));
TestStart();
const TUint KAllocPages = 2;
GetOriginalPageCount();
GetAllPageInfo();
TUint index = gZoneCount - 1;
while (index > 0 && gZoneUtilArray[index].iFreePages < KAllocPages)
{
-- index;
}
TUint zoneID = gZoneConfigArray[index].iZoneId;
if (index == 0 && gZoneUtilArray[index].iFreePages < KAllocPages)
{
test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
}
else
{
TUint allocBytes = KAllocPages << gPageShift;
r = Ldd.ZoneAllocContiguous(zoneID, allocBytes);
GetAllPageInfo();
if (r == KErrNone &&
gZoneUtilArray[index].iAllocFixed - gOriginalPageCountArray[index].iAllocFixed == KAllocPages)
{
test.Printf(_L("Pass: Correct number of fixed pages allocated to zone ID 0x%x\n"),zoneID);
}
else
{
test.Printf(_L("Fail: r = %d, expected = %d, or number of pages allocated is not expected\n"),
r, KErrNone);
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
Ldd.FreeAllFixedPages();
}
TestEnd();
test.Next(_L("Test2: Call function Epoc::ZoneAllocPhysicalRam() with an invalid aZoneID"));
TestStart();
zoneID = KInvalidZoneID;
TESTDEBUG(test.Printf(_L("zoneID = 0x%x\n"), zoneID));
r = Ldd.ZoneAllocContiguous(zoneID, gPageSize);
GetAllPageInfo();
if (r == KErrArgument)
{
test.Printf(_L("Pass: Correct return value\n"));
}
else
{
test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrArgument);
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
Ldd.FreeAllFixedPages();
TestEnd();
test.Next(_L("Test3: Call function Epoc::ZoneAllocPhysicalRam() with aSize > zone size"));
TestStart();
index = gZoneCount - 1;
zoneID = gZoneConfigArray[index].iZoneId;
TUint allocBytes = (gZoneUtilArray[index].iPhysPages + 5) << gPageShift;
r = Ldd.ZoneAllocContiguous(zoneID, allocBytes);
GetAllPageInfo();
if (r == KErrArgument)
{
test.Printf(_L("Pass: Correct return value and number of pages allocated is correct\n"));
}
else
{
test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrArgument);
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
Ldd.FreeAllFixedPages();
TestEnd();
const TUint KMultiZoneIds = 10;
TUint* zoneIdArray = new TUint[KMultiZoneIds];
test_NotNull(zoneIdArray);
test.Next(_L("Test4: Test Epoc::ZoneAllocPhysicaRam() always fails when at least one ID is invalid"));
TestStart();
index = gZoneCount - 1;
while (index > 0 && gZoneUtilArray[index].iFreePages < KAllocPages)
{
-- index;
}
if (index == 0 && gZoneUtilArray[index].iFreePages < KAllocPages)
{
test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
}
else
{
TUint zoneIdSize = 2;
zoneIdArray[0] = gZoneConfigArray[index].iZoneId;
zoneIdArray[1] = KInvalidZoneID;
TUint allocBytes = KAllocPages << gPageShift;
r = Ldd.MultiZoneAllocContiguous(zoneIdArray, zoneIdSize, allocBytes);
if (r != KErrArgument)
{
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
else
{
test.Printf(_L("Pass: Correct return value\n"));
}
}
TestEnd();
test.Next(_L("Test5: Test Epoc::ZoneAllocPhysicalRam() can span multiple RAM zones"));
TestStart();
// Attempt to find to physically contiguous RAM zones where higher addressed
// one is empty, relies on RAM zones are returned by HAL functions in
// ascending physical address order.
GetAllPageInfo();
TBool zonesFound = EFalse;
index = gZoneCount - 1;
for (; index > 1; index--)
{
if (gZoneUtilArray[index].iFreePages == gZoneUtilArray[index].iPhysPages &&
gZoneUtilArray[index-1].iFreePages == gZoneUtilArray[index-1].iPhysPages &&
gZoneConfigArray[index].iPhysBase - 1 == gZoneConfigArray[index-1].iPhysEnd)
{
zonesFound = ETrue;
break;
}
}
if (!zonesFound)
{
test.Printf(_L("Cannot find RAM zones to perform test, Skipping test step...\n"));
}
else
{
// Allocate one page more than the first RAM zone to force the allocation
// to spread over both RAM zones.
TUint allocPages = gZoneUtilArray[index-1].iPhysPages + 1;
TUint allocBytes = allocPages << gPageShift;
// Attempt to find a zone that has less free pages than the allocation
// size so we can test that the method continues past too full RAM zones.
zonesFound = EFalse;
TUint noAllocZone = 0;
for (; noAllocZone < gZoneCount; noAllocZone++)
{
if (allocPages > gZoneUtilArray[noAllocZone].iFreePages &&
noAllocZone != index && noAllocZone != index-1)
{
zonesFound = ETrue;
break;
}
}
TUint zoneIds = 2;
if (!zonesFound)
{
zoneIdArray[0] = gZoneConfigArray[index-1].iZoneId;
zoneIdArray[1] = gZoneConfigArray[index].iZoneId;
}
else
{// Have a zone that won't meet the allocation so use it
TESTDEBUG(test.Printf(_L("noAllocZone ID %x\n"), gZoneConfigArray[noAllocZone].iZoneId));
zoneIds++;
zoneIdArray[0] = gZoneConfigArray[noAllocZone].iZoneId;
zoneIdArray[1] = gZoneConfigArray[index-1].iZoneId;
zoneIdArray[2] = gZoneConfigArray[index].iZoneId;
}
r = Ldd.MultiZoneAllocContiguous(zoneIdArray, zoneIds, allocBytes);
GetAllPageInfo();
if (r != KErrNone ||
gZoneUtilArray[index].iFreePages == gZoneUtilArray[index].iPhysPages ||
gZoneUtilArray[index-1].iFreePages == gZoneUtilArray[index-1].iPhysPages)
{// The allocation failed.
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
// TestEnd() will free the allocation of fixed pages.
TestEnd();
test.Next(_L("Test6: Test Epoc::ZoneAllocPhysicalRam() returns KErrNoMemory when appropriate"));
TestStart();
// Attempt to find a RAM zone with some non-discarable pages allocated into it.
// (At time of writing discardable pages wouldn't be discarded on demand by
// this function but this may be changed in the future as discontiguous case does that).
GetAllPageInfo();
zonesFound = EFalse;
index = gZoneCount - 1;
for (; index > 0; index--)
{
if (gZoneUtilArray[index].iFreePages &&
(gZoneUtilArray[index].iAllocMovable || gZoneUtilArray[index].iAllocFixed))
{
zonesFound = ETrue;
break;
}
}
if (!zonesFound)
{
test.Printf(_L("Cannot find RAM zones to perform test, Skipping test step...\n"));
}
else
{
// Attempt to allocate the whole of the RAM zone.
GetOriginalPageCount();
TUint allocBytes = gZoneConfigArray[index].iPhysPages << gPageShift;
r = Ldd.ZoneAllocContiguous(gZoneConfigArray[index].iZoneId, allocBytes);
// The allocation should have failed and no pages should have
// been allocated.
GetAllPageInfo();
if (r != KErrNoMemory ||
gOriginalPageCountArray[index].iFreePages > gZoneUtilArray[index].iFreePages)
{
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
else
{
test.Printf(_L("Pass: Correct return value\n"));
}
}
// TestEnd() will free the allocation of fixed pages.
TestEnd();
delete[] zoneIdArray;
test.Next(_L("Test7: Test Epoc::ZoneAllocPhysicalRam() (Contiguous) doesn't affect the allocation of movable pages"));
r = TestZoneAllocNoAffect(Z_ALLOC_CONTIG, BEST_MOVABLE);
if (r != KErrNone)
{
TEST_FAIL;
}
test.Next(_L("Test8: Test Epoc::ZoneAllocPhysicalRam() (Contiguous) doesn't affect the allocation of discardable pages"));
r = TestZoneAllocNoAffect(Z_ALLOC_CONTIG, BEST_DISCARDABLE);
if (r != KErrNone)
{
TEST_FAIL;
}
test.End();
return KErrNone;
}
//
// TestZoneAllocDiscontiguous
//
//---------------------------------------------------------------------------------------------------------------------
//! @SYMTestCaseID KBASE-t_ramdefrag-0536
//! @SYMTestType CIT
//! @SYMTestCaseDesc Verifying the discontiguous overload of Epoc::ZoneAllocPhysicalRam().
//! @SYMPREQ PREQ308
//! @SYMTestPriority High
//! @SYMTestActions
//! 1. Call function with a valid aZoneID.
//! 2. Call function with an invalid aZoneID
//! 3. Call function with aNumPages > zone size
//! 4. Call multiple RAM zone overload of function with a mix of valid and invalid IDs
//! 5. Call multiple RAM zone overload of function so that the allocation will have to
//! span multiple RAM zones.
//! 6. Call function with memory full with DP cache that has reached it's
//! minimum cache size.
//! 7. Call function with memory not quite full with DP cache that has reached it's
//! minimum cache size and with the specified RAM zone full.
//! 8. Call function to allocate a whole RAM zone on a RAM zone that has non-discardable
//! pages already allocated into it.
//! 9. Call function to allocate one less than the whole RAM zone on a RAM zone that has movable
//! pages allocated.
//! 10. Get the most preferable zone for movable page allocations (mostPref). Allocate 1 discontiguous fixed page
//! in the least preferable zone. Following this allocate 1 movable page
//! 11. Get the most preferable zone for discardable page allocations (mostPref). Allocate 1 discontiguous fixed
//! page in the least preferable zone. Following this allocate 1 discardable page
//!
//! @SYMTestExpectedResults
//! 1. KErrNone
//! 2. KErrArgument
//! 3. KErrArgument
//! 4. KErrArgument
//! 5. KErrNone
//! 6. KErrNoMemory
//! 7. KErrNone
//! 8. KErrNoMemory
//! 9. KErrNone (i.e. the movable pages are shifted out of the way but only those that need to be moved).
//! 10. Movable pages are allocated into zone mostPref.
//! 11. Discardable pages are allocated into zone mostPref
//---------------------------------------------------------------------------------------------------------------------
TInt TestZoneAllocDiscontiguous()
{
TInt r = KErrNone;
test.Start(_L("Test1: Call function Epoc::ZoneAllocPhysicalRam() with a valid aZoneID"));
TestStart();
const TUint KAllocPages = 5;
// Detemine how many extra pages the kernel heap may grow by
// as these may need to be accounted for.
TUint fixedOverhead = Ldd.GetAllocDiff(KAllocPages);
GetOriginalPageCount();
GetAllPageInfo();
TUint index = gZoneCount - 1;
while (index > 0 && gZoneUtilArray[index].iFreePages < KAllocPages)
{
-- index;
}
if (gZoneUtilArray[index].iFreePages < KAllocPages || gTotalPageCount.iFreePages < KAllocPages + fixedOverhead)
{
test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
}
else
{
// Allocate KAllocPages discontiguous fixed pages into RAM zone zoneID
// and verfiy that the pages were allocated to the correct zone, allow for
// extra fixed pages to be allocated as the kernel heap may grow.
TUint zoneID = gZoneConfigArray[index].iZoneId;
r = Ldd.ZoneAllocDiscontiguous(zoneID, KAllocPages);
GetAllPageInfo();
if ((r == KErrNone) &&
(gZoneUtilArray[index].iAllocFixed >= gOriginalPageCountArray[index].iAllocFixed + KAllocPages))
{
test.Printf(_L("Pass: Correct return value and number of pages allocated is correct\n"));
}
else
{
test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrNone);
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
Ldd.FreeAllFixedPages();
}
TestEnd();
test.Next(_L("Test2: Call function Epoc::ZoneAllocPhysicalRam() with an invalid aZoneID"));
TestStart();
TUint zoneID = KInvalidZoneID;
r = Ldd.ZoneAllocDiscontiguous(zoneID, KAllocPages);
GetAllPageInfo();
if (r == KErrArgument)
{
test.Printf(_L("Pass: Correct return value\n"));
}
else
{
test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrArgument);
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
Ldd.FreeAllFixedPages();
TestEnd();
test.Next(_L("Test3: Call function Epoc::ZoneAllocPhysicalRam() when aNumPages > zone size"));
TestStart();
GetAllPageInfo();
index = gZoneCount - 1;
zoneID = gZoneConfigArray[index].iZoneId;
TUint allocPages = gZoneUtilArray[index].iPhysPages + 1;
r = Ldd.ZoneAllocDiscontiguous(zoneID, allocPages);
GetAllPageInfo();
if (r == KErrArgument)
{
test.Printf(_L("Pass: Correct return value and number of pages allocated is correct\n"));
}
else
{
test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrArgument);
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
Ldd.FreeAllFixedPages();
TestEnd();
const TUint KMultiZoneIds = 10;
TUint* zoneIdArray = new TUint[KMultiZoneIds];
test_NotNull(zoneIdArray);
test.Next(_L("Test4: Test Epoc::ZoneAllocPhysicaRam() always fails when at least one ID is invalid"));
TestStart();
TBool zonesFound = EFalse;
index = gZoneCount - 1;
for (; index > 0; index--)
{
if (gZoneUtilArray[index].iFreePages >= KAllocPages)
{
zonesFound = ETrue;
break;
}
}
if (!zonesFound)
{
test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
}
else
{
TUint zoneIdSize = 2;
zoneIdArray[0] = gZoneConfigArray[index].iZoneId;
zoneIdArray[1] = KInvalidZoneID;
r = Ldd.MultiZoneAllocDiscontiguous(zoneIdArray, zoneIdSize, KAllocPages);
if (r != KErrArgument)
{// Make sure we cleanup.
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
TestEnd();
test.Next(_L("Test5: Test Epoc::ZoneAllocPhysicalRam() can span multiple RAM zones"));
TestStart();
zonesFound = EFalse;
TUint zonesCount = 0;
const TUint KTest5Zones = 2;
TUint zoneIndices[KTest5Zones];
allocPages = 0;
// Attempt to find KTest5Zones RAM zones with some free pages,
// search in reverse preference order to reduce chances of kernel heap pages
// being allocated into the RAM zones under test.
GetPrefOrder();
index = gZoneCount - 1;
for (; index > 0; index--)
{
TUint prefIndex = gPrefArray[index];
if (gZoneUtilArray[prefIndex].iFreePages != 0)
{
allocPages += gZoneUtilArray[prefIndex].iFreePages;
zoneIndices[zonesCount++] = prefIndex;
if (zonesCount == KTest5Zones)
{
zonesFound = ETrue;
break;
}
}
}
if (!zonesFound)
{
test.Printf(_L("Cannot find RAM zones to perform test, Skipping test step...\n"));
}
else
{
// Attempt to find a zone that has less free pages than the allocation
// size so we can test that the method continues past too full RAM zones.
zonesFound = EFalse;
TUint noAllocZone = 0;
for (; noAllocZone < gZoneCount; noAllocZone++)
{
if (allocPages > gZoneUtilArray[noAllocZone].iFreePages &&
noAllocZone != zoneIndices[0] && noAllocZone != zoneIndices[1])
{
zonesFound = ETrue;
break;
}
}
if (gPagedRom)
{// Fill memory with DP pages to test the allocation will discard
// pages when necessary.
TInt discard;
r = AllocDiscardable(discard);
GetAllPageInfo();
if (r != KErrNone ||
gZoneUtilArray[zoneIndices[0]].iFreePages != 0 ||
gZoneUtilArray[zoneIndices[1]].iFreePages != 0)
{
test.Printf(_L("r %d\n"), r);
CLEANUP(ResetDPCache());
TEST_FAIL;
}
}
TUint zoneIds = KTest5Zones;
if (!zonesFound)
{
zoneIdArray[0] = gZoneConfigArray[zoneIndices[0]].iZoneId;
zoneIdArray[1] = gZoneConfigArray[zoneIndices[1]].iZoneId;
}
else
{// Have a zone that won't meet the allocation so use it
TESTDEBUG(test.Printf(_L("noAllocZone ID %x\n"), gZoneConfigArray[noAllocZone].iZoneId));
zoneIds++;
zoneIdArray[0] = gZoneConfigArray[noAllocZone].iZoneId;
zoneIdArray[1] = gZoneConfigArray[zoneIndices[0]].iZoneId;
zoneIdArray[2] = gZoneConfigArray[zoneIndices[1]].iZoneId;
}
// Adjust the allocation size for any kernel heap pages that may be
// required as they may get allocated into the RAM zones under test.
allocPages -= Ldd.GetAllocDiff(allocPages);
GetOriginalPageCount();
r = Ldd.MultiZoneAllocDiscontiguous(zoneIdArray, zoneIds, allocPages);
GetAllPageInfo();
if (r != KErrNone ||
gZoneUtilArray[zoneIndices[0]].iAllocFixed <= gOriginalPageCountArray[zoneIndices[0]].iAllocFixed ||
gZoneUtilArray[zoneIndices[1]].iAllocFixed <= gOriginalPageCountArray[zoneIndices[1]].iAllocFixed)
{// The allocation failed.
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
// TestEnd() will free the allocation of fixed pages.
TestEnd();
if (gPagedRom)
{
test.Next(_L("Test6: Test Epoc::ZoneAllocPhysicalRam() returns KErrNoMemory when DP minimum cache size is hit"));
TestStart();
GetPrefOrder();
TUint zoneFreePages = 0;
index = gZoneCount - 1;
for (; index > 0; index--)
{
TUint prefIndex = gPrefArray[index];
zoneFreePages = gZoneUtilArray[prefIndex].iFreePages;
if (zoneFreePages > 2)
{
index = prefIndex;
zonesFound = ETrue;
break;
}
}
if (!zonesFound)
{
test.Printf(_L("Cannot find RAM zones to perform test, Skipping test step...\n"));
}
else
{
// Fill the RAM with DP cache pages and up the minimum cache size so
// that the allocation will fail.
TInt discardBytes;
TInt r = AllocDiscardable(discardBytes, KMaxTUint64, (zoneFreePages - 1) << gPageShift);
test_KErrNone(r);
// Ensure that the RAM zone under test is full.
GetAllPageInfo();
if (gZoneUtilArray[index].iFreePages != 0)
{
CLEANUP(ResetDPCache());
TEST_FAIL;
}
r = Ldd.ZoneAllocDiscontiguous(gZoneConfigArray[index].iZoneId, zoneFreePages);
if (r != KErrNoMemory)
{
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
TestEnd();
test.Next(_L("Test7: Test Epoc::ZoneAllocPhysicalRam() replaces DP cache when DP minimum cache size is hit"));
TestStart();
gChunkArray1 = new RChunk;
gChunkArraySize1 = 1;
GetPrefOrder();
zonesFound = EFalse;
for (index = gZoneCount - 1; index > 0 && !zonesFound; index--)
{
TUint prefIndex = gPrefArray[index];
zoneFreePages = gZoneUtilArray[prefIndex].iFreePages;
if (zoneFreePages > 1)
{
// Check there is at least one free page in the other RAM zones.
TUint i = 0;
for (; i < gZoneCount; i++)
{
if (i != prefIndex && gZoneUtilArray[i].iFreePages != 0)
{
index = prefIndex;
zonesFound = ETrue;
break;
}
}
}
}
if (!zonesFound)
{
test.Printf(_L("Cannot find RAM zones to perform test, Skipping test step...\n"));
}
else
{
index++;
// Attempt to allocate a movable page to create a gap for the DP cache
// page to be replaced with.
GetOriginalPageCount();
r = AllocMovable(gChunkArray1, gChunkArraySize1, 1, gPageSize);
GetAllPageInfo();
TESTDEBUG(test.Printf(_L("index %d prev free 0x%x cur free 0x%x\n"),
index, gOriginalPageCountArray[index].iFreePages, gZoneUtilArray[index].iFreePages));
if (r != KErrNone ||
gOriginalPageCountArray[index].iFreePages != gZoneUtilArray[index].iFreePages)
{// The gap was allocated into the RAM zone under test so can't continue as
// the DP cache will attempt to be reallocated into the same RAM zone.
test.Printf(_L("Cannot find RAM zones to perform test, Skipping test step...\n"));
}
else
{
// Get the ldd to create the array for the fixed page addresses here
// so that any kernel heap allocations have already occurred before
// memory is filled etc. Make allocation really large so it will always be enough.
r = Ldd.AllocFixedArray(50);
// Fill RAM with DP cache pages and free the gap.
TInt discardBytes;
r = AllocDiscardable(discardBytes, KMaxTUint64, 0);
if (r != KErrNone)
{
CLEANUP(ResetDPCache());
TEST_FAIL;
}
UpdateRamInfo();
TInt prevFreeBytes = gFreeRam;
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
UpdateRamInfo();
TInt freedPages = (gFreeRam - prevFreeBytes) >> gPageShift;
if (freedPages < 1)
{// Something went wrong as should have freed at least one page
CLEANUP(ResetDPCache());
TEST_FAIL;
}
TUint extraFreePages = freedPages - 1;
// Ensure that the RAM zone under test is full.
GetAllPageInfo();
if (gZoneUtilArray[index].iFreePages != 0)
{
CLEANUP(ResetDPCache());
TEST_FAIL;
}
// Allocate from the RAM zone which should force a DP cache
// page to be allocated.
GetOriginalPageCount();
TUint fixedAllocPages = 1 + extraFreePages;
r = Ldd.ZoneAllocDiscontiguous2(gZoneConfigArray[index].iZoneId, fixedAllocPages);
GetAllPageInfo();
if (r != KErrNone ||
gOriginalPageCountArray[index].iAllocFixed + fixedAllocPages != gZoneUtilArray[index].iAllocFixed)
{
test.Printf(_L("r %d index %d alloc 0x%x prevFixed 0x%x curFixed 0x%x\n"), r, index, fixedAllocPages,
gOriginalPageCountArray[index].iAllocFixed, gZoneUtilArray[index].iAllocFixed);
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
}
// This should cleanup any fixed pages allocated.
TestEnd();
}
test.Next(_L("Test8: Test Epoc::ZoneAllocPhysicalRam() return KErrNoMemory when appropriate"));
TestStart();
// Search for a RAM zone that has some immovable pages allocated into
// it but isn't totally full.
GetAllPageInfo();
zonesFound = EFalse;
for (index = 0; index < gZoneCount; index++)
{
if (gZoneUtilArray[index].iFreePages &&
(gZoneUtilArray[index].iAllocUnknown || gZoneUtilArray[index].iAllocFixed))
{
zonesFound = ETrue;
break;
}
}
if (!zonesFound)
{
test.Printf(_L("Cannot find RAM zones to perform test, Skipping test step...\n"));
}
else
{
// Attempt to allocate the whole RAM zone.
r = Ldd.ZoneAllocDiscontiguous(gZoneConfigArray[index].iZoneId, gZoneUtilArray[index].iPhysPages);
if (r != KErrNoMemory)
{
test.Printf(_L("FAIL: r %d index %d\n"), r, index);
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
TestEnd();
test.Next(_L("Test9: Test Epoc::ZoneAllocPhysicalRam() moves the required number of movable pages"));
TestStart();
TUint allocFixedPages;
// Search for a RAM zone that has at least 2 movable pages allocated into it.
// Need 2 so that we can move one and leave one.
GetAllPageInfo();
zonesFound = EFalse;
for (index = 0; index < gZoneCount; index++)
{
if (gZoneUtilArray[index].iAllocMovable > 1)
{
// Only use this zone if the other RAM zones have enough free space for
// the movable page in this zone to be moved to.
TUint freeInOther = 0;
for (TUint i = 0; i < gZoneCount && !zonesFound; i++)
{
if (i != index)
{
freeInOther += gZoneUtilArray[i].iFreePages;
}
}
if (freeInOther >= gZoneUtilArray[index].iAllocMovable)
{
zonesFound = ETrue;
break;
}
}
}
if (!zonesFound)
{
test.Printf(_L("No suitable RAM zone could be found - Skipping...\n"));
goto skipTest9;
}
// Allocate up to one less than the RAM zone size. Do 2 stage fixed allocation
// to avoid kernel heap allocations spoiling test setup.
r = Ldd.AllocFixedArray(gZoneConfigArray[index].iPhysPages);
if (r != KErrNone)
{
test.Printf(_L("Not enough free RAM to perform test - Skipping...\n"));
goto skipTest9;
}
GetAllPageInfo();
if (gZoneUtilArray[index].iAllocMovable < 2)
{
test.Printf(_L("Expanding kernel heap for phys address array spoiled RAM zone - Skipping...\n"));
goto skipTest9;
}
allocFixedPages = gZoneUtilArray[index].iAllocMovable +
gZoneUtilArray[index].iAllocDiscardable +
gZoneUtilArray[index].iFreePages - 1;
r = Ldd.ZoneAllocDiscontiguous2(gZoneConfigArray[index].iZoneId, allocFixedPages);
if (r != KErrNone || !gZoneUtilArray[index].iAllocMovable)
{
test.Printf(_L("Fixed not allocated or too many movable moved RAM zone ID%x\n"),
gZoneConfigArray[index].iZoneId);
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
skipTest9 :
// This will clean up any fixed pages allocated.
TestEnd();
delete[] zoneIdArray;
test.Next(_L("Test10: Test Epoc::ZoneAllocPhysicalRam() (Discontiguous) doesn't affect the allocation of movable pages"));
r = TestZoneAllocNoAffect(Z_ALLOC_DISC, BEST_MOVABLE);
if (r != KErrNone)
{
TEST_FAIL;
}
test.Next(_L("Test11: Test Epoc::ZoneAllocPhysicalRam() (Discontiguous) doesn't affect the allocation of discardable pages"));
r = TestZoneAllocNoAffect(Z_ALLOC_DISC, BEST_DISCARDABLE);
if (r != KErrNone)
{
TEST_FAIL;
}
test.End();
return KErrNone;
}
//
// TestFreeZone
//
//---------------------------------------------------------------------------------------------------------------------
//! @SYMTestCaseID KBASE-t_ramdefrag-0537
//! @SYMTestType CIT
//! @SYMTestCaseDesc Verifying the function Epoc::FreePhysicalRam()
//! @SYMPREQ PREQ308
//! @SYMTestPriority High
//! @SYMTestActions
//! 1. Allocate fixed pages and call function to free all fixed pages allocated.
//! 2. Claim a RAM zone and then free it via Epoc::FreeRamZone().
//! 3. Invoke Epoc::FreeRamZone() with an invalid RAM zone ID.
//!
//! @SYMTestExpectedResults
//! 1. KErrNone
//! 2. KErrNone
//! 3. KErrArgument
//---------------------------------------------------------------------------------------------------------------------
TInt TestFreeZone()
{
TInt r = 0;
TUint zoneID = 0;
test.Start(_L("Test1: Freeing allocated pages"));
TestStart();
TInt pages = 50;
GetAllPageInfo();
TUint index = gZoneCount - 1;
while (index > 0 &&
(gZoneUtilArray[index].iAllocFixed != 0 ||
gZoneUtilArray[index].iAllocUnknown != 0 ||
(TInt)gZoneUtilArray[index].iFreePages < pages))
{
-- index;
}
zoneID = gZoneConfigArray[index].iZoneId;
if (index == 0 &&
(gZoneUtilArray[index].iAllocFixed != 0 ||
gZoneUtilArray[index].iAllocUnknown != 0 ||
(TInt)gZoneUtilArray[index].iFreePages < pages))
{
test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
}
else
{
TESTDEBUG(test.Printf(_L("Allocating 0x%x pages to zone ID 0x%x\n"), pages, zoneID));
r = Ldd.ZoneAllocDiscontiguous(zoneID, pages);
GetAllPageInfo();
TESTDEBUG(test.Printf(_L("Freeing 0x%x fixed pages\n"), pages));
if (r == KErrNone)
{
r = Ldd.FreeZone(pages);
}
TESTDEBUG(test.Printf(_L("r = %d\n"), r));
if (r == KErrNone)
{
test.Printf(_L("Pass: Correct return value\n"));
}
else
{
test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrNone);
TEST_FAIL;
}
}
TestEnd();
test.End();
test.Start(_L("Test2: Epoc::FreeRamZone() on a claimed RAM zone"));
TestStart();
GetAllPageInfo();
TUint zoneIndex = 0;
while (zoneIndex < gZoneCount)
{
if (gZoneUtilArray[zoneIndex].iFreePages == gZoneUtilArray[zoneIndex].iPhysPages)
break;
zoneIndex++;
}
if (zoneIndex >= gZoneCount)
{
test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
goto Test2End;
}
zoneID = gZoneConfigArray[zoneIndex].iZoneId;
r = Ldd.CallDefrag(DEFRAG_TYPE_CLAIM, DEFRAG_VER_SYNC, zoneID);
if (r != KErrNone)
{
test.Printf(_L("Fail: r = %d, expected = %d\n"), r, KErrNone);
TEST_FAIL;
}
GetAllPageInfo();
if (gZoneUtilArray[zoneIndex].iPhysPages != gZoneUtilArray[zoneIndex].iAllocFixed)
{
test.Printf(_L("Fail: RAM zone ID %d not claimed successfully"), zoneID);
TEST_FAIL;
}
r = Ldd.FreeZoneId(zoneID);
GetAllPageInfo();
if (r != KErrNone ||
gZoneUtilArray[zoneIndex].iPhysPages != gZoneUtilArray[zoneIndex].iFreePages)
{
test.Printf(_L("Fail: RAM zone ID %d not freed successfully r=%d"), zoneID, r);
TEST_FAIL;
}
Test2End:
TestEnd();
test.End();
test.Start(_L("Test2: Epoc::FreeRamZone() on an invalid RAM zone"));
TestStart();
r = Ldd.FreeZoneId(KInvalidZoneID);
if (r != KErrArgument)
{
test.Printf(_L("Fail: Error RAM zone ID %d r=%d"), KInvalidZoneID, r);
TEST_FAIL;
}
TestEnd();
test.End();
return KErrNone;
}
//
// TestDefragSemMethod
//
//---------------------------------------------------------------------------------------------------------------------
//! @SYMTestCaseID KBASE-t_ramdefrag-0538
//! @SYMTestType CIT
//! @SYMTestCaseDesc Verifying the semaphore versions of the various defrag methods
//! @SYMPREQ PREQ308
//! @SYMTestPriority High
//! @SYMTestActions
//! 1. Fragment the memory. Following this, call the semaphore variation of DefragRam.
//! 2. Fragment the memory. Following this, call the semaphore variation of EmptyRamZone
//! 3. Fragment the memory. Following this, call the semaphore variation of ClaimRamZone
//!
//! @SYMTestExpectedResults
//! 1. 1 or more zones have been emptied
//! 2. Zone specified has been emptied
//! 3. Zone has been claimed
//---------------------------------------------------------------------------------------------------------------------
TInt TestDefragSemMethod()
{
TInt r = 0;
test.Start(_L("Test1: Call semaphore method of DefragRam"));
TestStart();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
GetOriginalPageCount();
TBool genSucceed = CanGenSucceed();
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SEM);
if (r != KErrNone ||(genSucceed && CheckZonesSwitchedOff() == EFalse))
{
test.Printf(_L("Fail: r = %d, or zones have not been swtiched off\n"), r);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
TestEnd();
test.Next(_L("Test2: Call semaphore method of EmptyRamZone"));
TestStart();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
GetAllPageInfo();
TUint index = gZoneCount - 1;
while (index > 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
{
-- index;
}
TUint defragZoneID = gZoneConfigArray[index].iZoneId;
if (index == 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
{
test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
}
else
{
r = Ldd.CallDefrag(DEFRAG_TYPE_EMPTY, DEFRAG_VER_SEM, defragZoneID);
GetAllPageInfo();
TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
if (freeInOthers && (r != KErrNone || !CheckZoneIsOff(index)))
{
test.Printf(_L("Fail: r = %d, or zones has not been swtiched off\n"), r);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
// This will free any allocated memory.
TestEnd();
test.Next(_L("Test3: Call semaphore method of ClaimRamZone"));
TestStart();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
GetAllPageInfo();
index = gZoneCount - 2;
while (index > 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
{
-- index;
}
defragZoneID = gZoneConfigArray[index].iZoneId;
if (index == 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
{
test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
}
else
{
r = Ldd.CallDefrag(DEFRAG_TYPE_CLAIM, DEFRAG_VER_SEM, defragZoneID);
GetAllPageInfo();
TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
if (CheckZoneIsOff(index) ||
(freeInOthers && ( r != KErrNone ||
gZoneUtilArray[index].iAllocFixed != gZoneConfigArray[index].iPhysPages)))
{
test.Printf(_L("Fail: r = %d, or zone ID 0x%x has not been claimed\n"), r, defragZoneID);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
r = Ldd.FreeAllFixedPages();
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
TestEnd();
test.End();
return KErrNone;
}
//
// TestDefragDfcMethod
//
//---------------------------------------------------------------------------------------------------------------------
//! @SYMTestCaseID KBASE-t_ramdefrag-0539
//! @SYMTestType CIT
//! @SYMTestCaseDesc Verifying the Dfc versions of the various defrag methods
//! @SYMPREQ PREQ308
//! @SYMTestPriority High
//! @SYMTestActions
//! 1. Fragment the memory. Following this, call the Dfc variation of DefragRam.
//! 2. Fragment the memory. Following this, call the Dfc variation of EmptyRamZone
//! 3. Fragment the memory. Following this, call the Dfc variation of ClaimRamZone
//!
//! @SYMTestExpectedResults
//! 1. 1 or more zones have been emptied
//! 2. Zone specified has been emptied
//! 3. Zone has been claimed
//---------------------------------------------------------------------------------------------------------------------
TInt TestDefragDfcMethod()
{
TInt r = 0;
TRequestStatus req;
test.Start(_L("Test1: Call Dfc method of DefragRam"));
TestStart();
GetAllPageInfo();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
GetOriginalPageCount();
TBool genSucceed = CanGenSucceed();
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_DFC, 0, 0, -1, &req);
TESTDEBUG(test.Printf(_L("After queueing defrag r = %d\n"), r));
User::WaitForRequest(req);
r = req.Int();
if (r != KErrNone || (genSucceed && CheckZonesSwitchedOff() == EFalse))
{
test.Printf(_L("Fail: r = %d, or zones have not been swtiched off\n"), r);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
TestEnd();
test.Next(_L("Test2: Call Dfc method of EmptyRamZone"));
TestStart();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
GetAllPageInfo();
TUint index = gZoneCount - 1;
while (index > 0 &&
(gZoneUtilArray[index].iAllocMovable < 10 ||
gZoneUtilArray[index].iAllocFixed != 0 ||
gZoneUtilArray[index].iAllocUnknown != 0))
{
-- index;
}
TUint defragZoneID = gZoneConfigArray[index].iZoneId;
test.Printf(_L("zone ID = 0x%x\n"), defragZoneID);
if (index == 0 &&
(gZoneUtilArray[index].iAllocMovable < 10 ||
gZoneUtilArray[index].iAllocFixed != 0 ||
gZoneUtilArray[index].iAllocUnknown != 0))
{
test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
}
else
{
r = Ldd.CallDefrag(DEFRAG_TYPE_EMPTY, DEFRAG_VER_DFC, defragZoneID, 0, -1, &req);
User::WaitForRequest(req);
r = req.Int();
GetAllPageInfo();
TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
if (freeInOthers && (r != KErrNone || CheckZoneIsOff(index) == EFalse))
{
test.Printf(_L("Fail: r = %d, or zones have not been swtiched off\n"), r);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
// This will free any allocated memory
TestEnd();
test.Next(_L("Test3: Call Dfc method of ClaimRamZone"));
TestStart();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
GetAllPageInfo();
index = gZoneCount - 1;
while (index > 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
{
-- index;
}
defragZoneID = gZoneConfigArray[index].iZoneId;
if (index == 0 && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
{
test.Printf(_L("Cannot find zone to perform test, Skipping test step...\n"));
}
else
{
r = Ldd.CallDefrag(DEFRAG_TYPE_CLAIM, DEFRAG_VER_DFC, defragZoneID, 0, -1, &req);
User::WaitForRequest(req);
r = req.Int();
GetAllPageInfo();
TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
if (CheckZoneIsOff(index) ||
(freeInOthers && (r != KErrNone ||
gZoneUtilArray[index].iAllocFixed != gZoneConfigArray[index].iPhysPages)))
{
test.Printf(_L("Fail: r = %d, or zone ID 0x%x has not been claimed\n"), r, defragZoneID);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
if (r == KErrNone)
{
CLEANUP(Ldd.FreeFromAddr( gZoneUtilArray[index].iAllocFixed,
gZoneConfigArray[index].iPhysBase));
}
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
if (r == KErrNone)
{
Ldd.FreeFromAddr( gZoneUtilArray[index].iAllocFixed,
gZoneConfigArray[index].iPhysBase);
}
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
TestEnd();
test.End();
return KErrNone;
}
//
// TestPriorities
//
//---------------------------------------------------------------------------------------------------------------------
//! @SYMTestCaseID KBASE-t_ramdefrag-0540
//! @SYMTestType CIT
//! @SYMTestCaseDesc Verifying the priorities of the defrag methods
//! @SYMPREQ PREQ308
//! @SYMTestPriority High
//! @SYMTestActions
//! 1. Call DefragRam with a lower invalid priority value, e.g. -2
//! 2. Call DefragRam with a lower invalid priority value, e.g. 100
//! 3. Queue three asynchronous defrags using the Dfc method:
//! a. First one with the lowest priority, this will start the straight away
//! and will busy the defrag method, causing any other defrag requests to
//! be queued.
//! b. Queue a defrag with a relatively low priority
//! c. Queue a defrag with a higher priority than the one queued in (b)
//! Record the order in which the defrags are completed
//!
//! @SYMTestExpectedResults
//! 1. KErrArgument
//! 2. KErrArgument
//! 3. (a) will complete first as it started straight away.
//! (b) and (c) were both queued whilst (a) was running,
//! however as (c) has a higher priority, it will complete first -
//! therefore the order returned would be "a,c,b"
//---------------------------------------------------------------------------------------------------------------------
TInt TestPriorities()
{
test.Start(_L("Test1: Call defrag with an invalid lower priority"));
TestStart();
TInt r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC, 0, 0, -2);
TESTDEBUG(test.Printf(_L("r = %d\n"), r));
if (r != KErrArgument)
{
test.Printf(_L("Fail: r = %d, not expected\n"), r);
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
TestEnd();
test.Next(_L("Test2: Call defrag with an invalid higher priority"));
TestStart();
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC, 0, 0, 100);
TESTDEBUG(test.Printf(_L("r = %d\n"), r));
if (r != KErrArgument)
{
test.Printf(_L("Fail: r = %d, not expected\n"), r);
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
TestEnd();
if (UserSvr::HalFunction(EHalGroupKernel, EKernelHalNumLogicalCpus, 0, 0) == 1)
{// Only test priorities on single core system as this test is not smp safe.
test.Next(_L("Test3: Call Dfc method of EmptyRamZone to test priorities"));
TestStart();
TRequestStatus req;
TRequestStatus req2;
TRequestStatus req3;
TInt expectedOrder = 132; // Priorities set in Device driver
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
TUint index = (gZoneCount + 1) / 2;
TUint defragZoneID = gZoneConfigArray[index].iZoneId;
r = Ldd.CheckPriorities(DEFRAG_TYPE_EMPTY, defragZoneID, &req, &req2, &req3);
User::WaitForRequest(req);
User::WaitForRequest(req2);
User::WaitForRequest(req3);
TInt order = Ldd.GetDefragOrder();
if (order != expectedOrder)
{
test.Printf(_L("Fail: order = %d. expected = %d\n"), order, expectedOrder);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
// This will free any allocated memory
TestEnd();
}
test.End();
return KErrNone;
}
//
// TestFlags
//
//---------------------------------------------------------------------------------------------------------------------
//! @SYMTestCaseID KBASE-t_ramdefrag-0541
//! @SYMTestType CIT
//! @SYMTestCaseDesc Verifying that when certain flags are set,
//! only certain types of pages can be allocated to the zone.
//! @SYMPREQ PREQ308
//! @SYMTestPriority High
//! @SYMTestActions
//! 1. Set the NoFixed flag in a zone and allocate movable pages
//! 2. Set the NoFixed flag in a zone and allocate fixed pages
//! 3. Set the NoFixed flag in a zone and allocate discardable pages
//! 4. Set the NoFixed flag in a zone and allocate fixed pages to that zone using Epoc::ZoneAllocPhysicalRam()
//! 5. Set the NoFixed flag in a zone and allocate fixed pages by calling TRamDefragRequest::ClaimRamZone()
//! 6. Set the NoMovable flag in a zone and allocate movable pages
//! 7. Set the NoMovable flag in a zone and allocate fixed pages
//! 8. Set the NoMovable flag in a zone and allocate discardable pages
//! 9. Set the NoDiscardable flag in a zone and allocate movable pages
//! 10. Set the NoDiscardable flag in a zone and allocate fixed pages
//! 11. Set the NoDiscardable flag in a zone and allocate discardable pages
//! 12. Set the OnlyDiscardable flag in a zone and allocate movable pages
//! 13. Set the OnlyDiscardable flag in a zone and allocate fixed pages
//! 14. Set the OnlyDiscardable flag in a zone and allocate discardable pages
//! 15. Set the OnlyDiscardable flag in a zone and allocate fixed pages to that zone using Epoc::ZoneAllocPhysicalRam()
//! 16. Set the OnlyDiscardable flag in a zone and allocate fixed pages by calling TRamDefragRequest::ClaimRamZone()
//! 17. Set the NoFurtherAlloc flag in a zone and allocate movable pages
//! 18. Set the NoFurtherAlloc flag in a zone and allocate fixed pages
//! 19. Set the NoFurtherAlloc flag in a zone and allocate discardable pages
//! 20. Set the NoFurtherAlloc flag in a zone and allocate fixed pages to that zone using Epoc::ZoneAllocPhysicalRam()
//! 21. Set the NoFurtherAlloc flag in a zone and allocate fixed pages by calling TRamDefragRequest::ClaimRamZone()
//! 22. Set up memory so that the least preferable RAM zone has movable pages + discardable pages > free pages in the most
//! preferable zone. Ensure that the discardable pages cannot be discarded and so must be moved. Now set the flag on
//! all zones barring the most preferable zone to KRamZoneFlagNoMovable, ensuring that most pref has no flags set.
//! Following this call a general defrag.
//! 23. Set up memory so that the least preferable RAM zone has movable pages + discardable pages > free pages in the most
//! preferable RAM zone. Ensure that the discardable pages cannot be discarded and so must be moved.
//! Now set the flag on all zones barring the most preferable zone to KRamZoneFlagNoDiscard, ensuring that
//! most preferable RAM zone has no flags set. Following this call a general defrag.
//! 24. Set up memory so that the least preferable RAM zone has movable pages and discardable pages. Set all the zone
//! flags to KRamZoneFlagNoMovable. Following this call a general defrag.
//!
//! @SYMTestExpectedResults
//! 1. Movable pages are allocated and no fixed pages allocated
//! 2. No fixed pages have been allocated
//! 3. Discardable pages are allocated and no fixed pages allocated
//! 4. KErrNone, flag is ignored with zone specific allocation
//! 5. KErrNone, flag is ignored when claiming a zone
//! 6. No movable pages have been allocated
//! 7. Fixed pages allocated, no movable allocated
//! 8. Discardable pages allocated, no movable pages allocated
//! 9. Movable pages allocated, no discardable pages allocated
//! 10. Fixed pages allocated, no discardable allocated
//! 11. No discardable pages allocated
//! 12. No movable pages allocated
//! 13. No fixed pages allocated
//! 14. Discardable pages allocated, no movable or fixed allocated
//! 15. KErrNone, flag is ignored with zone specific allocation
//! 16. KErrNone, flag is ignored when claiming a zone
//! 17. No moving, fixed or discardable pages allocated
//! 18. No moving, fixed or discardable pages allocated
//! 19. No moving, fixed or discardable pages allocated
//! 20. KErrNoMemory, flag is obeyed with zone specific allocation
//! 21. KErrNone, flag is ignored when claiming a zone
//! 22. Movable pages moved to the most preferable zone, discardable pages moved to next most preferable zone
//! 23. Discardable pages moved to most preferable zone, movable pages moved to next next most preferable zone
//! 24. No pages are moved from the least preferable zone zone
//---------------------------------------------------------------------------------------------------------------------
TInt TestFlags()
{
TInt r = 0;
TUint zoneDefragID = 0;
test.Start(_L("Test1: No Fixed Flag, Alloc Movable"));
TestStart();
TInt index = GetBestZone(BEST_MOVABLE);
if (index == KErrNotFound)
{
test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
}
else
{
zoneDefragID = gZoneConfigArray[index].iZoneId;
if (SpaceAvailForPageTables(index, KFillAllMovable))
{
GetOriginalPageCount();
r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_FIXED_FLAG);
test_KErrNone(r);
AllocMovable(gChunkArray1, gChunkArraySize1, KFillAllMovable);
GetAllPageInfo();
if (gZoneUtilArray[index].iAllocMovable == gOriginalPageCountArray[index].iAllocMovable ||
gZoneUtilArray[index].iAllocFixed > gOriginalPageCountArray[index].iAllocFixed)
{
test.Printf(_L("Fail: Either fixed pages have been allocated or movable pages have not been allocated to zone ID %x\n"), gZoneConfigArray[index].iZoneId);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
else
{
test.Printf(_L("Skipping...\n"));
}
}
TestEnd();
test.Next(_L("Test2: No Fixed Flag, Alloc Fixed"));
TestStart();
if(gPagedRom)
{
r = DPTest::SetCacheSize(gOriginalMinCacheSize, gOriginalMinCacheSize);
test_KErrNone(r);
}
// find a zone that has free pages in it to block it
GetAllPageInfo();
TUint i = 0;
for (; i < gZoneCount; i++)
{
if (gZoneUtilArray[i].iFreePages > 0)
{
index = i;
break;
}
}
if (i == gZoneCount)
{
test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
}
else
{
zoneDefragID = gZoneConfigArray[index].iZoneId;
r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_FIXED_FLAG);
test_KErrNone(r);
GetOriginalPageCount();
r = Ldd.AllocateFixed(FILL_ALL_FIXED);
GetAllPageInfo();
// Ensure that either zone does not contain extra fixed pages
if (gZoneUtilArray[index].iAllocFixed > gOriginalPageCountArray[index].iAllocFixed)
{
test.Printf(_L("Fail: Fixed pages have been allocated into the zone ID 0x%x r = %d\n"), zoneDefragID, r);
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
TestEnd();
test.Next(_L("Test3: No Fixed Flag, Alloc Discardable"));
TestStart();
if (gPagedRom)
{
index = GetBestZone(BEST_DISCARDABLE);
if (index == KErrNotFound)
{
test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
}
else
{
zoneDefragID = gZoneConfigArray[index].iZoneId;
GetOriginalPageCount();
r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_FIXED_FLAG);
test_KErrNone(r);
UpdateRamInfo();
TInt discardablePages;
r = AllocDiscardable(discardablePages);
if (r != KErrNone)
{
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
TEST_FAIL;
}
GetAllPageInfo();
if (gZoneUtilArray[index].iAllocFixed > gOriginalPageCountArray[index].iAllocFixed)
{
test.Printf(_L("Fail: Fixed pages have been allocated\n"));
CLEANUP(ResetDPCache());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
}
else
{
test.Printf(_L("Not a paged ROM - Skipping test step\n"));
}
TestEnd();
test.Next(_L("Test4: No Fixed Flag, Alloc Fixed using ZoneAllocPhyicalRam"));
TestStart();
index = GetBestZone(BEST_FIXED);
if (index == KErrNotFound)
{
test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
}
else
{
zoneDefragID = gZoneConfigArray[index].iZoneId;
GetOriginalPageCount();
r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_FIXED_FLAG);
test_KErrNone(r);
// Just need to try and allocate one page
r = Ldd.ZoneAllocDiscontiguous(zoneDefragID, 1);
GetAllPageInfo();
if (r != KErrNone)
{
test.Printf(_L("Fail: Fixed pages have not been allocated into the zone\n"));
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
TestEnd();
test.Next(_L("Test5: No Fixed Flag, Alloc Fixed by attempting to claim zone"));
TestStart();
GetAllPageInfo();
index = 0;
while ((TUint)index < gZoneCount && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
{
index++;
}
if ((TUint)index == gZoneCount)
{
test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
}
else
{
zoneDefragID = gZoneConfigArray[index].iZoneId;
r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_FIXED_FLAG);
test_KErrNone(r);
r = Ldd.CallDefrag(DEFRAG_TYPE_CLAIM, DEFRAG_VER_SYNC, zoneDefragID);
GetAllPageInfo();
TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
if (freeInOthers && r != KErrNone)
{
test.Printf(_L("Fail: Claim zone ID 0x%x was unsuccessful, r = %d\n"), zoneDefragID, r);
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
TestEnd();
//------------------------------------------------------------
test.Next(_L("Test6: No Movable Flag, Alloc Movable"));
TestStart();
index = GetBestZone(BEST_MOVABLE);
if (index == KErrNotFound)
{
test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
}
else
{
zoneDefragID = gZoneConfigArray[index].iZoneId;
GetOriginalPageCount();
r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_MOVE_FLAG);
test_KErrNone(r);
AllocMovable(gChunkArray1, gChunkArraySize1, KFillAllMovable, KChunkDefaultSize, EFalse);
GetAllPageInfo();
if (gZoneUtilArray[index].iAllocMovable > gOriginalPageCountArray[index].iAllocMovable)
{
test.Printf(_L("Fail: Movable pages have been allocated in the zone\n"));
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
TestEnd();
test.Next(_L("Test7: No Movable Flag, Alloc Fixed"));
TestStart();
if(gPagedRom)
{
r = DPTest::SetCacheSize(gOriginalMinCacheSize, gOriginalMinCacheSize);
test_KErrNone(r);
}
index = GetBestZone(BEST_FIXED);
if (index == KErrNotFound)
{
test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
}
else
{
zoneDefragID = gZoneConfigArray[index].iZoneId;
r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_MOVE_FLAG);
test_KErrNone(r);
GetOriginalPageCount();
// Fill up all of RAM with fixed pages.
r = Ldd.AllocateFixed(FILL_ALL_FIXED);
test.Printf(_L("r = %d\n"), r);
GetAllPageInfo();
if (gZoneUtilArray[index].iAllocMovable > gOriginalPageCountArray[index].iAllocMovable ||
gZoneUtilArray[index].iAllocFixed <= gOriginalPageCountArray[index].iAllocFixed)
{
test.Printf(_L("Fail: orig mov 0x%x fix 0x%x current mov 0x%x fix 0x%x\n"), gOriginalPageCountArray[index].iAllocMovable,
gOriginalPageCountArray[index].iAllocFixed, gZoneUtilArray[index].iAllocMovable, gZoneUtilArray[index].iAllocFixed);
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
TestEnd();
test.Next(_L("Test8: No Movable Flag, Alloc Discardable"));
TestStart();
if (gPagedRom)
{
index = GetBestZone(BEST_DISCARDABLE);
if (index == KErrNotFound)
{
test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
}
else
{
zoneDefragID = gZoneConfigArray[index].iZoneId;
GetOriginalPageCount();
r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_MOVE_FLAG);
test_KErrNone(r)
UpdateRamInfo();
TInt discardablePages;
r = AllocDiscardable(discardablePages);
if (r != KErrNone)
{
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
TEST_FAIL;
}
GetAllPageInfo();
if (gZoneUtilArray[index].iAllocMovable > gOriginalPageCountArray[index].iAllocMovable)
{
test.Printf(_L("Fail: Movable pages have been allocated into the zone \n"));
CLEANUP(ResetDPCache());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
}
else
{
test.Printf(_L("Not a paged ROM - Skipping test step\n"));
}
TestEnd();
//-----------------------------------------------------------------------------------------------
test.Next(_L("Test9: No Discardable Flag, Alloc Movable"));
TestStart();
index = GetBestZone(BEST_MOVABLE);
if (index == KErrNotFound)
{
test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
}
else
{
zoneDefragID = gZoneConfigArray[index].iZoneId;
GetOriginalPageCount();
r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_DISCARD_FLAG);
test_KErrNone(r);
AllocMovable(gChunkArray1, gChunkArraySize1, KFillAllMovable);
GetAllPageInfo();
if (gZoneUtilArray[index].iAllocDiscardable > gOriginalPageCountArray[index].iAllocDiscardable ||
(gZoneUtilArray[index].iAllocMovable <= gOriginalPageCountArray[index].iAllocMovable &&
gZoneUtilArray[index].iAllocFixed == gOriginalPageCountArray[index].iAllocFixed))
{
test.Printf(_L("Fail: Either discardable pages have been allocated or movable pages have not been allocated\n"));
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
TestEnd();
test.Next(_L("Test10: No Discardable Flag, Alloc Fixed"));
TestStart();
if(gPagedRom)
{
r = DPTest::SetCacheSize(gOriginalMinCacheSize, gOriginalMinCacheSize);
test_KErrNone(r);
}
index = GetBestZone(BEST_FIXED);
if (index == KErrNotFound)
{
test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
}
else
{
zoneDefragID = gZoneConfigArray[index].iZoneId;
GetOriginalPageCount();
r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_DISCARD_FLAG);
test_KErrNone(r);
// Fill up all of RAM with fixed pages.
r = Ldd.AllocateFixed(FILL_ALL_FIXED);
GetAllPageInfo();
if (gZoneUtilArray[index].iAllocDiscardable > gOriginalPageCountArray[index].iAllocDiscardable ||
gZoneUtilArray[index].iAllocFixed <= gOriginalPageCountArray[index].iAllocFixed)
{
test.Printf(_L("Fail: Discardable pages have been allocated or fixed pages have not been allocated\n"));
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
TestEnd();
test.Next(_L("Test11: No Discardable Flag, Alloc Discardable"));
TestStart();
if (gPagedRom)
{
index = GetBestZone(BEST_DISCARDABLE);
if (index == KErrNotFound)
{
test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
}
else
{
zoneDefragID = gZoneConfigArray[index].iZoneId;
GetOriginalPageCount();
r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_DISCARD_FLAG);
test_KErrNone(r);
UpdateRamInfo();
TInt discardablePages;
r = AllocDiscardable(discardablePages);
if (r != KErrNoMemory)
{// Allocation should fail as no dis flag is set
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
TEST_FAIL;
}
GetAllPageInfo();
if (gZoneUtilArray[index].iAllocDiscardable > gOriginalPageCountArray[index].iAllocDiscardable)
{
test.Printf(_L("Fail: Discardable pages have been allocated into the zone\n"));
CLEANUP(ResetDPCache());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
}
else
{
test.Printf(_L("Not a paged ROM - Skipping test step\n"));
}
TestEnd();
//-----------------------------------------------------------------------------------------------
test.Next(_L("Test12: Only Discardable Flag, Alloc Movable"));
TestStart();
index = GetBestZone(BEST_MOVABLE);
if (index == KErrNotFound)
{
test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
}
else
{
zoneDefragID = gZoneConfigArray[index].iZoneId;
GetOriginalPageCount();
r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, ONLY_DISCARD_FLAG);
test_KErrNone(r);
AllocMovable(gChunkArray1, gChunkArraySize1, KFillAllMovable, KChunkDefaultSize, EFalse);
GetAllPageInfo();
if (gZoneUtilArray[index].iAllocMovable > gOriginalPageCountArray[index].iAllocMovable)
{
test.Printf(_L("Fail: Movable pages have been allocated\n"));
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
TestEnd();
test.Next(_L("Test13: Only Discardable Flag, Alloc Fixed"));
TestStart();
if(gPagedRom)
{
r = DPTest::SetCacheSize(gOriginalMinCacheSize, gOriginalMinCacheSize);
test_KErrNone(r);
}
index = GetBestZone(BEST_FIXED);
if (index == KErrNotFound)
{
test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
}
else
{
zoneDefragID = gZoneConfigArray[index].iZoneId;
GetOriginalPageCount();
r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, ONLY_DISCARD_FLAG);
test_KErrNone(r);
// Fill up all of RAM with fixed pages.
r = Ldd.AllocateFixed(FILL_ALL_FIXED);
GetAllPageInfo();
if (gZoneUtilArray[index].iAllocFixed > gOriginalPageCountArray[index].iAllocFixed)
{
test.Printf(_L("Fail: Fixed pages have been allocated\n"));
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
TestEnd();
test.Next(_L("Test14: Only Discardable Flag, Alloc Discardable"));
TestStart();
if (gPagedRom)
{
index = GetBestZone(BEST_DISCARDABLE);
if (index == KErrNotFound)
{
test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
}
else
{
zoneDefragID = gZoneConfigArray[index].iZoneId;
GetOriginalPageCount();
r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, ONLY_DISCARD_FLAG);
test_KErrNone(r);
UpdateRamInfo();
TInt discardablePages;
r = AllocDiscardable(discardablePages);
if (r != KErrNone)
{
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
TEST_FAIL;
}
GetAllPageInfo();
if (gZoneUtilArray[index].iAllocMovable > gOriginalPageCountArray[index].iAllocMovable ||
gZoneUtilArray[index].iAllocFixed > gOriginalPageCountArray[index].iAllocFixed)
{
test.Printf(_L("Fail: Pages other than discardable have been allocated\n"));
CLEANUP(ResetDPCache());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
}
else
{
test.Printf(_L("Not a paged ROM - Skipping test step\n"));
}
TestEnd();
test.Next(_L("Test15: Only Discardable Flag, Alloc Fixed using ZoneAllocPhyicalRam"));
TestStart();
index = GetBestZone(BEST_FIXED);
if (index == KErrNotFound)
{
test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
}
else
{
zoneDefragID = gZoneConfigArray[index].iZoneId;
GetOriginalPageCount();
r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, ONLY_DISCARD_FLAG);
test_KErrNone(r);
// Just need to try and allocate one page
r = Ldd.ZoneAllocDiscontiguous(zoneDefragID, 1);
GetAllPageInfo();
if (r != KErrNone)
{
test.Printf(_L("Fail: Fixed pages have not been allocated into zone ID 0x%x\n"), zoneDefragID);
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
TestEnd();
test.Next(_L("Test16: Only Discardable Flag, Alloc Fixed by attempting to claim zone"));
TestStart();
GetAllPageInfo();
index = 0;
while ((TUint)index < gZoneCount && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
{
index++;
}
if ((TUint)index == gZoneCount)
{
test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
}
else
{
zoneDefragID = gZoneConfigArray[index].iZoneId;
r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, ONLY_DISCARD_FLAG);
test_KErrNone(r);
r = Ldd.CallDefrag(DEFRAG_TYPE_CLAIM, DEFRAG_VER_SYNC, zoneDefragID);
GetAllPageInfo();
TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
if (freeInOthers && r != KErrNone)
{
test.Printf(_L("Fail: Claim zone ID 0x%x was unsuccessful, r = %d\n"), zoneDefragID, r);
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
TestEnd();
//-----------------------------------------------------------------------------------------------
test.Next(_L("Test17: No further alloc Flag, Alloc Movable"));
TestStart();
index = GetBestZone(BEST_MOVABLE);
if (index == KErrNotFound)
{
test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
}
else
{
zoneDefragID = gZoneConfigArray[index].iZoneId;
GetOriginalPageCount();
r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_ALLOC_FLAG);
test_KErrNone(r);
AllocMovable(gChunkArray1, gChunkArraySize1, KFillAllMovable, KChunkDefaultSize, EFalse);
GetAllPageInfo();
if (gZoneUtilArray[index].iAllocDiscardable > gOriginalPageCountArray[index].iAllocDiscardable ||
gZoneUtilArray[index].iAllocMovable > gOriginalPageCountArray[index].iAllocMovable ||
gZoneUtilArray[index].iAllocFixed > gOriginalPageCountArray[index].iAllocFixed)
{
test.Printf(_L("Fail: Pages been allocated\n"));
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
TestEnd();
test.Next(_L("Test18: No further alloc Flag, Alloc Fixed"));
TestStart();
if(gPagedRom)
{
r = DPTest::SetCacheSize(gOriginalMinCacheSize, gOriginalMinCacheSize);
test_KErrNone(r);
}
// Find a zone with free pages and set the flag on this zone
// as it will ensure that you cannot fill all of free RAM with fixed pages
index = KErrNotFound;
GetAllPageInfo();
for (TUint i = 0; i < gZoneCount; i++)
{
if (gZoneUtilArray[i].iFreePages != 0)
{
index = i;
break;
}
}
if (index == KErrNotFound)
{
test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
}
else
{
zoneDefragID = gZoneConfigArray[index].iZoneId;
r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_ALLOC_FLAG);
test_KErrNone(r);
GetOriginalPageCount();
r = Ldd.AllocateFixed(FILL_ALL_FIXED);
// Ensure memory wasn't filled as it should have hit the blocked zone.
GetAllPageInfo();
if (r != KErrNoMemory || gZoneUtilArray[index].iAllocFixed > gOriginalPageCountArray[index].iAllocFixed)
{
test.Printf(_L("Fail: orig fix 0x%x current fix 0x%x\n"), gOriginalPageCountArray[index].iAllocFixed, gZoneUtilArray[index].iAllocFixed);
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
TestEnd();
test.Next(_L("Test19: No further alloc Flag, Alloc Discardable"));
TestStart();
if (gPagedRom)
{
index = GetBestZone(BEST_DISCARDABLE);
if (index == KErrNotFound)
{
test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
}
else
{
zoneDefragID = gZoneConfigArray[index].iZoneId;
GetOriginalPageCount();
r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_ALLOC_FLAG);
test_KErrNone(r);
UpdateRamInfo();
TInt discardablePages;
r = AllocDiscardable(discardablePages);
if (r != KErrNoMemory)
{// Allocation should fail as no alloc flag is set
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
TEST_FAIL;
}
GetAllPageInfo();
if (gZoneUtilArray[index].iAllocDiscardable > gOriginalPageCountArray[index].iAllocDiscardable ||
gZoneUtilArray[index].iAllocMovable > gOriginalPageCountArray[index].iAllocMovable ||
gZoneUtilArray[index].iAllocFixed > gOriginalPageCountArray[index].iAllocFixed)
{
test.Printf(_L("Fail: Pages have been allocated into the zone\n"));
CLEANUP(ResetDPCache());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
}
else
{
test.Printf(_L("Not a paged ROM - Skipping test step\n"));
}
TestEnd();
test.Next(_L("Test20: No Further Alloc Flag, Alloc Fixed using ZoneAllocPhyicalRam"));
TestStart();
GetAllPageInfo();
index = 0;
while ((TUint)index < gZoneCount && (gZoneUtilArray[index].iFreePages == 0 ||
gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
{
index++;
}
if ((TUint)index == gZoneCount)
{
test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
}
else
{
zoneDefragID = gZoneConfigArray[index].iZoneId;
GetOriginalPageCount();
r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_ALLOC_FLAG);
test_KErrNone(r);
// Just need to try and allocate one page
r = Ldd.ZoneAllocDiscontiguous(zoneDefragID, 1);
GetAllPageInfo();
if (r != KErrNoMemory)
{
test.Printf(_L("Fail: Fixed pages have been allocated into zone ID 0x%x\n"), zoneDefragID);
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
TestEnd();
test.Next(_L("Test21: No Further Alloc Flag, Alloc Fixed by attempting to claim zone"));
TestStart();
GetAllPageInfo();
index = 0;
while ((TUint)index < gZoneCount && (gZoneUtilArray[index].iAllocFixed != 0 || gZoneUtilArray[index].iAllocUnknown != 0))
{
index++;
}
if ((TUint)index == gZoneCount)
{
test.Printf(_L("Cannot find zone to perform test - Skipping test step...\n"));
}
else
{
zoneDefragID = gZoneConfigArray[index].iZoneId;
r = Ldd.SetZoneFlag(zoneDefragID, gZoneConfigArray[index].iFlags, NO_ALLOC_FLAG);
test_KErrNone(r);
r = Ldd.CallDefrag(DEFRAG_TYPE_CLAIM, DEFRAG_VER_SYNC, zoneDefragID);
GetAllPageInfo();
TUint freeInOthers = gTotalPageCount.iFreePages - gZoneUtilArray[index].iFreePages;
if (freeInOthers && r != KErrNone)
{
test.Printf(_L("Fail: Claim zone ID 0x%x was unsuccessful, r = %d\n"), zoneDefragID, r);
CLEANUP(ResetRamZoneFlags());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
TestEnd();
TUint mostPrefArrayIndex = 0;
TUint mostPrefIndex = 0;
TUint leastPrefIndex = 0;
const TUint KFreeMostPref = 10;
TUint flag = 0;
TUint prefIndex;
TUint totalFree;
for (TUint testStep = 0; testStep < 2; testStep++)
{
switch(testStep)
{
case 0:
test.Next(_L("Test22: Ensure that the General Defrag looks at the flags 1"));
break;
case 1:
test.Next(_L("Test23: Ensure that the General Defrag looks at the flags 2"));
break;
}
TestStart();
gChunkArray1 = new RChunk;
gChunkArraySize1 = 1;
TUint minCacheSize = 0;
TUint maxCacheSize = 0;
TUint currentCacheSize = 0;
TUint freeNeededInMostPref = 0;
if (!gPagedRom)
{
test.Printf(_L("Not a paged ROM - Skipping...\n"));
goto skipTest22;
}
// Find the most pref zone with free pages
r = FindMostPrefWithFree(mostPrefIndex, &mostPrefArrayIndex);
if (r != KErrNone)
{
test.Printf(_L("Cannot find zone with free pages - Skipping...\n"));
goto skipTest22;
}
// Ensure that the least pref zone is empty
leastPrefIndex = gPrefArray[gZoneCount - 1];
if (gZoneUtilArray[leastPrefIndex].iFreePages != gZoneUtilArray[leastPrefIndex].iPhysPages)
{
test.Printf(_L("Least pref zone is not empty - Skipping...\n"));
goto skipTest22;
}
// Allocate 1 movable page to the least preferable zone
r = ZoneAllocMovable(gChunkArray1, gChunkArraySize1, leastPrefIndex, 1);
if (r != KErrNone)
{
test.Printf(_L("Failed to allocate movable r = %d - Skipping...\n"), r);
goto skipTest22;
}
// Allocate 1 discardable page to the least preferable zone
if (gZoneUtilArray[leastPrefIndex].iFreePages != 0)
{
TInt disPages;
r = ZoneAllocDiscard(leastPrefIndex, 1, disPages);
if (r != KErrNone)
{
test.Printf(_L("Failed to allocate discardable pages r = %d - Skipping...\n"), r);
goto skipTest22;
}
// up the minimum cache size so that the pages have to be moved - not discarded
DPTest::CacheSize(minCacheSize,maxCacheSize,currentCacheSize);
r = DPTest::SetCacheSize(currentCacheSize, currentCacheSize);
if (r != KErrNone)
{
test.Printf(_L("Failed to set cache size r = %d - Skipping...\n"), r);
goto skipTest22;
}
}
else
{
test.Printf(_L("Least pref zone has no free pages - Skipping...\n"));
goto skipTest22;
}
// Check that the least pref zone has movable and discardable pages in it
GetAllPageInfo();
if (gZoneUtilArray[leastPrefIndex].iAllocMovable == 0 ||
gZoneUtilArray[leastPrefIndex].iAllocDiscardable == 0)
{
test.Printf(_L("No movable or discardable in least pref zone\n"));
PrintPageInfo();
goto skipTest22;
}
ResetRamZoneFlags();
// if most pref zone has too many free pages fill up with fixed
if (gZoneUtilArray[mostPrefIndex].iFreePages > KFreeMostPref)
{
TUint allocPages = gZoneUtilArray[mostPrefIndex].iFreePages - KFreeMostPref;
r = Ldd.ZoneAllocToMany(mostPrefIndex, allocPages);
if (r != KErrNone)
{
test.Printf(_L("Failed allocate 0x%x fixed to index %d r = %d - Skipping...\n"),
allocPages, mostPrefIndex,r);
PrintPageInfo();
goto skipTest22;
}
}
// if the no. of discardable pages is less than free in most pref increase the min cache size
GetAllPageInfo();
if (gZoneUtilArray[leastPrefIndex].iAllocDiscardable < gZoneUtilArray[mostPrefIndex].iFreePages)
{
TUint discDiff = gZoneUtilArray[mostPrefIndex].iFreePages - gZoneUtilArray[leastPrefIndex].iAllocDiscardable;
test.Printf(_L("discDiff = 0x%x\n"), discDiff);
TInt disPages;
if (ZoneAllocDiscard(leastPrefIndex, discDiff, disPages) != KErrNone)
{
test.Printf(_L("Failed allocate discardable to zone index %d- Skipping...\n"), leastPrefIndex);
goto skipTest22;
}
// up the minimum cache size by the difference as we don't want these pages to be discarded
DPTest::CacheSize(minCacheSize,maxCacheSize,currentCacheSize);
r = DPTest::SetCacheSize(currentCacheSize, currentCacheSize);
test.Printf(_L("r = %d\n"), r);
if (r != KErrNone)
{
test.Printf(_L("Failed to set cache size r = %d - Skipping...\n"), r);
goto skipTest22;
}
}
ResetRamZoneFlags();
// if the rest of the zones are either full or empty put a fixed page into the next most pref empty zone
GetPrefOrder();
prefIndex = 0;
totalFree = 0;
for (; prefIndex < gZoneCount && totalFree < gZoneUtilArray[leastPrefIndex].iAllocDiscardable; prefIndex++)
{// Look for zone that has enough free pages to fit all the discardable
TUint zoneIndex = gPrefArray[prefIndex];
if (zoneIndex != mostPrefIndex && zoneIndex != leastPrefIndex)
{
if (gZoneUtilArray[zoneIndex].iFreePages != gZoneUtilArray[zoneIndex].iPhysPages)
{
totalFree += gZoneUtilArray[zoneIndex].iFreePages;
}
else
{
r = Ldd.ZoneAllocToMany(zoneIndex, 1);
if (r != KErrNone)
{
test.Printf(_L("Couldn't alloc fixed to zone index %d - r = %d\n"), zoneIndex, r);
goto skipTest22;
}
GetAllPageInfo();
totalFree += gZoneUtilArray[zoneIndex].iFreePages;
}
}
}
if (prefIndex >= gZoneCount)
{
test.Printf(_L("Couldn't find zone\n"));
goto skipTest22;
}
// If the most preferable zone does not have enough free pages, skip
freeNeededInMostPref = (testStep == 0) ? gZoneUtilArray[leastPrefIndex].iAllocMovable : gZoneUtilArray[leastPrefIndex].iAllocDiscardable;
if (gZoneUtilArray[mostPrefIndex].iFreePages < freeNeededInMostPref)
{
test.Printf(_L("Free needed in mostPref(%d) = %d, Free available in mostPref = %d - skipping...\n"),
mostPrefIndex,freeNeededInMostPref,gZoneUtilArray[mostPrefIndex].iFreePages);
goto skipTest22;
}
GetAllPageInfo();
// Set up the RAM zone flags for the test
flag = (testStep == 0)? NO_MOVE_FLAG: NO_DISCARD_FLAG;
// Set all zones except most pref to KRamZoneFlagNoMovable or KRamZoneFlagNoDiscard
for (TUint index = 0; index < gZoneCount; index++)
{
TUint zoneID = gZoneConfigArray[index].iZoneId;
if (index != mostPrefIndex)
{
r = Ldd.SetZoneFlag(zoneID, gZoneConfigArray[index].iFlags, flag);
if (r != KErrNone)
{
test.Printf(_L("Failed to set flag r = %d - Skipping...\n"), r);
goto skipTest22;
}
}
}
GetOriginalPageCount();
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
GetAllPageInfo();
switch(testStep)
{
case 0:
if (r != KErrNone ||
gOriginalPageCountArray[mostPrefIndex].iAllocMovable >= gZoneUtilArray[mostPrefIndex].iAllocMovable ||
gZoneUtilArray[leastPrefIndex].iFreePages != gZoneUtilArray[leastPrefIndex].iPhysPages)
{
test.Printf(_L("FAIL:r=%d MostPref(%d): origMov 0x%x curMov 0x%x LeastPref(%d): origMov 0x%x curMov 0x%x origDis 0x%x curDis 0x%x\n"),
r, mostPrefIndex, gOriginalPageCountArray[mostPrefIndex].iAllocMovable, gZoneUtilArray[mostPrefIndex].iAllocMovable,
leastPrefIndex, gOriginalPageCountArray[leastPrefIndex].iAllocMovable, gZoneUtilArray[leastPrefIndex].iAllocMovable,
gOriginalPageCountArray[leastPrefIndex].iAllocDiscardable, gZoneUtilArray[leastPrefIndex].iAllocDiscardable);
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
break;
case 1:
if (r != KErrNone ||
gOriginalPageCountArray[mostPrefIndex].iAllocDiscardable >= gZoneUtilArray[mostPrefIndex].iAllocDiscardable ||
gZoneUtilArray[leastPrefIndex].iFreePages != gZoneUtilArray[leastPrefIndex].iPhysPages)
{
test.Printf(_L("FAIL:r=%d MostPref(%d): origMov 0x%x curMov 0x%x LeastPref(%d): origMov 0x%x curMov 0x%x origDis 0x%x curDis 0x%x\n"),
r, mostPrefIndex, gOriginalPageCountArray[mostPrefIndex].iAllocMovable, gZoneUtilArray[mostPrefIndex].iAllocMovable,
leastPrefIndex, gOriginalPageCountArray[leastPrefIndex].iAllocMovable, gZoneUtilArray[leastPrefIndex].iAllocMovable,
gOriginalPageCountArray[leastPrefIndex].iAllocDiscardable, gZoneUtilArray[leastPrefIndex].iAllocDiscardable);
CLEANUP(Ldd.FreeAllFixedPages());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
break;
}
skipTest22:
TestEnd();
}
test.Next(_L("Test24: Ensure that the General Defrag doesnt move or discard pages if KRamZoneFlagNoMovable set on all zones "));
TestStart();
gChunkArray1 = new RChunk;
gChunkArraySize1 = 1;
// Find the most pref zone with free pages
GetPrefOrder();
TInt disPages = 0;
if (FindMostPrefWithFree(mostPrefIndex, &mostPrefArrayIndex) != KErrNone)
{
test.Printf(_L("Cannot find zone with free pages - Skipping...\n"));
goto skipTest24;
}
// Ensure that the least pref zone has free pages in it
leastPrefIndex = gPrefArray[gZoneCount-1];
if (gZoneUtilArray[leastPrefIndex].iFreePages == 0)
{
test.Printf(_L("Least pref zone has no free pages - Skipping...\n"));
goto skipTest24;
}
// Allocate 1 movable page to the least preferable zone
r = ZoneAllocMovable(gChunkArray1, gChunkArraySize1, leastPrefIndex, 1);
if (r != KErrNone)
{
test.Printf(_L("Failed to allocate movable page r = %d - Skipping...\n"), r);
goto skipTest24;
}
if (gPagedRom)
{
TUint minCacheSize = 0;
TUint maxCacheSize = 0;
TUint currentCacheSize = 0;
// Allocate 1 discardable page to the least preferable zone
if (gZoneUtilArray[leastPrefIndex].iFreePages != 0)
{
r = ZoneAllocDiscard(leastPrefIndex, 1, disPages);
if (r != KErrNone)
{
test.Printf(_L("Discardable pages not allocated r= %d\n"), r);
}
DPTest::CacheSize(minCacheSize,maxCacheSize,currentCacheSize);
r = DPTest::SetCacheSize(currentCacheSize, currentCacheSize);
if (r != KErrNone)
{
test.Printf(_L("Failed to set cache size r = %d - Skipping...\n"), r);
goto skipTest24;
}
}
}
// Check that the least pref zone has movable and discardable (if allocated) pages in it
GetAllPageInfo();
if (gZoneUtilArray[leastPrefIndex].iAllocMovable == 0 ||
gZoneUtilArray[leastPrefIndex].iAllocDiscardable < (TUint)disPages ||
gZoneUtilArray[leastPrefIndex].iAllocMovable > gTotalPageCount.iFreePages - gZoneUtilArray[leastPrefIndex].iFreePages)
{
test.Printf(_L("No movable in least pref zone or no space for moveable pages to be moved to\n"));
PrintPageInfo();
goto skipTest24;
}
ResetRamZoneFlags();
GetAllPageInfo();
// Now set all zones to KRamZoneFlagNoMovable
for (TUint index = 0; index < gZoneCount; index++)
{
TUint zoneID = gZoneConfigArray[index].iZoneId;
r = Ldd.SetZoneFlag(zoneID, gZoneConfigArray[index].iFlags, NO_MOVE_FLAG);
if (r != KErrNone)
{
test.Printf(_L("Failed to set cache size r = %d - Skipping...\n"), r);
goto skipTest24;
}
}
GetOriginalPageCount();
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
GetAllPageInfo();
if (r != KErrNone ||
gOriginalPageCountArray[leastPrefIndex].iAllocMovable != gZoneUtilArray[leastPrefIndex].iAllocMovable ||
gZoneUtilArray[leastPrefIndex].iAllocDiscardable < gOriginalPageCountArray[leastPrefIndex].iAllocDiscardable)
{
test.Printf(_L("FAIL:r=%d LeastPref(%d): origMov 0x%x curMov 0x%x origDis 0x%x curDis 0x%x\n"),
r,leastPrefIndex, gOriginalPageCountArray[leastPrefIndex].iAllocMovable, gZoneUtilArray[leastPrefIndex].iAllocMovable,
gOriginalPageCountArray[leastPrefIndex].iAllocDiscardable, gZoneUtilArray[leastPrefIndex].iAllocDiscardable);
CLEANUP(ResetRamZoneFlags());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
skipTest24:
TestEnd();
test.End();
return KErrNone;
}
//
// Template functions encapsulating ControlIo magic
//
template <class C>
TInt controlIo(RFs &fs, TInt drv, TInt fkn, C &c)
{
TPtr8 ptrC((TUint8 *)&c, sizeof(C), sizeof(C));
TInt r = fs.ControlIo(drv, fkn, ptrC);
return r;
}
//
// FormatMMC
//
// Formats the MMC card
//
void FormatMMC()
{
test.Printf(_L("Formatting MMC...\n"));
RFs theFs;
TBuf<4> driveBuf = _L("D:\\");
RFormat format;
TInt count;
TChar driveLet;
TInt r = theFs.Connect();
test_KErrNone(r);
r = theFs.DriveToChar(gDrive, driveLet);
test_KErrNone(r);
driveBuf[0] = driveLet;
test.Printf(_L("Formatting Drive: %C\n"),(TInt)driveLet);
r = format.Open(theFs,driveBuf,EFullFormat,count);
test_KErrNone(r);
while(count)
{
TInt r = format.Next(count);
test_KErrNone(r);
}
format.Close();
theFs.Close();
}
//
// FileNameGen
//
// Generates file names to create the files
//
void FileNameGen(TDes16& aBuffer, TInt aLong, TInt aPos)
{
TInt padding;
TInt i = 0;
TBuf16<10> tempbuf;
_LIT(KNumber,"%d");
tempbuf.Format(KNumber,aPos);
padding = aLong-tempbuf.Size()/2;
aBuffer = _L("");
while(i < padding)
{
aBuffer.Append('F');
i++;
}
aBuffer.Append(tempbuf);
_LIT(KExtension1, ".TXT");
aBuffer.Append(KExtension1);
}
//
// CreateFiles
//
// Creates the files to fill part of the read cache
//
void CreateFiles(TInt aFiles, TInt aFileSize)
{
TInt i = 0, r = 0;
RFile file;
TBuf16<50> directory;
TBuf16<50> path;
TBuf16<50> buffer(50);
directory = gSessionPath;
test.Printf(_L("Creating %d files for filling the cache (size %d)\n"), aFiles, aFileSize);
// create a big buffer to speed things up
HBufC8* bigBuf = NULL;
const TInt KBigBufferSize = 32 * 1024;
TRAPD(res,bigBuf = HBufC8::NewL(KBigBufferSize));
test(res == KErrNone && bigBuf != NULL);
TPtr8 bigBufWritePtr(NULL, 0);
bigBufWritePtr.Set(bigBuf->Des());
// Fill the buffer
TChar aC = 'A';
for(i = 0; i < KBigBufferSize; i++)
{
bigBufWritePtr.Append((i%32) + aC);
}
i = 0;
while(i < aFiles)
{
if (i % 10 == 0)
test.Printf(_L("Creating file %d of %d...\r"), i, aFiles);
FileNameGen(buffer, 8, i+3) ;
path = directory;
path.Append(buffer);
// delete file first to ensure it's contents are not in the cache (file may be on the closed file queue)
r = gTheFs.Delete(path);
test(r == KErrNone || r == KErrNotFound);
r = file.Create(gTheFs,path,EFileShareAny|EFileWrite|EFileReadDirectIO|EFileWriteDirectIO);
if(r == KErrAlreadyExists)
r = file.Open(gTheFs,path,EFileShareAny|EFileWrite|EFileReadDirectIO|EFileWriteDirectIO);
TInt j = 0;
i++;
while(j < aFileSize)
{
bigBufWritePtr.SetLength(Min(KBigBufferSize, aFileSize - j));
r = file.Write(bigBufWritePtr);
// Running out of disk space is expected for the last file.
// Premature "disk full" conditions need to abort.
if (r == KErrDiskFull)
{
test(i == aFiles);
break;
}
test_KErrNone(r);
j += bigBufWritePtr.Length();
}
file.Close();
}
test.Printf(_L("\nFiles created\n"));
delete bigBuf;
}
//
// FillCache
//
// Allocate discardable pages using file system caching
//
TInt FillCache(TInt aFiles, TInt aFileSize)
{
// Fail if files already open
test(!gFileCacheRun);
TInt i = 0, r = 0;
TBuf16<50> directory;
TBuf16<50> path;
TBuf16<50> buffer(50);
HBufC8* buf = NULL;
TPtr8 bufPtr(NULL, 0);
TRAPD(res,buf = HBufC8::NewL(2));
test(res == KErrNone && buf != NULL);
bufPtr.Set(buf->Des());
TESTDEBUG(test.Printf(_L("Filling the cache\n")));
directory = gSessionPath;
i = 0;
GetAllPageInfo();
TESTDEBUG(test.Printf(_L("total disc pages = %d\n"), gTotalPageCount.iDiscardablePages));
while(i < aFiles)
{
FileNameGen(buffer, 8, i+3) ;
path = directory;
path.Append(buffer);
r = gFile[i].Open(gTheFs,path,EFileShareAny|EFileRead|EFileReadBuffered|EFileReadAheadOff);
test_KErrNone(r);
TInt j = 0;
while(j < aFileSize)
{
r = gFile[i].Read(j,bufPtr);
test_KErrNone(r);
j += 4 * 1024;
}
i++;
}
gFileCacheRun = ETrue;
GetAllPageInfo();
TESTDEBUG(test.Printf(_L("after - total disc pages = %d\n"), gTotalPageCount.iDiscardablePages));
delete buf;
TESTDEBUG(test.Printf(_L("Cache filled\n")));
#if defined(_DEBUG) || defined(_DEBUG_RELEASE)
// get number of items on Page Cache
TFileCacheStats startPageCacheStats;
r = controlIo(gTheFs,gDrive, KControlIoFileCacheStats, startPageCacheStats);
test.Printf(_L("control stats r= %d\n"), r);
test(r==KErrNone || r == KErrNotSupported);
TESTDEBUG(test.Printf(_L("Allocated segment count=%d\n"),startPageCacheStats.iAllocatedSegmentCount));
#endif
// if we do not have any discardable pages then something went
// wrong with file caching
if (gTotalPageCount.iDiscardablePages == 0)
return KErrNotSupported;
return KErrNone;
}
//
// SetUpMMC
//
// Sets up the MMC to be used by the test by creating files on the MMC
//
void SetUpMMC()
{
FormatMMC();
TInt r = 0;
TChar driveToTest;
TVolumeInfo volInfo;
r = gTheFs.DriveToChar(gDrive, driveToTest);
test_KErrNone(r);
r = gTheFs.CharToDrive(driveToTest,gDrive);
test_KErrNone(r);
gSessionPath = _L("?:\\F32-TST\\");
gSessionPath[0] = (TUint16) driveToTest;
test.Printf(_L("Drive Letter=%C\n"),(TInt)driveToTest);
TDriveInfo info;
r = gTheFs.Drive(info,gDrive);
test_KErrNone(r);
r = gTheFs.SetSessionPath(gSessionPath);
test_KErrNone(r);
r = gTheFs.MkDirAll(gSessionPath);
if (r != KErrNone && r != KErrAlreadyExists)
{
test_KErrNone(r);
}
r = gTheFs.Volume(volInfo, gDrive);
test_KErrNone(r);
TInt64 gMediaSize = volInfo.iSize;
// This calculation is approximate because the client cannot know
// internal allocation mechanisms of the filesystem, i.e. how much
// metadata is associated with a file of name X / size Y, whether
// space used by such metadata is reflected in TDriveInfo::iSize and
// what block/clustersize the filesystem will round filesizes to.
// The last file that fills up the drive may therefore be partial
// (smaller than this calculation predicts).
TInt maxPossibleFiles = gFilesNeededToFillCache;
test.Printf(_L("Original files needed = %d\n"), maxPossibleFiles);
if(gMediaSize < (KDefaultCacheSize * maxPossibleFiles))
{
maxPossibleFiles = (gMediaSize - 10) / KDefaultCacheSize;
test.Printf(_L("Disk size is smaller - files needed = %d\n"), maxPossibleFiles);
}
gFilesNeededToFillCache = maxPossibleFiles;
CreateFiles(gFilesNeededToFillCache, KDefaultCacheSize);
}
//
// TestFileCaching
//
//---------------------------------------------------------------------------------------------------------------------
//! @SYMTestCaseID KBASE-t_ramdefrag-0599
//! @SYMTestType CIT
//! @SYMTestCaseDesc Verifying that when File System Caching allocates dicardable pages,
//! Defrag and allocation of fixed pages happens correctly.
//! @SYMPREQ PREQ308
//! @SYMTestPriority High
//! @SYMTestActions
//! 1. Fill the file system cache to allocate discardable pages
//! following this call EmptyRamZone() in a zone with discardable pages.
//! 2. Fill the file system cache to allocate discardable pages
//! folling this allocate discontiguous fixed pages to a zone
//! 3. Fill the file system cache to allocate discardable pages
//! . following this allocate discontuguous fixed pages
//! 4. Fill the file system cache to allocate discardable pages
//! following this allocate less than 16 contiguous fixed pages
//! 5. Fill the file system cache to allocate discardable pages
//! following this allocate more than 16 contiguous fixed pages
//!
//! @SYMTestExpectedResults
//! 1. Discardable pages are removed
//! 2. KErrNone
//! 3. KErrNone
//! 4. KErrNone and numDiscardablePages != 0
//! 5. KErrNone and numDiscardablePages = 0
//---------------------------------------------------------------------------------------------------------------------
TInt TestFileCaching()
{
const TUint KDisPagesReq = 1;
TInt r = KErrNone;
TInt allocSize = 0;
TUint zoneID = 0;
TUint index = 0;
TUint minDiscardPages = 0;
if (gDrive == KNoRemovableDrive)
{
test.Start(_L("Cannot find drive to write files to - Skipping FS Caching Tests\n"));
test.End();
return 0;
}
r = gTheFs.Connect();
test_KErrNone(r);
SetUpMMC();
RRamDefragFuncTestLdd Ldd2;
r = Ldd2.Open();
test_KErrNone(r);
test.Start(_L("Test1: Test EmptyRamZone() clears file server cache pages"));
TestStart();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
r = FillCache(gFilesNeededToFillCache, KDefaultCacheSize);
if (r != KErrNone)
{
test.Printf(_L("File system caching failed - Skipping all file caching tests...\n"));
goto skipFileCacheTests;
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
GetAllPageInfo();
while (index < gZoneCount && gZoneUtilArray[index].iAllocDiscardable < KDisPagesReq)
{
++ index;
}
if (index == gZoneCount)
{
test.Printf(_L("Cannot find zone to perform test on - Skipping test step...\n"));
}
else
{
zoneID = gZoneConfigArray[index].iZoneId;
r = Ldd.CallDefrag(DEFRAG_TYPE_EMPTY, DEFRAG_VER_SYNC, zoneID);
GetAllPageInfo();
if (gZoneUtilArray[index].iAllocDiscardable != 0)
{
test.Printf(_L("Fail: Zone ID 0x%x has 0x%x discardable pages\n"), zoneID, gZoneUtilArray[index].iAllocDiscardable);
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
}
TestEnd();
test.Next(_L("Test2: Filling the FS Cache and allocating fixed pages to a zone"));
TestStart();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
r = FillCache(gFilesNeededToFillCache, KDefaultCacheSize);
if (r != KErrNone)
{
test.Printf(_L("File system caching failed - Skipping all file caching tests...\n"));
goto skipFileCacheTests;
}
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
GetAllPageInfo();
index = 0;
while (index < gZoneCount && gZoneUtilArray[index].iAllocDiscardable < KDisPagesReq)
{
++ index;
}
if (index == gZoneCount)
{
test.Printf(_L("Cannot find zone to perform test on - Skipping test step...\n"));
}
else
{
zoneID = gZoneConfigArray[index].iZoneId;
// Just need to attempt to allocate one more page than there is free in the zone
allocSize = gZoneUtilArray[index].iFreePages + 1;
test.Printf(_L("Allocating 0x%x fixed pages to zone ID 0x%x.....\n"), allocSize, zoneID);
r = Ldd.ZoneAllocDiscontiguous(zoneID, allocSize);
test.Printf(_L("r = %d\n"), r);
GetAllPageInfo();
if (r != KErrNone)
{
test.Printf(_L("Fail: Fixed pages have not been allocated, r = %d, expected = %d\n"), r, KErrNone);
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
TESTDEBUG(test.Printf(_L("Freeing all Fixed Pages.....\n")));
Ldd.FreeAllFixedPages();
}
TestEnd();
test.Next(_L("Test3: Filling the FS Cache and allocating fixed pages"));
TestStart();
r = FillCache(gFilesNeededToFillCache, KDefaultCacheSize);
if (r != KErrNone)
{
test.Printf(_L("File system caching failed - Skipping all file caching tests...\n"));
goto skipFileCacheTests;
}
GetAllPageInfo();
index = 0;
while (index < gZoneCount && gZoneUtilArray[index].iAllocDiscardable < KDisPagesReq)
{
++ index;
}
if (index == gZoneCount)
{
test.Printf(_L("Cannot find zone to perform test on - Skipping test step...\n"));
}
else
{
zoneID = gZoneConfigArray[index].iZoneId;
allocSize = 14;
TESTDEBUG(test.Printf(_L("Filling the remaining free pages with fixed pages.....\n")));
Ldd.AllocateFixed(gTotalPageCount.iFreePages);
test.Printf(_L("Allocating 0x%x fixed pages to zone ID 0x%x.....\n"), allocSize, zoneID);
r = Ldd2.AllocateFixed(allocSize);
TESTDEBUG(test.Printf(_L("r = %d\n"), r));
GetAllPageInfo();
if (r != KErrNone)
{
test.Printf(_L("Fail: Fixed pages have not been allocated, r = %d, expected = %d\n"), r, KErrNone);
CLEANUP(Ldd.FreeAllFixedPages());
CLEANUP(Ldd2.FreeAllFixedPages());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
TESTDEBUG(test.Printf(_L("Freeing all Fixed Pages.....\n")));
Ldd2.FreeAllFixedPages();
}
TestEnd();
test.Next(_L("Test4: Filling the FS Cache and allocating less than 16 contiguous fixed pages"));
TestStart();
r = FillCache(gFilesNeededToFillCache, KDefaultCacheSize);
if (r != KErrNone)
{
test.Printf(_L("File system caching failed - Skipping all file caching tests...\n"));
goto skipFileCacheTests;
}
allocSize = 14 << gPageShift;
TESTDEBUG(test.Printf(_L("Filling the remaining free pages with fixed pages.....\n")));
GetAllPageInfo();
// Allocate the fixed array before getting any page counts
for (TUint index = 0; index < gZoneCount; index++)
{
GetAllPageInfo();
if (gZoneUtilArray[index].iFreePages)
{
r = Ldd.ZoneAllocToManyArray(index, gZoneUtilArray[index].iFreePages);
if (r != KErrNone)
{
test.Printf(_L("Failed to allocate fixed array Zone %d r = %d - Skipping...\n"), index, r);
goto SkipTest4;
}
}
}
// Now fill all zones with fixed pages, 1 zone at a time
// to avoid the discardable pages being disturbed
for (TUint index = 0; index < gZoneCount; index++)
{
GetAllPageInfo();
if (gZoneUtilArray[index].iFreePages)
{
r = Ldd.ZoneAllocToMany2(index, gZoneUtilArray[index].iFreePages);
if (r != KErrNone)
{
test.Printf(_L("Failed to allocate %d fixed to Zone %d r = %d - Skipping...\n"),
gZoneUtilArray[index].iFreePages, index, r);
goto SkipTest4;
}
}
}
GetAllPageInfo();
test.Printf(_L("number of free pages = 0x%x\n"), gTotalPageCount.iFreePages);
if (gTotalPageCount.iFreePages ||
gTotalPageCount.iDiscardablePages <= (TUint)(allocSize >> gPageShift))
{
test.Printf(_L("Setup failed - Skipping...\n"));
goto SkipTest4;
}
test.Printf(_L("Allocating 0x%x fixed pages.....\n"), allocSize >> gPageShift);
r = Ldd2.AllocContiguous(allocSize);
TESTDEBUG(test.Printf(_L("r = %d\n"), r));
GetAllPageInfo();
if (r != KErrNone || !gTotalPageCount.iDiscardablePages)
{
test.Printf(_L("Fail: Fixed pages have not been allocated, r = %d, expected = %d\n"), r, KErrNone);
CLEANUP(Ldd.FreeAllFixedPages());
CLEANUP(Ldd2.FreeAllFixedPages());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
SkipTest4:
TESTDEBUG(test.Printf(_L("Freeing all Fixed Pages.....\n")));
Ldd2.FreeAllFixedPages();
TestEnd();
test.Next(_L("Test5: Filling the FS Cache and allocating more than 16 contiguous fixed pages"));
TestStart();
if (gMemModel >= EMemModelTypeFlexible)
{// The flexible memory model won't flush the whole paging cache for
// contiguous allocations >16 pages so skip the next test.
test.Printf(_L("This memory model won't flush the cache - Skipping...\n"));
goto SkipTest5;
}
// TestEnd() will have reduced any cache pages to minimum so just get current
// count of discardable pages.
GetAllPageInfo();
minDiscardPages = gTotalPageCount.iDiscardablePages;
r = FillCache(gFilesNeededToFillCache, KDefaultCacheSize);
if (r != KErrNone)
{
test.Printf(_L("File system caching failed - Skipping all file caching tests...\n"));
goto skipFileCacheTests;
}
allocSize = 18 << gPageShift;
TESTDEBUG(test.Printf(_L("Filling the remaining free pages with fixed pages.....\n")));
GetAllPageInfo();
// Allocate the fixed array before getting any page counts
for (TUint index = 0; index < gZoneCount; index++)
{
GetAllPageInfo();
if (gZoneUtilArray[index].iFreePages)
{
r = Ldd.ZoneAllocToManyArray(index, gZoneUtilArray[index].iFreePages);
if (r != KErrNone)
{
test.Printf(_L("Failed to allocate fixed array Zone %d r = %d - Skipping...\n"), index, r);
goto SkipTest5;
}
}
}
// Now fill all zones with fixed pages, 1 zone at a time
// to avoid the discardable pages being disturbed
for (TUint index = 0; index < gZoneCount; index++)
{
GetAllPageInfo();
if (gZoneUtilArray[index].iFreePages)
{
r = Ldd.ZoneAllocToMany2(index, gZoneUtilArray[index].iFreePages);
if (r != KErrNone)
{
test.Printf(_L("Failed to allocate %d fixed to Zone %d r = %d - Skipping...\n"),
gZoneUtilArray[index].iFreePages, index, r);
goto SkipTest5;
}
}
}
GetAllPageInfo();
test.Printf(_L("number of free pages = 0x%x\n"), gTotalPageCount.iFreePages);
if (gTotalPageCount.iFreePages)
{
test.Printf(_L("Setup failed - Skipping...\n"));
goto SkipTest5;
}
test.Printf(_L("Allocating 0x%x fixed pages.....\n"), allocSize >> gPageShift);
r = Ldd2.AllocContiguous(allocSize);
TESTDEBUG(test.Printf(_L("r = %d\n"), r));
GetAllPageInfo();
if (r != KErrNone || gTotalPageCount.iDiscardablePages != minDiscardPages)
{
test.Printf(_L("Fail: r = %d, expected = %d - Discardable Pages = 0x%x, expected = %d\n"),
r, KErrNone, gTotalPageCount.iDiscardablePages, minDiscardPages);
CLEANUP(Ldd.FreeAllFixedPages());
CLEANUP(Ldd2.FreeAllFixedPages());
TEST_FAIL;
}
else
{
test.Printf(_L("Passed...\n"));
}
SkipTest5:
skipFileCacheTests:
TestEnd();
TESTDEBUG(test.Printf(_L("Freeing all Fixed Pages.....\n")));
Ldd2.FreeAllFixedPages();
Ldd2.Close();
gTheFs.Close();
FormatMMC();
test.End();
return KErrNone;
}
//
// TestOneZoneConfig
//
//---------------------------------------------------------------------------------------------------------------------
//! @SYMTestCaseID KBASE-t_ramdefrag-0600
//! @SYMTestType CIT
//! @SYMTestCaseDesc Verifying that when only 1 zone is cofigured in the variant, that
//! the defrag and allocation of fixed pages happend correctly
//! @SYMPREQ PREQ308
//! @SYMTestPriority High
//! @SYMTestActions
//! 1. Fragment the memory and perform a DefragRam
//! 2. Fragment the memory and perform an EmptyZone
//! 3. Fragment the memory and perform a ClaimZone
//! 4. Call ZoneAllocPhysicalRam to allocate discontiguous fixed pages
//! 5. Call ZoneAllocPhysicalRam to allocate contiguous fixed pages
//!
//! @SYMTestExpectedResults
//! 1. Number of pages does not differ from the original
//! 2. KErrNoMemroy and discardable pages are discarded of
//! 3. KErrNoMemory
//! 4. KErrNone
//! 5. KErrNone
//---------------------------------------------------------------------------------------------------------------------
TInt TestOneZoneConfig()
{
TInt r = gTheFs.Connect();
test_KErrNone(r);
if (gDrive != KNoRemovableDrive)
{
SetUpMMC();
}
TUint index = 0;
GetAllPageInfo();
TUint zoneID = gZoneConfigArray[index].iZoneId;
test.Printf(_L("Zone ID = 0x%x\n"), zoneID);
TUint minCacheSize = 0;
TUint maxCacheSize = 0;
TUint currentCacheSize = 0;
TUint origFree = 0;
TUint origUnknown = 0;
TUint origFixed = 0;
TUint origMovable = 0;
TUint origDiscard = 0;
TUint origOther = 0;
if (gPagedRom)
{
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));
TUint setMin = 60 << gPageShift;
TInt setMax = -1;
TInt r = DPTest::SetCacheSize(setMin, setMax);
if (r != KErrNone)
{
test.Printf(_L("r = %d, expected = %d\n"), r, KErrNone);
CLEANUP(ResetDPCache());
TEST_FAIL;
}
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));
}
test.Start(_L("Test1: Fragmenting the memory and performing a general defrag"));
TestStart();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
if (gDrive != KNoRemovableDrive)
{
FillCache(gFilesNeededToFillCache, KDefaultCacheSize);
}
else
{
test.Printf(_L("Cannot find drive to write files to - Not allocating discardable pages through FS Caching\n"));
}
GetAllPageInfo();
origFree = gTotalPageCount.iFreePages;
origUnknown = gTotalPageCount.iUnknownPages;
origFixed = gTotalPageCount.iFixedPages;
origMovable = gTotalPageCount.iMovablePages;
origDiscard = gTotalPageCount.iDiscardablePages;
origOther = gTotalPageCount.iOtherPages;
r = Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
GetAllPageInfo();
if ((origUnknown != gTotalPageCount.iUnknownPages) ||
(origFixed != gTotalPageCount.iFixedPages) ||
(origMovable != gTotalPageCount.iMovablePages) ||
(origDiscard != gTotalPageCount.iDiscardablePages) ||
(origOther != gTotalPageCount.iOtherPages))
{
test.Printf(_L("Fail: Pages after defrag are not equal to those before"));
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed..."));
}
// This will free any allocated memory
TestEnd();
test.Next(_L("Test2: Fragmenting the memory and performing an EmptyZone"));
TestStart();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
if (gDrive != KNoRemovableDrive)
{
FillCache(gFilesNeededToFillCache, KDefaultCacheSize);
}
else
{
test.Printf(_L("Cannot find drive to write files to - Not allocating discardable pages through FS Caching\n"));
}
r = Ldd.CallDefrag(DEFRAG_TYPE_EMPTY, DEFRAG_VER_SYNC, zoneID);
if (r != KErrNoMemory || CheckZoneIsOff(index))
{
test.Printf(_L("Fail: r = %d, expected = -4"), r);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed..."));
}
// This will free any allocated memory
TestEnd();
test.Next(_L("Test3: Fragmenting the memory and performing a ClaimZone"));
TestStart();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
if (gDrive != KNoRemovableDrive)
{
FillCache(gFilesNeededToFillCache, KDefaultCacheSize);
}
else
{
test.Printf(_L("Cannot find drive to write files to - Not allocating discardable pages through FS Caching\n"));
}
GetAllPageInfo();
origMovable = gTotalPageCount.iMovablePages;
r = Ldd.CallDefrag(DEFRAG_TYPE_CLAIM, DEFRAG_VER_SYNC, zoneID);
GetAllPageInfo();
if (r != KErrNoMemory || origMovable != gTotalPageCount.iMovablePages)
{
test.Printf(_L("Fail: r = %d, expected = -4"), r);
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed..."));
}
// This will free any allocated memory.
TestEnd();
test.Next(_L("Test4: Calling ZoneAllocPhysicalRam to allocate discontiguous fixed pages"));
TestStart();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
GetAllPageInfo();
origFree = gTotalPageCount.iFreePages;
origUnknown = gTotalPageCount.iUnknownPages;
origFixed = gTotalPageCount.iFixedPages;
origMovable = gTotalPageCount.iMovablePages;
origDiscard = gTotalPageCount.iDiscardablePages;
origOther = gTotalPageCount.iOtherPages;
r = Ldd.ZoneAllocDiscontiguous(zoneID, (TInt)(origFree / 2));
GetAllPageInfo();
if (gTotalPageCount.iFixedPages < (origFixed + (origFree / 2)))
{
test.Printf(_L("Fail: fixed pages = 0x%x, expected >= 0x%x\n"),
gTotalPageCount.iFixedPages, (origFixed + (origFree / 2)));
CLEANUP(Ldd.FreeAllFixedPages());
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed..."));
}
Ldd.FreeAllFixedPages();
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
TestEnd();
test.Next(_L("Test5: Calling ZoneAllocPhysicalRam to allocate contiguous fixed pages"));
TestStart();
AllocMovable(gChunkArray1, gChunkArraySize1, KNumAllocChunks);
FreeMovable(gChunkArray1, gChunkArraySize1);
GetAllPageInfo();
origFree = gTotalPageCount.iFreePages;
origUnknown = gTotalPageCount.iUnknownPages;
origFixed = gTotalPageCount.iFixedPages;
origMovable = gTotalPageCount.iMovablePages;
origDiscard = gTotalPageCount.iDiscardablePages;
origOther = gTotalPageCount.iOtherPages;
TInt allocSize = 50 << gPageShift;
r = Ldd.ZoneAllocContiguous(zoneID, allocSize);
GetAllPageInfo();
if (gTotalPageCount.iFixedPages < (origFixed + (allocSize >> gPageShift)))
{
test.Printf(_L("Fail: fixed pages = 0x%x, expected >= 0x%x\n"),
gTotalPageCount.iFixedPages, (origFixed + (allocSize >> gPageShift)));
CLEANUP(Ldd.FreeAllFixedPages());
CLEANUP(RemoveChunkAlloc(gChunkArray1, gChunkArraySize1));
TEST_FAIL;
}
else
{
test.Printf(_L("Passed..."));
}
Ldd.FreeAllFixedPages();
RemoveChunkAlloc(gChunkArray1, gChunkArraySize1);
TestEnd();
if (gPagedRom)
{
test_KErrNone(DPTest::FlushCache());
ResetDPCache();
}
gTheFs.Close();
if (gDrive != KNoRemovableDrive)
{
FormatMMC();
}
test.End();
return KErrNone;
}
//
// RunDefragTests
//
// List of defrag tests to be run
//
void RunDefragTests()
{
test.Start(_L("Testing the moving of pages in a defrag"));
TestMovPgsDefrag();
test.Next(_L("Verifying the implementation of the function TRamDefragRequest::DefragRam() arg aMaxPages"));
TestDefragRamMaxPages();
test.Next(_L("Verifying the implementation of the function TRamDefragRequest::EmptyRamZone()"));
TestEmptyRamZone();
test.Next(_L("Verifying the implementation of the function Epoc::GetRamZonePageCount()"));
TestGetRamZonePageCount();
test.Next(_L("Verifying the implementation of the function TRamDefragRequest::ClaimRamZone()"));
TestClaimRamZone();
test.Next(_L("Verifying the implementation of the function TRamDefragRequest::Cancel()"));
TestCancelDefrag();
test.Next(_L("Verifying that pages are moved correctly"));
TestMovingPages();
test.Next(_L("Verifying Semaphore Methods of the Defrag"));
TestDefragSemMethod();
test.Next(_L("Verifying Dfc Methods of the Defrag"));
TestDefragDfcMethod();
test.Next(_L("Testing priorities"));
TestPriorities();
test.Next(_L("Testing File System Caching"));
if (!gPagedRom)
{
TestFileCaching();
}
else
{
test.Printf(_L("Skipping... \n"));
}
test.Next(_L("Testing general RAM defrag implementation"));
TestGenDefrag();
test.End();
}
//
// RunAllocTests
//
// List of allocating tests to be run
// These tests only need to be executed once
//
void RunAllocTests()
{
test.Start(_L("Verifying the allocating strategies"));
TestAllocStrategies();
test.Next(_L("Verifying the contiguous overload of Epoc::ZoneAllocPhysicalRam()"));
TestZoneAllocContiguous();
test.Next(_L("Verifying the discontiguous overload of Epoc::ZoneAllocPhysicalRam()"));
TestZoneAllocDiscontiguous();
test.Next(_L("Test Free Zone"));
TestFreeZone();
test.Next(_L("Testing zone flags"));
TestFlags();
test.End();
}
//
// E32Main
//
// Main entry point.
//
TInt E32Main()
{
test.Title();
DeviceDriver(TEST_DRIVER_OPEN);
gTotalRamLost = 0;
TInt r = TestSetup();
if (r != KErrNone)
{
test.Printf(_L("Test Setup failed, r = %d\n"), r);
TestCleanup();
return r;
}
if (gZoneCount == 1)
{
GetAllPageInfo();
test.Start(_L("Zone Count 1..."));
TestOneZoneConfig();
}
else
{
test.Start(_L("Running Alloc tests"));
RunAllocTests();
Ldd.ResetDriver();
Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
test.Next(_L("Running Defrag tests"));
RunDefragTests();
Ldd.ResetDriver();
Ldd.CallDefrag(DEFRAG_TYPE_GEN, DEFRAG_VER_SYNC);
}
test.Printf(_L("The total number of test steps failed = %d\n"), gTestStepFailed);
test_Equal(KErrNone, gTestStepFailed);
TestCleanup();
DeviceDriver(TEST_DRIVER_CLOSE);
test.End();
test.Close();
return 0;
}