// Copyright (c) 1996-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:
// f32test/bench/t_fsysbm.cpp
//
//

#define __E32TEST_EXTENSION__

#include <f32file.h>
#include <e32test.h>
#include <hal.h>
#include <e32math.h>
#include "t_server.h"
#include "../../e32test/mmu/d_sharedchunk.h"

#define SYMBIAN_TEST_EXTENDED_BUFFER_SIZES	// test using a greater number of buffer sizes
//#define SYMBIAN_TEST_COPY					// read from one drive and write to another


GLDEF_D RTest test(_L("File System Benchmarks"));

static const TUint K1K = 1024;								// 1K
static const TUint K1M = 1024 * 1024;						// 1M
static const TUint K2M = 2 * K1M;						    // 2M

#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
const TInt64 KGb  	= 1 << 30;
const TInt64 K3GB   = 3 * KGb;
const TInt64 K4GB   = 4 * KGb;
#endif //SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

#if defined(__WINS__)
LOCAL_D TInt KMaxFileSize = 256 * K1K;						// 256K
//LOCAL_D TInt KMaxFileSize = K1M;							// 1M
#else
//LOCAL_D TInt KMaxFileSize = 256 * K1K;					// 256K
//LOCAL_D TInt KMaxFileSize = K1M;							// 1M
LOCAL_D TInt KMaxFileSize = K2M;							// 2M
#endif

const TTimeIntervalMicroSeconds32 KFloatingPointTestTime = 10000000;	// 10 seconds
LOCAL_D const TInt KHeapSize = 0x4000;

LOCAL_D TPtr8 DataBuf(NULL, KMaxFileSize,KMaxFileSize);
LOCAL_D HBufC8* DataBufH = NULL;

LOCAL_D RSharedChunkLdd Ldd;
LOCAL_D RChunk TheChunk;
LOCAL_D TInt PageSize;
const TUint ChunkSize = KMaxFileSize;


LOCAL_D RFile File, File2;
LOCAL_D TChar gDriveToTest2;

// if enabled, Read and Write operations are not boundary aligned.
LOCAL_D TBool gMisalignedReadWrites = EFalse;

// read & write caching enabled flags - may be overriden by +/-r +/-w command line switches
LOCAL_D TBool gReadCachingOn  = EFalse;
LOCAL_D TBool gWriteCachingOn = EFalse;

// if enabled, timings are for write AND flush
LOCAL_D TBool gFlushAfterWrite = ETrue;

// if enabled, contiguous shared memory is used for Data buffer
LOCAL_D TBool gSharedMemory = EFalse;

// if enabled, fragmented shared memory is used for Data buffer
LOCAL_D TBool gFragSharedMemory = EFalse;

LOCAL_D TInt gFastCounterFreq;



LOCAL_C void RecursiveRmDir(const TDesC& aDes)
//
// Delete directory contents recursively
//
	{
	CDir* pD;
	TFileName n=aDes;
	n.Append(_L("*"));
	TInt r=TheFs.GetDir(n,KEntryAttMaskSupported,EDirsLast,pD);
	if (r==KErrNotFound || r==KErrPathNotFound)
		return;
	test(r==KErrNone);
	TInt count=pD->Count();
	TInt i=0;
	while (i<count)
		{
		const TEntry& e=(*pD)[i++];
		if (e.IsDir())
			{
			TFileName dirName;
			dirName.Format(_L("%S%S\\"),&aDes,&e.iName);
			RecursiveRmDir(dirName);
			}
		else
			{
			TFileName fileName;
			fileName.Format(_L("%S%S"),&aDes,&e.iName);
			r=TheFs.Delete(fileName);
			test(r==KErrNone);
			}
		}
	delete pD;
	r=TheFs.RmDir(aDes);
	test(r==KErrNone);
	}


void LOCAL_C ClearSessionDirectory()
//
// Delete the contents of F32-TST
//
	{
	TParse sessionPath;
	TInt r=TheFs.Parse(_L("\\F32-TST\\"),_L(""),sessionPath);
	test(r==KErrNone);
	RecursiveRmDir(sessionPath.FullName());
	r=TheFs.MkDir(sessionPath.FullName());
	test(r==KErrNone);
	}


