// 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

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

#endif //SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

#if defined(__WINS__)

#else

#endif

const TTimeIntervalMicroSeconds32 KFloatingPointTestTime = 10000000;	// 10 seconds

const TUint ChunkSize = KMaxFileSize;

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

// if enabled, timings are for write AND flush

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

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

//

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

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

			}

		}

	delete pD;

	r=TheFs.RmDir(aDes);

	}

//

// Delete the contents of F32-TST

//

	{

	TParse sessionPath;

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

	RecursiveRmDir(sessionPath.FullName());

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

	}

//

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

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

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

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

			if (DataBuf.Length() == 0)

				break;

#if defined SYMBIAN_TEST_COPY

			r = File2.Write(DataBuf, readLen);

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

	return;

	}

//

// 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

	}

	{

	TUint& count = *(TUint*) funcCount;

	TReal eq = KPi;

	FOREVER

		{

		eq *= eq;

		count++;

		}

	}

//

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

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

		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;

	}

//

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

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

	}

//

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

	TFileName fileName;

	if (aUpdate)

		{

		TInt r = File.SetSize(aFileSize);

		}

	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)

		{