// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32test\mmu\t_nandpaging.cpp

// Suite of tests specifically to test the demand paging subsystem when

// booted from NAND.

// 002 Read/Write and Page test

// 003 Defering test

// 

//

//! @SYMTestCaseID			KBASE-T_NANDPAGING-0332

//! @SYMTestType			UT

//! @SYMPREQ				PREQ1110

//! @SYMTestCaseDesc		Demand Paging Nand Paging tests.

//! @SYMTestActions			001 Check that the rom is paged

//! @SYMTestExpectedResults All tests should pass.

//! @SYMTestPriority        High

//! @SYMTestStatus          Implemented

#define __E32TEST_EXTENSION__

#include <e32test.h>

RTest test(_L("T_NANDPAGING"));

#include <e32rom.h>

#include <e32svr.h>

#include <u32hal.h>

#include <f32file.h>

#include <f32dbg.h>

#include "testdefs.h"

#include <hal.h>

#include "nfe.h"

TInt DriveNumber=-1;   // Parameter - Which drive?  -1 = autodetect.

TInt locDriveNumber;

TInt MaxDeferLoops=40; // Parameter - Defer test, for how long?

TInt Maxloops=400;	   // Parameter - RW Soak, for how long?

TBool Forever=EFalse;  // Parameter - RW Soak forever?

TBool Testing=ETrue;	// Used to communicate when testing has finished between threads.

RFs TheFs;

TBusLocalDrive Drive;

TLocalDriveCapsV4 DriveCaps;

TInt PagedTrashCount=0; // Incremented by threads, is used to detect preemption.

TInt GlobError=KErrNone; // To communicate an error between threads.

TBool CtrlIoCollectGarbageSupported = ETrue;

TBool CtrlIoGetDeferStatsSupported = ETrue;

const TInt KDiskSectorShift=9;

const TInt KBufSizeInSectors=8;

const TInt KBufSizeInBytes=(KBufSizeInSectors<<KDiskSectorShift)*40;

LOCAL_D TBuf8<KBufSizeInBytes> Buffer;

// Three functions for the garbage test.

// CreateFile creates a file, and sets up the buffer for WriteNumber.

// After the code has finished writing numbers to the start,

// CloseAndDestroy cleans up.

void CreateFile(RFile &aFile,const TDesC& aFileName)

	{

	TBuf<256> fileName;	

	fileName.Append((TChar)('A'+DriveNumber));

	fileName+=_L(":\\f32-tst\\");

	TInt r=TheFs.MkDirAll(fileName);

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

	fileName += aFileName;	

	r=aFile.Replace(TheFs,fileName,EFileWrite);

	if (r!=KErrNone)

		test.Printf(_L("Error %d: file '%S' could not be created\n"),r,&fileName);

	test(r==KErrNone);	

	Buffer.SetLength(4);

	}

void CloseAndDestroy(RFile &aFile)

	{

	TBuf<256> fileName;	

	aFile.FullName(fileName);

	aFile.Close();

	TheFs.Delete(fileName);

	}

TInt WriteNumber(RFile &aFile)

	{

	TInt r;

	Buffer[0]++;

	r = aFile.Write(0,Buffer);

	if (r==KErrNone)

		return aFile.Flush();

	else

		return r; 

	}

// The r/w soaktest leaves the drive in a mess.

// Formatting is needed afterwards.

void silentFormat(TInt driveNo) 

	{    

    TBuf<4> driveBuf=_L("?:\\");

    RFormat format;

    TInt    count;

	driveBuf[0] = (TText)(driveNo + 'A');

    TInt r = format.Open(TheFs, driveBuf, EHighDensity, count);

    test(r == KErrNone);

    while(count) 

		{

        r=format.Next(count);

        test(r == KErrNone);

		}

    format.Close();

	}

// Finds the 1st r/w NAND drive, or checks the specified one fits requirements  

static TInt FindFsNANDDrive()

	{

	TDriveList driveList;

	TDriveInfo driveInfo;

	TInt r=TheFs.DriveList(driveList);

    test(r == KErrNone);

	for (TInt drvNum= (DriveNumber<0)?0:DriveNumber; drvNum<KMaxDrives; ++drvNum)

		{

	    if(!driveList[drvNum])

	        continue;   //-- skip unexisting drive

	    test(TheFs.Drive(driveInfo, drvNum) == KErrNone);

		if ((driveInfo.iMediaAtt&KMediaAttPageable) &&

			(driveInfo.iType == EMediaNANDFlash) && 

			(driveInfo.iDriveAtt & KDriveAttInternal))

			{

			TBool readOnly = driveInfo.iMediaAtt & KMediaAttWriteProtected;		// skip ROFS partitions

			if(!readOnly)

				{

				if ((drvNum==DriveNumber) || (DriveNumber<0))		// only test if running on this drive

					{

					return (drvNum);

					}

				}

			}

		}

	return (-1);

	}

