// 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 <e32hal.h>

#include <hal.h>

#include <e32math.h>

#include <e32ldr.h>

#include <e32ldr_private.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

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

const TInt64 K3GB   = 3 * KGb;								// 3GB

const TInt64 K4GB   = 4 * KGb;								// 4GB

#endif //SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

#if defined(__WINS__)

static TInt KMaxFileSize = 256 * K1K;					// 256K

//static TInt KMaxFileSize = K1M;						// 1M

#else

//static TInt KMaxFileSize = 256 * K1K;					// 256K

//static TInt KMaxFileSize = K1M;						// 1M

static TInt KMaxFileSize = K2M;							// 2M

#endif

const TTimeIntervalMicroSeconds32 KFloatingPointTestTime = 10000000;	// 10 seconds

static const TInt KHeapSize = 0x4000;

static TPtr8 DataBuf(NULL, KMaxFileSize,KMaxFileSize);

static HBufC8* DataBufH = NULL;

static RSharedChunkLdd Ldd;

static RChunk TheChunk;

static TInt PageSize;

const TUint ChunkSize = KMaxFileSize;

static RFile File, File2;

#if defined SYMBIAN_TEST_COPY

static TChar gDriveToTest2;

#endif

// if enabled, Read and Write operations are not boundary aligned.

static TBool gMisalignedReadWrites = EFalse;

// read & write caching enabled flags - may be overridden by +/-r +/-w command line switches

static TBool gReadCachingOn  = EFalse;

static TBool gWriteCachingOn = EFalse;

// if enabled, timings are for write AND flush

static TBool gFlushAfterWrite = ETrue;

// if enabled, contiguous shared memory is used for Data buffer

static TBool gSharedMemory = EFalse;

// if enabled, fragmented shared memory is used for Data buffer

static TBool gFragSharedMemory = EFalse;

// if enabled, file is opened in EFileSequential (non-Rugged) file mode for write tests

// - may be overridden by +/-q command line switches

static TBool gFileSequentialModeOn = EFalse;

static TInt gFastCounterFreq;

static 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_KErrNone(r);

	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_KErrNone(r);

			}

		}

	delete pD;

	r=TheFs.RmDir(aDes);

	test_KErrNone(r);

	}

void static ClearSessionDirectory()

//

// Delete the contents of F32-TST

//

	{

	TParse sessionPath;

	TInt r=TheFs.Parse(_L("\\F32-TST\\"),_L(""),sessionPath);

	test_KErrNone(r);

	RecursiveRmDir(sessionPath.FullName());

	r=TheFs.MkDir(sessionPath.FullName());

	test_KErrNone(r);

	}

static 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_KErrNone(r);

	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_KErrNone(r);

//	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_KErrNone(r);

#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_KErrNone(r);

			if (DataBuf.Length() == 0)

				break;

#if defined SYMBIAN_TEST_COPY

			r = File2.Write(DataBuf, readLen);

			test_KErrNone(r);

#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_KErrNone(r);

	return;

	}

static 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);

#ifndef __WINS__	// Block sizes are too large for the emulator

	DoTestFileRead(512 * 1024+misalignedOffset, aFileSize, aReRead);

	DoTestFileRead(1024 * 1024+misalignedOffset, aFileSize, aReRead);

#endif

#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

	}

static TInt FloatingPointLoop(TAny* funcCount)

	{

	TUint& count = *(TUint*) funcCount;

	TReal eq = KPi;

	FOREVER

		{

		eq *= eq;

		count++;

		}

	}

static 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_KErrNone(r);

	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_KErrNone(r);

		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;

	}

static 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_KErrNone(r);

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

#ifndef __WINS__	// Block sizes are too large for the emulator

	DoTestFileReadCPU(512 * 1024+misalignedOffset);

	DoTestFileReadCPU(K1M+misalignedOffset);

#endif

	r = TheFs.Delete(_L("READCPUTEST"));

	test_KErrNone(r);

	}

static 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_Value(r, r == KErrNone || r == KErrAlreadyExists);

	TFileName fileName;

	r = File.Temp(TheFs, testDir, fileName, EFileWrite | (gFileSequentialModeOn ? EFileSequential : 0) 

											| (gWriteCachingOn ? EFileWriteBuffered : EFileWriteDirectIO));

	test_KErrNone(r);

	if (aUpdate)

		{

		TInt r = File.SetSize(aFileSize);

		test_KErrNone(r);

		}

	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)