// Copyright (c) 2006-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_fcachebm.cpp

// 

//

#include <f32file.h>

#include <e32test.h>

#include <e32math.h>

#include "t_select.h"

#include "t_benchmain.h"

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

//! @SYMTestCaseID      PBASE-T_RCACHE-0192

//! @SYMTestType        CIT

//! @SYMPREQ            PREQ914

//! @SYMTestCaseDesc    This test case is testing performance of the File Server Cache.  

//! @SYMTestActions     0   setup the environment to execute the tests

//!						1	small random reads/writes

//!						2	large sequential reads/writes

//!						3 	streaming test (100, 200 and 500 kbps)

//! @SYMTestExpectedResults Finishes if the system behaves as expected, panics otherwise

//! @SYMTestPriority        High

//! @SYMTestStatus          Implemented

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

GLDEF_D RTest test(_L("File Cache BM"));

LOCAL_D RSemaphore client;

LOCAL_D const TInt KHeapSize = 0x4000;

LOCAL_D const TInt KTobps = 1000;

LOCAL_D const TInt KByte = 8;

LOCAL_D const TInt KOneSec = 1000000; // One second in microseconds

// Tests setup

LOCAL_D const TInt KSmallRow = 11;

LOCAL_D const TInt KSmallCol = 7;

LOCAL_D const TInt KSmallThreshold = 64;

LOCAL_D const TInt KSeveralTimes = 10;

LOCAL_D const TInt KLargeRow = 19;

LOCAL_D const TInt KLargeCol = 3;

LOCAL_D TInt gCurrentSpeed = 0; 

LOCAL_D TInt gCurrentBS = 0;

LOCAL_D TBuf8<4096> buf;

LOCAL_D TDriveList gDriveList;

// Concurrent thread

RThread gSpeedy;

RThread gSpeedyII;

TBuf16<25> gBaseFile;

TBuf16<25> gFileA;

TBuf16<25> gFileB;

TBuf16<25> gStreamFile;

TInt64 gMediaSize;

HBufC8* gBuf = NULL;

TPtr8 gBufReadPtr(NULL, 0);	

HBufC8* gBufSec = NULL;

TPtr8 gBufWritePtr(NULL, 0);	

HBufC8* gBufB = NULL;

TPtr8 gBufReadBPtr(NULL, 0);	

TBool gWriting = EFalse;

LOCAL_D TInt ThreadCount=0;

enum TTestState 

	{

	ENoThreads,			// No threads 

	ETwoThreadsDif,		// Accessing to different files 

	ETwoThreadsDifDif, 	// Accessing to different files, different blocksizes

	ETwoThreadsSame		// Accessing the same file

	};

/** 2 ^ b

	@param b Power 

*/

LOCAL_C TInt Pow(TInt b)

{

	return 1 << b;

}

/** Pseudo-random number generator, random enough for the purpose

	@param aMax Upper limit of the number. The interval of generated numbers is [0,aMax)

*/

LOCAL_C TInt Rand(TInt aMax) 

{

	return (Math::Random() % aMax);

}

/** Fills a buffer with character aC, aC+1, aC+2, ..., aC+32, aC, etc 

	@param aBuffer 	Buffer to fill out

	@param aLength 	Length to be filled with characters

	@param aC 		Base character to fill the buffer

*/

LOCAL_C void FillBuffer(TDes8& aBuffer, TInt aLength, TChar aC)

	{

	test (aBuffer.MaxLength() >= aLength);

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

		{

		aBuffer.Append((i%32)+aC);

		}

	}

/** Send content through the RDebug for trgtest 

	not to hung, when the test is not writing

*/

LOCAL_C TInt noise(TAny* )

{

	FOREVER

	{	

		User::After(2147483647); // max value, 35 minutes, 47 seconds

		if(!gWriting)

			RDebug::Print(_L("."));

	}

}

/**  Delete content of directory

	@param aDir Directory to be emptied

*/

LOCAL_C TInt DeleteAll(TDes16& aDir) 

	{

		TBuf16<100> dir;

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

		TInt r = 0;

		dir = aDir;

		dir.Append(_L("F*.*"));

		r = fMan->Delete(dir);	

		delete fMan;

		return r;

	}

/**   Creates a file of aSize KBytes

	@param aFile File name 

	@param aSize Size of the file to be created

*/

LOCAL_C void CreateFile(TDes16& aFile, TInt aSize)

{

	TInt r = 0;

	RFile file;

	r = file.Replace(TheFs, aFile, EFileShareAny|EFileWrite);

	FailIfError(r);

	TInt j = 0;

	while(j <= aSize)

		{

			r = file.Write(gBufWritePtr, KOneK);

			FailIfError(r);

			j += KOneK;

		}					

	file.Close();

}

