FCL/sf/os/kernelhwsrv: comparison kerneltest/f32test/server/t

equal deleted inserted replaced

-:75252ea6123b
+:c7a0ce20c48c
 #include <e32test.h>
 #include <e32svr.h>
 #include <f32dbg.h>
 #include "t_server.h"
 #include <e32twin.h>
+#include <hal.h>
+#include "tf32testtimer.h"
 const TInt KTotalCacheSize = 32 * 1024 * 1024;
 const TInt KDefaultCacheSize = (128 + 12) * 1024; 	// This size is the default configuration size
 const TInt KFilesNeededToFillCache = (KTotalCacheSize / KDefaultCacheSize) + 2;
 const TInt KMinSize = 254; // Boundary minim limit
 const TInt KOneK = 1024;
 const TInt KOneMeg = KOneK * 1024;
 const TInt KBlockSize = KOneK;
 const TInt KWaitRequestsTableSize = 256;
-const TInt KMs = 1000;
 TInt gSecondFileSize = 0;
 TInt gFirstFileSize = 0;
 TInt64 gMediaSize = 0;
 TBuf16<25> gFirstFile;
 TBuf16<25> gSecondFile;
 TBuf16<25> gCurrentFile;
 TInt gNextFile = 0;
-TTime gTime1;
-TTime gTime2;
 // Concurrent Threads
 RThread gThread1;
 RSemaphore gClient;
 const TInt KHeapSize = 0x4000;
 	@param aBlockSize 	Size of the block
 	@param aMode 		Mode in which the file is going to be opened
 	@return time taken to perform the operation in uS
 */
-TInt WriteTestFile(RFile& aFile, TDes16& aFileName, TInt aSize, TInt aBlockSize, TInt aMode)
+TTimeIntervalMicroSeconds WriteTestFile(RFile& aFile, TDes16& aFileName, TInt aSize, TInt aBlockSize, TInt aMode)
 	{
 	RTest test(_L("T_WCACHE"));
-	TTime startTime;
-	TTime endTime;
 	TInt r = 0;
-	startTime.HomeTime();
+TF32TestTimer timer;
+	timer.Start();
 	r = WriteFile(gTheFs,aFile, aFileName , aSize * KOneK, aBlockSize, gBufWritePtr, aMode);
 	test_KErrNone(r);
-	endTime.HomeTime();
+	timer.Stop();
+	gTimeTakenBigFile = timer.Time();
-	gTimeTakenBigFile = I64LOW(endTime.MicroSecondsFrom(startTime).Int64());
 	test.Close();
-	return I64LOW(gTimeTakenBigFile.Int64());
+	return timer.Time();
 	}
 /** Measure the time taken for this file to be read synchronously
 	@param aFile 	 	File object
 	@param aMode 		Mode in which the file is going to be opened
 	@return time taken to perform the operation in uS
 */
-TInt ReadTestFile(RFile& aFile, TDes16& aFileName, TInt aSize, TInt aBlockSize, TInt aMode)
+TTimeIntervalMicroSeconds ReadTestFile(RFile& aFile, TDes16& aFileName, TInt aSize, TInt aBlockSize, TInt aMode)
 	{
-	TTime startTime;
+TF32TestTimer timer;
-	TTime endTime;
+	timer.Start();
-	startTime.HomeTime();
 	ReadFile(gTheFs,aFile, aFileName, aSize * KOneK, aBlockSize, aMode);
-	endTime.HomeTime();
+	timer.Stop();
-	gTimeTakenBigFile = I64LOW(endTime.MicroSecondsFrom(startTime).Int64());
+	gTimeTakenBigFile = timer.Time();
-	return I64LOW(gTimeTakenBigFile.Int64()) ;
+	return timer.Time();
 	}
 /** Read asynchronously the test file from the disc
 	@param aFile 	 	File object
 	@param aBlockSize 	Size of the block
 	@param aMode 		Mode in which the file is going to be opened
 	@return time taken to perform the operation in uS
 */