//

// Writes to main area for the entire disk and reads back to verify.

// The function is called from TestNandAccuratcy, which will have also

// started the background RepeatedPagingThread

//

void testWriteMain()

	{

	TInt i;

	TInt r;

	TInt changeCount=0;

	TInt totChangeCount=0;

	TInt cCount=0;

	TInt fullcCount=0;

	TInt oldPagedTrashCount=0;

	TInt delta=0;

	TInt high=0;

	TInt tot=0;

	TInt fullTot=0;

	TInt blockNo;

	// read size is 64K

	TInt readSize = (64*1024);	

	TInt64 size = DriveCaps.iSize - (DriveCaps.iSize % readSize);

	// print position every 128K

	TInt64 printBlockPos = 128 * 1024;

	test (size > printBlockPos);

	// check for paging activity every 1MB

	TInt64 checkChangePos = 1024*1024;

	while (checkChangePos > size)

		checkChangePos>>= 1;

	SDeferStats stats;

	TInt pageGarbageCount=0;

	TInt pageOtherCount=0;	

	TInt normalGarbageCount=0;

	TInt normalOtherCount=0;

	Buffer.SetLength(2*readSize);

	TPtr8 subBuf1(&Buffer[0],readSize);

	TPtrC8 subBuf2(&Buffer[readSize], readSize);

	test.Printf(_L("Page size = %d\n"), DriveCaps.iNumBytesMain);

	test.Printf(_L("Erase block size = %d\n"), DriveCaps.iEraseBlockSize);

	test.Printf(_L("Media size (rounded down) = %ld\n"), size);

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

		Buffer[readSize+i] = (char)(i%100);

	// Zero Stats

	if(CtrlIoGetDeferStatsSupported)

		{

		TPtr8 statsBuf((TUint8*) &stats, sizeof(stats));

 		test(Drive.ControlIO(KNandGetDeferStats,statsBuf,0)==KErrNone);

		}

	while (((totChangeCount<Maxloops) || Forever) && (GlobError==KErrNone))

		{

		for(TInt64 pos=0;

			(pos<size) && ((totChangeCount<Maxloops) || Forever) && (GlobError==KErrNone);

			pos+=(TUint)(readSize))

			{

			blockNo=I64LOW(pos / DriveCaps.iEraseBlockSize);

			if ((pos % printBlockPos) == 0)

				test.Printf(_L("Block %d at pos %lu \r"), blockNo, pos);

			//write the pattern

			r = Drive.Write(pos,subBuf2);

			test(r==KErrNone);

			//read back and verify

			r = Drive.Read(pos,readSize,subBuf1);

			test(r==KErrNone);

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

				if(Buffer[i]!=Buffer[readSize+i])

					{

					r = KErrCorrupt;

					break;

					}

			delta = PagedTrashCount-oldPagedTrashCount;

			cCount++;

			if (delta)

				{	

				if (delta>high)

					high=delta;

				tot+=delta;

				oldPagedTrashCount=PagedTrashCount;

				changeCount++;

				}

			if ((pos > 0) && (pos % checkChangePos) == 0)

				{

				totChangeCount+=changeCount;

				if(CtrlIoGetDeferStatsSupported)

					{

					test.Printf(_L("\nHigh%4d Avg%2d %d%% CC=%4d \n"), high, (TInt) (tot/cCount), (TInt)(changeCount*100)/cCount, totChangeCount);

					TPtr8 statsBuf((TUint8*) &stats, sizeof(stats));

					Drive.ControlIO(KNandGetDeferStats,statsBuf,0);

					test.Printf(_L("PG %d PO %d(%d%%) NG %d NO %d\n"),stats.iPageGarbage,  stats.iPageOther, (TInt) ((stats.iPageOther*100)/cCount), stats.iNormalGarbage,  stats.iNormalOther);

					test(stats.iPageOther>0);

				 	pageGarbageCount+=stats.iPageGarbage; 

				 	pageOtherCount+=stats.iPageOther;			 	

				 	normalGarbageCount+=stats.iNormalGarbage; 

				 	normalOtherCount+=stats.iNormalOther;			 	

					}

				high=0;

				fullTot+=tot;

				tot=0;

				fullcCount+=cCount;

				cCount=0;

				changeCount=0;

				}

			test(r==KErrNone);

			}	// for loop

		if (CtrlIoGetDeferStatsSupported)

			{

			test.Printf(_L("\nTotals: Avg %2d %d%% CC=%4d \n"), fullTot/fullcCount, (TInt)(totChangeCount*100)/fullcCount, totChangeCount);

			test.Printf(_L("PG %d PO %d(%d%%) NG %d NO %d\n"),pageGarbageCount,  pageOtherCount,(TInt) (pageOtherCount*100/fullcCount), normalGarbageCount,  normalOtherCount );

			}

		// If totChangeCount does not change, nand maybe busy waiting.

		test(totChangeCount>0);

		}	// while ()

	if (GlobError!=KErrNone)

		{

		test.Printf(_L("\nPaging failed with %x\n"), GlobError);

		test(0);

		}

	else

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

	}