LOCAL_C void DoTestFileRead(TInt aBlockSize, TInt aFileSize = KMaxFileSize, TBool aReRead = EFalse)
//
// Do Read Test
//
	{
	// Create test data
//	test.Printf(_L("Creating test file..."));
	TInt writeBlockLen = aFileSize > DataBuf.MaxSize() ? DataBuf.MaxSize() : aFileSize;
	DataBuf.SetLength(writeBlockLen);
#if defined(_DEBUG)
	for (TInt m = 0; m < DataBuf.Length(); m++)
		DataBuf[m] = TText8(m % 256);
#endif
	// To allow this test to run on a non-preq914 branch :
	enum {EFileWriteDirectIO = 0x00001000};
	TInt r = File.Create(TheFs, _L("READTEST"), EFileStream | EFileWriteDirectIO);
	test(r == KErrNone);
	TInt count = aFileSize / DataBuf.Length();
	while (count--)
		File.Write(DataBuf);
//	test.Printf(_L("done\n"));
	File.Close();

	enum {EFileReadBuffered = 0x00002000, EFileReadDirectIO = 0x00004000};
	r = File.Open(TheFs, _L("READTEST"), EFileStream | (gReadCachingOn ? EFileReadBuffered : EFileReadDirectIO));
	test(r == KErrNone);

//	const TInt maxReadCount = aFileSize / aBlockSize;
	TUint functionCalls = 0;

#if defined SYMBIAN_TEST_COPY
	// To allow this test to run on a non-preq914 branch :
	enum {EFileWriteDirectIO = 0x00001000};
	TInt r = File2.Replace(TheFs, _L("WRITETEST"), EFileStream | EFileWriteDirectIO);
	test(r == KErrNone);
#endif

	TTime startTime(0);
	TTime endTime(0);

	// we stop after the entire file has been read or after 10 seconds, whichever happens sooner
	RTimer timer;
	timer.CreateLocal();
	TRequestStatus reqStat;


	TUint initTicks = 0;
	TUint finalTicks = 0;

	// if aReRead file is set, then read file twice
	for (TInt n=0; n<(aReRead?2:1); n++)
		{
		functionCalls = 0;

		const TInt readLen = (aReRead && n == 0) ? writeBlockLen : aBlockSize;
		const TInt maxReadCount = aFileSize / readLen;

		TInt pos = 0;
		File.Seek(ESeekStart, pos);

		timer.After(reqStat, 10000000); // After 10 secs
		startTime.HomeTime();
		initTicks = User::FastCounter();

		for (TInt i = 0; i<maxReadCount && reqStat==KRequestPending; i++)
			{
//			test.Printf(_L("Read %d\n"),i);
//			for (TInt a = 0; a < 512; a++)
//				test.Printf(_L("%d"),DataBuf[a]);

			TInt r = File.Read(DataBuf, readLen);
			test (r == KErrNone);

			if (DataBuf.Length() == 0)
				break;

#if defined SYMBIAN_TEST_COPY
			r = File2.Write(DataBuf, readLen);
			test (r == KErrNone);
#endif
			functionCalls++;

#if defined(_DEBUG)
//			for (TInt a = 0; a < 512; a++)
//				test.Printf(_L("%d"),DataBuf[a]);

			for (TInt j = 0; j < DataBuf.Size(); j++)
				test(DataBuf[j] == (j + i * readLen) % 256);
#endif

			}

		finalTicks = User::FastCounter();
		endTime.HomeTime();
		timer.Cancel();
		}

	TInt dataTransferred = functionCalls * aBlockSize;

//	TTimeIntervalMicroSeconds duration = endTime.MicroSecondsFrom(startTime);
	TTimeIntervalMicroSeconds duration = TInt64(finalTicks - initTicks) * TInt64(1000000) / TInt64(gFastCounterFreq) ;

	TReal transferRate =
		TReal32(dataTransferred) /
		TReal(duration.Int64()) * TReal(1000000) / TReal(K1K); // KB/s
	test.Printf(_L("Read %7d bytes in %7d byte blocks:\t%11.3f KBytes/s (%d microsecs)\n"),
		dataTransferred, aBlockSize, transferRate, endTime.MicroSecondsFrom(startTime).Int64());


	timer.Close();
#if defined SYMBIAN_TEST_COPY
	File2.Close();
#endif

	File.Close();
	r = TheFs.Delete(_L("READTEST"));
	test(r == KErrNone);
	return;
	}


LOCAL_C void TestFileRead(TInt aFileSize = KMaxFileSize, TBool aMisalignedReadWrites = EFalse, TBool aReRead = EFalse)
//
// Benchmark read method
//
	{
	ClearSessionDirectory();
	test.Next(_L("Benchmark read method"));

	_LIT(KLitReadOnce,"Read-once");
	_LIT(KLitReRead,"Re-read");
	test.Printf(_L("FileSize %d, MisalignedReadWrites %d %S\n"), aFileSize, aMisalignedReadWrites, aReRead ? &KLitReRead : &KLitReadOnce);
	TInt misalignedOffset = aMisalignedReadWrites ? 1 : 0;

#if defined (SYMBIAN_TEST_EXTENDED_BUFFER_SIZES)
	DoTestFileRead(1+misalignedOffset, aFileSize, aReRead);
	DoTestFileRead(2+misalignedOffset, aFileSize, aReRead);
	DoTestFileRead(4+misalignedOffset, aFileSize, aReRead);
	DoTestFileRead(8+misalignedOffset, aFileSize, aReRead);
	DoTestFileRead(16+misalignedOffset, aFileSize, aReRead);
	DoTestFileRead(32+misalignedOffset, aFileSize, aReRead);
	DoTestFileRead(64+misalignedOffset, aFileSize, aReRead);
	DoTestFileRead(128+misalignedOffset, aFileSize, aReRead);
	DoTestFileRead(256+misalignedOffset, aFileSize, aReRead);
	DoTestFileRead(512+misalignedOffset, aFileSize, aReRead);
	DoTestFileRead(1024+misalignedOffset, aFileSize, aReRead);
	DoTestFileRead(2 * 1024+misalignedOffset, aFileSize, aReRead);
	DoTestFileRead(4 * 1024+misalignedOffset, aFileSize, aReRead);
	DoTestFileRead(8 * 1024+misalignedOffset, aFileSize, aReRead);
	DoTestFileRead(16 * 1024+misalignedOffset, aFileSize, aReRead);
	DoTestFileRead(32 * 1024+misalignedOffset, aFileSize, aReRead);
	DoTestFileRead(64 * 1024+misalignedOffset, aFileSize, aReRead);
	DoTestFileRead(128 * 1024+misalignedOffset, aFileSize, aReRead);
	DoTestFileRead(256 * 1024+misalignedOffset, aFileSize, aReRead);
	DoTestFileRead(512 * 1024+misalignedOffset, aFileSize, aReRead);
	DoTestFileRead(1024 * 1024+misalignedOffset, aFileSize, aReRead);
#else
	DoTestFileRead(16+misalignedOffset, aFileSize, aReRead);
	DoTestFileRead(512+misalignedOffset, aFileSize, aReRead);
	DoTestFileRead(4096+misalignedOffset, aFileSize, aReRead);
	DoTestFileRead(32768+misalignedOffset, aFileSize, aReRead);
	DoTestFileRead(64 * 1024+misalignedOffset, aFileSize, aReRead);
	DoTestFileRead(K1M+misalignedOffset, aFileSize, aReRead);
#endif

	}


LOCAL_C TInt FloatingPointLoop(TAny* funcCount)
	{
	TUint& count = *(TUint*) funcCount;
	TReal eq = KPi;

	FOREVER
		{
		eq *= eq;
		count++;
		}

	}


