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

// Do benchmarking comparisons in asynchronous and synchronous modes.

//

//

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

#include <f32file.h>

#include <e32test.h>

#include <f32dbg.h>

#include "t_server.h"

#include "t_tdebug.h"

// The following #defines are for using older (and less accurate) benchmark

// timings.  They use multiple threads to get the operations simultaneous

// but this is inherrently inaccurate (it depends whether one of them starts

// and/or ends before the other how accurate the timings are).  If you leave

// them both commented out then the tests will be done in a single thread

// using asynchronous file operations, thus avoiding the problem.

// Uncomment the following if you want to test asynchronous file operations

// using two threads rather than in a single thread.

// #define TEST_ASYNC_IN_THREAD

// Uncomment the following if you want to test using synchronous file

// operations, using two threads to do both at once.

// #define TEST_SYNC_IN_THREAD

struct TStats

//

// Statistics -- size and time of operations.

//

	{

	TInt64 iSize;

	TInt64 iTime;

	void Init() { iSize = 0; iTime = 0; }

	};

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;

#if defined(TEST_SYNC_IN_THREAD) || defined(TEST_ASYNC_IN_THREAD)

LOCAL_D TInt      gThreadNumber = 0;

#endif

LOCAL_D RMutex gDataLock;

LOCAL_D TStats gWrStats;

LOCAL_D TStats gRdStats;

_LIT(KFsFile, "CFAFSDLY");

_LIT(KFsName, "DelayFS");

LOCAL_D const TInt32 KSecond = 1000000;

LOCAL_D const TInt32 KTimeBM = 20;

LOCAL_D const TInt32 KNumBuf = 100;

LOCAL_D const TInt32 KBufLen = 0x100;

LOCAL_D const TInt32 KMaxThr = 10;

LOCAL_D const TInt32 KMaxLag = 4;

LOCAL_D TBuf8<KBufLen> gBufferArr[KMaxThr][KNumBuf];

LOCAL_D TRequestStatus gStatusArr[KMaxThr][KNumBuf];

LOCAL_C void AddStats(TStats& aStats, TInt64 aSize, TInt64 aTime)

/// Add values to the statistics.

	{

	gDataLock.Wait();

	aStats.iSize += aSize;

	aStats.iTime += aTime;

	gDataLock.Signal();

	}

LOCAL_C TInt GetSpeed(TStats& aStats)

/// Calculate and return the data throughput from the statistics, rounded.

	{

	gDataLock.Wait();

	TInt speed = I64LOW((aStats.iSize + aStats.iTime/2) / aStats.iTime);

	gDataLock.Signal();

	return speed;

	}

LOCAL_C TInt32 GetSpeed(TInt aOps, 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, KBufLen) * 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(r==KErrNone);

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

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

	test.Next(b);

	r=TheFs.AddFileSystem(KFsFile);

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

	r=TheFs.FileSystemName(gOldFsName,aDrive);

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

	TDriveInfo drv;

	r = TheFs.Drive(drv, aDrive);

	test(r == KErrNone);

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

		}

	r=TheFs.MountFileSystem(KFsName,aDrive);

	test(r==KErrNone);

	r=TheFs.FileSystemName(gNewFsName,aDrive);

	test(r==KErrNone);

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

	r=TheFs.DismountFileSystem(gNewFsName,aDrive);

	test(r==KErrNone);

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

		}

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

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

	}

enum TOper

	{

	ERead,

	EWrite

	};

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

#if defined(TEST_SYNC_IN_THREAD)

LOCAL_C TInt testSyncAccess(TAny* aData)

///

/// Test read file handling.

///