TUint8 ReadByte(volatile TUint8* aPtr)

	{

	return *aPtr;

	}

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

TUint32 RandomNo =0;

TUint32 Random()

	{

	RandomNo = RandomNo*69069+1;

	return RandomNo;

	}

// Many instances of this run while testWriteMain runs,

// to cause random background paging.

LOCAL_C TInt RepeatedPagingThread(TAny* aUseTb)

	{

	TBool trashBurst = EFalse;

	// This makes the paging system continually page stuff.

	// get info about a paged ROM...

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

	TUint8* start = (TUint8*)romHeader+romHeader->iPageableRomStart;

	TUint size = romHeader->iPageableRomSize;

	TInt pageSize = 0;

	PagedTrashCount=1;

	UserSvr::HalFunction(EHalGroupKernel,EKernelHalPageSizeInBytes,&pageSize,0);

	RandomNo=123;

	PagedTrashCount++;

	while (Testing)

		{

		TInt r=UserSvr::HalFunction(EHalGroupVM,EVMHalFlushCache,0,0);

		if (Random() & 1)

			User::AfterHighRes(500+Random() & 2047);

		if (r<0)

			{

			GlobError=r;

			PagedTrashCount=99;

			return (KErrNone);

			}

		if (trashBurst)

			{

			if ((Random() & 0xf) == 0xf)

				trashBurst=EFalse;

			PagedTrashCount++;

			}

		else 

			{

			for(TInt i=size/(pageSize); (i>0) && !trashBurst; --i)

				{

				READ(start+((TInt64(Random())*TInt64(size))>>32));

				if ((RandomNo & 0x3f) == 0x3f)

					{

					trashBurst= (TBool) aUseTb;

					}

				PagedTrashCount++;

				if (RandomNo & 1)

					User::AfterHighRes(500+Random() & 2047);

				}

			}

		}

	return(KErrNone);

	}

// This starts up multiple instances of repeatedPagingThread, and runs testWriteMain.

// After its done, it calls format, to clean up the drive.

