kerneltest/e32test/pccd/t_pccdbm.cpp
changeset 0 a41df078684a
child 33 0173bcd7697c
equal deleted inserted replaced
-1:000000000000 0:a41df078684a
       
     1 // Copyright (c) 1996-2009 Nokia Corporation and/or its subsidiary(-ies).
       
     2 // All rights reserved.
       
     3 // This component and the accompanying materials are made available
       
     4 // under the terms of the License "Eclipse Public License v1.0"
       
     5 // which accompanies this distribution, and is available
       
     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     7 //
       
     8 // Initial Contributors:
       
     9 // Nokia Corporation - initial contribution.
       
    10 //
       
    11 // Contributors:
       
    12 //
       
    13 // Description:
       
    14 // e32test\pccd\t_pccdbm.cpp
       
    15 // 
       
    16 //
       
    17 #include "../mmu/d_sharedchunk.h"
       
    18 #include <hal.h>
       
    19 #include <e32test.h>
       
    20 #include <e32svr.h>
       
    21 #include <e32hal.h>
       
    22 #include <e32uid.h>
       
    23 
       
    24 const TInt K1K = 1024;
       
    25 const TInt K4K = 4096;
       
    26 const TInt K1MB = K1K*K1K;
       
    27 const TInt KMaxTestSize = K1MB;     // Redefine to increase test length
       
    28 const TInt KVeryLongRdWrBufLen=((KMaxTestSize*2)+K4K);	// Double Max Test size + 4K
       
    29 
       
    30 LOCAL_D TPtr8 DataBuf(NULL, KVeryLongRdWrBufLen,KVeryLongRdWrBufLen);
       
    31 LOCAL_D HBufC8* wrBufH = NULL;
       
    32 
       
    33 LOCAL_D TInt DriveNumber;
       
    34 LOCAL_D TBusLocalDrive TheDrive;
       
    35 LOCAL_D TBool IsReadOnly;
       
    36 
       
    37 LOCAL_D RSharedChunkLdd Ldd;
       
    38 LOCAL_D RChunk TheChunk;
       
    39 const TUint ChunkSize = KVeryLongRdWrBufLen;
       
    40 
       
    41 const TTimeIntervalMicroSeconds32 KFloatingPointTestTime = 10000000;	// 10 seconds
       
    42 LOCAL_D TInt gFastCounterFreq;
       
    43 LOCAL_D TBool ChangeFlag;
       
    44 
       
    45 RTest test(_L("Local Drive BenchMark Test"));
       
    46 
       
    47 ///// Buffer Allocation
       
    48 void AllocateBuffers()
       
    49 	{
       
    50 	test.Next(_L("Allocate Buffers"));
       
    51 
       
    52 	wrBufH = HBufC8::New(KVeryLongRdWrBufLen);
       
    53 	test(wrBufH != NULL);
       
    54 	}
       
    55 	
       
    56 void AllocateSharedBuffers(TBool Fragmented, TBool Caching)
       
    57 	{
       
    58 	// Setup SharedMemory Buffers
       
    59 	test.Next(_L("Allocate Shared Memory\n"));
       
    60 	
       
    61 	RLoader l;
       
    62 	test(l.Connect()==KErrNone);
       
    63 	test(l.CancelLazyDllUnload()==KErrNone);
       
    64 	l.Close();
       
    65 
       
    66 	test.Printf(_L("Initialise\n"));
       
    67 	TInt PageSize = 0;
       
    68 	TInt r = UserHal::PageSizeInBytes(PageSize);
       
    69 	test(r==KErrNone);
       
    70 
       
    71 	test.Printf(_L("Loading test driver\n"));
       
    72 	r = User::LoadLogicalDevice(KSharedChunkLddName);
       
    73 	test(r==KErrNone || r==KErrAlreadyExists);
       
    74 
       
    75 	test.Printf(_L("Opening channel\n"));
       
    76 	r = Ldd.Open();
       
    77 	test(r==KErrNone);
       
    78 
       
    79 	test.Printf(_L("Create chunk\n"));
       
    80 	
       
    81 	TUint aCreateFlags = EMultiple|EOwnsMemory;
       
    82 	
       
    83 	if (Caching)
       
    84 		{
       
    85 		test.Printf(_L("Chunk Type:Caching\n"));
       
    86 		aCreateFlags |= ECached;
       
    87 		}
       
    88 	else
       
    89 		test.Printf(_L("Chunk Type:Fully Blocking\n"));
       
    90 	
       
    91     TCommitType aCommitType = EContiguous;
       
    92       
       
    93     TUint TotalChunkSize = ChunkSize;  // rounded to nearest Page Size
       
    94     
       
    95 	TUint ChunkAttribs = TotalChunkSize|aCreateFlags;	
       
    96 	r = Ldd.CreateChunk(ChunkAttribs);
       
    97 	test(r==KErrNone);
       
    98 
       
    99 	if(Fragmented)
       
   100 		{
       
   101 		test.Printf(_L("Commit Fragmented Memory\n"));
       
   102 			
       
   103 		// Allocate Pages in reverse order to maximise memory fragmentation
       
   104 		TUint i = ChunkSize;
       
   105 		do
       
   106 			{
       
   107 			i-=PageSize;
       
   108 			test.Printf(_L("Commit %d\n"), i);
       
   109 			r = Ldd.CommitMemory(aCommitType|i,PageSize);
       
   110 			test(r==KErrNone);
       
   111 			}while (i>0);
       
   112 		}
       
   113 	else
       
   114 		{
       
   115 		test.Printf(_L("Commit Contigouos Memory\n"));
       
   116 		r = Ldd.CommitMemory(aCommitType,TotalChunkSize);
       
   117 		test(r==KErrNone);
       
   118 		}
       
   119 
       
   120 	test.Printf(_L("Open user handle\n"));
       
   121 	r = Ldd.GetChunkHandle(TheChunk);
       
   122 	test(r==KErrNone);
       
   123 	
       
   124 	}
       
   125 
       
   126 void DeAllocateBuffers()
       
   127 	{
       
   128 	delete wrBufH;
       
   129 	}
       
   130 
       
   131 void DeAllocareSharedMemory()
       
   132 	{
       
   133 // destory chunk
       
   134 	test.Printf(_L("Shared Memory\n"));
       
   135 	test.Printf(_L("Close user chunk handle\n"));
       
   136 	TheChunk.Close();
       
   137 
       
   138 	test.Printf(_L("Close kernel chunk handle\n"));
       
   139 	TInt r = Ldd.CloseChunk();  // 1==DObject::EObjectDeleted
       
   140 	test(r==1);
       
   141 
       
   142 	test.Printf(_L("Check chunk is destroyed\n"));
       
   143 	r = Ldd.IsDestroyed();
       
   144 	test(r==1);
       
   145         
       
   146 	test.Printf(_L("Close test driver\n"));
       
   147 	Ldd.Close();
       
   148 	}
       
   149 
       
   150 // end Buffer allocation
       
   151 
       
   152 
       
   153 LOCAL_C void FillRegion(TInt aBlockSize)
       
   154 /**
       
   155  * Fill media starting at pos 0, 
       
   156  * with a pattern of 2*aBlockSize in length
       
   157  */
       
   158 	{
       
   159 	test.Printf(_L("Fill Region with Data!\n"));
       
   160 	DataBuf.SetLength(aBlockSize);
       
   161 		
       
   162 	//fill up buffer
       
   163 	for (TInt i=0;i<(aBlockSize);i++)
       
   164 		{
       
   165 		DataBuf[i]=(TUint8)(0xFF-i);
       
   166 		}
       
   167 	
       
   168 	TInt r = TheDrive.Write(0, DataBuf);
       
   169 	test (r == KErrNone);
       
   170 	}
       
   171 
       
   172 LOCAL_C void DoTestRead(TInt aBlockSize)
       
   173 // 
       
   174 // Multiple Read operations of aBlockSize are performed for 10 seconds.
       
   175 // Average is then displayed.
       
   176 //
       
   177 	{
       
   178 	DataBuf.SetLength(aBlockSize);
       
   179 	
       
   180 	TUint functionCalls = 0;
       
   181 	TUint initTicks = 0;
       
   182 	TUint finalTicks = 0;
       
   183 
       
   184 	RTimer timer;
       
   185 	timer.CreateLocal();
       
   186 	TRequestStatus reqStat;
       
   187 
       
   188 	TInt pos = 0;
       
   189 
       
   190 	timer.After(reqStat, KFloatingPointTestTime);
       
   191 	initTicks = User::FastCounter();
       
   192 	
       
   193 	for (TInt i = 0; reqStat==KRequestPending; i++)
       
   194 		{
       
   195 		TInt r = TheDrive.Read(pos, aBlockSize, DataBuf);
       
   196 		
       
   197 		test (r == KErrNone);
       
   198 		
       
   199 		pos += aBlockSize;
       
   200 		if (pos > KVeryLongRdWrBufLen-aBlockSize)
       
   201 			pos = 0;
       
   202 
       
   203 		functionCalls++;
       
   204 		}
       
   205 
       
   206 	finalTicks = User::FastCounter();
       
   207 	timer.Close();
       
   208 	
       
   209 	TTimeIntervalMicroSeconds duration = TInt64(finalTicks - initTicks) * TInt64(1000000) / TInt64(gFastCounterFreq) ;
       
   210 
       
   211 	TInt dataTransferred = functionCalls * aBlockSize;
       
   212 	TReal transferRate =  TReal32(dataTransferred) / 
       
   213 						 TReal(duration.Int64()) * TReal(1000000) / TReal(K1K); // KB/s
       
   214 		
       
   215 	test.Printf(_L("Read  %7d bytes in %7d byte blocks:\t%11.3f KBytes/s\n"), 
       
   216 				    dataTransferred, aBlockSize, transferRate);
       
   217 
       
   218 	return;
       
   219 	}	
       
   220 
       
   221 
       
   222 LOCAL_C void TestRead()
       
   223 /**
       
   224  * Repeat read test for values between 1Byte and KMaxTestSize, in steps of power of 2
       
   225  */
       
   226 	{
       
   227 	FillRegion(KVeryLongRdWrBufLen);
       
   228 	
       
   229 	for (TInt i = 1; i<=KMaxTestSize; i*=2)
       
   230 		{
       
   231 		DoTestRead(i);
       
   232 		}
       
   233 	}
       
   234 
       
   235 LOCAL_C void DoTestWrite(TInt aBlockSize)
       
   236 // 
       
   237 // Multiple Write operations of aBlockSize are performed for 10 seconds.
       
   238 // Average is then displayed.
       
   239 //
       
   240 	{
       
   241 	DataBuf.SetLength(aBlockSize);
       
   242 	
       
   243 	//fill up buffer
       
   244 	for (TInt i=0;i<aBlockSize;i++)
       
   245 		{
       
   246 		DataBuf[i]=(TUint8)(0xFF-i);
       
   247 		}
       
   248 	
       
   249 	TUint functionCalls = 0;
       
   250 	TUint initTicks = 0;
       
   251 	TUint finalTicks = 0;
       
   252 
       
   253 	RTimer timer;
       
   254 	timer.CreateLocal();
       
   255 	TRequestStatus reqStat;
       
   256 
       
   257 	TInt pos = 0;
       
   258 
       
   259 	timer.After(reqStat, KFloatingPointTestTime);
       
   260 	initTicks = User::FastCounter();
       
   261 	
       
   262 	for (TInt j = 0; reqStat==KRequestPending; j++)
       
   263 		{
       
   264 		TInt r = TheDrive.Write(pos, DataBuf);
       
   265 		
       
   266 		test (r == KErrNone);
       
   267 		
       
   268 		pos += aBlockSize;
       
   269 		if (pos > KVeryLongRdWrBufLen-aBlockSize)
       
   270 			pos = 0;
       
   271 
       
   272 		functionCalls++;
       
   273 		}
       
   274 
       
   275 	finalTicks = User::FastCounter();
       
   276 	timer.Close();
       
   277 	
       
   278 	TTimeIntervalMicroSeconds duration = TInt64(finalTicks - initTicks) * TInt64(1000000) / TInt64(gFastCounterFreq) ;
       
   279 
       
   280 	TInt dataTransferred = functionCalls * aBlockSize;
       
   281 	TReal transferRate =  TReal32(dataTransferred) / 
       
   282 						 TReal(duration.Int64()) * TReal(1000000) / TReal(K1K); // KB/s
       
   283 		
       
   284 	test.Printf(_L("Write %7d bytes in %7d byte blocks:\t%11.3f KBytes/s\n"), 
       
   285 				    dataTransferred, aBlockSize, transferRate);
       
   286 
       
   287 	return;
       
   288 	}	
       
   289 
       
   290 LOCAL_C void TestWrite()
       
   291 /**
       
   292  * Repeat write test for values between 1Byte and KMaxTestSize, in steps of power of 2
       
   293  */
       
   294 	{
       
   295 	for (TInt i = 1; i<=KMaxTestSize; i*=2)
       
   296 		{
       
   297 		DoTestWrite(i);
       
   298 		}
       
   299 	}
       
   300 
       
   301 TBool TestDriveInfo()
       
   302 	{
       
   303 	test.Next( _L("Test drive info") );
       
   304 	
       
   305 	TLocalDriveCapsV6Buf DriveCaps;
       
   306 	TheDrive.Caps( DriveCaps );
       
   307 
       
   308 	test.Printf( _L("Caps V1:\n\tiSize=0x%lx\n\tiType=%d\n\tiBattery=%d\n\tiDriveAtt=0x%x\n\tiMediaAtt=0x%x\n\tiBaseAddress=0x%x\n\tiFileSystemId=0x%x\n\tiPartitionType=0x%x\n"),
       
   309 			DriveCaps().iSize,
       
   310 			DriveCaps().iType,
       
   311 			DriveCaps().iBattery,
       
   312 			DriveCaps().iDriveAtt,
       
   313 			DriveCaps().iMediaAtt,
       
   314 			DriveCaps().iBaseAddress,
       
   315 			DriveCaps().iFileSystemId,
       
   316 			DriveCaps().iPartitionType );
       
   317 
       
   318 	test.Printf( _L("Caps V2:\n\tiHiddenSectors=0x%x\n\tiEraseBlockSize=0x%x\nCaps V3:\n\tiExtraInfo=%x\n\tiMaxBytesPerFormat=0x%x\n"),
       
   319 			DriveCaps().iHiddenSectors,
       
   320 			DriveCaps().iEraseBlockSize, 
       
   321 			DriveCaps().iExtraInfo,
       
   322 			DriveCaps().iMaxBytesPerFormat );
       
   323 
       
   324 	test.Printf( _L("Format info:\n\tiCapacity=0x%lx\n\tiSectorsPerCluster=0x%x\n\tiSectorsPerTrack=0x%x\n\tiNumberOfSides=0x%x\n\tiFatBits=%d\n"),
       
   325 			DriveCaps().iFormatInfo.iCapacity,
       
   326 			DriveCaps().iFormatInfo.iSectorsPerCluster,
       
   327 			DriveCaps().iFormatInfo.iSectorsPerTrack,
       
   328 			DriveCaps().iFormatInfo.iNumberOfSides,
       
   329 			DriveCaps().iFormatInfo.iFATBits );
       
   330 
       
   331 	test.Printf( _L("Caps V4:\n"));
       
   332 	test.Printf(_L("\tiNumberOfSectors: %d\r\n"),DriveCaps().iNumberOfSectors);
       
   333 	test.Printf(_L("\tiNumPagesPerBlock: %d\r\n"),DriveCaps().iNumPagesPerBlock);
       
   334 	test.Printf(_L("\tiSectorSizeInBytes: %d\r\n"),DriveCaps().iSectorSizeInBytes);
       
   335 	test.Printf(_L("\tiNumBytesSpare: %d\r\n"),DriveCaps().iNumBytesSpare);
       
   336 	test.Printf(_L("\tiEffectiveBlks: %d\r\n"),DriveCaps().iEffectiveBlks);
       
   337 	test.Printf(_L("\tiStartPage: %d\r\n"),DriveCaps().iStartPage);
       
   338 	test.Printf(_L("\tMediaSizeInBytes: %ld\r\n"),DriveCaps().MediaSizeInBytes());
       
   339 	
       
   340 	test.Printf( _L("Caps V5:\n"));
       
   341 	if(DriveCaps().iSerialNumLength > 0)
       
   342 		{
       
   343         test.Printf( _L("\tiSerialNum : ") );
       
   344         TBuf8<2*KMaxSerialNumLength> snBuf;
       
   345         TUint i;
       
   346 		for (i=0; i<DriveCaps().iSerialNumLength; i++)
       
   347 			{
       
   348             snBuf.AppendNumFixedWidth( DriveCaps().iSerialNum[i], EHex, 2 );
       
   349 			test.Printf( _L("%02x"), DriveCaps().iSerialNum[i]);
       
   350 			}
       
   351 		test.Printf( _L("\n") );
       
   352 		}
       
   353 	else
       
   354 		{
       
   355 		test.Printf( _L("\tiSerialNum : Not Supported") );
       
   356 		}
       
   357 	
       
   358 	test.Printf(_L("Caps V6:\n"));
       
   359 	test.Printf(_L("\tiBlockSize: %d\r\n"),DriveCaps().iBlockSize);
       
   360 	
       
   361 	TBool isReadOnly = DriveCaps().iMediaAtt & KMediaAttWriteProtected;
       
   362 	return(isReadOnly);
       
   363 	}
       
   364 
       
   365 
       
   366 
       
   367 void ParseCommandLineArgs()
       
   368 	{
       
   369 	TBuf<0x100> buf;
       
   370 	
       
   371 	TChar driveToTest;
       
   372 
       
   373 	// Get the list of drives
       
   374 	TDriveInfoV1Buf diBuf;
       
   375 	UserHal::DriveInfo(diBuf);
       
   376 	TDriveInfoV1 &di=diBuf();
       
   377 	TInt driveCount = di.iTotalSupportedDrives;
       
   378 
       
   379 	// Parse command line arguments for the drive to test
       
   380 	User::CommandLine(buf);
       
   381 	TLex lex(buf);
       
   382 	TPtrC token=lex.NextToken();
       
   383 	TFileName thisfile=RProcess().FileName();
       
   384 	if (token.MatchF(thisfile)==0)
       
   385 		{
       
   386 		token.Set(lex.NextToken());
       
   387 		}
       
   388 
       
   389 	if(token.Length()!=0)
       
   390 		{
       
   391 		driveToTest=token[0];
       
   392 		}
       
   393 	else
       
   394 		{		
       
   395 		//Print the list of usable drives
       
   396 		test.Printf(_L("\nDRIVES USED AT PRESENT :\r\n"));
       
   397 
       
   398 		for (TInt i=0; i < driveCount; i++)
       
   399 			{
       
   400 			TBool flag=EFalse;
       
   401 			RLocalDrive d;
       
   402 			TInt r=d.Connect(i,flag);
       
   403 			//Not all the drives are used at present
       
   404 			if (r == KErrNotSupported)
       
   405 				continue;
       
   406 
       
   407 			test.Printf(_L("%d : DRIVE NAME  :%- 16S\r\n"), i, &di.iDriveName[i]);
       
   408 			}	
       
   409 		
       
   410 		test.Printf(_L("\r\nWarning - all data on drive will be lost.\r\n"));
       
   411 		test.Printf(_L("<<<Hit drive number to continue>>>\r\n"));
       
   412 
       
   413 		driveToTest=(TUint)test.Getch();
       
   414 		}
       
   415 
       
   416 	DriveNumber=((TUint)driveToTest) - '0';
       
   417 	test(DriveNumber >= 1 && DriveNumber < di.iTotalSupportedDrives);
       
   418 	}
       
   419 
       
   420 GLDEF_C TInt E32Main()
       
   421     {
       
   422 	test.Title();
       
   423 	test.Start(_L("Benchmark Testing for Local Media Drivers"));
       
   424 	
       
   425 	ParseCommandLineArgs();
       
   426 	
       
   427 	AllocateBuffers();
       
   428 	
       
   429 	test.Printf(_L("Connect to local drive (%d)\n"),DriveNumber);
       
   430 
       
   431 	ChangeFlag=EFalse;
       
   432 	test(TheDrive.Connect(DriveNumber,ChangeFlag)==KErrNone);
       
   433 	
       
   434 	TInt r = HAL::Get(HAL::EFastCounterFrequency, gFastCounterFreq);	
       
   435 	test(r == KErrNone);
       
   436 
       
   437 	IsReadOnly = TestDriveInfo();
       
   438 	
       
   439 	if (IsReadOnly)
       
   440 		{
       
   441 		test.Printf(_L("Drive is read only - can't run test!!\n"));
       
   442 		DeAllocateBuffers();
       
   443 	    test.End();
       
   444 		return(0);
       
   445 		}
       
   446 	
       
   447 // Heap Memory 	
       
   448 	DataBuf.Set(wrBufH->Des());
       
   449 	test.Next(_L("Read Benchmark - Heap Memory"));
       
   450 	TestRead();
       
   451 	test.Next(_L("Write Benchmark - Heap Memory"));
       
   452 	TestWrite();
       
   453 	DeAllocateBuffers();
       
   454 	
       
   455 // Contiguous Shared Chunk	
       
   456 	AllocateSharedBuffers(EFalse, EFalse);
       
   457 	DataBuf.Set(TheChunk.Base(),KVeryLongRdWrBufLen, KVeryLongRdWrBufLen);
       
   458 	test.Next(_L("Read Benchmark - Shared Contiguous Memory"));
       
   459 	TestRead();
       
   460 	test.Next(_L("Write Benchmark - Shared Contiguous Memory"));
       
   461 	TestWrite();
       
   462 	DeAllocareSharedMemory();
       
   463 
       
   464 // Fragmented Shared Chunk	
       
   465 	AllocateSharedBuffers(ETrue, EFalse);
       
   466 	DataBuf.Set(TheChunk.Base(),KVeryLongRdWrBufLen, KVeryLongRdWrBufLen);
       
   467 	test.Next(_L("Read Benchmark - Shared Fragmented Memory"));
       
   468 	TestRead();
       
   469 	test.Next(_L("Write Benchmark - Shared Fragmented Memory"));
       
   470 	TestWrite();
       
   471 	DeAllocareSharedMemory();	
       
   472 	
       
   473     test.End();
       
   474 
       
   475 	return(0);
       
   476 	}
       
   477