LOCAL_C void DoTestFileReadCPU(TInt aBlockSize)
//
// Benchmark CPU utilisation for Read method
//
// Read operations are performed for 10 seconds whilst a second thread executes floating point calculations
// The higher the number of calculations the less amount of CPU time has been used by the Read method.
//
	{
	enum {EFileReadBuffered = 0x00002000, EFileReadDirectIO = 0x00004000};
	TInt r = File.Open(TheFs, _L("READCPUTEST"), EFileStream | (gReadCachingOn ? EFileReadBuffered : EFileReadDirectIO));
	test(r == KErrNone);

	TInt pos = 0;

	TUint functionCalls = 0;
	TUint fltPntCalls = 0;
	RThread fltPntThrd;

	TBuf<6> buf = _L("Floaty");
	fltPntThrd.Create(buf, FloatingPointLoop, KDefaultStackSize, KHeapSize, KHeapSize, (TAny*) &fltPntCalls);

	RTimer timer;
	timer.CreateLocal();
	TRequestStatus reqStat;

	TUint initTicks = 0;
	TUint finalTicks = 0;

	timer.After(reqStat, KFloatingPointTestTime); // After 10 secs
	initTicks = User::FastCounter();

	// up the priority of this thread so that we only run the floating point thread when this thread is idle
	RThread				thisThread;
	thisThread.SetPriority(EPriorityMuchMore);

	TRequestStatus req;
	fltPntThrd.Logon(req);

	fltPntThrd.Resume();

	for (TInt i = 0; reqStat==KRequestPending; i++)
		{
		TInt r = File.Read(pos, DataBuf, aBlockSize);
		test (r == KErrNone);

		pos += aBlockSize;
		if (pos > KMaxFileSize-aBlockSize)
			pos = 0;

		functionCalls++;
		}

	TUint fltPntCallsFinal = fltPntCalls;
	fltPntThrd.Kill(KErrNone);

	finalTicks = User::FastCounter();

	fltPntThrd.Close();
	User::WaitForRequest(req);

	TInt dataTransferred = functionCalls * aBlockSize;

	TTimeIntervalMicroSeconds duration = TInt64(finalTicks - initTicks) * TInt64(1000000) / TInt64(gFastCounterFreq) ;

	TReal transferRate =  TReal32(dataTransferred) /
						 TReal(duration.Int64()) * TReal(1000000) / TReal(K1K); // KB/s

	test.Printf(_L("Read %7d bytes in %7d byte blocks:\t%11.3f KBytes/s; %d Flt Calcs\n"),
				    dataTransferred, aBlockSize, transferRate, fltPntCallsFinal);

	timer.Close();

	File.Close();

	return;
	}


LOCAL_C void TestFileReadCPU(TBool aMisalignedReadWrites = EFalse)
//
// Benchmark CPU utilisation for Read method
//
	{
	ClearSessionDirectory();
	test.Next(_L("Benchmark Read method CPU Utilisation"));

	test.Printf(_L("MisalignedReadWrites %d\n"), aMisalignedReadWrites);
	TInt misalignedOffset = aMisalignedReadWrites ? 1 : 0;

	// Create test data
	test.Printf(_L("Creating test file..."));
	DataBuf.SetLength(KMaxFileSize);

	TInt r = File.Create(TheFs, _L("READCPUTEST"), EFileStream | EFileWriteDirectIO);
	test(r == KErrNone);

	File.Write(DataBuf);

	test.Printf(_L("done\n"));
	File.Close();

	DoTestFileReadCPU(1+misalignedOffset);
	DoTestFileReadCPU(2+misalignedOffset);
	DoTestFileReadCPU(4+misalignedOffset);
	DoTestFileReadCPU(8+misalignedOffset);
	DoTestFileReadCPU(16+misalignedOffset);
	DoTestFileReadCPU(32+misalignedOffset);
	DoTestFileReadCPU(64+misalignedOffset);
	DoTestFileReadCPU(128+misalignedOffset);
	DoTestFileReadCPU(256+misalignedOffset);
	DoTestFileReadCPU(512+misalignedOffset);
	DoTestFileReadCPU(1024+misalignedOffset);
	DoTestFileReadCPU(2 * 1024+misalignedOffset);
	DoTestFileReadCPU(4 * 1024+misalignedOffset);
	DoTestFileReadCPU(8 * 1024+misalignedOffset);
	DoTestFileReadCPU(16 * 1024+misalignedOffset);
	DoTestFileReadCPU(32 * 1024+misalignedOffset);
	DoTestFileReadCPU(64 * 1024+misalignedOffset);
	DoTestFileReadCPU(128 * 1024+misalignedOffset);
	DoTestFileReadCPU(256 * 1024+misalignedOffset);
	DoTestFileReadCPU(512 * 1024+misalignedOffset);
	DoTestFileReadCPU(K1M+misalignedOffset);


	r = TheFs.Delete(_L("READCPUTEST"));
	test(r == KErrNone);
	}


