--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/f32test/bench/t_fsysbm.cpp Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,1376 @@
+// 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 <hal.h>
+#include <e32math.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
+
+
+GLDEF_D RTest test(_L("File System Benchmarks"));
+
+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
+const TInt64 KGb = 1 << 30;
+const TInt64 K3GB = 3 * KGb;
+const TInt64 K4GB = 4 * KGb;
+#endif //SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
+
+#if defined(__WINS__)
+LOCAL_D TInt KMaxFileSize = 256 * K1K; // 256K
+//LOCAL_D TInt KMaxFileSize = K1M; // 1M
+#else
+//LOCAL_D TInt KMaxFileSize = 256 * K1K; // 256K
+//LOCAL_D TInt KMaxFileSize = K1M; // 1M
+LOCAL_D TInt KMaxFileSize = K2M; // 2M
+#endif
+
+const TTimeIntervalMicroSeconds32 KFloatingPointTestTime = 10000000; // 10 seconds
+LOCAL_D const TInt KHeapSize = 0x4000;
+
+LOCAL_D TPtr8 DataBuf(NULL, KMaxFileSize,KMaxFileSize);
+LOCAL_D HBufC8* DataBufH = NULL;
+
+LOCAL_D RSharedChunkLdd Ldd;
+LOCAL_D RChunk TheChunk;
+LOCAL_D TInt PageSize;
+const TUint ChunkSize = KMaxFileSize;
+
+
+LOCAL_D RFile File, File2;
+LOCAL_D TChar gDriveToTest2;
+
+// if enabled, Read and Write operations are not boundary aligned.
+LOCAL_D TBool gMisalignedReadWrites = EFalse;
+
+// read & write caching enabled flags - may be overriden by +/-r +/-w command line switches
+LOCAL_D TBool gReadCachingOn = EFalse;
+LOCAL_D TBool gWriteCachingOn = EFalse;
+
+// if enabled, timings are for write AND flush
+LOCAL_D TBool gFlushAfterWrite = ETrue;
+
+// if enabled, contiguous shared memory is used for Data buffer
+LOCAL_D TBool gSharedMemory = EFalse;
+
+// if enabled, fragmented shared memory is used for Data buffer
+LOCAL_D TBool gFragSharedMemory = EFalse;
+
+LOCAL_D TInt gFastCounterFreq;
+
+
+
+LOCAL_C void RecursiveRmDir(const TDesC& aDes)
+//
+// 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;
+ test(r==KErrNone);
+ 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);
+ test(r==KErrNone);
+ }
+ }
+ delete pD;
+ r=TheFs.RmDir(aDes);
+ test(r==KErrNone);
+ }
+
+
+void LOCAL_C ClearSessionDirectory()
+//
+// Delete the contents of F32-TST
+//
+ {
+ TParse sessionPath;
+ TInt r=TheFs.Parse(_L("\\F32-TST\\"),_L(""),sessionPath);
+ test(r==KErrNone);
+ RecursiveRmDir(sessionPath.FullName());
+ r=TheFs.MkDir(sessionPath.FullName());
+ test(r==KErrNone);
+ }
+
+
+LOCAL_C void DoTestFileRead(TInt aBlockSize, TInt aFileSize = KMaxFileSize, TBool aReRead = EFalse)
+//
+// 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);
+ test(r == KErrNone);
+ 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));
+ test(r == KErrNone);
+
+// 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);
+ test(r == KErrNone);
+#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);
+ test (r == KErrNone);
+
+ if (DataBuf.Length() == 0)
+ break;
+
+#if defined SYMBIAN_TEST_COPY
+ r = File2.Write(DataBuf, readLen);
+ test (r == KErrNone);
+#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"));
+ test(r == KErrNone);
+ return;
+ }
+
+
+LOCAL_C void TestFileRead(TInt aFileSize = KMaxFileSize, TBool aMisalignedReadWrites = EFalse, TBool aReRead = EFalse)
+//
+// 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
+
+ }
+
+
+LOCAL_C TInt FloatingPointLoop(TAny* funcCount)
+ {
+ TUint& count = *(TUint*) funcCount;
+ TReal eq = KPi;
+
+ FOREVER
+ {
+ eq *= eq;
+ count++;
+ }
+
+ }
+
+
+LOCAL_C void DoTestFileReadCPU(TInt aBlockSize)
+//
+// 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));
+ test(r == KErrNone);
+
+ 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);
+ test (r == KErrNone);
+
+ 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;
+ }
+
+
+LOCAL_C void TestFileReadCPU(TBool aMisalignedReadWrites = EFalse)
+//
+// 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);
+ test(r == KErrNone);
+
+ 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"));
+ test(r == KErrNone);
+ }
+
+
+LOCAL_C void DoTestFileWrite(TInt aBlockSize, TInt aFileSize = KMaxFileSize, TBool aUpdate = EFalse)
+//
+// 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);
+ test(r == KErrNone || r == KErrAlreadyExists);
+
+ TFileName fileName;
+ enum {EFileWriteDirectIO = 0x00001000, EFileWriteBuffered = 0x00000800};
+ r = File.Temp(TheFs, testDir, fileName, EFileWrite | (gWriteCachingOn ? EFileWriteBuffered : EFileWriteDirectIO));
+ test(r == KErrNone);
+
+ if (aUpdate)
+ {
+ TInt r = File.SetSize(aFileSize);
+ test(r == KErrNone);
+ }
+
+ 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)
+ {
+ r = File.Flush();
+ test_KErrNone(r)
+ }
+
+ // write file once only
+ finalTicks = User::FastCounter();
+ endTime.HomeTime();
+// TTimeIntervalMicroSeconds duration = endTime.MicroSecondsFrom(startTime);
+ TTimeIntervalMicroSeconds duration = TInt64(finalTicks - initTicks) * TInt64(1000000) / TInt64(gFastCounterFreq) ;
+
+ TInt dataTransferred = functionCalls * aBlockSize;
+ TReal transferRate =
+ TReal32(dataTransferred) /
+ TReal(duration.Int64()) * TReal(1000000) / TReal(K1K); // KB/s
+ test.Printf(_L("Write %7d bytes in %7d byte blocks:\t%11.3f KBytes/s (%d microsecs)\n"),
+ dataTransferred, aBlockSize, transferRate, endTime.MicroSecondsFrom(startTime).Int64());
+
+ timer.Close();
+
+ File.Close();
+ r = TheFs.Delete(fileName);
+ test_KErrNone(r)
+
+ return;
+ }
+
+
+LOCAL_C void TestFileWrite(TInt aFileSize = KMaxFileSize, TBool aMisalignedReadWrites = EFalse, TBool aUpdate = EFalse)
+//
+// Benchmark write method
+//
+ {
+ ClearSessionDirectory();
+ test.Next(_L("Benchmark write method"));
+
+ _LIT(KLitUpdate,"update");
+ _LIT(KLitAppend,"append");
+ test.Printf(_L("FileSize %d %S MisalignedReadWrites %d\n"), aFileSize, aUpdate? &KLitUpdate : &KLitAppend, aMisalignedReadWrites);
+
+ TInt misalignedOffset = aMisalignedReadWrites ? 1 : 0;
+
+#if defined (SYMBIAN_TEST_EXTENDED_BUFFER_SIZES)
+ DoTestFileWrite(1+misalignedOffset, aFileSize, aUpdate);
+ DoTestFileWrite(2+misalignedOffset, aFileSize, aUpdate);
+ DoTestFileWrite(4+misalignedOffset, aFileSize, aUpdate);
+ DoTestFileWrite(8+misalignedOffset, aFileSize, aUpdate);
+ DoTestFileWrite(16+misalignedOffset, aFileSize, aUpdate);
+ DoTestFileWrite(32+misalignedOffset, aFileSize, aUpdate);
+ DoTestFileWrite(64+misalignedOffset, aFileSize, aUpdate);
+ DoTestFileWrite(128+misalignedOffset, aFileSize, aUpdate);
+ DoTestFileWrite(256+misalignedOffset, aFileSize, aUpdate);
+ DoTestFileWrite(512+misalignedOffset, aFileSize, aUpdate);
+ DoTestFileWrite(1024+misalignedOffset, aFileSize, aUpdate);
+ DoTestFileWrite(2 * 1024+misalignedOffset, aFileSize, aUpdate);
+ DoTestFileWrite(4 * 1024+misalignedOffset, aFileSize, aUpdate);
+ DoTestFileWrite(8 * 1024+misalignedOffset, aFileSize, aUpdate);
+ DoTestFileWrite(16 * 1024+misalignedOffset, aFileSize, aUpdate);
+ DoTestFileWrite(32 * 1024+misalignedOffset, aFileSize, aUpdate);
+ DoTestFileWrite(64 * 1024+misalignedOffset, aFileSize, aUpdate);
+ DoTestFileWrite(128 * 1024+misalignedOffset, aFileSize, aUpdate);
+ DoTestFileWrite(256 * 1024+misalignedOffset, aFileSize, aUpdate);
+ DoTestFileWrite(512 * 1024+misalignedOffset, aFileSize, aUpdate);
+ DoTestFileWrite(1024 * 1024+misalignedOffset, aFileSize, aUpdate);
+#else
+ DoTestFileWrite(16+misalignedOffset, aFileSize, aUpdate);
+ DoTestFileWrite(512+misalignedOffset, aFileSize, aUpdate);
+ DoTestFileWrite(4096+misalignedOffset, aFileSize, aUpdate);
+ DoTestFileWrite(32768+misalignedOffset, aFileSize, aUpdate);
+ DoTestFileWrite(64 * 1024+misalignedOffset, aFileSize, aUpdate);
+ DoTestFileWrite(K1M+misalignedOffset, aFileSize, aUpdate);
+#endif
+ }
+
+
+
+LOCAL_C void DoTestFileWriteCPU(TInt aBlockSize)
+//
+// Benchmark CPU utilisation for Write method
+//
+// Write 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 Write method.
+//
+ {
+ DataBuf.SetLength(aBlockSize);
+
+ TFileName testDir(_L("?:\\F32-TST\\"));
+ testDir[0] = (TText) gDriveToTest;
+ TInt r = TheFs.MkDir(testDir);
+ test(r == KErrNone || r == KErrAlreadyExists);
+
+ TFileName fileName;
+ enum {EFileWriteDirectIO = 0x00001000, EFileWriteBuffered = 0x00000800};
+ r = File.Temp(TheFs, testDir, fileName, EFileWrite | (gWriteCachingOn ? EFileWriteBuffered : EFileWriteDirectIO));
+ test(r == KErrNone);
+
+ TUint functionCalls = 0;
+ TUint fltPntCalls = 0;
+ RThread fltPntThrd;
+
+ TBuf<6> buf = _L("Floaty");
+ fltPntThrd.Create(buf, FloatingPointLoop, KDefaultStackSize, KHeapSize, KHeapSize, (TAny*) &fltPntCalls);
+
+ TUint initTicks = 0;
+ TUint finalTicks = 0;
+
+ // 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);
+
+ RTimer timer;
+ timer.CreateLocal();
+ TRequestStatus reqStat;
+
+ TInt pos = 0;
+ File.Seek(ESeekStart, pos);
+
+ timer.After(reqStat, KFloatingPointTestTime);
+ initTicks = User::FastCounter();
+
+ fltPntThrd.Resume();
+
+ for (TInt i = 0 ; reqStat==KRequestPending; i++)
+ {
+ File.Write(DataBuf, aBlockSize);
+ functionCalls++;
+ }
+ TUint fltPntCallsFinal = fltPntCalls;
+
+ fltPntThrd.Kill(KErrNone);
+
+ finalTicks = User::FastCounter();
+
+ fltPntThrd.Close();
+ User::WaitForRequest(req);
+
+ TTimeIntervalMicroSeconds duration = TInt64(finalTicks - initTicks) * TInt64(1000000) / TInt64(gFastCounterFreq) ;
+
+ TInt dataTransferred = functionCalls * aBlockSize;
+ TReal transferRate = TReal32(dataTransferred) /
+ TReal(duration.Int64()) * TReal(1000000) / TReal(K1K); // KB/s
+
+ test.Printf(_L("Write %7d bytes in %7d byte blocks:\t%11.3f KBytes/s; %d Flt Calcs\n"),
+ dataTransferred, aBlockSize, transferRate, fltPntCallsFinal);
+
+ timer.Close();
+
+ File.Close();
+ r = TheFs.Delete(fileName);
+ test_KErrNone(r)
+
+ return;
+ }
+
+
+LOCAL_C void TestFileWriteCPU(TBool aMisalignedReadWrites = EFalse)
+//
+// Benchmark CPU utilisation for Write method
+//
+ {
+ ClearSessionDirectory();
+ test.Next(_L("Benchmark Write method CPU Utilisation"));
+
+ test.Printf(_L("MisalignedReadWrites %d\n"), aMisalignedReadWrites);
+ TInt misalignedOffset = aMisalignedReadWrites ? 1 : 0;
+
+ DoTestFileWriteCPU(1+misalignedOffset);
+ DoTestFileWriteCPU(2+misalignedOffset);
+ DoTestFileWriteCPU(4+misalignedOffset);
+ DoTestFileWriteCPU(8+misalignedOffset);
+ DoTestFileWriteCPU(16+misalignedOffset);
+ DoTestFileWriteCPU(32+misalignedOffset);
+ DoTestFileWriteCPU(64+misalignedOffset);
+ DoTestFileWriteCPU(128+misalignedOffset);
+ DoTestFileWriteCPU(256+misalignedOffset);
+ DoTestFileWriteCPU(512+misalignedOffset);
+ DoTestFileWriteCPU(1024+misalignedOffset);
+ DoTestFileWriteCPU(2 * 1024+misalignedOffset);
+ DoTestFileWriteCPU(4 * 1024+misalignedOffset);
+ DoTestFileWriteCPU(8 * 1024+misalignedOffset);
+ DoTestFileWriteCPU(16 * 1024+misalignedOffset);
+ DoTestFileWriteCPU(32 * 1024+misalignedOffset);
+ DoTestFileWriteCPU(64 * 1024+misalignedOffset);
+ DoTestFileWriteCPU(128 * 1024+misalignedOffset);
+ DoTestFileWriteCPU(256 * 1024+misalignedOffset);
+ DoTestFileWriteCPU(512 * 1024+misalignedOffset);
+ DoTestFileWriteCPU(K1M+misalignedOffset);
+ }
+
+
+LOCAL_C void TestFileSeek()
+//
+// Benchmark file seek method
+//
+ {
+ ClearSessionDirectory();
+ test.Next(_L("RFile::Seek method"));
+ TInt increment=1789; // random number > cluster size
+ TInt count=0;
+ TInt pos=0;
+
+ // Create test file
+ TBuf8<1024> testdata(1024);
+ RFile f;
+ TInt r=f.Create(TheFs,_L("SEEKTEST"),EFileStream);
+ test(r==KErrNone);
+ count=64;
+ while (count--)
+ f.Write(testdata);
+ TInt fileSize=count*testdata.MaxLength();
+
+ pos=0;
+ count=0;
+ RTimer timer;
+ timer.CreateLocal();
+ TRequestStatus reqStat;
+ timer.After(reqStat,10000000); // After 10 secs
+ while(reqStat==KRequestPending)
+ {
+ TInt dum=(pos+=increment)%fileSize;
+ f.Seek(ESeekStart,dum);
+ count++;
+ }
+ test.Printf(_L("RFile::Seek operations in 10 secs == %d\n"),count);
+ timer.Close();
+
+ f.Close();
+ TheFs.Delete(_L("SEEKTEST"));
+ }
+
+#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
+
+LOCAL_C void CreateManyLargFiles(TInt aNumber)
+//
+// Make a directory with aNumber entries
+//
+ {
+ RFile64 f;
+ TInt maxEntry=aNumber;
+
+ test.Printf(_L("Create a directory with %d entries\n"),aNumber);
+
+ TFileName sessionPath;
+ TInt r=TheFs.SessionPath(sessionPath);
+ test(r==KErrNone);
+ r=TheFs.MkDir(_L("\\F32-TST\\"));
+ test((r==KErrNone)||(r==KErrAlreadyExists));
+ r=TheFs.MkDir(_L("\\F32-TST\\BENCH_DELETE\\"));
+ test((r==KErrNone)||(r==KErrAlreadyExists));
+ TBuf8<8> WriteData =_L8("Wibbleuy");
+ for (TInt i=0;i<maxEntry;i++)
+ {
+ TFileName baseName=_L("\\F32-TST\\BENCH_DELETE\\FILE");
+ baseName.AppendNum(i);
+ r=f.Replace(TheFs,baseName,EFileWrite);
+ test(r==KErrNone);
+ r = f.SetSize(K3GB);
+ test(r==KErrNone);
+ r=f.Write((K3GB-30),WriteData);
+ test(r==KErrNone);
+ f.Flush();
+ f.Close();
+ }
+
+ test.Printf(_L("Test all entries have been created successfully\n"));
+ TBuf8<8> ReadData;
+ TInt64 Size=0;
+ for (TInt j=0;j<=maxEntry;j++)
+ {
+ TFileName baseName=_L("\\F32-TST\\BENCH_DELETE\\FILE");
+ baseName.AppendNum(j);
+
+ TInt r=f.Open(TheFs,baseName,EFileRead);
+ if (r!=KErrNone)
+ {
+ test(r==KErrNotFound && j==maxEntry);
+ return;
+ }
+ ReadData.FillZ();
+ r=f.Read((K3GB-30),ReadData);
+ test(r==KErrNone);
+ test(f.Size(Size)==KErrNone);
+ test(K3GB == Size);
+ test(ReadData==WriteData);
+ f.Close();
+ }
+ }
+
+
+LOCAL_C void TestLargeFileDelete()
+//
+// This test require MMC/SD card size >=4GB-2 in size
+//
+ {
+ ClearSessionDirectory();
+ test.Next(_L("Benchmark delete large file"));
+
+ TInt64 total=0;
+
+ TInt cycles=1;
+
+ TInt i=0;
+
+ //check Disk space and decide how many files to create
+ TVolumeInfo volInfo;
+ TInt r;
+
+ r = TheFs.Volume(volInfo);
+ test(r == KErrNone);
+
+ TInt numberOfFiles = (TUint)(volInfo.iFree/(K4GB -2));
+ test.Printf(_L("Number of large files =%d \n"),numberOfFiles);
+
+ if(numberOfFiles<=0)
+ {
+ test.Printf(_L("Large File delete is skipped \n"));
+ return;
+ }
+
+ for (; i<cycles; i++)
+ {
+ // Create many files
+ CreateManyLargFiles(numberOfFiles);
+
+ test.Next(_L("Time the delete"));
+ // Now delete them and time it
+ TTime startTime;
+ startTime.HomeTime();
+
+ for (TInt index=0;index<numberOfFiles;index++)
+ {
+ TFileName baseName=_L("\\F32-TST\\BENCH_DELETE\\FILE");
+ baseName.AppendNum(index);
+
+ TInt r=TheFs.Delete(baseName);
+ test(r==KErrNone);
+ }
+
+ TTime endTime;
+ endTime.HomeTime();
+ TTimeIntervalMicroSeconds timeTaken;
+ timeTaken=endTime.MicroSecondsFrom(startTime);
+ TInt64 time=timeTaken.Int64();
+ total+=time;
+ }
+// We deleted cycles*numberOfFiles files in total microseconds
+ TInt64 fileDeleteTime=total/(numberOfFiles*cycles);
+ test.Next(_L("Benchmarked RFs::Delete()"));
+ test.Printf(_L("Delete time per file = %d microseconds\n"),fileDeleteTime);
+
+ CFileMan* fMan=CFileMan::NewL(TheFs);
+ total=0;
+
+ cycles=1;
+ i=0;
+ for (; i<cycles; i++)
+ {
+ // Create many files
+ CreateManyLargFiles(numberOfFiles);
+
+ test.Next(_L("Time the delete"));
+ // Now delete them and time it
+ TTime startTime;
+ startTime.HomeTime();
+
+ for (TInt index=0;index<numberOfFiles;index++)
+ {
+ TInt r=fMan->Delete(_L("\\F32-TST\\BENCH_DELETE\\FILE*"));
+ test(r==KErrNone || r==KErrNotFound);
+ }
+
+ TTime endTime;
+ endTime.HomeTime();
+ TTimeIntervalMicroSeconds timeTaken;
+ timeTaken=endTime.MicroSecondsFrom(startTime);
+ TInt64 time=timeTaken.Int64();
+ total+=time;
+ }
+// We deleted cycles*numberOfFiles files in total microseconds
+ fileDeleteTime=total/(numberOfFiles*cycles);
+ test.Next(_L("Benchmarked CFileMan::Delete()"));
+ test.Printf(_L("Delete time per file = %d microseconds\n"),fileDeleteTime);
+
+ delete fMan;
+}
+
+#endif //SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
+
+
+LOCAL_C void CreateManyFiles(TInt aNumber)
+//
+// Make a directory with aNumber entries
+//
+ {
+ RFile f;
+ TInt maxEntry=aNumber;
+
+ test.Printf(_L("Create a directory with %d entries\n"),aNumber);
+
+ TFileName sessionPath;
+ TInt r=TheFs.SessionPath(sessionPath);
+ test(r==KErrNone);
+ r=TheFs.MkDir(_L("\\F32-TST\\"));
+ test((r==KErrNone)||(r==KErrAlreadyExists));
+ r=TheFs.MkDir(_L("\\F32-TST\\BENCH_DELETE\\"));
+ test((r==KErrNone)||(r==KErrAlreadyExists));
+
+ for (TInt i=0;i<maxEntry;i++)
+ {
+ TFileName baseName=_L("\\F32-TST\\BENCH_DELETE\\FILE");
+ baseName.AppendNum(i);
+ r=f.Replace(TheFs,baseName,EFileRead);
+ test(r==KErrNone);
+ r=f.Write(_L8("Wibble"));
+ test(r==KErrNone);
+ f.Close();
+ }
+
+ test.Printf(_L("Test all entries have been created successfully\n"));
+ for (TInt j=0;j<=maxEntry;j++)
+ {
+ TFileName baseName=_L("\\F32-TST\\BENCH_DELETE\\FILE");
+ baseName.AppendNum(j);
+ TInt r=f.Open(TheFs,baseName,EFileRead);
+ if (r!=KErrNone)
+ {
+ test(r==KErrNotFound && j==maxEntry);
+ return;
+ }
+ TBuf8<16> data;
+ r=f.Read(data);
+ test(r==KErrNone);
+ test(data==_L8("Wibble"));
+ f.Close();
+ }
+ }
+
+
+LOCAL_C void TestFileDelete()
+//
+//
+//
+ {
+ ClearSessionDirectory();
+ test.Next(_L("Benchmark delete"));
+
+ TInt64 total=0;
+ TInt numberOfFiles=100;
+ TInt cycles=1;
+
+ TInt i=0;
+ for (; i<cycles; i++)
+ {
+ // Create many files
+ CreateManyFiles(numberOfFiles);
+
+ test.Next(_L("Time the delete"));
+ // Now delete them and time it
+ TTime startTime;
+ startTime.HomeTime();
+
+ for (TInt index=0;index<numberOfFiles;index++)
+ {
+ TFileName baseName=_L("\\F32-TST\\BENCH_DELETE\\FILE");
+ baseName.AppendNum(index);
+
+ TInt r=TheFs.Delete(baseName);
+ test(r==KErrNone);
+ }
+
+ TTime endTime;
+ endTime.HomeTime();
+ TTimeIntervalMicroSeconds timeTaken;
+ timeTaken=endTime.MicroSecondsFrom(startTime);
+ TInt64 time=timeTaken.Int64();
+ total+=time;
+ }
+// We deleted cycles*numberOfFiles files in total microseconds
+ TInt64 fileDeleteTime=total/(numberOfFiles*cycles);
+ test.Next(_L("Benchmarked RFs::Delete()"));
+ test.Printf(_L("Delete time per file = %d microseconds\n"),fileDeleteTime);
+
+ CFileMan* fMan=CFileMan::NewL(TheFs);
+ total=0;
+ numberOfFiles=100;
+ cycles=1;
+ i=0;
+ for (; i<cycles; i++)
+ {
+ // Create many files
+ CreateManyFiles(numberOfFiles);
+
+ test.Next(_L("Time the delete"));
+ // Now delete them and time it
+ TTime startTime;
+ startTime.HomeTime();
+
+ for (TInt index=0;index<numberOfFiles;index++)
+ {
+ TInt r=fMan->Delete(_L("\\F32-TST\\BENCH_DELETE\\FILE*"));
+ test(r==KErrNone || r==KErrNotFound);
+ }
+
+ TTime endTime;
+ endTime.HomeTime();
+ TTimeIntervalMicroSeconds timeTaken;
+ timeTaken=endTime.MicroSecondsFrom(startTime);
+ TInt64 time=timeTaken.Int64();
+ total+=time;
+ }
+// We deleted cycles*numberOfFiles files in total microseconds
+ fileDeleteTime=total/(numberOfFiles*cycles);
+ test.Next(_L("Benchmarked CFileMan::Delete()"));
+ test.Printf(_L("Delete time per file = %d microseconds\n"),fileDeleteTime);
+
+ delete fMan;
+}
+
+
+/*
+TInt maxDirEntry=200;
+LOCAL_C void TestDirRead()
+//
+// Benchmark directory read method
+//
+ {
+
+ ClearSessionDirectory();
+ test.Next(_L("Benchmark directory read method"));
+// Create one test entry
+ RFile f;
+ f.Create(TheFs,_L("ONE.XXX"),EFileStream);
+ f.Close();
+ TTime start;
+ start.HomeTime();
+ TInt i=0;
+ for (i=0;i<maxDirEntry;i++)
+ {
+ CDir* dirPtr;
+ TheFs.GetDir(_L("*"),KEntryAttMaskSupported,ESortByName,dirPtr);
+ delete dirPtr;
+ }
+ TTime end;
+ end.HomeTime();
+ DirReadOne=end.MicroSecondsFrom(start);
+// Create lost of test entries
+ for (i=0;i<maxDirEntry;i++)
+ {
+ TBuf<12> baseName(_L("MANY"));
+ baseName.AppendNum(i,EHex);
+ baseName.Append(_L(".TXT"));
+ RFile f;
+ f.Create(TheFs,baseName,EFileStream);
+ f.Close();
+ }
+ start.HomeTime();
+ CDir* dirPtr;
+ TheFs.GetDir(_L("*"),KEntryAttMaskSupported,ESortByName,dirPtr);
+ delete dirPtr;
+ end.HomeTime();
+ DirReadMany=end.MicroSecondsFrom(start);
+// Select one entry from lots
+ start.HomeTime();
+ TheFs.GetDir(_L("*.XXX"),KEntryAttMaskSupported,ESortByName,dirPtr);
+ end.HomeTime();
+ test(dirPtr->Count()==1);
+ delete dirPtr;
+ DirMatchOne=end.MicroSecondsFrom(start);
+ }
+
+
+void LOCAL_C PrintDirResults()
+//
+// Print results of Directory Benchmark
+//
+ {
+ test.Printf(_L("\nBenchmark: Dir Results\n"));
+ test.Printf(_L("Read one entry %d times = %d ms\n"),maxDirEntry,DirReadOne.Int64().GetTInt()/1000);
+ test.Printf(_L("Read %d entries = %d ms\n"),maxDirEntry,DirReadMany.Int64().GetTInt()/1000);
+ test.Printf(_L("Match 1 entry from %d entries = %d ms\n"),maxDirEntry,DirMatchOne.Int64().GetTInt()/1000);
+ test.Printf(_L("Press Enter to continue\n\n"));
+ test.Getch();
+ }
+*/
+
+
+LOCAL_C void TestMkDir()
+ {
+ test.Next(_L("Benchmark MkDir"));
+ ClearSessionDirectory();
+
+ TTime startTime;
+ TTime endTime;
+ TTimeIntervalMicroSeconds timeTaken(0);
+ startTime.HomeTime();
+
+ const TInt KNumDirEntries = 100;
+ for (TInt n=0; n<KNumDirEntries; n++)
+ {
+ TFileName dirName = _L("\\F32-TST\\DIR_");
+ dirName.AppendNum(n);
+ dirName.Append(_L("\\"));
+ TInt r = TheFs.MkDir(dirName);
+ test(r == KErrNone);
+ }
+
+ endTime.HomeTime();
+ timeTaken=endTime.MicroSecondsFrom(startTime);
+ TInt timeTakenInMs = I64LOW(timeTaken.Int64() / 1000);
+ test.Printf(_L("Time taken to create %d entries = %d ms\n"), KNumDirEntries, timeTakenInMs);
+ }
+
+
+// Allocate Data Buffers for Read/Write Tests
+void AllocateBuffers()
+ {
+ test.Printf(_L("Allocate Buffers -"));
+
+ if (gFragSharedMemory || gSharedMemory)
+ {
+ test.Printf(_L("Shared Memory\n"));
+
+ RLoader l;
+ test(l.Connect()==KErrNone);
+ test(l.CancelLazyDllUnload()==KErrNone);
+ l.Close();
+
+ test.Printf(_L("Initialise\n"));
+ TInt r = UserHal::PageSizeInBytes(PageSize);
+ test(r==KErrNone);
+
+ test.Printf(_L("Loading test driver\n"));
+ r = User::LoadLogicalDevice(KSharedChunkLddName);
+ test(r==KErrNone || r==KErrAlreadyExists);
+
+ test.Printf(_L("Opening channel\n"));
+ r = Ldd.Open();
+ test(r==KErrNone);
+
+ test.Printf(_L("Create chunk\n"));
+
+ TUint aCreateFlags = EMultiple|EOwnsMemory;
+ TCommitType aCommitType = EContiguous;
+
+ TUint TotalChunkSize = ChunkSize; // rounded to nearest Page Size
+
+ TUint ChunkAttribs = TotalChunkSize|aCreateFlags;
+ r = Ldd.CreateChunk(ChunkAttribs);
+ test(r==KErrNone);
+
+ if (gSharedMemory)
+ {
+ test.Printf(_L("Commit Contigouos Memory\n"));
+ r = Ldd.CommitMemory(aCommitType,TotalChunkSize);
+ test(r==KErrNone);
+ }
+ else
+ {
+ test.Printf(_L("Commit Fragmented Memory\n"));
+
+ // Allocate Pages in reverse order to maximise memory fragmentation
+ TUint i = ChunkSize;
+ do
+ {
+ i-=PageSize;
+ test.Printf(_L("Commit %d\n"), i);
+ r = Ldd.CommitMemory(aCommitType|i,PageSize);
+ test(r==KErrNone);
+ }while (i>0);
+/*
+ for (TInt i = (ChunkSize-PageSize); i>=0; )
+ {
+ test.Printf(_L("Commit %d\n"), i);
+ r = Ldd.CommitMemory(aCommitType|i,PageSize);
+ test(r==KErrNone);
+ i-=PageSize;
+ }
+*/
+ }
+
+ test.Printf(_L("\nOpen user handle\n"));
+ r = Ldd.GetChunkHandle(TheChunk);
+ test(r==KErrNone);
+
+ DataBuf.Set(TheChunk.Base(),KMaxFileSize, KMaxFileSize);
+ }
+ else
+ {
+ test.Printf(_L("Heap Memory\n"));
+ DataBufH = HBufC8::New(KMaxFileSize);
+ test(DataBufH != NULL);
+
+ DataBuf.Set(DataBufH->Des());
+ }
+ }
+
+
+void DeAllocateBuffers()
+ {
+ test.Printf(_L("DeAllocate Buffers -"));
+
+ if (gFragSharedMemory || gSharedMemory)
+ {
+ test.Printf(_L("Shared Memory\n"));
+ test.Printf(_L("Close user chunk handle\n"));
+ TheChunk.Close();
+
+ test.Printf(_L("Close kernel chunk handle\n"));
+ TInt r = Ldd.CloseChunk();
+ test(r==1);
+
+ test.Printf(_L("Check chunk is destroyed\n"));
+ r = Ldd.IsDestroyed();
+ test(r==1);
+
+ test.Printf(_L("Close test driver\n"));
+ Ldd.Close();
+ }
+ else
+ {
+ test.Printf(_L("Heap Memory\n"));
+ test.Printf(_L("Delete Heap Buffer\n"));
+ delete DataBufH;
+ }
+ }
+
+void ParseCommandLine()
+ {
+ TBuf<0x100> cmd;
+ User::CommandLine(cmd);
+ TLex lex(cmd);
+
+ for (TPtrC token=lex.NextToken(); token.Length() != 0;token.Set(lex.NextToken()))
+ {
+ if (token.MatchF(RProcess().FileName())==0)
+ {
+ continue;
+ }
+
+ if (token.CompareF(_L("-m"))== 0)
+ {
+ gMisalignedReadWrites = ETrue;
+ continue;
+ }
+ if (token.CompareF(_L("-r"))== 0)
+ {
+ gReadCachingOn = EFalse;
+ continue;
+ }
+ if (token.CompareF(_L("+r"))== 0)
+ {
+ gReadCachingOn = ETrue;
+ continue;
+ }
+ if (token.CompareF(_L("-w"))== 0)
+ {
+ gWriteCachingOn = EFalse;
+ continue;
+ }
+ if (token.CompareF(_L("+w"))== 0)
+ {
+ gWriteCachingOn = ETrue;
+ continue;
+ }
+
+ if (token.CompareF(_L("-f"))== 0)
+ {
+ gFlushAfterWrite = EFalse;
+ continue;
+ }
+ if (token.CompareF(_L("+f"))== 0)
+ {
+ gFlushAfterWrite = ETrue;
+ continue;
+ }
+ if (token.CompareF(_L("+s"))== 0)
+ {
+ gSharedMemory = ETrue;
+ continue;
+ }
+ if (token.CompareF(_L("+x"))== 0)
+ {
+ gFragSharedMemory = ETrue;
+ continue;
+ }
+
+ test.Printf(_L("CLP=%S\n"),&token);
+
+ if(token.Length()!=0)
+ {
+ gDriveToTest=token[0];
+ gDriveToTest.UpperCase();
+ }
+ else
+ gDriveToTest='C';
+
+#if defined SYMBIAN_TEST_COPY
+ token.Set(lex.NextToken());
+ if(token.Length()!=0)
+ {
+ gDriveToTest2=token[0];
+ gDriveToTest2.UpperCase();
+ }
+ else
+ gDriveToTest2='C';
+ test.Printf(_L("CLP2=%S\n"),&token);
+#endif
+
+ }
+ }
+
+
+GLDEF_C void CallTestsL(void)
+//
+// Call all tests
+//
+ {
+ test.Title();
+ test.Start(_L("Start Benchmarking ..."));
+
+ test.Next(gSessionPath);
+
+ ParseCommandLine();
+
+ AllocateBuffers();
+ RProcess().SetPriority(EPriorityBackground);
+
+ TInt r = HAL::Get(HAL::EFastCounterFrequency, gFastCounterFreq);
+ test(r == KErrNone);
+ test.Printf(_L("HAL::EFastCounterFrequency %d\n"), gFastCounterFreq);
+
+ test.Printf(_L("gReadCachingOn %d gWriteCachingOn %d gFlushAfterWrite %d\n"), gReadCachingOn, gWriteCachingOn, gFlushAfterWrite);
+
+ TestFileSeek();
+
+ // read once
+ TestFileRead(KMaxFileSize, gMisalignedReadWrites, EFalse);
+
+ // re-read
+ TestFileRead(KMaxFileSize, gMisalignedReadWrites, ETrue);
+
+ TestFileReadCPU(gMisalignedReadWrites);
+
+ // append to file
+ TestFileWrite(KMaxFileSize, gMisalignedReadWrites, EFalse);
+
+ // update (overwrite) file
+ TestFileWrite(KMaxFileSize, gMisalignedReadWrites, ETrue);
+
+ TestFileWriteCPU(gMisalignedReadWrites);
+
+ TestFileDelete();
+
+// TestDirRead();
+// PrintDirResults();
+#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
+ TestLargeFileDelete();
+#endif //SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
+
+ TestMkDir();
+
+ RecursiveRmDir(gSessionPath);
+
+ DeAllocateBuffers();
+
+ test.End();
+ test.Close();
+ }