60 		return (SendReceive(aFunction, aPtr));

    76 		return SendReceive(aFunction, aPtr);

    61 		}

    62 	TInt PublicSend(TInt aFunction, const TIpcArgs &aPtr)

    63 		{

    64 		return (Send(aFunction, aPtr));

    71 	// Read the command line to get the number of chunk to map and whether or 

    92 	// Read the command line to get the number of chunk to map and whether or not to access their

    72 	// not to access their data.

    93 	// data.

    81 	test_KErrNone(r);

   109 	CLIENT_TEST(r == KErrNone, r);	

    86 	test_KErrNone(r);

   116 	CLIENT_TEST(r == KErrNone, r);

    87 

   117 

    88 

   118 	r = session.CreateSession(KClientPtServerName, 1);

    89 	RDataPagingSession session;

   119 	CLIENT_TEST(r == KErrNone, r);

    90 	test_KErrNone(session.CreateSession(KClientPtServerName, 1));

   120 

    91 

   121 	r = parent.SetReturnedHandle(session.PublicSendReceive(EClientGetParentProcess, TIpcArgs()));

    92 	RChunk* chunks = new RChunk[chunkCount];

   122 	CLIENT_TEST(r == KErrNone, r);

    93 	for (TInt i = 0; i < chunkCount; i++)

   123 	

    94 		{

   124 	for (i = 0; i < chunkCount; i++)

    95 		TInt r = chunks[i].SetReturnedHandle(session.PublicSendReceive(EClientGetChunk, TIpcArgs(i)));

   125 		{

   126 		r = chunks[i].SetReturnedHandle(session.PublicSendReceive(EClientGetChunk, TIpcArgs(i)));

    98 			test.Printf(_L("Failed to create a handle to the server's chunk r=%d\n"), r);

   129 			RDebug::Printf("Failed to create a handle to chunk %d r=%d", i, r);

    99 			for (TInt j = 0; j < i; j++)

   130 			goto exit;

   100 				chunks[j].Close();

   131 			}

   101 			session.Close();

   132 		CLIENT_TEST(chunks[i].Size() >= gPageSize, KErrGeneral);

   102 			return r;

   133 		}

   103 			}

   134 

   104 		test_Value(chunks[i].Size(), chunks[i].Size() >= gPageSize);

   135 	// Logon to parent process

   105 		}

   136 	parent.Logon(parentStatus);

   106 	if (!accessData)

   137 

   107 		{

   138 	// Touch each mapped page of all of the chunks.

   108 		// Touch the 1st page of each of the chunks.

   139 	do

   140 		{

   111 			// Write the chunk data from top to bottom of the chunk's first page.

   143 			for (TUint j = 0 ; j < KPageTablesPerChunk ; j++)

   112 			TUint8* base = chunks[i].Base();

   113 			TUint8* end = base + gPageSize - 1;

   114 			*base = *end;

   115 			}

   116 		// Tell parent we've touched each chunk.

   117 		TInt r =  (TThreadId)session.PublicSendReceive(EClientReadChunks,TIpcArgs());	// Assumes id is only 32-bit.

   118 		test_KErrNone(r);

   119 		for(;;)

   120 			{// Wake up every 100ms to be killed by the main process.

   121 			User::After(100000);

   122 			}

   123 		}

   124 	else

   125 		{

   126 		for (;;)

   127 			{

   128 			TInt offset = 0;

   129 			for (TInt i = 0; i < chunkCount; i++)

   132 				TUint8* base = chunks[i].Base();

   146 				TUint8* base = chunks[i].Base() + j * KSizeMappedByPageTable;

   136 			if (++offset >= (gPageSize >> 1))

   162 			}

   137 				offset = 0;

   163 		offset = (offset + 1) % (gPageSize / 2);

   138 			}

   164 		}

   139 		}

   165 	while (accessData);

   140 	}

   166 

   141 

   167 	// Tell parent we've touched each page.

   168 	r = (TThreadId)session.PublicSendReceive(EClientReadChunks,TIpcArgs());	

   169 	CLIENT_TEST(r == KErrNone, r);

   170 		

   171 	// Wait till we get killed by the main process or the main process dies

   172 	User::WaitForRequest(parentStatus);

   173 	// if we get here the test failed and the main process exited without killing us, so just exit

   174 	r = KErrGeneral;

   175 

   176 exit:

   177 	if (chunks)

   178 		{

   179 		for (TInt i = 0 ; i < chunkCount; ++i)

   180 			chunks[i].Close();

   181 		}

   182 	session.Close();

   183 	parent.Close();

   184 			

   185 	return r;

   186 	}

   187 

   188 TInt FreeSwap()

   189 	{

   190 	SVMSwapInfo swapInfo;

   191 	test_KErrNone(UserSvr::HalFunction(EHalGroupVM, EVMHalGetSwapInfo, &swapInfo, 0));

   192 	return swapInfo.iSwapFree;

   193 	}

   194 

   195 void PrintFreeRam()

   196 	{

   197 	test.Printf(_L("%d KB RAM / %d KB swap free\n"), FreeRam() / 1024, FreeSwap() / 1024);

   198 	}

   199 

   200 void CreateChunk(RChunk& aChunk, TInt aChunkIndex, TInt aPageTables, TBool aPaged)

   201 	{

   202 	// Creates a global chunk.

   203 	//

   204 	// The chunk uses KPageTablesPerChunk page tables by committing that number of pages at 1MB

   205 	// intervals.  Its max size is set so that it is not a multiple of 1MB and hence the FMM will

   206 	// use a fine mapping objects whose page tables are not shared between processes.

   207 	

   208 	test.Printf(_L("  creating chunk %d: "), aChunkIndex);

   209 	PrintFreeRam();

   210 	

   211 	TChunkCreateInfo createInfo;

   212 	createInfo.SetDisconnected(0, 0, aPageTables * KSizeMappedByPageTable + gPageSize);

   213 	createInfo.SetPaging(aPaged ? TChunkCreateInfo::EPaged : TChunkCreateInfo::EUnpaged);

   214 	TBuf<32> name;

   215 	name.AppendFormat(_L("t_pagetable_limit chunk %d"), aChunkIndex);

   216 	createInfo.SetGlobal(name);

   217 	test_KErrNone(aChunk.Create(createInfo));

   218 	for (TInt i = 0 ; i < aPageTables ; ++i)

   219 		test_KErrNone(aChunk.Commit(i * KSizeMappedByPageTable, gPageSize));

   220 	}

   221 

   222 void CreateProcess(RProcess& aProcess, TInt aProcessIndex, TInt aNumChunks, TBool aAccessData)

   223 	{

   224 	test.Printf(_L("  creating process %d: "), aProcessIndex);

   225 	PrintFreeRam();

   226 	

   227 	TBuf<80> args;

   228 	args.AppendFormat(_L("%d %d"), aNumChunks, aAccessData);

   229 	test_KErrNone(aProcess.Create(KClientProcessName, args));

   230 	aProcess.SetPriority(EPriorityLow);

   231 	}

   145 	// Flexible memory model reserves 0xF800000-0xFFF00000 for page tables

   235 	test.Printf(_L("Waiting for system idle and kernel cleanup\n"));

   146 	// this allows 130,048 pages tables.  Therefore mapping 1000 one 

   236 	// If this test was run previously, there may be lots of dead processes waiting to be cleaned up

   147 	// page chunks into 256 processes would require 256,000 page tables, i.e.

   237 	TInt r;

   148 	// more than enough to hit the limit.  So that the limit is reached in the middle,

   238 	while((r = FreeRam(10 * 1000)), r == KErrTimedOut)

   149 	// map 500 unpaged and 500 paged chunks in each process.

   239 		{

   150 	const TUint KNumChunks = 1000;

   240 		test.Printf(_L("  waiting: "));

   151 	const TUint KPagedChunksStart = (KNumChunks >> 1);

   241 		PrintFreeRam();

   152 	const TUint KNumProcesses = 256;

   153 	const TInt KMinFreeRam = (1000 * gPageSize) + (130048 * (gPageSize>>2));

   154 	TInt freeRam;

   155 	HAL::Get(HALData::EMemoryRAMFree, freeRam);

   156 	if (freeRam < KMinFreeRam)

   157 		{

   158 		test.Printf(_L("Only 0x%x bytes of free RAM not enough to perform the test.  Skipping test.\n"), freeRam);

   159 		return;

   166 	DPTest::CacheSize(minCacheSize,maxCacheSize,currentCacheSize);

   249 	test_KErrNone(DPTest::CacheSize(minCacheSize,maxCacheSize,currentCacheSize));

   170 	TInt r = ptServer.CreateGlobal(KClientPtServerName);

   265 	r = ptServer.CreateGlobal(KClientPtServerName);

   173 	// Create the global unpaged chunks.  They have one page committed

   268 	test.Printf(_L("Create chunks\n"));

   174 	// but have a maximum size large enough to prevent their page tables being

   269 	const TUint KPagedChunksStart = (KChunksPerProcess >> 1);

   175 	// shared between the chunks.  On arm with 4KB pages each page table maps 1MB

   270 	RChunk* chunks = new RChunk[KChunksPerProcess];

   176 	// so make chunk 1MB+4KB so chunk requires 2 page tables and is not aligned on

   271 	test_NotNull(chunks);

   177 	// a 1MB boundary so it is a fine memory object.

   178 	const TUint KChunkSize = (1024 * 1024) + gPageSize;

   179 	RChunk* chunks = new RChunk[KNumChunks];

   180 	TChunkCreateInfo createInfo;

   181 	createInfo.SetNormal(gPageSize, KChunkSize);

   182 	createInfo.SetGlobal(KNullDesC);

   183 	createInfo.SetPaging(TChunkCreateInfo::EUnpaged);

   185 	for (; i < KPagedChunksStart; i++)

   273 	for (i = 0 ; i< KChunksPerProcess; i++)

   186 		{

   274 		CreateChunk(chunks[i], i, KPageTablesPerChunk, i >= KPagedChunksStart);

   187 		r = chunks[i].Create(createInfo);

   188 		test_KErrNone(r);

   189 		}

   190 	// Create paged chunks.

   191 	createInfo.SetPaging(TChunkCreateInfo::EPaged);

   192 	for (; i< KNumChunks; i++)

   193 		{

   194 		r = chunks[i].Create(createInfo);

   195 		test_KErrNone(r);

   196 		}

   200 	RMessage2 ptMessage;

   279 	test_NotNull(processes);

   201 	TUint processIndex = 0;

   280 	TRequestStatus* statuses = new TRequestStatus[KNumProcesses];

   202 	TUint processLimit = 0;

   281 	test_NotNull(statuses);

   282 	TUint processIndex = 0;	

   206 		test.Printf(_L("Creating process %d\n"), processIndex);

   286 		CreateProcess(processes[processIndex], processIndex, KChunksPerProcess, EFalse);

   207 		TBuf<80> args;

   287 		

   208 		args.AppendFormat(_L("%d %d"), KNumChunks, EFalse);

   288 		// logon to process

   209 		r = processes[processIndex].Create(KClientProcessName, args);

   289 		processes[processIndex].Logon(statuses[processIndex]);

   210 		test_KErrNone(r);

   290 		test_Equal(KRequestPending, statuses[processIndex].Int());

   211 		TRequestStatus s;

   212 		processes[processIndex].Logon(s);

   213 		test_Equal(KRequestPending, s.Int());

   219 		TInt func = EClientGetChunk;

   298 

   299 		// pass client a handle to this process

   300 		ptServer.Receive(ptMessage);

   301 		test_Equal(EClientGetParentProcess, ptMessage.Function());

   302 		ptMessage.Complete(RProcess());

   303 

   304 		// pass client chunk handles

   305 		TInt func;

   221 		for (; chunkIndex < KNumChunks && func == EClientGetChunk; chunkIndex++)

   307 		for (; chunkIndex < KChunksPerProcess ; chunkIndex++)

   225 			if (func == EClientGetChunk)

   311 			if (func != EClientGetChunk)

   226 				{

   312 				break;

   227 				TUint index = ptMessage.Int0();

   313 			ptMessage.Complete(chunks[ptMessage.Int0()]);

   228 				ptMessage.Complete(chunks[index]);

   229 				}

   237 			test_Value(chunkIndex, chunkIndex < (KNumChunks >> 1));

   321 			test_Value(chunkIndex, chunkIndex < (KChunksPerProcess >> 1));

   248 		test_Equal(KNumChunks, chunkIndex);

   333 		test_Equal(KChunksPerProcess, chunkIndex);

   249 		}

   334 		}

   335 	

   252 	processLimit = processIndex;

   338 	TUint processLimit = processIndex;

   253 

   339 

   254 	// Now create more processes to access paged data even though the page table 

   340 	// Now create more processes to access paged data even though the page table address space has

   255 	// address space has been exhausted.  Limit to 10 more processes as test takes 

   341 	// been exhausted.  Limit to 10 more processes as test takes long enough already.

   256 	// long enough already.

   342 	test.Printf(_L("Start accessor processes\n"));

   262 		// Start the process.

   348 		// start the process.

   263 		test.Printf(_L("Creating process %d\n"), processIndex);

   349 		CreateProcess(processes[processIndex], processIndex, KChunksPerProcess-KPagedChunksStart, ETrue);

   264 		TBuf<80> args;

   350 

   265 		args.AppendFormat(_L("%d %d"), KNumChunks-KPagedChunksStart, ETrue);

   351 		// logon to process

   266 		r = processes[processIndex].Create(KClientProcessName, args);

   352 		processes[processIndex].Logon(statuses[processIndex]);

   267 		if (r != KErrNone)

   353 		test_Equal(KRequestPending, statuses[processIndex].Int());

   268 			{// Have hit the limit of processes.

   269 			processIndex--;

   270 			// Should have created at least one more process.

   271 			test_Value(processIndex, processIndex > processLimit);

   272 			break;

   273 			}

   274 		TRequestStatus s;

   275 		processes[processIndex].Logon(s);

   276 		test_Equal(KRequestPending, s.Int());

   285 		for (; chunkIndex < KNumChunks && func == EClientGetChunk; chunkIndex++)

   369 		for (; chunkIndex < KChunksPerProcess && func == EClientGetChunk; chunkIndex++)

   286 			{// Pass handles to all the unpaged chunks to the new process.

   370 			{// Pass handles to all the paged chunks to the new process.

   304 		test_Equal(KNumChunks, chunkIndex);

   388 		test_Equal(KChunksPerProcess, chunkIndex);

   305 		}

   389 		}

   390 	

   312 		test.Printf(_L("killing process %d\n"), j);

   403 		test.Printf(_L("  killing process %d\n"), j);

   313 		TRequestStatus req;

   404 		if (statuses[j] == KRequestPending)

   314 		processes[j].Logon(req);

   315 		if (req == KRequestPending)

   316 			{

   321 		}

   407 		User::WaitForRequest(statuses[j]);

   322 	delete[] processes;

   408 		}

   409 	delete [] processes;

   410 	delete [] statuses;

   411 	

   324 	for (TUint k = 0; k < KNumChunks; k++)

   413 	for (TUint k = 0; k < KChunksPerProcess; k++)

   327 	

   416 

   417 	// Reset live list size