76 		return SendReceive(aFunction, aPtr);

    60 		return (SendReceive(aFunction, aPtr));

    61 		}

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

    63 		{

    64 		return (Send(aFunction, aPtr));

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

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

    93 	// data.

    72 	// not to access their data.

   109 	CLIENT_TEST(r == KErrNone, r);	

    81 	test_KErrNone(r);

   116 	CLIENT_TEST(r == KErrNone, r);

    86 	test_KErrNone(r);

   117 

    87 

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

    88 

   119 	CLIENT_TEST(r == KErrNone, r);

    89 	RDataPagingSession session;

   120 

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

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

    91 

   122 	CLIENT_TEST(r == KErrNone, r);

    92 	RChunk* chunks = new RChunk[chunkCount];

   123 	

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

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

    94 		{

   125 		{

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

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

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

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

   130 			goto exit;

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

   131 			}

   100 				chunks[j].Close();

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

   101 			session.Close();

   133 		}

   102 			return r;

   134 

   103 			}

   135 	// Logon to parent process

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

   136 	parent.Logon(parentStatus);

   105 		}

   137 

   106 	if (!accessData)

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

   107 		{

   139 	do

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

   140 		{

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

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

   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++)

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

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

   162 			}

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

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

   137 				offset = 0;

   164 		}

   138 			}

   165 	while (accessData);

   139 		}

   166 

   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;

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

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

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

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

   237 	TInt r;

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

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

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

   239 		{

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

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

   150 	const TUint KNumChunks = 1000;

   241 		PrintFreeRam();

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

   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;

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

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

   265 	r = ptServer.CreateGlobal(KClientPtServerName);

   170 	TInt r = ptServer.CreateGlobal(KClientPtServerName);

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

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

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

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

   270 	RChunk* chunks = new RChunk[KChunksPerProcess];

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

   271 	test_NotNull(chunks);

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

   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);

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

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

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

   186 		{

   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 		}

   279 	test_NotNull(processes);

   200 	RMessage2 ptMessage;

   280 	TRequestStatus* statuses = new TRequestStatus[KNumProcesses];

   201 	TUint processIndex = 0;

   281 	test_NotNull(statuses);

   202 	TUint processLimit = 0;

   282 	TUint processIndex = 0;	

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

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

   287 		

   207 		TBuf<80> args;

   288 		// logon to process

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

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

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

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

   210 		test_KErrNone(r);

   211 		TRequestStatus s;

   212 		processes[processIndex].Logon(s);

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

   298 

   219 		TInt func = EClientGetChunk;

   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;

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

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

   311 			if (func != EClientGetChunk)

   225 			if (func == EClientGetChunk)

   312 				break;

   226 				{

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

   227 				TUint index = ptMessage.Int0();

   228 				ptMessage.Complete(chunks[index]);

   229 				}

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

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

   333 		test_Equal(KChunksPerProcess, chunkIndex);

   248 		test_Equal(KNumChunks, chunkIndex);

   334 		}

   249 		}

   335 	

   338 	TUint processLimit = processIndex;

   252 	processLimit = processIndex;

   339 

   253 

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

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

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

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

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

   256 	// long enough already.

   348 		// start the process.

   262 		// Start the process.

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

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

   350 

   264 		TBuf<80> args;

   351 		// logon to process

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

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

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

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

   267 		if (r != KErrNone)

   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());

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

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

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

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

   388 		test_Equal(KChunksPerProcess, chunkIndex);

   304 		test_Equal(KNumChunks, chunkIndex);

   389 		}

   305 		}

   390 	

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

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

   404 		if (statuses[j] == KRequestPending)

   313 		TRequestStatus req;

   314 		processes[j].Logon(req);

   315 		if (req == KRequestPending)

   316 			{

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

   321 		}

   408 		}

   322 	delete[] processes;

   409 	delete [] processes;

   410 	delete [] statuses;

   411 	

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

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

   416 

   327 	

   417 	// Reset live list size