LOCAL_C void DoTestFileWrite(TInt aBlockSize, TInt aFileSize = KMaxFileSize, TBool aUpdate = EFalse)
//
// Do Write benchmark
//
	{
	DataBuf.SetLength(aBlockSize);
	const TInt maxWriteCount = aFileSize / aBlockSize;

	TFileName testDir(_L("?:\\F32-TST\\"));
	testDir[0] = (TText) gDriveToTest;
	TInt r = TheFs.MkDir(testDir);
	test(r == KErrNone || r == KErrAlreadyExists);

	TFileName fileName;
	enum {EFileWriteDirectIO = 0x00001000, EFileWriteBuffered = 0x00000800};
	r = File.Temp(TheFs, testDir, fileName, EFileWrite | (gWriteCachingOn ? EFileWriteBuffered : EFileWriteDirectIO));
	test(r == KErrNone);

	if (aUpdate)
		{
		TInt r = File.SetSize(aFileSize);
		test(r == KErrNone);
		}

	TUint functionCalls = 0;

	TTime startTime;
	TTime endTime;
	TUint initTicks = 0;
	TUint finalTicks = 0;


	// we stop after the entire file has been written or after 10 seconds, whichever happens sooner
	RTimer timer;
	timer.CreateLocal();
	TRequestStatus reqStat;

	TInt pos = 0;
	File.Seek(ESeekStart, pos);

	timer.After(reqStat, 10000000); // After 10 secs

	startTime.HomeTime();
	initTicks = User::FastCounter();

	for (TInt i = 0 ; i<maxWriteCount && reqStat==KRequestPending; i++)
		{
		File.Write(pos, DataBuf, aBlockSize);

		pos += aBlockSize;
		if (pos > KMaxFileSize-aBlockSize)
			pos = 0;

		functionCalls++;
		}

	if (gFlushAfterWrite)
		{
		r = File.Flush();
		test_KErrNone(r)
		}

	// write file once only
	finalTicks = User::FastCounter();
	endTime.HomeTime();
//	TTimeIntervalMicroSeconds duration = endTime.MicroSecondsFrom(startTime);
	TTimeIntervalMicroSeconds duration = TInt64(finalTicks - initTicks) * TInt64(1000000) / TInt64(gFastCounterFreq) ;

	TInt dataTransferred = functionCalls * aBlockSize;
	TReal transferRate =
		TReal32(dataTransferred) /
		TReal(duration.Int64()) * TReal(1000000) / TReal(K1K); // KB/s
	test.Printf(_L("Write %7d bytes in %7d byte blocks:\t%11.3f KBytes/s (%d microsecs)\n"),
		dataTransferred, aBlockSize, transferRate, endTime.MicroSecondsFrom(startTime).Int64());

	timer.Close();

	File.Close();
	r = TheFs.Delete(fileName);
	test_KErrNone(r)

	return;
	}


LOCAL_C void TestFileWrite(TInt aFileSize = KMaxFileSize, TBool aMisalignedReadWrites = EFalse, TBool aUpdate = EFalse)
//
// Benchmark write method
//
	{
	ClearSessionDirectory();
	test.Next(_L("Benchmark write method"));

	_LIT(KLitUpdate,"update");
	_LIT(KLitAppend,"append");
	test.Printf(_L("FileSize %d %S MisalignedReadWrites %d\n"), aFileSize, aUpdate? &KLitUpdate : &KLitAppend, aMisalignedReadWrites);

	TInt misalignedOffset = aMisalignedReadWrites ? 1 : 0;

#if defined (SYMBIAN_TEST_EXTENDED_BUFFER_SIZES)
	DoTestFileWrite(1+misalignedOffset, aFileSize, aUpdate);
	DoTestFileWrite(2+misalignedOffset, aFileSize, aUpdate);
	DoTestFileWrite(4+misalignedOffset, aFileSize, aUpdate);
	DoTestFileWrite(8+misalignedOffset, aFileSize, aUpdate);
	DoTestFileWrite(16+misalignedOffset, aFileSize, aUpdate);
	DoTestFileWrite(32+misalignedOffset, aFileSize, aUpdate);
	DoTestFileWrite(64+misalignedOffset, aFileSize, aUpdate);
	DoTestFileWrite(128+misalignedOffset, aFileSize, aUpdate);
	DoTestFileWrite(256+misalignedOffset, aFileSize, aUpdate);
	DoTestFileWrite(512+misalignedOffset, aFileSize, aUpdate);
	DoTestFileWrite(1024+misalignedOffset, aFileSize, aUpdate);
	DoTestFileWrite(2 * 1024+misalignedOffset, aFileSize, aUpdate);
	DoTestFileWrite(4 * 1024+misalignedOffset, aFileSize, aUpdate);
	DoTestFileWrite(8 * 1024+misalignedOffset, aFileSize, aUpdate);
	DoTestFileWrite(16 * 1024+misalignedOffset, aFileSize, aUpdate);
	DoTestFileWrite(32 * 1024+misalignedOffset, aFileSize, aUpdate);
	DoTestFileWrite(64 * 1024+misalignedOffset, aFileSize, aUpdate);
	DoTestFileWrite(128 * 1024+misalignedOffset, aFileSize, aUpdate);
	DoTestFileWrite(256 * 1024+misalignedOffset, aFileSize, aUpdate);
	DoTestFileWrite(512 * 1024+misalignedOffset, aFileSize, aUpdate);
	DoTestFileWrite(1024 * 1024+misalignedOffset, aFileSize, aUpdate);
#else
	DoTestFileWrite(16+misalignedOffset, aFileSize, aUpdate);
	DoTestFileWrite(512+misalignedOffset, aFileSize, aUpdate);
	DoTestFileWrite(4096+misalignedOffset, aFileSize, aUpdate);
	DoTestFileWrite(32768+misalignedOffset, aFileSize, aUpdate);
	DoTestFileWrite(64 * 1024+misalignedOffset, aFileSize, aUpdate);
	DoTestFileWrite(K1M+misalignedOffset, aFileSize, aUpdate);
#endif
	}