/**   Kills the concurrent session

*/

LOCAL_C void DoTestKill()

{

	TInt r = 0;

	gSpeedy.Kill(KErrNone);

	FailIfError(r);

	gSpeedy.Close();	

	gSpeedyII.Kill(KErrNone);

	FailIfError(r);

	gSpeedyII.Close();	

}

/** Read aSize KBs from aFile file in blocks of aBlockSize bytes

	@param aFile 		Name of the file

	@param aPos			Position from where the read starts within the file

	@param aBlockSize 	Block size for the I/O operation

	@param aSize 		

*/

LOCAL_C TInt ReadFromFile(TDes16& aFile, TInt aPos, TInt aBlockSize, TInt aSize) 

{

	TInt r = 0;

	TTime startTime;

	TTime endTime;

	RFile file;

	TInt j = 0;

	TInt size = aSize * KOneK;

	TTimeIntervalMicroSeconds timeTaken(0);

	r = file.Open(TheFs,aFile,EFileShareAny|EFileRead);

	FailIfError(r);

	startTime.HomeTime();	

	r = file.Seek(ESeekStart, aPos);

	FailIfError(r);	

	while(j <= size)

		{

			r = file.Read(gBufReadPtr, aBlockSize);

			FailIfError(r);

			j += aBlockSize;

		}					

	endTime.HomeTime();

	file.Close();

	timeTaken = endTime.MicroSecondsFrom(startTime);

	return I64LOW(timeTaken.Int64() / gTimeUnit);

}

/** Read aSize KBs from aFile file in blocks of aBlockSize bytes several times

	@param aFile 		Name of the file

	@param ayMax 		Maximum for the position

	@param aBlockSize 	Block size for the I/O operation

	@param aSize 		Size of the file in KB

*/

LOCAL_C TInt ReadFromFileSeveralTimes(TDes16& aFile, TInt ayMax, TInt aBlockSize, TInt aSize) 

{

	TInt r = 0;

	TTime startTime;

	TTime endTime;

	RFile file;

	TInt j = 0, i, pos;

	TInt size = aSize * KOneK;

	TTimeIntervalMicroSeconds timeTaken(0);

	TInt64 time = 0;

	r = file.Open(TheFs, aFile, EFileShareAny|EFileRead);

	FailIfError(r);

	i = 0;

	while( i < KSeveralTimes ) 

		{

		pos = Rand(Pow(ayMax - 1));

		startTime.HomeTime();	

		r = file.Seek(ESeekStart, pos); 

		FailIfError(r);	

		j = 0;

		while(j <= size)

			{

				r = file.Read(gBufReadPtr, aBlockSize);

				FailIfError(r);

				j += aBlockSize;

			}					

		endTime.HomeTime();

		timeTaken = endTime.MicroSecondsFrom(startTime);

		time += I64LOW(timeTaken.Int64());

		i++;

		}

	file.Close();

	return I64LOW((time / gTimeUnit) / KSeveralTimes); // Overflow not expected here, since the number is not big enough

}

/** Write aSize KBs to  aFile file in blocks of aBlockSize bytes

	@param aFile 		Name of the file

	@param aPos			Position from where the read starts within the file

	@param aBlockSize 	Block size for the I/O operation

	@param aSize 		Size of the file in KB

*/

LOCAL_C TInt WriteToFile(TDes16& aFile, TInt aPos, TInt aBlockSize, TInt aSize) 

{

	TInt r = 0;

	TTime startTime;

	TTime endTime;

	RFile file;

	TInt j = 0;

	TInt size = aSize * KOneK;

	TTimeIntervalMicroSeconds timeTaken(0);

	r = file.Open(TheFs, aFile, EFileShareAny|EFileWrite);

	FailIfError(r);

	startTime.HomeTime();	

	r = file.Seek(ESeekStart, aPos);

	FailIfError(r);	

	while(j <= size)

		{

			r = file.Write(gBufWritePtr, aBlockSize);

			FailIfError(r);

			j += aBlockSize;

		}					

	endTime.HomeTime();

	file.Close();

	timeTaken = endTime.MicroSecondsFrom(startTime);

	return I64LOW(timeTaken.Int64() / gTimeUnit);

}

/** Write aSize KBs to  aFile file in blocks of aBlockSize bytes several times

	@param aFile 		Name of the file

	@param ayMax 		Maximum for the position

	@param aBlockSize 	Block size for the I/O operation

	@param aSize 		Size of the file in KB

*/

LOCAL_C TInt WriteToFileSeveralTimes(TDes16& aFile, TInt ayMax, TInt aBlockSize, TInt aSize) 