/// @param aData pointer to the thread data area

    {

	TThreadData& data = *(TThreadData*)aData;

	TFileName fileName = data.iFile;

	TBool     dowrite  = (data.iData != NULL);

	RFs   myFs;

	TInt r = myFs.Connect();

	TEST(r==KErrNone);

	r = myFs.SetSessionPath(gSessionPath);

	if (r != KErrNone)

		TTest::Fail(HERE, _L("SetSessionPath returned %d"), r);

	TVolumeInfo vol;

	TInt        drv;

	r = myFs.CharToDrive(fileName[0], drv);

	if (r != KErrNone)

		TTest::Fail(HERE, _L("CharToDrive(%c) returned %d"), fileName[0], r);

	r = myFs.Volume(vol, drv);

	if (r != KErrNone)

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

	TInt maxwrite = TInt(vol.iFree / 2 - KBufLen);

	if (maxwrite < KBufLen*2)

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

					 TInt(vol.iFree/1024));

    RFile f;

	RTimer timer;

	TTime startTime;

	TTime endTime;

	TTimeIntervalMicroSeconds timeTaken;

	TBuf8<KBufLen> buff;

	TRequestStatus tstat;

	TInt wrnum = 0;

	TInt rdnum = 0;

	timer.CreateLocal();

	if (dowrite)

		{

		// write tests

		r = f.Replace(myFs, fileName, EFileStreamText | EFileWrite);

		TEST(r==KErrNone);

		// wait for both tasks to have a chance to complete opening the files

		User::After(1000);

		buff.Fill('_', KBufLen);

		timer.After(tstat, KTimeBM * KSecond);

		startTime.HomeTime();

		while (tstat == KRequestPending)

			{

			TInt pos = (wrnum * KBufLen) % maxwrite;

			r = f.Write(pos, buff);

			TEST(r==KErrNone);

			++wrnum;

			}

		endTime.HomeTime();

		timeTaken=endTime.MicroSecondsFrom(startTime);

		TInt64 dtime = timeTaken.Int64();

		TInt64 dsize = wrnum * KBufLen * TInt64(KSecond);

		TInt32 speed = TInt32((dsize + dtime/2) / dtime);

		AddStats(gWrStats, dsize, dtime);

		TTest::Printf(_L("%8d writes in %6d mS = %8d bytes per second\n"),

					  wrnum, TInt32(dtime)/1000, speed);

		timer.Cancel();

		f.Close();

		}

	else

		{

		// read tests

		r = f.Open(myFs, fileName, EFileStreamText);

		TEST(r==KErrNone);

		// wait for both tasks to have a chance to complete opening the files

		User::After(1000);

		timer.After(tstat, KTimeBM * KSecond);

		startTime.HomeTime();

		while (tstat == KRequestPending)

			{

			TInt pos = (rdnum * KBufLen) % maxwrite;

			r = f.Read(pos, buff, KBufLen);

			TEST(r==KErrNone);

			++rdnum;

			}

		endTime.HomeTime();

		timeTaken=endTime.MicroSecondsFrom(startTime);

		TInt64 dtime = timeTaken.Int64();

		TInt64 dsize = rdnum * KBufLen * TInt64(KSecond);

		TInt32 speed = TInt32((dsize + dtime/2) / dtime);

		AddStats(gRdStats, dsize, dtime);

		// wait to allow the dust to settle

		User::After(KSecond);

		TTest::Printf(_L("%8d reads  in %6d mS = %8d bytes per second\n"),

					  rdnum, TInt32(dtime)/1000, speed);

		timer.Cancel();

		timer.Close();

		f.Close();

		// delete file after reading it

		myFs.Delete(fileName);

		}

	myFs.Close();

	return r;

    }

#endif

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

#if defined(TEST_ASYNC_IN_THREAD)

LOCAL_C TInt testAsyncAccess(TAny* aData)

//

/// Test read file handling.

///

