// Copyright (c) 2004-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:

// tests read/write throughput on two drives simultaneously

// 

//

//! @file f32test\concur\t_cfsbench.cpp

#define	__E32TEST_EXTENSION__

#include <f32file.h>

#include <e32test.h>

#include <f32dbg.h>

#include "t_server.h"

#include "t_tdebug.h"

//IMPORT_C TUint32 DebugRegister();

GLDEF_D RTest test(_L("T_CFSBENCH"));

GLDEF_D	RFs TheFs;

LOCAL_D TFullName gFsName;

LOCAL_D TFullName gFsName1;

LOCAL_D TFullName gFsName2;

LOCAL_D TFullName gOldFsName;

LOCAL_D TFullName gNewFsName;

LOCAL_D TBool     gNoMedia = ETrue;

_LIT(KFsFile, "CFAFSDLY");

_LIT(KFsName, "DelayFS");

LOCAL_D const TInt32 KSecond = 1000000;

LOCAL_D const TInt32 KTimeBM = 20;

LOCAL_D const TInt32 KBufLen = 0x100;

LOCAL_D const TInt32 KMaxLag = 4;

LOCAL_D TBool gVerbose = EFalse;

TBuf16<KBufLen> gResults;

const TInt KMaxFileSize = (4*1024*1024);

const TInt KMinBufferSize = (16);

const TInt KMaxBufferSize = (512*1024);

const TInt KMaxIter = 17;

TBool gReadTests = EFalse;

TBool gWriteTests = EFalse;

TBool gAsyncTests = EFalse;

TBool gSyncTests = EFalse;

LOCAL_C TInt32 GetSpeed(TInt aOps, TInt aBufSize, TInt64 aDtime)

/// Calculate and return the throughput from the umber of blocks transferred

/// and the elapsed time.

	{

	TInt64 dsize = MAKE_TINT64(0, aOps) * MAKE_TINT64(0, aBufSize) * MAKE_TINT64(0, KSecond);

	TInt32 speed = I64LOW((dsize + aDtime/2) / aDtime);

	return speed;

	}

LOCAL_C TBool DriveIsOK(TChar c)

/// Test that a selected drive leter is OK to write files.

	{

	TInt r;

	TInt drv;

	r=TheFs.CharToDrive(c, drv);

	if (r != KErrNone)

		return EFalse;

	TDriveInfo info;

	r=TheFs.Drive(info,drv);

	test_KErrNone(r);

	return (info.iDriveAtt != 0 && !(info.iDriveAtt & KDriveAttRom));

	}

LOCAL_C TChar MountTestFileSystem(TInt aDrive)

//

// Mount a new CTestFileSystem on the drive under test

//

	{

	TInt r;

	TBuf<64> b;

	TChar c;

	r=TheFs.DriveToChar(aDrive,c);

	test_KErrNone(r);

	b.Format(_L("Mount test file system on %c:"),(TUint)c);

	test.Next(b);

	r=TheFs.AddFileSystem(KFsFile);

	test_Value(r, r == KErrNone || r==KErrAlreadyExists);

	r=TheFs.FileSystemName(gOldFsName,aDrive);

	test_Value(r, r == KErrNone || r==KErrNotFound);

	TDriveInfo drv;

	r = TheFs.Drive(drv, aDrive);

	test_KErrNone(r);

	gNoMedia = (drv.iType == EMediaUnknown || drv.iType == EMediaNotPresent);

	if (gOldFsName.Length() > 0)

		{

		TTest::Printf(_L("Dismount %C: %S"), (TUint)c, &gOldFsName);

		r=TheFs.DismountFileSystem(gOldFsName,aDrive);

		test_KErrNone(r);

		}

	r=TheFs.MountFileSystem(KFsName,aDrive);

	test_KErrNone(r);

	r=TheFs.FileSystemName(gNewFsName,aDrive);

	test_KErrNone(r);

	test(gNewFsName.CompareF(KFsName)==0);

	return c;

	}

LOCAL_C void UnmountFileSystem(TInt aDrive)

/// Unmount a test filesystem and mount the old one.

	{

	TChar c;

	TInt r=TheFs.DriveToChar(aDrive,c);

	test_KErrNone(r);

	r=TheFs.DismountFileSystem(gNewFsName,aDrive);

	test_KErrNone(r);

	// if there's no media present, don't try to mount it

	if (gNoMedia)

		{

		test.Printf(_L("No media on %C: so don't remount it"), (TUint)c);

		}

	else if (gOldFsName.Length() > 0)

		{

		test.Printf(_L("Mount    %C: %S"), (TUint)c, &gOldFsName);

		r=TheFs.MountFileSystem(gOldFsName,aDrive);

		test_KErrNone(r);

		}

	if (r != KErrNone)

		test.Printf(_L("Error %d remounting %S on %C\n"), r, &gOldFsName, (TUint)c);

	}

LOCAL_C void RemountFileSystem(TInt aDrive, TBool aSync)