{

	TInt r = 0;

	TTime startTime;

	TTime endTime;

	RFile file;

	TInt i, j = 0, pos;

	TInt size = aSize * KOneK;

	TTimeIntervalMicroSeconds timeTaken(0);

	TInt64 time = 0;

	r = file.Open(TheFs, aFile, EFileShareAny|EFileWrite);

	FailIfError(r);

	i = 0;

	while( i < KSeveralTimes ) 

		{

		pos = Rand(Pow(ayMax - 1));

		startTime.HomeTime();	

		r = file.Seek(ESeekStart, pos);

		FailIfError(r);	

		j = 0;

		while(j <= size)

			{

				r = file.Write(gBufWritePtr, aBlockSize);

				FailIfError(r);

				j += aBlockSize;

			}					

		endTime.HomeTime();

		timeTaken = endTime.MicroSecondsFrom(startTime);

		time += I64LOW(timeTaken.Int64());

		i++;

		}

	file.Close();

	return I64LOW((time / gTimeUnit) / KSeveralTimes); // Overflow not expected here, since the number is not big enough

}

/** Read small blocks in the gBaseFile

*/

LOCAL_C TInt ReadSmallBase(TAny* )

{

	RTest test(_L("test 2"));

	RFs fs;

	RFile file;

	TBuf8<1024> dummy(1024);

	TInt blockSize = 0;

	TInt randPos = 0;

	TInt i = 0;

	TInt r = fs.Connect();

	fs.SetSessionPath(gSessionPath);

	r = file.Open(fs, gBaseFile, EFileShareAny|EFileRead);

	client.Signal();

	FailIfError(r);

	FOREVER

	{	

			randPos = Rand(64) * KOneK ; 

			r = file.Seek(ESeekStart, randPos);

			FailIfError(r);

			blockSize = i;

			r = file.Read(dummy, blockSize); // Sync operation

			if(i >= 1023) i = 0;

			else i++;

	}

}

/** Read small blocks in gFileA

*/

LOCAL_C TInt ReadSmallA(TAny* )

{

	RTest test(_L("test 2"));

	RFs fs;

	RFile file;

	TInt blockSize = 0;

	TInt randPos = 0;

	TBuf8<1024> dummy(1024);

	TInt i = 0;

	TInt r = fs.Connect();

	fs.SetSessionPath(gSessionPath);

	r = file.Open(fs,gFileA,EFileShareAny|EFileRead);

	client.Signal();

	FailIfError(r);

	FOREVER

	{	

			randPos = Rand(64) * KOneK ; 

			r = file.Seek(ESeekStart, randPos);

			FailIfError(r);

			blockSize = i;

			r = file.Read(dummy, blockSize); // Sync operation

			FailIfError(r);

			if(i >= 1023) i = 0;

			else i++;

	}

}

/** Read small blocks in gFileB

*/

LOCAL_C TInt ReadSmallB(TAny* )

	{

	RTest test(_L("test 2"));

	RFs fs;

	RFile file;

	TBuf8<1024> dummy(1024);

	TInt blockSize = 0;

	TInt randPos = 0;

	TInt i = 0;

	TInt r = fs.Connect();

	fs.SetSessionPath(gSessionPath);

	r = file.Open(fs, gFileB, EFileShareAny|EFileRead);

	client.Signal();

	FailIfError(r);

	FOREVER

	{

		randPos = Rand(64) * KOneK ; 

		r = file.Seek(ESeekStart, randPos);

		FailIfError(r);

		blockSize = i;

		r = file.Read(dummy, blockSize); // Sync operation

		FailIfError(r);

		if(i >= 1023) i = 0;

		else i++;

	}

}

/** Read large blocks in gBaseFile

*/

LOCAL_C TInt ReadLargeBase(TAny* )

	{

	RTest test(_L("test 2"));

	RFs fs;

	RFile file;

	TInt pos = 0;

	TInt blockSize = 128 * KOneK;

	TInt r = fs.Connect();

	fs.SetSessionPath(gSessionPath);

	r = file.Open(fs,gBaseFile,EFileShareAny|EFileRead);

	client.Signal();

	FailIfError(r);

	FOREVER

	{	

			r = file.Seek(ESeekStart, pos);

			FailIfError(r);

			r = file.Read(gBufReadBPtr, blockSize); // Sync operation

			FailIfError(r);

	}

}

/** Read large blocks in gFileA

*/

LOCAL_C TInt ReadLargeA(TAny* )

{

	RTest test(_L("test 2"));

	RFs fs;

	RFile file;

	TInt blockSize = 128 * KOneK;

	TInt pos = 0;

	TInt r = fs.Connect();

	fs.SetSessionPath(gSessionPath);

	r = file.Open(fs,gFileA,EFileShareAny|EFileRead);

	client.Signal();