LOCAL_C void DoTestFileWriteCPU(TInt aBlockSize)
//
// Benchmark CPU utilisation for Write method
//
// Write operations are performed for 10 seconds whilst a second thread executes floating point calculations
// The higher the number of calculations the less amount of CPU time has been used by the Write method.
//
	{
	DataBuf.SetLength(aBlockSize);

	TFileName testDir(_L("?:\\F32-TST\\"));
	testDir[0] = (TText) gDriveToTest;
	TInt r = TheFs.MkDir(testDir);
	test(r == KErrNone || r == KErrAlreadyExists);

	TFileName fileName;
	enum {EFileWriteDirectIO = 0x00001000, EFileWriteBuffered = 0x00000800};
	r = File.Temp(TheFs, testDir, fileName, EFileWrite | (gWriteCachingOn ? EFileWriteBuffered : EFileWriteDirectIO));
	test(r == KErrNone);

	TUint functionCalls = 0;
	TUint fltPntCalls = 0;
	RThread fltPntThrd;

	TBuf<6> buf = _L("Floaty");
	fltPntThrd.Create(buf, FloatingPointLoop, KDefaultStackSize, KHeapSize, KHeapSize, (TAny*) &fltPntCalls);

	TUint initTicks = 0;
	TUint finalTicks = 0;

	// up the priority of this thread so that we only run the floating point thread when this thread is idle
	RThread				thisThread;
	thisThread.SetPriority(EPriorityMuchMore);

	TRequestStatus req;
	fltPntThrd.Logon(req);

	RTimer timer;
	timer.CreateLocal();
	TRequestStatus reqStat;

	TInt pos = 0;
	File.Seek(ESeekStart, pos);

	timer.After(reqStat, KFloatingPointTestTime);
	initTicks = User::FastCounter();

	fltPntThrd.Resume();

	for (TInt i = 0 ; reqStat==KRequestPending; i++)
		{
		File.Write(DataBuf, aBlockSize);
		functionCalls++;
		}
	TUint fltPntCallsFinal = fltPntCalls;

	fltPntThrd.Kill(KErrNone);

	finalTicks = User::FastCounter();

	fltPntThrd.Close();
	User::WaitForRequest(req);

	TTimeIntervalMicroSeconds duration = TInt64(finalTicks - initTicks) * TInt64(1000000) / TInt64(gFastCounterFreq) ;

	TInt dataTransferred = functionCalls * aBlockSize;
	TReal transferRate =  TReal32(dataTransferred) /
						 TReal(duration.Int64()) * TReal(1000000) / TReal(K1K); // KB/s

	test.Printf(_L("Write %7d bytes in %7d byte blocks:\t%11.3f KBytes/s; %d Flt Calcs\n"),
				    dataTransferred, aBlockSize, transferRate, fltPntCallsFinal);

	timer.Close();

	File.Close();
	r = TheFs.Delete(fileName);
	test_KErrNone(r)

	return;
	}


LOCAL_C void TestFileWriteCPU(TBool aMisalignedReadWrites = EFalse)
//
// Benchmark CPU utilisation for Write method
//
	{
	ClearSessionDirectory();
	test.Next(_L("Benchmark Write method CPU Utilisation"));

	test.Printf(_L("MisalignedReadWrites %d\n"), aMisalignedReadWrites);
	TInt misalignedOffset = aMisalignedReadWrites ? 1 : 0;

	DoTestFileWriteCPU(1+misalignedOffset);
	DoTestFileWriteCPU(2+misalignedOffset);
	DoTestFileWriteCPU(4+misalignedOffset);
	DoTestFileWriteCPU(8+misalignedOffset);
	DoTestFileWriteCPU(16+misalignedOffset);
	DoTestFileWriteCPU(32+misalignedOffset);
	DoTestFileWriteCPU(64+misalignedOffset);
	DoTestFileWriteCPU(128+misalignedOffset);
	DoTestFileWriteCPU(256+misalignedOffset);
	DoTestFileWriteCPU(512+misalignedOffset);
	DoTestFileWriteCPU(1024+misalignedOffset);
	DoTestFileWriteCPU(2 * 1024+misalignedOffset);
	DoTestFileWriteCPU(4 * 1024+misalignedOffset);
	DoTestFileWriteCPU(8 * 1024+misalignedOffset);
	DoTestFileWriteCPU(16 * 1024+misalignedOffset);
	DoTestFileWriteCPU(32 * 1024+misalignedOffset);
	DoTestFileWriteCPU(64 * 1024+misalignedOffset);
	DoTestFileWriteCPU(128 * 1024+misalignedOffset);
	DoTestFileWriteCPU(256 * 1024+misalignedOffset);
	DoTestFileWriteCPU(512 * 1024+misalignedOffset);
	DoTestFileWriteCPU(K1M+misalignedOffset);
	}


LOCAL_C void TestFileSeek()
//
// Benchmark file seek method
//
	{
	ClearSessionDirectory();
	test.Next(_L("RFile::Seek method"));
	TInt increment=1789; // random number > cluster size
	TInt count=0;
	TInt pos=0;

	// Create test file
	TBuf8<1024> testdata(1024);
	RFile f;
	TInt r=f.Create(TheFs,_L("SEEKTEST"),EFileStream);
	test(r==KErrNone);
	count=64;
	while (count--)
		f.Write(testdata);
	TInt fileSize=count*testdata.MaxLength();

	pos=0;
	count=0;
	RTimer timer;
	timer.CreateLocal();
	TRequestStatus reqStat;
	timer.After(reqStat,10000000); // After 10 secs
	while(reqStat==KRequestPending)
		{
		TInt dum=(pos+=increment)%fileSize;
		f.Seek(ESeekStart,dum);
		count++;
		}
	test.Printf(_L("RFile::Seek operations in 10 secs == %d\n"),count);
	timer.Close();

	f.Close();
	TheFs.Delete(_L("SEEKTEST"));
	}

#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

LOCAL_C void CreateManyLargFiles(TInt aNumber)
//
// Make a directory with aNumber entries
//
	{
	RFile64 f;
	TInt maxEntry=aNumber;

	test.Printf(_L("Create a directory with %d entries\n"),aNumber);

	TFileName sessionPath;
	TInt r=TheFs.SessionPath(sessionPath);
	test(r==KErrNone);
	r=TheFs.MkDir(_L("\\F32-TST\\"));
	test((r==KErrNone)||(r==KErrAlreadyExists));
	r=TheFs.MkDir(_L("\\F32-TST\\BENCH_DELETE\\"));
	test((r==KErrNone)||(r==KErrAlreadyExists));
	TBuf8<8> WriteData =_L8("Wibbleuy");
	for (TInt i=0;i<maxEntry;i++)
		{
		TFileName baseName=_L("\\F32-TST\\BENCH_DELETE\\FILE");
		baseName.AppendNum(i);
		r=f.Replace(TheFs,baseName,EFileWrite);
		test(r==KErrNone);
		r = f.SetSize(K3GB);
		test(r==KErrNone);
		r=f.Write((K3GB-30),WriteData);
		test(r==KErrNone);
		f.Flush();
		f.Close();
		}

	test.Printf(_L("Test all entries have been created successfully\n"));
	TBuf8<8> ReadData;
	TInt64 Size=0;
	for (TInt j=0;j<=maxEntry;j++)
		{
		TFileName baseName=_L("\\F32-TST\\BENCH_DELETE\\FILE");
		baseName.AppendNum(j);

		TInt r=f.Open(TheFs,baseName,EFileRead);
		if (r!=KErrNone)
			{
			test(r==KErrNotFound && j==maxEntry);
			return;
			}
		ReadData.FillZ();
		r=f.Read((K3GB-30),ReadData);
		test(r==KErrNone);
		test(f.Size(Size)==KErrNone);
		test(K3GB == Size);
		test(ReadData==WriteData);
		f.Close();
		}
	}