void TestNandAccuratcy()

	{

	RThread thisThread;

	const TInt KNoThreads=10;

	TInt i;

	test.Printf(_L("Reset concurrency stats\n"));

	i=UserSvr::HalFunction(EHalGroupMedia,EMediaHalResetConcurrencyInfo,(TAny*)locDriveNumber,(TAny*)EMediaPagingStatsRom);

	test(i==KErrNone || i==KErrNotSupported);

	if(i==KErrNotSupported)

		test.Printf(_L("Concurrency stats not supported on this build\n"));

	i=UserSvr::HalFunction(EHalGroupMedia,EMediaHalResetPagingBenchmark,(TAny*)locDriveNumber,(TAny*)EMediaPagingStatsRom);

	test(i==KErrNone || i==KErrNotSupported);

	if(i==KErrNotSupported)

		test.Printf(_L("Benchmark stats not supported on this build\n"));

	if (Maxloops>0)

		{

		TRequestStatus stat[KNoThreads];

		// Start Read Test

		RThread repeatedPagingThread[KNoThreads];

		test.Next(_L("Read/Write and Page test"));

		Testing=ETrue;

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

			{

			test(repeatedPagingThread[i].Create(_L(""),RepeatedPagingThread,KDefaultStackSize,NULL,(TAny*) ETrue)==KErrNone);

			repeatedPagingThread[i].Logon(stat[i]);

			test(stat[i]==KRequestPending);	

			repeatedPagingThread[i].Resume();

			}

		// Start repeated paging.

		thisThread.SetPriority(EPriorityMore);

		testWriteMain();

		Testing = 0;

		thisThread.SetPriority(EPriorityNormal);

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

	 		User::WaitForRequest(stat[i]);

		test.Printf(_L("Collect concurrency stats\n"));

		SMediaROMPagingConcurrencyInfo info;

		SPagingBenchmarkInfo infoBench;

		i=UserSvr::HalFunction(EHalGroupMedia,EMediaHalGetROMConcurrencyInfo,(TAny*)locDriveNumber,&info);

		test(i==KErrNone || i==KErrNotSupported);

		TInt r=UserSvr::HalFunction(EHalGroupMedia,EMediaHalGetROMPagingBenchmark,(TAny*)locDriveNumber,&infoBench);

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

		if(i==KErrNone)

			{

			test.Printf(_L("Media concurrency stats:\n\n"));

			test.Printf(_L("The total number of page in requests issued whilst processing other page in requests: %d\n"),info.iTotalConcurrentReqs);

			test.Printf(_L("The total number of page in requests issued with at least one queue not empty: %d\n"),info.iTotalReqIssuedNonEmptyQ);

			test.Printf(_L("The maximum number of pending page in requests in the main queue any time during this session: %d\n"),info.iMaxReqsInPending);

			test.Printf(_L("The maximum number of pending page in requests in the deferred queue any time during this session: %d\n"),info.iMaxReqsInDeferred);

			test.Printf(_L("The total number of page in requests first-time deferred during this session: %d\n"),info.iTotalFirstTimeDeferrals);

			test.Printf(_L("The total number of page in requests re-deferred during this session: %d\n"),info.iTotalReDeferrals);

			test.Printf(_L("The maximum number of deferrals of any single page in request during this session: %d\n"),info.iMaxDeferrals);

			test.Printf(_L("The total number of times the main queue was emptied when completing an asynchronous request during this session: %d\n"),info.iTotalSynchEmptiedMainQ);

			test.Printf(_L("The total number of page in requests serviced from main queue when completing an asynchronous request: %d\n"),info.iTotalSynchServicedFromMainQ);

			test.Printf(_L("The total number of page in requests deferred after being picked out of main queue when completing an asynchronous request: %d\n"),info.iTotalSynchDeferredFromMainQ);

			test.Printf(_L("The total number of times the page in DFC run with an empty main queue during this session: %d\n"),info.iTotalRunDry);

			test.Printf(_L("The total number of dry runs of paging DFC avoided during this session: %d\n"),info.iTotalDryRunsAvoided);

			}

		if(r==KErrNone)

			{

			TInt freq = 0;

			r = HAL::Get(HAL::EFastCounterFrequency, freq);

			if (r==KErrNone)

				{

				TReal mult = 1000000.0 / freq;

				TReal min = 0.0;

				TReal max = 0.0;

				TReal avg = 0.0;

				if (infoBench.iCount != 0)

					{

					min = infoBench.iMinTime * mult;

					max = infoBench.iMaxTime * mult;

					avg = (infoBench.iTotalTime * mult) / infoBench.iCount;

					}

				test.Printf(_L("Media benchmarks:\n\n"));

				test.Printf(_L("The total number of page in requests issued: %d\n"),infoBench.iCount);

				test.Printf(_L("The average latency of any page in request in the Media subsystem: %9.1f(us)\n"),avg);

				test.Printf(_L("The maximum latency of any page in request in the Media subsystem: %9.1f(us)\n"),max);

				test.Printf(_L("The minimum latency of any page in request in the Media subsystem: %9.1f(us)\n"),min);

				}

			}

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

		silentFormat(DriveNumber);

		}

		else

			test.Next(_L("Read/Write test - Skipped!"));

	}

// ************************************************************************************

// This code causes a flush

// It is done in a second thread to see if you really do get just

// one deferral, with the other page requests just waiting in line.

// (Paging is not re-entrant)

TInt PagesBeingPaged=0;

RMutex PageMutex;

RSemaphore PageSemaphore;

RSemaphore PageDoneSemaphore;

LOCAL_C TInt CausePage(TAny*)

	{	

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

	TUint8* start = (TUint8*)romHeader+romHeader->iPageableRomStart;

	TUint size = romHeader->iPageableRomSize;

	TUint8* addr=NULL;

	TBool flush;

	while (Testing)

		{

			PageSemaphore.Wait(); // wait for main thread to want paging.

			flush = (PagesBeingPaged==0);

			addr=start+((TInt64(Random())*TInt64(size))>>32);	

			PageDoneSemaphore.Signal(); // Acknolage request.

			PageMutex.Wait();

			PagesBeingPaged++;

			PageMutex.Signal();

			if (flush)

				UserSvr::HalFunction(EHalGroupVM,EVMHalFlushCache,0,0);