/// Unmount and remount the file system on the specified drive in the

/// selected mode.

/// @param aDrive Drive number (EDriveC etc.).

/// @param aSync  Mount synchronous if true, asynchronous if not.

	{

	TChar c;

	TInt r=TheFs.DriveToChar(aDrive,c);

	r=TheFs.FileSystemName(gFsName, aDrive);

	test_Value(r, r == KErrNone || r==KErrNotFound);

	if (gFsName.Length() > 0)

		{

		r=TheFs.DismountFileSystem(gFsName, aDrive);

		if(r!=KErrNone)

			{

			test.Printf(_L("Error = %d"),r);

			test(EFalse);

			}

		}

	TBufC<16> type = _L("asynchronous");

	if (aSync)

		type = _L("synchronous");

	if (gVerbose)

		test.Printf(_L("Mount filesystem %c: %-8S as %S\n"), (TUint)c, &gFsName, &type);

#ifdef __CONCURRENT_FILE_ACCESS__

	r=TheFs.MountFileSystem(gFsName, aDrive, aSync);

#else

	r=TheFs.MountFileSystem(gFsName, aDrive);

#endif

	test_KErrNone(r);

	}

enum TOper

	{

	ERead,

	EWrite

	};

// ---------------------------------------------------------------------------

class RFileOps

/// Do operations on a file.

	{

public:

	RFileOps();

	enum TOper

	{

	ERead,

	EWrite

	};

	TInt Init(TChar dr, TInt aBufSize);

	void DeInit();

	void CalculateFreeSpace();

	TInt Open(TOper aOper);

	TInt Close();

	TInt Delete();

	TInt Reset();

	TInt Erase();

	TInt Write();

	TInt Read();

	TInt End();

	TInt CreateReadFile();

public:

	TFileName      iNameRead;

	TFileName      iNameWrite;

	RFile          iF;

	HBufC8* iBuffer[KMaxLag];

	TPtr8* iBufPtr[KMaxLag];

	TRequestStatus iStatus[KMaxLag];

	TInt iPtr;

	TInt iNum;

	TInt iOps;

	TInt iMax;

	TBool iOpen;

	TInt iBufSize;

	TChar iDrvCh;

	TInt64 iFree;

	TInt iFileSize;

	// counters

	TInt iFileWraps;

	TInt iFileSyncAccesses;

	TInt iFileAsyncAccesses;

	};

RFileOps::RFileOps() : iPtr(0), iNum(0), iOps(0), iMax(0), iOpen(EFalse)

	{

	for (TInt i = 0; i < KMaxLag; i++)

		{

		iStatus[i] = KErrNone;

		iBuffer[i] = NULL;

		iBufPtr[i] = NULL;

		}

	}

TInt RFileOps::Init(TChar aDrvCh, TInt aBufSize)

	{

	TInt r = KErrNone;

	test(!iOpen);

	iDrvCh = aDrvCh;

	iBufSize = aBufSize;

	iNameWrite.Format(_L("%c:\\TESTWT"), (TUint)aDrvCh);

	iNameRead.Format(_L("%c:\\TESTRD"), (TUint)aDrvCh);

	for (TInt i = 0; i < KMaxLag; i++)

		{

		iStatus[i] = KErrNone;

		iBuffer[i] = HBufC8::NewL(aBufSize);

		if (iBuffer[i] == NULL)

			return KErrNoMemory;

		iBufPtr[i] = new TPtr8(iBuffer[i]->Des());

		//TPtr8 buffer(iBuffer[i]->Des());

		//buffer.Fill(TChar('_'), aBufSize);

		iBufPtr[i]->Fill(TChar('_'), aBufSize);

		}

	return r;

	}

void RFileOps::DeInit()

	{

	test(!iOpen);

	for (TInt i = 0; i < KMaxLag; i++)

		{

		delete iBuffer[i];

		iBuffer[i] = NULL;

		delete iBufPtr[i];

		iBufPtr[i] = NULL;

		}

	}

void RFileOps::CalculateFreeSpace()

	{

	TVolumeInfo vol;

	TInt        drv;

	TInt r = TheFs.CharToDrive(iDrvCh, drv);

	if (r != KErrNone)

		TTest::Fail(HERE, _L("CharToDrive(%c) returned %d"), (TUint)iDrvCh, r);

	r = TheFs.Volume(vol, drv);

	if (r != KErrNone)

		TTest::Fail(HERE, _L("Volume(%c:) returned %d"), (TUint)iDrvCh, r);

	iFree = vol.iFree;

	TInt64 fileSize = iFree / 2;

	if (fileSize > KMaxFileSize)

		fileSize = KMaxFileSize;

	iFileSize = I64LOW(fileSize);

	// calculate the number of buffers to use

	// if we assume we'll be able to use half the available disk space

	TInt max = iFileSize / iBufSize;

	iMax = max;

    if (gVerbose)

		{

		test.Printf(_L("Free space on drive %c = %d KB\n"), (TUint)iDrvCh, I64LOW(iFree/1024));

		test.Printf(_L("File Size = %d KB. Using %d buffers of size %d\n"), iFileSize/1024, iMax, iBufSize);

		}

	}