LOCAL_C void TestLargeFileDelete()
//
// This test require MMC/SD card size >=4GB-2 in size
//
	{
	ClearSessionDirectory();
	test.Next(_L("Benchmark delete large file"));

	TInt64 total=0;

	TInt cycles=1;

	TInt i=0;

	//check Disk space and decide how many files to create
	TVolumeInfo volInfo;
    TInt r;

    r = TheFs.Volume(volInfo);
    test(r == KErrNone);

	TInt numberOfFiles = (TUint)(volInfo.iFree/(K4GB -2));
	test.Printf(_L("Number of large files =%d \n"),numberOfFiles);

	if(numberOfFiles<=0)
		{
		test.Printf(_L("Large File delete is skipped \n"));
		return;
		}

	for (; i<cycles; i++)
		{
	//	Create many files
		CreateManyLargFiles(numberOfFiles);

		test.Next(_L("Time the delete"));
	//	Now delete them and time it
		TTime startTime;
		startTime.HomeTime();

		for (TInt index=0;index<numberOfFiles;index++)
			{
			TFileName baseName=_L("\\F32-TST\\BENCH_DELETE\\FILE");
			baseName.AppendNum(index);

			TInt r=TheFs.Delete(baseName);
			test(r==KErrNone);
			}

		TTime endTime;
		endTime.HomeTime();
		TTimeIntervalMicroSeconds timeTaken;
		timeTaken=endTime.MicroSecondsFrom(startTime);
		TInt64 time=timeTaken.Int64();
		total+=time;
		}
//	We deleted cycles*numberOfFiles files in total microseconds
	TInt64 fileDeleteTime=total/(numberOfFiles*cycles);
	test.Next(_L("Benchmarked RFs::Delete()"));
	test.Printf(_L("Delete time per file = %d microseconds\n"),fileDeleteTime);

	CFileMan* fMan=CFileMan::NewL(TheFs);
	total=0;

	cycles=1;
	i=0;
	for (; i<cycles; i++)
		{
	//	Create many files
		CreateManyLargFiles(numberOfFiles);

		test.Next(_L("Time the delete"));
	//	Now delete them and time it
		TTime startTime;
		startTime.HomeTime();

		for (TInt index=0;index<numberOfFiles;index++)
			{
			TInt r=fMan->Delete(_L("\\F32-TST\\BENCH_DELETE\\FILE*"));
			test(r==KErrNone || r==KErrNotFound);
			}

		TTime endTime;
		endTime.HomeTime();
		TTimeIntervalMicroSeconds timeTaken;
		timeTaken=endTime.MicroSecondsFrom(startTime);
		TInt64 time=timeTaken.Int64();
		total+=time;
		}
//	We deleted cycles*numberOfFiles files in total microseconds
	fileDeleteTime=total/(numberOfFiles*cycles);
	test.Next(_L("Benchmarked CFileMan::Delete()"));
	test.Printf(_L("Delete time per file = %d microseconds\n"),fileDeleteTime);

	delete fMan;
}

#endif //SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API


LOCAL_C void CreateManyFiles(TInt aNumber)
//
// Make a directory with aNumber entries
//
	{
	RFile f;
	TInt maxEntry=aNumber;

	test.Printf(_L("Create a directory with %d entries\n"),aNumber);

	TFileName sessionPath;
	TInt r=TheFs.SessionPath(sessionPath);
	test(r==KErrNone);
	r=TheFs.MkDir(_L("\\F32-TST\\"));
	test((r==KErrNone)||(r==KErrAlreadyExists));
	r=TheFs.MkDir(_L("\\F32-TST\\BENCH_DELETE\\"));
	test((r==KErrNone)||(r==KErrAlreadyExists));

	for (TInt i=0;i<maxEntry;i++)
		{
		TFileName baseName=_L("\\F32-TST\\BENCH_DELETE\\FILE");
		baseName.AppendNum(i);
		r=f.Replace(TheFs,baseName,EFileRead);
		test(r==KErrNone);
		r=f.Write(_L8("Wibble"));
		test(r==KErrNone);
		f.Close();
		}

	test.Printf(_L("Test all entries have been created successfully\n"));
	for (TInt j=0;j<=maxEntry;j++)
		{
		TFileName baseName=_L("\\F32-TST\\BENCH_DELETE\\FILE");
		baseName.AppendNum(j);
		TInt r=f.Open(TheFs,baseName,EFileRead);
		if (r!=KErrNone)
			{
			test(r==KErrNotFound && j==maxEntry);
			return;
			}
		TBuf8<16> data;
		r=f.Read(data);
		test(r==KErrNone);
		test(data==_L8("Wibble"));
		f.Close();
		}
	}


