Convert Kernelhwsrv package from SFL to EPL
kernel\eka\compsupp is subject to the ARM EABI LICENSE
userlibandfileserver\fatfilenameconversionplugins\unicodeTables is subject to the Unicode license
kernel\eka\kernel\zlib is subject to the zlib license
// 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
#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(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");
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(r==KErrNone);
}
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(r == KErrNone);
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);
if (r != KErrNone)
test.Printf(_L("Write() returned %d\n"), r);
test(r == KErrNone);
}
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;
while (iNum < iOps && iStatus[iNum%KMaxLag] != KRequestPending)
{
TInt status = iStatus[iNum%KMaxLag].Int();
if (status != KErrNone)
test.Printf(_L("drive %c, iNum = %d, iOps=%d, Status = %d\n"), (TUint)iDrvCh, iNum, iOps, status);
test (status == KErrNone);
iNum++;
}
if (iOps < KMaxLag || iStatus[iPtr] != KRequestPending)
{
TInt pos = iOps%iMax * iBufSize;
iBufPtr[iPtr]->SetLength(0);
iF.Read(pos, *iBufPtr[iPtr], iStatus[iPtr]);
TInt len = iBufPtr[iPtr]->Length();
TInt status = iStatus[iPtr].Int();
TInt err = KErrNone;
if (status == KErrNone)
{
iFileSyncAccesses++;
if (len < iBufPtr[iPtr]->MaxLength())
err = KErrUnderflow;
}
else if (status == KRequestPending)
{
iFileAsyncAccesses++;
}
else
{
err = status;
}
if (gVerbose || err != KErrNone)
{
test.Printf(_L("Reading buf #%d, drive %c, pos %d, status %d, len %d, iNum %d, iOps %d, iMax %d\n"),
iPtr, (TUint)iDrvCh, pos, status, len, iNum, iOps, iMax);
}
test (err == KErrNone);
iOps++;
iPtr++;
iPtr %= KMaxLag;
// have we wrapped to postion zero ?
if (iOps % iMax == 0)
iFileWraps++;
return 1;
}
return 0;
}
TInt RFileOps::End()
/// Wait until all outstanding operations have ended, then return the number.
{
if (!iOpen)
return 0;
if (gVerbose)
test.Printf(_L("Waiting for reads/writes to %c to complete, iNum=%d, iOps=%d...\n"), (TUint)iDrvCh, iNum, iOps);
while (iNum < iOps)
{
if (iStatus[iNum%KMaxLag] == KRequestPending)
{
User::WaitForRequest(iStatus[iNum%KMaxLag]);
}
else
{
TInt status = iStatus[iNum%KMaxLag].Int();
if (gVerbose || (status != KErrNone && status != KRequestPending))
test.Printf(_L("Buf#%d: Status = %d\n"), iNum, status);
test (status == KErrNone || status == KRequestPending);
iNum++;
}
}
return iNum;
}
LOCAL_C TInt testAsyncAccess(
TInt aDrive1,
TInt aDrive2,
TInt aBufSize1,
TInt aBufSize2,
TBool aSync1,
TBool aSync2,
TInt& aThroughput1,
TInt& aThroughput2)
//
// Test one drive against the other.
//
{
TInt r;
RFileOps f1;
RFileOps f2;
TChar dc1;
TChar dc2;
TInt op1 = 0;
TInt op2 = 0;
RTimer timer;
TRequestStatus tstat;
TTime startTime;
TTime endTime;
TTimeIntervalMicroSeconds timeTaken(0);
TInt64 dtime;
aThroughput1 = aThroughput2 = 0;
if (aBufSize1 == 0 && aBufSize2 == 0)
return KErrNone;
timer.CreateLocal();
r = TheFs.DriveToChar(aDrive1, dc1);
test(r == KErrNone);
r = TheFs.DriveToChar(aDrive2, dc2);
test(r == KErrNone);
// allocate buffers
r = f1.Init(dc1, aBufSize1);
test(r == KErrNone);
r = f2.Init(dc2, aBufSize2);
test(r == KErrNone);
_LIT(KSync, " sync");
_LIT(KAsync, "async");
if (gVerbose)
test.Printf(_L("%c: (%S) %d, %c: (%S) %d\n"),
(TUint)dc1,
aSync1?&KSync:&KAsync,
aBufSize1,
(TUint)dc2,
aSync2?&KSync:&KAsync,
aBufSize2);
RemountFileSystem(aDrive1, aSync1);
RemountFileSystem(aDrive2, aSync2);
if (gReadTests)
{
//********************************************************************
// read test
//********************************************************************
if (aBufSize1 > 0)
{
r = f1.CreateReadFile();
test(r == KErrNone);
}
if (aBufSize2 > 0)
{
r = f2.CreateReadFile();
test(r == KErrNone);
}
if (aBufSize1 > 0)
r = f1.Open(RFileOps::ERead);
test(r == KErrNone);
if (aBufSize2 > 0)
r = f2.Open(RFileOps::ERead);
test(r == KErrNone);
timer.After(tstat, KTimeBM * KSecond);
startTime.HomeTime();
while (tstat == KRequestPending)
{
TInt num = 0;
if (aBufSize1 > 0)
num = f1.Read();
if (aBufSize2 > 0)
num += f2.Read();
if (num == 0)
User::WaitForAnyRequest();
}
timer.Cancel();
if (aBufSize1 > 0)
op1 = f1.End();
if (aBufSize2 > 0)
op2 = f2.End();
endTime.HomeTime();
timeTaken=endTime.MicroSecondsFrom(startTime);
//********************************************************************
// Read test end
//********************************************************************
} // if (gReadTests)
if (gWriteTests)
{
//********************************************************************
// write test
//********************************************************************
if (aBufSize1 > 0)
{
r = f1.Open(RFileOps::EWrite);
test(r == KErrNone);
}
if (aBufSize2 > 0)
{
r = f2.Open(RFileOps::EWrite);
test(r == KErrNone);
}
timer.After(tstat, KTimeBM * KSecond);
startTime.HomeTime();
while (tstat == KRequestPending)
{
TInt num = 0;
if (aBufSize1 > 0)
num = f1.Write();
if (aBufSize2 > 0)
num += f2.Write();
if (num == 0)
User::WaitForAnyRequest();
}
timer.Cancel();
if (aBufSize1 > 0)
op1 = f1.End();
if (aBufSize2 > 0)
op2 = f2.End();
endTime.HomeTime();
timeTaken=endTime.MicroSecondsFrom(startTime);
//********************************************************************
// Write test end
//********************************************************************
} // if gWriteTests
dtime = timeTaken.Int64();
aThroughput1 = GetSpeed(op1, aBufSize1, dtime);
aThroughput2 = GetSpeed(op2, aBufSize2, dtime);
test.Printf(_L("%c:,%c:,%10d,%10d,%10d,%10d\n"),
(TUint)dc1, (TUint)dc2,
aBufSize1,aBufSize2,
aThroughput1,
aThroughput2
);
if (gVerbose)
{
test.Printf(_L("%c: %d async reads, %d sync reads, wraps = %d\n"),
(TUint)dc1, f1.iFileAsyncAccesses, f1.iFileSyncAccesses, f1.iFileWraps);
test.Printf(_L("%c: %d async reads, %d sync reads, wraps = %d\n"),
(TUint)dc2, f2.iFileAsyncAccesses, f2.iFileSyncAccesses, f2.iFileWraps);
}
f1.Close();
f2.Close();
timer.Close();
f1.DeInit();
f2.DeInit();
return KErrNone;
}
LOCAL_C TInt parseCmd(TChar& aDrvCh1, TChar& aDrvCh2)
/// Get parameters from the comand line; if there aren't enough then
/// prompt the user for them and return KErrAbort if ^C is pressed.
{
while (aDrvCh1 < 'A' || aDrvCh1 > 'Z')
{
test.Printf(_L("Enter drive letter: "));
while (aDrvCh1 < 'A' || aDrvCh1 > 'Z')
{
if (aDrvCh1 == 0x03)
return KErrAbort;
aDrvCh1 = User::UpperCase(test.Getch());
}
if (!DriveIsOK(aDrvCh1))
{
test.Printf(_L("%c: is not a valid drive\n"), (TUint)aDrvCh1);
aDrvCh1 = 0;
}
else
{
TInt drv;
TheFs.CharToDrive(aDrvCh1, drv);
TheFs.FileSystemName(gFsName1, drv);
test.Printf(_L("%c: (%S)\n"), (TUint)aDrvCh1, &gFsName1);
}
}
while (aDrvCh2 < 'A' || aDrvCh2 > 'Z')
{
test.Printf(_L("Enter drive letter: "));
while (aDrvCh2 < 'A' || aDrvCh2 > 'Z')
{
if (aDrvCh2 == 0x03)
return KErrAbort;
aDrvCh2 = User::UpperCase(test.Getch());
}
if (!DriveIsOK(aDrvCh2))
{
test.Printf(_L("%c: is not a valid drive\n"), (TUint)aDrvCh2);
aDrvCh2 = 0;
}
else
{
TInt drv;
TheFs.CharToDrive(aDrvCh2, drv);
TheFs.FileSystemName(gFsName2, drv);
test.Printf(_L("%c: (%S)\n"), (TUint)aDrvCh2, &gFsName2);
}
}
return KErrNone;
}
typedef TInt RESULTS[KMaxIter][KMaxIter];
LOCAL_C void PrintResults(RESULTS& aResults, TChar aDrvCh, TChar aDrvCh2)
{
TInt bufSize2;
TInt drive1Index, drive2Index;
test.Printf(_L("*** Throughput for drive %c ***\n"), (TUint)aDrvCh);
test.Printf(_L(" BufferSize (%C:)....\n"), (TUint)aDrvCh2);
gResults.Zero();
for (bufSize2 = drive2Index = 0; bufSize2 <= KMaxBufferSize; bufSize2 = bufSize2 << 1, drive2Index++)
{
gResults.AppendFormat(_L("%10d,"), bufSize2);
if (bufSize2 == 0)
bufSize2 = KMinBufferSize >> 1;
}
test.Printf(_L("%S\n"), &gResults);
for (drive1Index = 0; drive1Index < KMaxIter; drive1Index++)
{
gResults.Zero();
for (drive2Index = 0; drive2Index < KMaxIter; drive2Index++)
{
gResults.AppendFormat(_L("%10d,"), aResults[drive1Index][drive2Index]);
}
test.Printf(_L("%S\n"), &gResults);
}
}
//
// Do all tests
//
GLDEF_C void CallTestsL()
{
TInt r = TTest::Init();
test(r == KErrNone);
TChar drvch1 = 0;
TChar drvch2 = 0;
TInt drive1;
TInt drive2;
const TInt KMaxArgs = 5;
TPtrC argv[KMaxArgs];
TInt argc = TTest::ParseCommandArguments(argv, KMaxArgs);
if (argc > 1)
drvch1 = User::UpperCase(argv[1][0]);
if (argc > 2)
drvch2 = User::UpperCase(argv[2][0]);
TBool testFs = EFalse;
for (TInt n=3; n<argc; n++)
{
if (argc > 3)
{
if (argv[n].Compare(_L("verbose")) == 0)
gVerbose = ETrue;
if (argv[n].Compare(_L("read")) == 0)
gReadTests = ETrue;
if (argv[n].Compare(_L("write")) == 0)
gWriteTests = ETrue;
if (argv[n].Compare(_L("async")) == 0)
gAsyncTests = ETrue;
if (argv[n].Compare(_L("sync")) == 0)
gSyncTests = ETrue;
if (argv[n].Compare(_L("testfs")) == 0)
testFs = ETrue;
}
}
if ((!gReadTests && !gWriteTests) ||
(!gAsyncTests && !gSyncTests))
{
test.Printf(_L("T_CFSPERFORM - tests read/write throughput on two drives simultaneously\n"));
test.Printf(_L("Syntax : t_cfsperform <Drive1> <Drive2> [verbose] [testfs] read|write sync|async\n"));
test.Printf(_L("Where : async = concurrent access, sync = non-concurrent access\n"));
test.Printf(_L("E.g. : t_cfsperform c d read async\n"));
test.Printf(_L("Press any key"));
test.Getch();
test.Printf(_L("\n"));
return;
}
r = parseCmd(drvch1, drvch2);
if (r != KErrNone)
{
User::Panic(_L("USER ABORT"), 0);
}
r = TheFs.CharToDrive(drvch1, drive1);
test(r == KErrNone);
r = TheFs.CharToDrive(drvch2, drive2);
test(r == KErrNone);
r = TheFs.FileSystemName(gFsName1, drive1);
test(r == KErrNone || r == KErrNotFound);
r = TheFs.FileSystemName(gFsName2, drive2);
test(r == KErrNone || r == KErrNotFound);
if (testFs)
{
MountTestFileSystem(drive1);
MountTestFileSystem(drive2);
}
TInt bufSize1;
TInt bufSize2;
// delete temp files before starting
RFileOps f;
f.Init(drvch1, 256);
f.Delete();
f.DeInit();
f.Init(drvch2, 256);
f.Delete();
f.DeInit();
TInt resultsDrive1[KMaxIter][KMaxIter];
TInt resultsDrive2[KMaxIter][KMaxIter];
TInt drive1Index;
TInt drive2Index;
test.Printf(_L(" BufSize(%c) BufSize(%c) ThruPut(%c) ThruPut(%c) \n"),
(TUint)drvch1, (TUint)drvch2, (TUint)drvch1, (TUint)drvch2);
for (bufSize1 = drive1Index = 0; bufSize1 <= KMaxBufferSize; bufSize1 = bufSize1 << 1, drive1Index++)
{
for (bufSize2 = drive2Index = 0; bufSize2 <= KMaxBufferSize; bufSize2 = bufSize2 << 1, drive2Index++)
{
// // !!! Disable platform security tests until we get the new APIs
// if (User::Capability() & KCapabilityRoot)
// {
// CheckMountLFFS(TheFs, drvch1);
// CheckMountLFFS(TheFs, drvch2);
// }
if (gVerbose)
test.Printf(_L("Using drives %c: (%S) and %c: (%S)\n"),
(TUint)drvch1, &gFsName1, (TUint)drvch2, &gFsName2);
TInt throughputDrive1;
TInt throughputDrive2;
TBool sync = EFalse;
if (gSyncTests)
sync = ETrue;
testAsyncAccess(
drive1, drive2,
bufSize1, bufSize2,
sync, sync,
throughputDrive1, throughputDrive2);
resultsDrive1[drive1Index][drive2Index] = throughputDrive1;
resultsDrive2[drive1Index][drive2Index] = throughputDrive2;
// buffer size sequence is 0,16,32,64,128, ...
if (bufSize2 == 0)
bufSize2 = KMinBufferSize >> 1;
}
// buffer size sequence is 0,16,32,64,128, ...
if (bufSize1 == 0)
bufSize1 = KMinBufferSize >> 1;
}
PrintResults(resultsDrive1, drvch1, drvch2);
PrintResults(resultsDrive2, drvch2, drvch2);
if (testFs)
{
UnmountFileSystem(drive1);
UnmountFileSystem(drive2);
}
test(r == 0);
}
GLDEF_C TInt E32Main()
//
// Main entry point
//
{
TInt r;
CTrapCleanup* cleanup;
cleanup=CTrapCleanup::New();
__UHEAP_MARK;
test.Title();
test.Start(_L("Starting tests..."));
r=TheFs.Connect();
test(r==KErrNone);
// TheFs.SetAllocFailure(gAllocFailOn);
TTime timerC;
timerC.HomeTime();
// Do the tests
TRAP(r,CallTestsL());
// reset the debug register
TheFs.SetDebugRegister(0);
TTime endTimeC;
endTimeC.HomeTime();
TTimeIntervalSeconds timeTakenC;
r=endTimeC.SecondsFrom(timerC,timeTakenC);
test(r==KErrNone);
test.Printf(_L("Time taken for test = %d seconds\n"),timeTakenC.Int());
// TheFs.SetAllocFailure(gAllocFailOff);
TheFs.Close();
test.End();
test.Close();
__UHEAP_MARKEND;
delete cleanup;
return(KErrNone);
}