-TInt ReadAsyncTestFile(RFile& file, TDes16& aFile, TInt aSize, TInt aBlockSize, TInt aMode)
+TTimeIntervalMicroSeconds ReadAsyncTestFile(RFile& file, TDes16& aFile, TInt aSize, TInt aBlockSize, TInt aMode)
 	{
-	TTime startTime;
-	TTime endTime;
 	TRequestStatus status[KWaitRequestsTableSize];
+TF32TestTimer timer;
-	startTime.HomeTime();
+	timer.Start();
 	ReadFileAsync(gTheFs, file, aFile, aSize * KOneK, aBlockSize, status, aMode);
 	WaitForAll(status,  (aSize * KOneK)/KBlockSize);
+	timer.Stop();
-	endTime.HomeTime();
+	gTimeTakenBigFile = timer.Time();
-	gTimeTakenBigFile = I64LOW(endTime.MicroSecondsFrom(startTime).Int64());
+	return timer.Time();
-	return I64LOW(gTimeTakenBigFile.Int64());
 	}
 /** Read asynchronously the test file from the disc
 	@param aFile 	 	File object
 	@param aSize 		Size in kilobytes
 	@param aMode 		Mode in which the file is going to be opened
 	@return time taken to perform the operation in uS
 */
-TInt WriteAsyncTestFile(RFile& aFile, TDes16& aFileName, TInt aSize, TInt aMode)
+TTimeIntervalMicroSeconds WriteAsyncTestFile(RFile& aFile, TDes16& aFileName, TInt aSize, TInt aMode)
 	{
-	TTime startTime;
-	TTime endTime;
 	TRequestStatus status[KWaitRequestsTableSize];
+TF32TestTimer timer;
-	startTime.HomeTime();
+timer.Start();
 	WriteFileAsync(gTheFs, aFile, aFileName, aSize * KOneK, aMode, status );
 	WaitForAll(status, (aSize * KOneK)/KBlockSize);
+	timer.Stop();
-	endTime.HomeTime();
+	gTimeTakenBigFile = timer.Time();
-	gTimeTakenBigFile = I64LOW(endTime.MicroSecondsFrom(startTime).Int64());
+	return timer.Time();
-	return I64LOW(gTimeTakenBigFile.Int64());
 	}
 /**  Test Boundaries
 	This function is testing the behaviour on the boundaries of the write cache size
 */
 void TestBoundaries()
 	{
 	TInt r = 0;
-	TInt time = 0;
+	TTimeIntervalMicroSeconds time = 0;
-	TInt rtime = 0;
+	TTimeIntervalMicroSeconds rtime = 0;
-	TInt tcreate = 0;
+	TTimeIntervalMicroSeconds tcreate = 0;
 	RFile fileWriter;
 	RFile fileWriter2;
 	RFile fileReader;
 	test.Start(_L("Test Boundaries"));
 	while(i < KMaxSize)
 		{
 		test.Printf(_L("\nSync: Write from 1 K to %d K \n"), i);
 		tcreate = WriteTestFile(fileWriter, gSecondFile, i, KBlockSize, EFileShareAny|EFileWrite|EFileWriteDirectIO);
-		test.Printf(_L("Time to write %d K without caching: %d mS\n"), i, tcreate/KMs);
+		test.Printf(_L("Time to write %d K without caching: %d mS\n"), i, TF32TestTimer::TimeInMilliSeconds(tcreate));
 		fileWriter.Close();
 		time =  WriteTestFile(fileWriter2, gFirstFile, i, KBlockSize, EFileShareAny|EFileWrite|EFileWriteBuffered);
-		test.Printf(_L("Time to write %d K WITH caching: %d mS\n"), i, time/KMs);
+		test.Printf(_L("Time to write %d K WITH caching: %d mS\n"), i, TF32TestTimer::TimeInMilliSeconds(time));
 		rtime = ReadTestFile(fileReader, gFirstFile, i, KBlockSize, EFileShareAny|EFileRead|EFileReadBuffered);
-		test.Printf(_L("Time to read %d K from the cache: %d mS\n"), i, rtime/KMs);
+		test.Printf(_L("Time to read %d K from the cache: %d mS\n"), i, TF32TestTimer::TimeInMilliSeconds(rtime));
 		fileReader.Close();
 		fileWriter2.Close();
 		#if !defined(__WINS__)
-			test((tcreate > time) || (tcreate > rtime));
+test(tcreate > TTimeIntervalMicroSeconds(0));  // test measured time is correct
+			test(tcreate > time);
+test(tcreate > rtime);
 		#endif
 		r = gTheFs.Delete(gFirstFile);
 		test_KErrNone(r);
 		r = gTheFs.Delete(gSecondFile);
 	while(i < KMaxSize)
 		{
 		test.Printf(_L("\nAsync: Write from 1 K to %d K \n"), i);
 		tcreate = WriteAsyncTestFile(fileWriter, gSecondFile, i, EFileShareAny|EFileWrite|EFileWriteDirectIO);
-		test.Printf(_L("Time to write %d K without caching: %d mS\n"), i, tcreate/KMs);
+		test.Printf(_L("Time to write %d K without caching: %d mS\n"), i, TF32TestTimer::TimeInMilliSeconds(tcreate));
 		fileWriter.Close();
 		time =  WriteAsyncTestFile(fileWriter2, gFirstFile, i,EFileShareAny|EFileWrite|EFileWriteBuffered);
-		test.Printf(_L("Time to write %d K WITH caching: %d mS\n"), i, time/KMs);
+		test.Printf(_L("Time to write %d K WITH caching: %d mS\n"), i, TF32TestTimer::TimeInMilliSeconds(time));
 		rtime = ReadAsyncTestFile(fileReader, gFirstFile, i, KBlockSize, EFileShareAny|EFileRead|EFileReadBuffered);
-		test.Printf(_L("Time to read %d K from the cache: %d mS\n"), i, rtime/KMs);
+		test.Printf(_L("Time to read %d K from the cache: %d mS\n"), i, TF32TestTimer::TimeInMilliSeconds(rtime));
 		fileReader.Close();
 		fileWriter2.Close();
 		#if !defined(__WINS__)
-			test((tcreate > time) || (tcreate > rtime));
+test(tcreate > TTimeIntervalMicroSeconds(0));  // test measured time is correct
+			test(tcreate > time);
+test(tcreate > rtime);
 		#endif
 		r = gTheFs.Delete(gFirstFile);
 		test_KErrNone(r);
 		r = gTheFs.Delete(gSecondFile);
 	@param aFile file name to verify
 	@return returns the time that took to do the verification in mS, fails if the file is not corrupted/modified
 */
-TInt ReadTestFileVerif(TDes16& aFile)
+TTimeIntervalMicroSeconds ReadTestFileVerif(TDes16& aFile)
 	{
-	TTime startTime;
-	TTime endTime;
 	TInt r = 0;
 	TInt size = 0;
 	RFile fileRead;
 	TInt corrupt = 0;
 	TBool isFat=IsFSFAT(gTheFs,gDrive);
-	startTime.HomeTime();
+TF32TestTimer timer;
+	timer.Start();
 	r = fileRead.Open(gTheFs,aFile,EFileShareAny|EFileRead|EFileReadBuffered|EFileReadAheadOff);
 	test_KErrNone(r);
 	r = fileRead.Size(size);
 		}
 	fileRead.Close();
 	test(corrupt>0); // Ensure the cache returns the changed content
+	timer.Stop();
-	endTime.HomeTime();
+	gTimeTakenBigFile = timer.Time();
-	gTimeTakenBigFile = I64LOW(endTime.MicroSecondsFrom(startTime).Int64());
+	return timer.Time();
-	return I64LOW(gTimeTakenBigFile.Int64()) / KMs;
 	}
 /**  Modifies the second file
 */
 */
 LOCAL_C void TestIntegrity()
 	{
 	TInt r = 0;
-	TInt time;
+	TTimeIntervalMicroSeconds time;
-	TInt tcreate = 0;
+	TTimeIntervalMicroSeconds tcreate = 0;
 	RFile file;
 	// Modify file in some position
 	test.Printf(_L("Overwrite partially a file\n"));
 	test.Printf(_L("\nSync: Write from 1 K to %d K \n"), 255);
 	tcreate = WriteTestFile(file, gSecondFile, 255, KBlockSize, EFileShareAny|EFileWrite|EFileWriteBuffered);
-	test.Printf(_L("Time to write %d K with caching: %d mS\n"), 255, tcreate/KMs);
+	test.Printf(_L("Time to write %d K with caching: %d mS\n"), 255, TF32TestTimer::TimeInMilliSeconds(tcreate));
 	file.Close();
 	test.Printf(_L("Mess the content that is still in the cache\n"));
 	CorruptSecondFile();
 	time = ReadTestFileVerif(gSecondFile);
-	test.Printf(_L("Time taken to verify: %d\n"),time);
+	test.Printf(_L("Time taken to verify: %ld\n"),time.Int64());
 	test.Printf(_L("Integrity verified\n"));
 	r = DeleteAllL(gSessionPath);
 	test_KErrNone(r);
 /** Manual test for card removal
 */
 void TestRemoval()
 	{
-	TInt time = 0, rtime = 0;
+	TTimeIntervalMicroSeconds time = 0, rtime = 0;
 	RFile file1, file2;
 	TInt r = gClient.CreateLocal(0);
 	test_KErrNone(r);
 	test.Printf(_L("\nSync: Write from 1 K to 254 K \n"));
 	time =  WriteTestFile(file1, gSecondFile, KMinSize, KBlockSize, EFileShareAny|EFileWrite|EFileWriteBuffered);
-	test.Printf(_L("Time to write %d K WITH caching: %d mS\n"), KMinSize, time/KMs);
+	test.Printf(_L("Time to write %d K WITH caching: %d mS\n"), KMinSize, TF32TestTimer::TimeInMilliSeconds(time));
 	test.Printf(_L("Remove MMC card,! and then press a key\n"));
 	test.Getch();
 	test.Printf(_L("Wait 3 seconds and insert MMC card! and then press a key\n"));
 	test.Getch();
 	rtime = ReadTestFile(file2, gSecondFile, KMinSize, KBlockSize, EFileShareAny|EFileRead|EFileReadBuffered);
-	test.Printf(_L("Time to read %d K from the cache: %d mS\n"), KMinSize, rtime/KMs);
+	test.Printf(_L("Time to read %d K from the cache: %d mS\n"), KMinSize, TF32TestTimer::TimeInMilliSeconds(rtime));
 	test.Printf(_L("Remove MMC card! and then press a key\n"));
 	test.Getch();
 	test.Printf(_L("Wait 3 seconds and insert MMC card! and then press a key\n"));
 	test.Printf(_L("\nSync: Write from 1 K to 255 K \n"));
 	time =  WriteTestFile(file1, gFirstFile, KMinSize + 1 , KBlockSize, EFileShareAny|EFileWrite|EFileWriteBuffered);
-	test.Printf(_L("Time to write %d K WITH caching: %d mS\n"), KMinSize + 1, time/KMs);
+	test.Printf(_L("Time to write %d K WITH caching: %d mS\n"), KMinSize + 1, TF32TestTimer::TimeInMilliSeconds(time));
 	test.Printf(_L("Remove MMC card and delete the file //F32-TST//FFFFFFF0.TXT and then press a key\n"));
 	test.Getch();
 	test.Printf(_L("Wait 3 seconds and insert MMC card! and then press a key\n"));
 	test.Getch();
 	rtime = ReadTestFile(file2, gFirstFile, KMinSize + 1, KBlockSize, EFileShareAny|EFileRead|EFileReadBuffered);
-	test.Printf(_L("Time to read %d K from the cache: %d mS\n"), KMinSize + 1, rtime/KMs);
+	test.Printf(_L("Time to read %d K from the cache: %d mS\n"), KMinSize + 1, TF32TestTimer::TimeInMilliSeconds(rtime));
 	test.Printf(_L("Remove MMC card! and then press a key\n"));
 	test.Getch();
 	test.Printf(_L("Wait 3 seconds and insert MMC card! and then press a key\n"));

changeset 243	c7a0ce20c48c
parent 189	a5496987b1da
child 245	647ab20fee2e