LOCAL_C void TestFileDelete()
//
//
//
	{
	ClearSessionDirectory();
	test.Next(_L("Benchmark delete"));

	TInt64 total=0;
	TInt numberOfFiles=100;
	TInt cycles=1;

	TInt i=0;
	for (; i<cycles; i++)
		{
	//	Create many files
		CreateManyFiles(numberOfFiles);

		test.Next(_L("Time the delete"));
	//	Now delete them and time it
		TTime startTime;
		startTime.HomeTime();

		for (TInt index=0;index<numberOfFiles;index++)
			{
			TFileName baseName=_L("\\F32-TST\\BENCH_DELETE\\FILE");
			baseName.AppendNum(index);

			TInt r=TheFs.Delete(baseName);
			test(r==KErrNone);
			}

		TTime endTime;
		endTime.HomeTime();
		TTimeIntervalMicroSeconds timeTaken;
		timeTaken=endTime.MicroSecondsFrom(startTime);
		TInt64 time=timeTaken.Int64();
		total+=time;
		}
//	We deleted cycles*numberOfFiles files in total microseconds
	TInt64 fileDeleteTime=total/(numberOfFiles*cycles);
	test.Next(_L("Benchmarked RFs::Delete()"));
	test.Printf(_L("Delete time per file = %d microseconds\n"),fileDeleteTime);

	CFileMan* fMan=CFileMan::NewL(TheFs);
	total=0;
	numberOfFiles=100;
	cycles=1;
	i=0;
	for (; i<cycles; i++)
		{
	//	Create many files
		CreateManyFiles(numberOfFiles);

		test.Next(_L("Time the delete"));
	//	Now delete them and time it
		TTime startTime;
		startTime.HomeTime();

		for (TInt index=0;index<numberOfFiles;index++)
			{
			TInt r=fMan->Delete(_L("\\F32-TST\\BENCH_DELETE\\FILE*"));
			test(r==KErrNone || r==KErrNotFound);
			}

		TTime endTime;
		endTime.HomeTime();
		TTimeIntervalMicroSeconds timeTaken;
		timeTaken=endTime.MicroSecondsFrom(startTime);
		TInt64 time=timeTaken.Int64();
		total+=time;
		}
//	We deleted cycles*numberOfFiles files in total microseconds
	fileDeleteTime=total/(numberOfFiles*cycles);
	test.Next(_L("Benchmarked CFileMan::Delete()"));
	test.Printf(_L("Delete time per file = %d microseconds\n"),fileDeleteTime);

	delete fMan;
}


/*
TInt maxDirEntry=200;
LOCAL_C void TestDirRead()
//
// Benchmark directory read method
//
	{

	ClearSessionDirectory();
	test.Next(_L("Benchmark directory read method"));
// Create one test entry
	RFile f;
	f.Create(TheFs,_L("ONE.XXX"),EFileStream);
	f.Close();
	TTime start;
	start.HomeTime();
	TInt i=0;
	for (i=0;i<maxDirEntry;i++)
		{
		CDir* dirPtr;
		TheFs.GetDir(_L("*"),KEntryAttMaskSupported,ESortByName,dirPtr);
		delete dirPtr;
		}
	TTime end;
	end.HomeTime();
	DirReadOne=end.MicroSecondsFrom(start);
// Create lost of test entries
	for (i=0;i<maxDirEntry;i++)
		{
		TBuf<12> baseName(_L("MANY"));
		baseName.AppendNum(i,EHex);
		baseName.Append(_L(".TXT"));
		RFile f;
		f.Create(TheFs,baseName,EFileStream);
		f.Close();
		}
	start.HomeTime();
	CDir* dirPtr;
	TheFs.GetDir(_L("*"),KEntryAttMaskSupported,ESortByName,dirPtr);
	delete dirPtr;
	end.HomeTime();
	DirReadMany=end.MicroSecondsFrom(start);
// Select one entry from lots
	start.HomeTime();
	TheFs.GetDir(_L("*.XXX"),KEntryAttMaskSupported,ESortByName,dirPtr);
	end.HomeTime();
	test(dirPtr->Count()==1);
	delete dirPtr;
	DirMatchOne=end.MicroSecondsFrom(start);
	}


void LOCAL_C PrintDirResults()
//
// Print results of Directory Benchmark
//
	{
	test.Printf(_L("\nBenchmark: Dir Results\n"));
	test.Printf(_L("Read one entry %d times = %d ms\n"),maxDirEntry,DirReadOne.Int64().GetTInt()/1000);
	test.Printf(_L("Read %d entries = %d ms\n"),maxDirEntry,DirReadMany.Int64().GetTInt()/1000);
	test.Printf(_L("Match 1 entry from %d entries = %d ms\n"),maxDirEntry,DirMatchOne.Int64().GetTInt()/1000);
	test.Printf(_L("Press Enter to continue\n\n"));
	test.Getch();
	}
*/


LOCAL_C void TestMkDir()
	{
	test.Next(_L("Benchmark MkDir"));
	ClearSessionDirectory();

	TTime startTime;
	TTime endTime;
	TTimeIntervalMicroSeconds timeTaken(0);
	startTime.HomeTime();

	const TInt KNumDirEntries = 100;
	for (TInt n=0; n<KNumDirEntries; n++)
		{
		TFileName dirName = _L("\\F32-TST\\DIR_");
		dirName.AppendNum(n);
		dirName.Append(_L("\\"));
		TInt r = TheFs.MkDir(dirName);
		test(r == KErrNone);
		}

	endTime.HomeTime();
	timeTaken=endTime.MicroSecondsFrom(startTime);
	TInt timeTakenInMs = I64LOW(timeTaken.Int64() / 1000);
	test.Printf(_L("Time taken to create %d entries = %d ms\n"), KNumDirEntries, timeTakenInMs);
	}