/// @param aData pointer to the thread data area

    {

	TThreadData& data = *(TThreadData*)aData;

	TFileName fileName = data.iFile;

	TBool     dowrite  = (data.iData != NULL);

	TBuf8<KBufLen>* buffer = gBufferArr[data.iNum];

	TRequestStatus* status = gStatusArr[data.iNum];

	RFs   myFs;

	TInt r = myFs.Connect();

	TEST(r==KErrNone);

	r = myFs.SetSessionPath(gSessionPath);

	if (r != KErrNone)

		TTest::Fail(HERE, _L("SetSessionPath returned %d"), r);

	TVolumeInfo vol;

	TInt        drv;

	r = myFs.CharToDrive(fileName[0], drv);

	if (r != KErrNone)

		TTest::Fail(HERE, _L("CharToDrive(%c) returned %d"), fileName[0], r);

	r = myFs.Volume(vol, drv);

	if (r != KErrNone)

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

	TInt64 maxwrite = vol.iFree / 2 - KBufLen;

	if (maxwrite < KBufLen*2)

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

					 TInt(vol.iFree/1024));

    RFile f;

	RTimer timer;

	TRequestStatus tstat;

	TTime startTime;

	TTime endTime;

	TTimeIntervalMicroSeconds timeTaken;

	TInt wrnum = 0;

	TInt rdnum = 0;

	TInt opnum = 0;

	TInt opfin = 0;

	TInt i;

	timer.CreateLocal();

	if (dowrite)

		{

		r = f.Replace(myFs, fileName, EFileStreamText | EFileWrite);

		TEST(r==KErrNone);

		// wait for both tasks to have a chance to complete opening the files

		User::After(1000);

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

			buffer[i].Fill('_', KBufLen);

		timer.After(tstat, KTimeBM * KSecond);

		startTime.HomeTime();

		while (tstat == KRequestPending)

			{

			TInt pos = TInt((wrnum * KBufLen) % maxwrite);

			TInt bnum = opnum++ % KNumBuf;

			f.Write(pos, buffer[bnum], status[bnum]);

			if (opnum - opfin > KMaxLag)

				{

				while (status[opfin % KNumBuf] == KRequestPending)

					User::WaitForRequest(status[opfin % KNumBuf]);

				opfin++;

				}

			++wrnum;

			}

		while (opfin < opnum)

			{

			while (status[opfin % KNumBuf] == KRequestPending)

				User::WaitForRequest(status[opfin % KNumBuf]);

			opfin++;

			}

		endTime.HomeTime();

		TTimeIntervalMicroSeconds timeTaken=endTime.MicroSecondsFrom(startTime);

		TInt64 dtime = timeTaken.Int64();

		TInt64 dsize = wrnum * KBufLen * TInt64(KSecond);

		TInt32 speed = TInt32((dsize + dtime/2) / dtime);

		AddStats(gWrStats, dsize, dtime);

		TTest::Printf(_L("%8d writes in %6d mS = %8d bytes per second\n"),

					  wrnum, TInt32(dtime)/1000, speed);

		}

	else

		{

		r = f.Open(myFs, fileName, EFileStreamText);

		TEST(r==KErrNone);

		timer.After(tstat, KTimeBM * KSecond);

		startTime.HomeTime();

		while (tstat == KRequestPending)

			{

			TInt pos = TInt((rdnum * KBufLen) % maxwrite);

			TInt bnum = opnum++ % KNumBuf;

			f.Read(pos, buffer[bnum], status[bnum]);

			if (opnum - opfin > KMaxLag)

				{

				User::WaitForRequest(status[opfin++ % KNumBuf]);

				}

			++rdnum;

			}

		while (opfin < opnum)

			{

			if (status[opfin % KNumBuf] == KRequestPending)

				User::WaitForRequest(status[opfin % KNumBuf]);

			opfin++;

			}

		endTime.HomeTime();

		timeTaken=endTime.MicroSecondsFrom(startTime);

		TInt64 dtime = timeTaken.Int64();

		TInt64 dsize = rdnum * KBufLen * TInt64(KSecond);

		TInt32 speed = TInt32((dsize + dtime/2) / dtime);

		AddStats(gRdStats, dsize, dtime);

		// wait to allow the dust to settle

		User::After(KSecond);

		TTest::Printf(_L("%8d reads  in %6d mS = %8d bytes per second\n"),

					  rdnum, TInt32(dtime)/1000, speed);

		myFs.Delete(fileName);

		}

	timer.Cancel();

	timer.Close();

	f.Close();

	myFs.Close();

	return r;

    }

#endif

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

class TFileOps

/// Do operations on a file.

	{

public:

	TFileOps();

	TInt Open(TChar dr, TInt n);