kerneltest/e32test/demandpaging/t_datapaging.cpp
changeset 90 947f0dc9f7a8
parent 33 0173bcd7697c
child 132 e4a7b1cbe40c
child 152 657f875b013e
equal deleted inserted replaced
52:2d65c2f76d7b 90:947f0dc9f7a8
    42 #include "t_dpcmn.h"
    42 #include "t_dpcmn.h"
    43 #include "../mmu/mmudetect.h"
    43 #include "../mmu/mmudetect.h"
    44 #include "../mmu/d_memorytest.h"
    44 #include "../mmu/d_memorytest.h"
    45 #include "../mmu/paging_info.h"
    45 #include "../mmu/paging_info.h"
    46 
    46 
       
    47 _LIT(KChunkName, "t_datapaging chunk");
       
    48 
    47 RTest test(_L("T_DATAPAGING"));
    49 RTest test(_L("T_DATAPAGING"));
    48 
    50 SVMSwapInfo InitialSwapInfo;
    49 _LIT(KChunkName, "t_datapaging chunk");
       
    50 
    51 
    51 class TRandom
    52 class TRandom
    52 	{
    53 	{
    53 public:
    54 public:
    54 	TRandom();
    55 	TRandom();
   328 	{
   329 	{
   329 	TUint32 aActual = *aPtr;
   330 	TUint32 aActual = *aPtr;
   330 	if (aActual != aExpected)
   331 	if (aActual != aExpected)
   331 		{
   332 		{
   332 		StopSoakTest(aMsgQueue);
   333 		StopSoakTest(aMsgQueue);
   333 		RDebug::Printf("  thread %d failure reading page %d at iteration %d address %08x: expected %08x but got %08x",
   334 		RDebug::Printf("  thread %d failure reading page %d at iteration %d address %08x line %d: expected %08x but got %08x",
   334 					   aThread, aPage, aIteration, aPtr, aExpected, aActual);
   335 					   aThread, aPage, aIteration, aPtr, aLine, aExpected, aActual);
   335 		return EFalse;
   336 		return EFalse;
   336 		}
   337 		}
   337 	return ETrue;
   338 	return ETrue;
   338 	}
   339 	}
   339 
   340 
   340 TInt SoakTestFunc(TAny* aArg)
   341 TInt SoakTestFunc(TAny* aArg)
   341 	{
   342 	{
   342 	SSoakTestArgs* args = (SSoakTestArgs*)aArg;
   343 	SSoakTestArgs* args = (SSoakTestArgs*)aArg;
   343 
   344 
   344 	
       
   345 	RMsgQueue<TInt> msgQueue;
   345 	RMsgQueue<TInt> msgQueue;
   346 	TInt r = msgQueue.OpenGlobal(KMsgQueueName, EOwnerThread);
   346 	TInt r = msgQueue.OpenGlobal(KMsgQueueName, EOwnerThread);
   347 	if (r != KErrNone)
   347 	if (r != KErrNone)
   348 		return r;
   348 		return r;
   349 
   349 
   593 	SVMSwapInfo swapInfo;
   593 	SVMSwapInfo swapInfo;
   594 	test_KErrNone(UserSvr::HalFunction(EHalGroupVM, EVMHalGetSwapInfo, &swapInfo, 0));
   594 	test_KErrNone(UserSvr::HalFunction(EHalGroupVM, EVMHalGetSwapInfo, &swapInfo, 0));
   595 	test(swapInfo.iSwapFree <= swapInfo.iSwapSize);
   595 	test(swapInfo.iSwapFree <= swapInfo.iSwapSize);
   596 	test.Printf(_L("  Swap size == 0x%x bytes\n"), swapInfo.iSwapSize);
   596 	test.Printf(_L("  Swap size == 0x%x bytes\n"), swapInfo.iSwapSize);
   597 	test.Printf(_L("  Swap free == 0x%x bytes\n"), swapInfo.iSwapFree);
   597 	test.Printf(_L("  Swap free == 0x%x bytes\n"), swapInfo.iSwapFree);
   598 	if (!gDataPagingSupported)
   598 	test(swapInfo.iSwapSize != 0);
   599 		{
   599 	InitialSwapInfo = swapInfo;
   600 		test_Equal(0, swapInfo.iSwapSize);
       
   601 		}
       
   602 	else
       
   603 		{
       
   604 		test(swapInfo.iSwapSize != 0);
       
   605 		
   600 		
   606 		CommitPage(chunk, 0);
   601 	CommitPage(chunk, 0);
   607 		SVMSwapInfo swapInfo2;
   602 	SVMSwapInfo swapInfo2;
   608 		test_KErrNone(UserSvr::HalFunction(EHalGroupVM, EVMHalGetSwapInfo, &swapInfo2, 0));
   603 	test_KErrNone(UserSvr::HalFunction(EHalGroupVM, EVMHalGetSwapInfo, &swapInfo2, 0));
   609 		test_Equal(swapInfo.iSwapSize, swapInfo2.iSwapSize);
   604 	test_Equal(swapInfo.iSwapSize, swapInfo2.iSwapSize);
   610 		test_Equal(swapInfo.iSwapFree - gPageSize, swapInfo2.iSwapFree);
   605 	test_Equal(swapInfo.iSwapFree - gPageSize, swapInfo2.iSwapFree);
   611 		
   606 		
   612 		DecommitPage(chunk, 0);
   607 	DecommitPage(chunk, 0);
   613 		test_KErrNone(UserSvr::HalFunction(EHalGroupVM, EVMHalGetSwapInfo, &swapInfo2, 0));
   608 	test_KErrNone(UserSvr::HalFunction(EHalGroupVM, EVMHalGetSwapInfo, &swapInfo2, 0));
   614 		test_Equal(swapInfo.iSwapSize, swapInfo2.iSwapSize);
   609 	test_Equal(swapInfo.iSwapSize, swapInfo2.iSwapSize);
   615 		test_Equal(swapInfo.iSwapFree, swapInfo2.iSwapFree);
   610 	test_Equal(swapInfo.iSwapFree, swapInfo2.iSwapFree);
   616 
   611 
   617 		// Test that closing the chunk releases the swap page.
   612 	// Test that closing the chunk releases the swap page.
   618 		CommitPage(chunk, 0);
   613 	CommitPage(chunk, 0);
   619 		test_KErrNone(UserSvr::HalFunction(EHalGroupVM, EVMHalGetSwapInfo, &swapInfo2, 0));
   614 	test_KErrNone(UserSvr::HalFunction(EHalGroupVM, EVMHalGetSwapInfo, &swapInfo2, 0));
   620 		test_Equal(swapInfo.iSwapSize, swapInfo2.iSwapSize);
   615 	test_Equal(swapInfo.iSwapSize, swapInfo2.iSwapSize);
   621 		test_Equal(swapInfo.iSwapFree - gPageSize, swapInfo2.iSwapFree);
   616 	test_Equal(swapInfo.iSwapFree - gPageSize, swapInfo2.iSwapFree);
   622 		
   617 		
   623 		chunk.Close();
   618 	chunk.Close();
   624 		test_KErrNone(UserSvr::HalFunction(EHalGroupVM, EVMHalGetSwapInfo, &swapInfo2, 0));
   619 	test_KErrNone(UserSvr::HalFunction(EHalGroupVM, EVMHalGetSwapInfo, &swapInfo2, 0));
   625 		test_Equal(swapInfo.iSwapSize, swapInfo2.iSwapSize);
   620 	test_Equal(swapInfo.iSwapSize, swapInfo2.iSwapSize);
   626 		test_Equal(swapInfo.iSwapFree, swapInfo2.iSwapFree);
   621 	test_Equal(swapInfo.iSwapFree, swapInfo2.iSwapFree);
   627 
   622 
   628 		// Chunk must be created for rest of testing.
   623 	// Chunk must be created for rest of testing.
   629 		test_KErrNone(chunk.Create(createInfo));
   624 	test_KErrNone(chunk.Create(createInfo));
   630 		if (gDataPagingSupported)
   625 	if (gDataPagingSupported)
   631 			test(chunk.IsPaged());
   626 		test(chunk.IsPaged());
   632 		}
       
   633 	
   627 	
   634 	//	EVMHalSetSwapThresholds,
   628 	//	EVMHalSetSwapThresholds,
   635 	test.Next(_L("Test EVMHalSetSwapThresholds"));
   629 	test.Next(_L("Test EVMHalSetSwapThresholds"));
   636 	SVMSwapThresholds thresholds;
   630 	SVMSwapThresholds thresholds;
   637 	thresholds.iLowThreshold = 1;
   631 	thresholds.iLowThreshold = 1;
   686 	thresholds.iLowThreshold = (10 * swapInfo.iSwapSize) / 100;
   680 	thresholds.iLowThreshold = (10 * swapInfo.iSwapSize) / 100;
   687 	thresholds.iGoodThreshold = (20 * swapInfo.iSwapSize) / 100;
   681 	thresholds.iGoodThreshold = (20 * swapInfo.iSwapSize) / 100;
   688 	test_KErrNone(UserSvr::HalFunction(EHalGroupVM, EVMHalSetSwapThresholds, &thresholds, 0));
   682 	test_KErrNone(UserSvr::HalFunction(EHalGroupVM, EVMHalSetSwapThresholds, &thresholds, 0));
   689 
   683 
   690 	CLOSE_AND_WAIT(chunk);
   684 	CLOSE_AND_WAIT(chunk);
       
   685 	}
       
   686 
       
   687 void TestSwapInfoUnchanged()
       
   688 	{
       
   689 	SVMSwapInfo swapInfo;
       
   690 	test_KErrNone(UserSvr::HalFunction(EHalGroupVM, EVMHalGetSwapInfo, &swapInfo, 0));
       
   691 	test.Printf(_L("  Swap size == 0x%x bytes\n"), swapInfo.iSwapSize);
       
   692 	test.Printf(_L("  Swap free == 0x%x bytes\n"), swapInfo.iSwapFree);
       
   693 	test_Equal(InitialSwapInfo.iSwapSize, swapInfo.iSwapSize);
       
   694 	test_Equal(InitialSwapInfo.iSwapFree, swapInfo.iSwapFree);
   691 	}
   695 	}
   692 
   696 
   693 void TestSwapHalNotSupported()
   697 void TestSwapHalNotSupported()
   694 	{
   698 	{
   695 	test_Equal(KErrNotSupported, UserSvr::HalFunction(EHalGroupVM, EVMHalGetSwapInfo, 0, 0));
   699 	test_Equal(KErrNotSupported, UserSvr::HalFunction(EHalGroupVM, EVMHalGetSwapInfo, 0, 0));
  1239 				for (TUint pages = gMaxCacheSize / 2 ; pages <= gMaxCacheSize * 2 ; pages *= 2)
  1243 				for (TUint pages = gMaxCacheSize / 2 ; pages <= gMaxCacheSize * 2 ; pages *= 2)
  1240 					{
  1244 					{
  1241 					for (TUint pin = 0 ; pin <= 1 ; ++pin)
  1245 					for (TUint pin = 0 ; pin <= 1 ; ++pin)
  1242 						{
  1246 						{
  1243 						test.Printf(_L("processes=%d threads=%d pages=%d maxcachesize=%d pin=%d\r\n"),processes, threads, pages, gMaxCacheSize,pin);
  1247 						test.Printf(_L("processes=%d threads=%d pages=%d maxcachesize=%d pin=%d\r\n"),processes, threads, pages, gMaxCacheSize,pin);
  1244 						SoakTest(processes, threads, pages, pin, 3);
  1248 						SoakTest(processes, threads, pages, pin, 5);
  1245 						}
  1249 						}
  1246 					}
  1250 					}
  1247 				}
  1251 				}
  1248 			}
  1252 			}
  1249 
  1253 
  1250 			//Reset the cache size to normal
  1254 		//Reset the cache size to normal
  1251 			test.Next(_L("Soak test: Reset cache size to normal"));
  1255 		test.Next(_L("Soak test: Reset cache size to normal"));
  1252 			test_KErrNone(DPTest::SetCacheSize(cacheOriginalMin, cacheOriginalMax)); 
  1256 		test_KErrNone(DPTest::SetCacheSize(cacheOriginalMin, cacheOriginalMax)); 
       
  1257 
       
  1258 		test.Next(_L("Check we haven't leaked any swap in the course of the test"));
       
  1259 		TestSwapInfoUnchanged();
  1253 		}
  1260 		}
  1254 
  1261 
  1255 	test.End();
  1262 	test.End();
  1256 	return 0;
  1263 	return 0;
  1257 	}
  1264 	}