// Allocate Data Buffers for Read/Write Tests
void AllocateBuffers()
	{
	test.Printf(_L("Allocate Buffers -"));

	if (gFragSharedMemory || gSharedMemory)
		{
		test.Printf(_L("Shared Memory\n"));

		RLoader l;
		test(l.Connect()==KErrNone);
		test(l.CancelLazyDllUnload()==KErrNone);
		l.Close();

		test.Printf(_L("Initialise\n"));
		TInt r = UserHal::PageSizeInBytes(PageSize);
		test(r==KErrNone);

		test.Printf(_L("Loading test driver\n"));
		r = User::LoadLogicalDevice(KSharedChunkLddName);
		test(r==KErrNone || r==KErrAlreadyExists);

		test.Printf(_L("Opening channel\n"));
		r = Ldd.Open();
		test(r==KErrNone);

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

		TUint aCreateFlags = EMultiple|EOwnsMemory;
	    TCommitType aCommitType = EContiguous;

	    TUint TotalChunkSize = ChunkSize;  // rounded to nearest Page Size

		TUint ChunkAttribs = TotalChunkSize|aCreateFlags;
		r = Ldd.CreateChunk(ChunkAttribs);
		test(r==KErrNone);

		if (gSharedMemory)
			{
		    test.Printf(_L("Commit Contigouos Memory\n"));
		    r = Ldd.CommitMemory(aCommitType,TotalChunkSize);
			test(r==KErrNone);
			}
		else
			{
			test.Printf(_L("Commit Fragmented Memory\n"));

			// Allocate Pages in reverse order to maximise memory fragmentation
			TUint i = ChunkSize;
			do
				{
				i-=PageSize;
				test.Printf(_L("Commit %d\n"), i);
				r = Ldd.CommitMemory(aCommitType|i,PageSize);
				test(r==KErrNone);
				}while (i>0);
/*
			for (TInt i = (ChunkSize-PageSize); i>=0; )
				{
				test.Printf(_L("Commit %d\n"), i);
				r = Ldd.CommitMemory(aCommitType|i,PageSize);
				test(r==KErrNone);
				i-=PageSize;
				}
*/
			}

		test.Printf(_L("\nOpen user handle\n"));
		r = Ldd.GetChunkHandle(TheChunk);
		test(r==KErrNone);

		DataBuf.Set(TheChunk.Base(),KMaxFileSize, KMaxFileSize);
		}
	else
		{
		test.Printf(_L("Heap Memory\n"));
		DataBufH = HBufC8::New(KMaxFileSize);
		test(DataBufH != NULL);

		DataBuf.Set(DataBufH->Des());
		}
	}


void DeAllocateBuffers()
	{
	test.Printf(_L("DeAllocate Buffers -"));

	if (gFragSharedMemory || gSharedMemory)
	{
		test.Printf(_L("Shared Memory\n"));
		test.Printf(_L("Close user chunk handle\n"));
		TheChunk.Close();

		test.Printf(_L("Close kernel chunk handle\n"));
		TInt r = Ldd.CloseChunk();
		test(r==1);

		test.Printf(_L("Check chunk is destroyed\n"));
		r = Ldd.IsDestroyed();
		test(r==1);

		test.Printf(_L("Close test driver\n"));
		Ldd.Close();
		}
	else
		{
		test.Printf(_L("Heap Memory\n"));
		test.Printf(_L("Delete Heap Buffer\n"));
		delete DataBufH;
		}
	}

void ParseCommandLine()
	{
	TBuf<0x100> cmd;
	User::CommandLine(cmd);
	TLex lex(cmd);

    for (TPtrC token=lex.NextToken(); token.Length() != 0;token.Set(lex.NextToken()))
		{
		if (token.MatchF(RProcess().FileName())==0)
			{
			continue;
			}

		if (token.CompareF(_L("-m"))== 0)
			{
			gMisalignedReadWrites = ETrue;
			continue;
			}
		if (token.CompareF(_L("-r"))== 0)
			{
			gReadCachingOn = EFalse;
			continue;
			}
		if (token.CompareF(_L("+r"))== 0)
			{
			gReadCachingOn = ETrue;
			continue;
			}
		if (token.CompareF(_L("-w"))== 0)
			{
			gWriteCachingOn = EFalse;
			continue;
			}
		if (token.CompareF(_L("+w"))== 0)
			{
			gWriteCachingOn = ETrue;
			continue;
			}

		if (token.CompareF(_L("-f"))== 0)
			{
			gFlushAfterWrite = EFalse;
			continue;
			}
		if (token.CompareF(_L("+f"))== 0)
			{
			gFlushAfterWrite = ETrue;
			continue;
			}
		if (token.CompareF(_L("+s"))== 0)
			{
			gSharedMemory = ETrue;
			continue;
			}
		if (token.CompareF(_L("+x"))== 0)
			{
			gFragSharedMemory = ETrue;
			continue;
			}

		test.Printf(_L("CLP=%S\n"),&token);

		if(token.Length()!=0)
			{
			gDriveToTest=token[0];
			gDriveToTest.UpperCase();
			}
		else
			gDriveToTest='C';

#if defined SYMBIAN_TEST_COPY
		token.Set(lex.NextToken());
		if(token.Length()!=0)
			{
			gDriveToTest2=token[0];
			gDriveToTest2.UpperCase();
			}
		else
			gDriveToTest2='C';
		test.Printf(_L("CLP2=%S\n"),&token);
#endif

		}
	}


GLDEF_C void CallTestsL(void)
//
// Call all tests
//
	{
	test.Title();
	test.Start(_L("Start Benchmarking ..."));

	test.Next(gSessionPath);

	ParseCommandLine();

	AllocateBuffers();
	RProcess().SetPriority(EPriorityBackground);

	TInt r = HAL::Get(HAL::EFastCounterFrequency, gFastCounterFreq);
	test(r == KErrNone);
	test.Printf(_L("HAL::EFastCounterFrequency %d\n"), gFastCounterFreq);

	test.Printf(_L("gReadCachingOn %d  gWriteCachingOn %d gFlushAfterWrite %d\n"), gReadCachingOn, gWriteCachingOn, gFlushAfterWrite);

	TestFileSeek();

	// read once
	TestFileRead(KMaxFileSize, gMisalignedReadWrites, EFalse);

	// re-read
	TestFileRead(KMaxFileSize, gMisalignedReadWrites, ETrue);

	TestFileReadCPU(gMisalignedReadWrites);

	// append to file
	TestFileWrite(KMaxFileSize, gMisalignedReadWrites, EFalse);

	// update (overwrite) file
	TestFileWrite(KMaxFileSize, gMisalignedReadWrites, ETrue);

	TestFileWriteCPU(gMisalignedReadWrites);

	TestFileDelete();

//	TestDirRead();
//	PrintDirResults();
#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
	TestLargeFileDelete();
#endif //SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

	TestMkDir();

	RecursiveRmDir(gSessionPath);

	DeAllocateBuffers();

	test.End();
	test.Close();
	}