TInt RFileOps::Open(TOper aOper)

/// Open the file for testing, give error if there is not enough space for it.

	{

	TInt r;

	test(!iOpen);

	// reset counters

	iFileWraps = 0;

	iFileSyncAccesses = 0;

	iFileAsyncAccesses = 0;

	TheFs.Delete(iNameWrite);

	if (aOper == ERead)

		{

		r = iF.Open(TheFs, iNameRead, EFileStreamText | EFileRead);

		if (r != KErrNone)

			return r;

		TInt sizeFile = 0;

		r = iF.Size(sizeFile);

		test_KErrNone(r);

        if (gVerbose)

			{

			test.Printf(_L("File Size = %d, %d buffers of size %d\n"), sizeFile, iMax, iBufSize);

			}

		iMax = sizeFile / iBufSize;

		}

	else

		{

		CalculateFreeSpace();

		if (iMax < KMaxLag)

			{

			test.Printf(_L("Insufficient free space on drive %c, deleting read file\n"), (TUint)iDrvCh);

			TInt maxOld = iMax;

			TheFs.Delete(iNameRead);

			CalculateFreeSpace();

			test.Printf(_L("Old available buffers = %d, new available buffers = %d\n"), maxOld, iMax);

			}

			if (iMax < KMaxLag)

				TTest::Fail(HERE, _L("Not enough space to do test, only %d KB available. Only %d buffers of %d bytes available"),

												  I64LOW(iFree/1024), iMax, iBufSize );

		r = iF.Replace(TheFs, iNameWrite, EFileStreamText | EFileWrite);

		}

	if (r == KErrNone)

		iOpen = ETrue;

	Reset();

	return r;

	}

// Close and delete the file, returning the number of operations done.

TInt RFileOps::Close()

	{

	if (!iOpen)

		return 0;

	iF.Close();

	iOpen = EFalse;

	// always delete the write file

	TheFs.Delete(iNameWrite);

	return iNum;

	}

TInt RFileOps::Delete()

	{

	TInt r = TheFs.Delete(iNameRead);

	r = TheFs.Delete(iNameWrite);

	return r;

	}

TInt RFileOps::Reset()

/// Reset all of the counts.

	{

	TInt err = KErrNone;

	iPtr = 0;

	iNum = 0;

	iOps = 0;

	return err;

	}

TInt RFileOps::CreateReadFile()

	{

	TInt r = KErrNone;

	CalculateFreeSpace();	// get iMax

	if (iOpen)

		iF.Close();

	iOpen = EFalse;

	r = iF.Open(TheFs, iNameRead, EFileStreamText | EFileRead);

	if (r == KErrNone)

		{

		if (gVerbose)

			test.Printf(_L("temp file already exists.\n"));

		iF.Close();

		return r;

		}

	r = iF.Replace(TheFs, iNameRead, EFileStreamText | EFileWrite);

	if (r != KErrNone)

		return r;

	iOpen = ETrue;

	Reset();

	test.Printf(_L("Creating temp file on drive %c of size %d..."), (TUint)iDrvCh, iFileSize);

	HBufC8* buf = HBufC8::NewL(KMaxBufferSize);

	TPtr8 bufptr(buf->Des());

	bufptr.Fill(TChar('_'), KMaxBufferSize);

	test(buf != NULL);

	for (TInt pos=0; pos<iFileSize; pos+= buf->Length())

		{

		r = iF.Write(pos, bufptr);

		test_KErrNone(r);

		}

	delete buf; buf = NULL;

	//	if (gVerbose)

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

	iF.Close();

	iOpen = EFalse;

	return r;

	}

TInt RFileOps::Write()

/// If there is a free buffer available, start a write.

	{

	if (!iOpen)

		return 0;

	while (iNum < iOps && iStatus[iNum%KMaxLag] != KRequestPending)

		{

		TInt status = iStatus[iNum%KMaxLag].Int();

		test (status == KErrNone);

		iNum++;

		}

	if (iOps < KMaxLag || iStatus[iPtr] != KRequestPending)

		{

		TInt pos = iOps%iMax * iBufSize;

		iF.Write(pos, *iBufPtr[iPtr], iStatus[iPtr]);

		TInt status = iStatus[iPtr].Int();

        if (gVerbose)

			{

			test.Printf(_L("Writing buf #%d to drive %c at pos %d, status = %d\n"), 

				iPtr, (TUint)iDrvCh, pos, status);

			}

		test (status == KErrNone || status == KRequestPending);

		iOps++;

		iPtr++;

		iPtr %= KMaxLag;

		return 1;

		}

	return 0;

	}

TInt RFileOps::Read()

/// If there is a free buffer available, start a read.

	{

	if (!iOpen)

		return 0;