author | hgs |
Mon, 10 May 2010 11:40:53 +0100 | |
changeset 132 | e4a7b1cbe40c |
parent 31 | 56f325a607ea |
child 176 | af6ec97d9189 |
permissions | -rw-r--r-- |
0 | 1 |
// Copyright (c) 1997-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\mmu\t_ramall.cpp |
|
15 |
// |
|
16 |
// |
|
17 |
||
18 |
#define __E32TEST_EXTENSION__ |
|
19 |
||
20 |
#include <e32test.h> |
|
21 |
#include <e32uid.h> |
|
22 |
#include <e32hal.h> |
|
132 | 23 |
#include <dptest.h> |
0 | 24 |
#include "d_shadow.h" |
25 |
#include "mmudetect.h" |
|
26 |
#include "freeram.h" |
|
27 |
||
28 |
LOCAL_D RTest test(_L("T_RAMALL")); |
|
29 |
||
30 |
_LIT(KLddFileName,"D_SHADOW.LDD"); |
|
31 |
||
32 |
TInt PageSize; |
|
33 |
TInt PageShift; |
|
34 |
RShadow Shadow; |
|
35 |
TInt InitFreeRam; |
|
132 | 36 |
RChunk Chunk; |
37 |
TUint ChunkCommitEnd; |
|
38 |
RThread TouchThread; |
|
39 |
TRequestStatus TouchStatus; |
|
40 |
TBool TouchDataStop; |
|
41 |
RThread FragThread; |
|
42 |
TRequestStatus FragStatus; |
|
43 |
TBool FragThreadStop; |
|
44 |
TBool ManualTest; |
|
45 |
TBool CacheSizeAdjustable; |
|
46 |
TUint OrigMinCacheSize; |
|
47 |
TUint OrigMaxCacheSize; |
|
0 | 48 |
|
49 |
TInt AllocPhysicalRam(TUint32& aAddr, TInt aSize, TInt aAlign) |
|
50 |
{ |
|
51 |
return Shadow.AllocPhysicalRam(aAddr,aSize,aAlign); |
|
52 |
} |
|
53 |
||
54 |
TInt FreePhysicalRam(TUint32 aAddr, TInt aSize) |
|
55 |
{ |
|
56 |
return Shadow.FreePhysicalRam(aAddr,aSize); |
|
57 |
} |
|
58 |
||
59 |
TInt ClaimPhysicalRam(TUint32 aAddr, TInt aSize) |
|
60 |
{ |
|
61 |
return Shadow.ClaimPhysicalRam(aAddr,aSize); |
|
62 |
} |
|
63 |
||
64 |
void TestAlignedAllocs() |
|
65 |
{ |
|
66 |
TInt align; |
|
67 |
TInt size; |
|
68 |
for (align=PageShift; align<=20; ++align) |
|
69 |
{ |
|
70 |
for (size=PageSize; size<=0x100000; size+=PageSize) |
|
71 |
{ |
|
72 |
TInt free=FreeRam(); |
|
73 |
TUint32 pa=0; |
|
74 |
TInt r=AllocPhysicalRam(pa,size,align); |
|
75 |
test.Printf(_L("Size %08x Align %d r=%d pa=%08x\n"),size,align,r,pa); |
|
76 |
if (r==KErrNone) |
|
77 |
{ |
|
78 |
TUint32 as=1u<<align; |
|
79 |
TUint32 am=as-1; |
|
80 |
test(FreeRam()==free-size); |
|
81 |
test((pa&am)==0); |
|
82 |
r=FreePhysicalRam(pa,size); |
|
83 |
test(r==KErrNone); |
|
84 |
} |
|
85 |
test(FreeRam()==free); |
|
86 |
} |
|
87 |
} |
|
88 |
} |
|
89 |
||
90 |
void TestClaimPhys() |
|
91 |
{ |
|
92 |
TInt free=FreeRam(); |
|
31
56f325a607ea
Revision: 200951
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
93 |
|
0 | 94 |
TUint32 pa=0; |
31
56f325a607ea
Revision: 200951
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
95 |
TInt r=AllocPhysicalRam(pa,4*PageSize,0); |
0 | 96 |
test(r==KErrNone); |
97 |
test(FreeRam()==free-4*PageSize); |
|
31
56f325a607ea
Revision: 200951
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
98 |
|
0 | 99 |
r=FreePhysicalRam(pa,4*PageSize); |
100 |
test(r==KErrNone); |
|
101 |
test(FreeRam()==free); |
|
31
56f325a607ea
Revision: 200951
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
102 |
|
56f325a607ea
Revision: 200951
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
103 |
r=ClaimPhysicalRam(pa,4*PageSize); |
0 | 104 |
test(r==KErrNone); |
105 |
test(FreeRam()==free-4*PageSize); |
|
31
56f325a607ea
Revision: 200951
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
106 |
|
0 | 107 |
r=FreePhysicalRam(pa,3*PageSize); |
108 |
test(r==KErrNone); |
|
109 |
test(FreeRam()==free-PageSize); |
|
31
56f325a607ea
Revision: 200951
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
110 |
|
0 | 111 |
r=ClaimPhysicalRam(pa,4*PageSize); |
112 |
test(r==KErrInUse); |
|
113 |
test(FreeRam()==free-PageSize); |
|
31
56f325a607ea
Revision: 200951
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
114 |
|
56f325a607ea
Revision: 200951
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
115 |
#ifdef MANUAL_PANIC_TEST |
56f325a607ea
Revision: 200951
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
116 |
//This section of the test should be run as a manual test as it results in |
56f325a607ea
Revision: 200951
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
117 |
// a panic due to attempting to Free an unclaimed page |
0 | 118 |
if (HaveVirtMem()) |
119 |
{ |
|
31
56f325a607ea
Revision: 200951
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
120 |
test.Printf(_L("HaveVirtMem() \n")); |
0 | 121 |
r=FreePhysicalRam(pa,4*PageSize); |
31
56f325a607ea
Revision: 200951
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
122 |
test.Printf(_L("FreePhysicalRam() \n")); |
0 | 123 |
test(r==KErrGeneral); |
124 |
test(FreeRam()==free-PageSize); |
|
125 |
} |
|
31
56f325a607ea
Revision: 200951
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
126 |
#endif |
56f325a607ea
Revision: 200951
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
127 |
|
0 | 128 |
r=FreePhysicalRam(pa+3*PageSize,PageSize); |
129 |
test(r==KErrNone); |
|
130 |
test(FreeRam()==free); |
|
31
56f325a607ea
Revision: 200951
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
131 |
|
0 | 132 |
} |
133 |
||
132 | 134 |
|
135 |
struct SPhysAllocData |
|
136 |
{ |
|
137 |
TUint iSize; |
|
138 |
TUint iAlign; |
|
139 |
TBool iCheckMaxAllocs; |
|
140 |
TBool iCheckFreeRam; |
|
141 |
}; |
|
142 |
||
143 |
||
144 |
TInt FillPhysicalRam(TAny* aArgs) |
|
145 |
{ |
|
146 |
SPhysAllocData& allocData = *((SPhysAllocData*)aArgs); |
|
147 |
TUint maxAllocs = FreeRam() / allocData.iSize; |
|
148 |
TUint32* physAddrs = new TUint32[maxAllocs + 1]; |
|
149 |
if (!physAddrs) |
|
150 |
return KErrNoMemory; |
|
151 |
TUint32* pa = physAddrs; |
|
152 |
TUint32 alignMask = (1 << allocData.iAlign) - 1; |
|
153 |
TUint initialFreeRam = FreeRam(); |
|
154 |
TInt r = KErrNone; |
|
155 |
TUint allocations = 0; |
|
156 |
for(; allocations <= maxAllocs; ++allocations) |
|
157 |
{ |
|
158 |
TUint freeRam = FreeRam(); |
|
159 |
r = AllocPhysicalRam(*pa, allocData.iSize, allocData.iAlign); |
|
160 |
if (r != KErrNone) |
|
161 |
break; |
|
162 |
if (*pa++ & alignMask) |
|
163 |
{ |
|
164 |
r = KErrGeneral; |
|
165 |
RDebug::Printf("Error alignment phys addr 0x%08x", *(pa - 1)); |
|
166 |
break; |
|
167 |
} |
|
168 |
if (allocData.iCheckFreeRam && freeRam - allocData.iSize != (TUint)FreeRam()) |
|
169 |
{ |
|
170 |
r = KErrGeneral; |
|
171 |
RDebug::Printf("Error in free ram 0x%08x orig 0x%08x", FreeRam(), freeRam); |
|
172 |
break; |
|
173 |
} |
|
174 |
} |
|
175 |
||
176 |
TUint32* physEnd = pa; |
|
177 |
TBool failFrees = EFalse; |
|
178 |
for (pa = physAddrs; pa < physEnd; pa++) |
|
179 |
{ |
|
180 |
if (FreePhysicalRam(*pa, allocData.iSize) != KErrNone) |
|
181 |
failFrees = ETrue; |
|
182 |
} |
|
183 |
if (failFrees) |
|
184 |
r = KErrNotFound; |
|
185 |
if (allocData.iCheckMaxAllocs && allocations > maxAllocs) |
|
186 |
{ |
|
187 |
r = KErrOverflow; |
|
188 |
RDebug::Printf("Error able to allocate too many pages"); |
|
189 |
} |
|
190 |
if (allocData.iCheckFreeRam && initialFreeRam != (TUint)FreeRam()) |
|
191 |
{ |
|
192 |
r = KErrGeneral; |
|
193 |
RDebug::Printf("Error in free ram 0x%08x initial 0x%08x", FreeRam(), initialFreeRam); |
|
194 |
} |
|
195 |
delete[] physAddrs; |
|
196 |
if (r != KErrNone && r != KErrNoMemory) |
|
197 |
return r; |
|
198 |
TUint possibleAllocs = initialFreeRam / allocData.iSize; |
|
199 |
if (allocData.iCheckMaxAllocs && possibleAllocs != allocations) |
|
200 |
{ |
|
201 |
RDebug::Printf("Error in number of allocations possibleAllocs %d allocations %d", possibleAllocs, allocations); |
|
202 |
return KErrGeneral; |
|
203 |
} |
|
204 |
return allocations; |
|
205 |
} |
|
206 |
||
207 |
||
208 |
void TestMultipleContiguousAllocations(TUint aNumThreads, TUint aSize, TUint aAlign) |
|
209 |
{ |
|
210 |
test.Printf(_L("TestMultiContig threads %d size 0x%x, align %d\n"), aNumThreads, aSize, aAlign); |
|
211 |
SPhysAllocData allocData; |
|
212 |
allocData.iSize = aSize; |
|
213 |
allocData.iAlign = aAlign; |
|
214 |
allocData.iCheckMaxAllocs = EFalse; |
|
215 |
allocData.iCheckFreeRam = EFalse; |
|
216 |
// Start several threads all contiguous allocating memory. |
|
217 |
RThread* threads = new RThread[aNumThreads]; |
|
218 |
TRequestStatus* status = new TRequestStatus[aNumThreads]; |
|
219 |
TUint i = 0; |
|
220 |
for (; i < aNumThreads; i++) |
|
221 |
{// Need enough heap to store addr of every possible allocation + 1. |
|
222 |
TUint requiredHeapMax = Max(PageSize, ((InitFreeRam / aSize) / sizeof(TUint32)) + sizeof(TUint32)); |
|
223 |
TInt r = threads[i].Create(KNullDesC, FillPhysicalRam, KDefaultStackSize, PageSize, requiredHeapMax, (TAny*)&allocData); |
|
224 |
test_KErrNone(r); |
|
225 |
threads[i].Logon(status[i]); |
|
226 |
} |
|
227 |
for (i = 0; i < aNumThreads; i++) |
|
228 |
{ |
|
229 |
threads[i].Resume(); |
|
230 |
} |
|
231 |
for (i = 0; i < aNumThreads; i++) |
|
232 |
{ |
|
233 |
User::WaitForRequest(status[i]); |
|
234 |
test_Equal(EExitKill, threads[i].ExitType()); |
|
235 |
TInt exitReason = threads[i].ExitReason(); |
|
236 |
test_Value(exitReason, exitReason >= 0 || exitReason == KErrNoMemory); |
|
237 |
threads[i].Close(); |
|
238 |
} |
|
239 |
delete[] status; |
|
240 |
delete[] threads; |
|
241 |
} |
|
242 |
||
243 |
struct STouchData |
|
244 |
{ |
|
245 |
TUint iSize; |
|
246 |
TUint iFrequency; |
|
247 |
}TouchData; |
|
248 |
||
249 |
||
250 |
TInt TouchMemory(TAny*) |
|
251 |
{ |
|
252 |
while (!TouchDataStop) |
|
253 |
{ |
|
254 |
TUint8* p = Chunk.Base(); |
|
255 |
TUint8* pEnd = p + ChunkCommitEnd; |
|
256 |
TUint8* fragPEnd = p + TouchData.iFrequency; |
|
257 |
for (TUint8* fragP = p + TouchData.iSize; fragPEnd < pEnd;) |
|
258 |
{ |
|
259 |
TUint8* data = fragP; |
|
260 |
for (; data < fragPEnd; data += PageSize) |
|
261 |
{ |
|
262 |
*data = (TUint8)(data - fragP); |
|
263 |
} |
|
264 |
for (data = fragP; data < fragPEnd; data += PageSize) |
|
265 |
{ |
|
266 |
if (*data != (TUint8)(data - fragP)) |
|
267 |
{ |
|
268 |
RDebug::Printf("Error unexpected data 0x%x read from 0x%08x", *data, data); |
|
269 |
return KErrGeneral; |
|
270 |
} |
|
271 |
} |
|
272 |
fragP = fragPEnd + TouchData.iSize; |
|
273 |
fragPEnd += TouchData.iFrequency; |
|
274 |
} |
|
275 |
} |
|
276 |
return KErrNone; |
|
277 |
} |
|
278 |
||
279 |
struct SFragData |
|
280 |
{ |
|
281 |
TUint iSize; |
|
282 |
TUint iFrequency; |
|
283 |
TUint iDiscard; |
|
284 |
TBool iFragThread; |
|
285 |
}FragData; |
|
286 |
||
287 |
void FragmentMemoryFunc() |
|
288 |
{ |
|
289 |
ChunkCommitEnd = 0; |
|
290 |
TInt r; |
|
291 |
while(KErrNone == (r = Chunk.Commit(ChunkCommitEnd,PageSize)) && !FragThreadStop) |
|
292 |
{ |
|
293 |
ChunkCommitEnd += PageSize; |
|
294 |
} |
|
295 |
if (FragThreadStop) |
|
296 |
return; |
|
297 |
test_Equal(KErrNoMemory, r); |
|
298 |
TUint freeBlocks = 0; |
|
299 |
for ( TUint offset = 0; |
|
300 |
(offset + FragData.iSize) < ChunkCommitEnd; |
|
301 |
offset += FragData.iFrequency, freeBlocks++) |
|
302 |
{ |
|
303 |
test_KErrNone(Chunk.Decommit(offset, FragData.iSize)); |
|
304 |
} |
|
305 |
if (!FragData.iFragThread) |
|
306 |
test_Equal(FreeRam(), freeBlocks * FragData.iSize); |
|
307 |
||
308 |
if (FragData.iDiscard && CacheSizeAdjustable && !FragThreadStop) |
|
309 |
{ |
|
310 |
TUint minCacheSize = FreeRam(); |
|
311 |
TUint maxCacheSize = minCacheSize; |
|
312 |
TUint currentCacheSize; |
|
313 |
test_KErrNone(DPTest::CacheSize(OrigMinCacheSize, OrigMaxCacheSize, currentCacheSize)); |
|
314 |
test_KErrNone(DPTest::SetCacheSize(minCacheSize, maxCacheSize)); |
|
315 |
test_KErrNone(DPTest::SetCacheSize(OrigMinCacheSize, maxCacheSize)); |
|
316 |
} |
|
317 |
} |
|
318 |
||
319 |
||
320 |
void UnfragmentMemoryFunc() |
|
321 |
{ |
|
322 |
if (FragData.iDiscard && CacheSizeAdjustable) |
|
323 |
test_KErrNone(DPTest::SetCacheSize(OrigMinCacheSize, OrigMaxCacheSize)); |
|
324 |
Chunk.Decommit(0, Chunk.MaxSize()); |
|
325 |
} |
|
326 |
||
327 |
||
328 |
TInt FragmentMemoryThreadFunc(TAny*) |
|
329 |
{ |
|
330 |
while (!FragThreadStop) |
|
331 |
{ |
|
332 |
FragmentMemoryFunc(); |
|
333 |
UnfragmentMemoryFunc(); |
|
334 |
} |
|
335 |
return KErrNone; |
|
336 |
} |
|
337 |
||
338 |
||
339 |
void FragmentMemory(TUint aSize, TUint aFrequency, TBool aDiscard, TBool aTouchMemory, TBool aFragThread) |
|
340 |
{ |
|
341 |
test_Value(aTouchMemory, !aTouchMemory || !aFragThread); |
|
342 |
test_Value(aSize, aSize < aFrequency); |
|
343 |
FragData.iSize = aSize; |
|
344 |
FragData.iFrequency = aFrequency; |
|
345 |
FragData.iDiscard = aDiscard; |
|
346 |
FragData.iFragThread = aFragThread; |
|
347 |
||
348 |
TChunkCreateInfo chunkInfo; |
|
349 |
chunkInfo.SetDisconnected(0, 0, FreeRam()); |
|
350 |
chunkInfo.SetPaging(TChunkCreateInfo::EUnpaged); |
|
351 |
test_KErrNone(Chunk.Create(chunkInfo)); |
|
352 |
||
353 |
if (aFragThread) |
|
354 |
{ |
|
355 |
TInt r = FragThread.Create(KNullDesC, FragmentMemoryThreadFunc, KDefaultStackSize, PageSize, PageSize, NULL); |
|
356 |
test_KErrNone(r); |
|
357 |
FragThread.Logon(FragStatus); |
|
358 |
FragThreadStop = EFalse; |
|
359 |
FragThread.Resume(); |
|
360 |
} |
|
361 |
else |
|
362 |
{ |
|
363 |
FragmentMemoryFunc(); |
|
364 |
} |
|
365 |
if (aTouchMemory && !ManualTest) |
|
366 |
{ |
|
367 |
TouchData.iSize = aSize; |
|
368 |
TouchData.iFrequency = aFrequency; |
|
369 |
TInt r = TouchThread.Create(KNullDesC, TouchMemory, KDefaultStackSize, PageSize, PageSize, NULL); |
|
370 |
test_KErrNone(r); |
|
371 |
TouchThread.Logon(TouchStatus); |
|
372 |
TouchDataStop = EFalse; |
|
373 |
TouchThread.Resume(); |
|
374 |
} |
|
375 |
} |
|
376 |
||
377 |
||
378 |
void UnfragmentMemory(TBool aDiscard, TBool aTouchMemory, TBool aFragThread) |
|
379 |
{ |
|
380 |
test_Value(aTouchMemory, !aTouchMemory || !aFragThread); |
|
381 |
if (aTouchMemory && !ManualTest) |
|
382 |
{ |
|
383 |
TouchDataStop = ETrue; |
|
384 |
User::WaitForRequest(TouchStatus); |
|
385 |
test_Equal(EExitKill, TouchThread.ExitType()); |
|
386 |
test_KErrNone(TouchThread.ExitReason()); |
|
387 |
CLOSE_AND_WAIT(TouchThread); |
|
388 |
} |
|
389 |
if (aFragThread) |
|
390 |
{ |
|
391 |
FragThreadStop = ETrue; |
|
392 |
User::WaitForRequest(FragStatus); |
|
393 |
test_Equal(EExitKill, FragThread.ExitType()); |
|
394 |
test_KErrNone(FragThread.ExitReason()); |
|
395 |
CLOSE_AND_WAIT(FragThread); |
|
396 |
} |
|
397 |
else |
|
398 |
UnfragmentMemoryFunc(); |
|
399 |
CLOSE_AND_WAIT(Chunk); |
|
400 |
} |
|
401 |
||
402 |
||
403 |
void TestFillPhysicalRam(TUint aFragSize, TUint aFragFreq, TUint aAllocSize, TUint aAllocAlign, TBool aDiscard, TBool aTouchMemory) |
|
404 |
{ |
|
405 |
test.Printf(_L("TestFillPhysicalRam aFragSize 0x%x aFragFreq 0x%x aAllocSize 0x%x aAllocAlign %d dis %d touch %d\n"), |
|
406 |
aFragSize, aFragFreq, aAllocSize, aAllocAlign, aDiscard, aTouchMemory); |
|
407 |
FragmentMemory(aFragSize, aFragFreq, aDiscard, aTouchMemory, EFalse); |
|
408 |
SPhysAllocData allocData; |
|
409 |
// Only check free all ram could be allocated in manual tests as fixed pages may be fragmented. |
|
410 |
allocData.iCheckMaxAllocs = (ManualTest && !aTouchMemory && !aAllocAlign)? ETrue : EFalse; |
|
411 |
allocData.iCheckFreeRam = ETrue; |
|
412 |
allocData.iSize = aAllocSize; |
|
413 |
allocData.iAlign = aAllocAlign; |
|
414 |
FillPhysicalRam(&allocData); |
|
415 |
UnfragmentMemory(aDiscard, aTouchMemory, EFalse); |
|
416 |
} |
|
417 |
||
418 |
||
419 |
void TestFragmentedAllocation() |
|
420 |
{ |
|
421 |
// Test every other page free. |
|
422 |
TestFillPhysicalRam(PageSize, PageSize * 2, PageSize, 0, EFalse, EFalse); |
|
423 |
if (ManualTest) |
|
424 |
{ |
|
425 |
TestFillPhysicalRam(PageSize, PageSize * 2, PageSize * 2, 0, EFalse, EFalse); |
|
426 |
TestFillPhysicalRam(PageSize, PageSize * 2, PageSize, 0, EFalse, ETrue); |
|
427 |
} |
|
428 |
TestFillPhysicalRam(PageSize, PageSize * 2, PageSize * 2, 0, EFalse, ETrue); |
|
429 |
// Test every 2 pages free. |
|
430 |
TestFillPhysicalRam(PageSize * 2, PageSize * 4, PageSize * 8, 0, EFalse, EFalse); |
|
431 |
if (ManualTest) |
|
432 |
TestFillPhysicalRam(PageSize * 2, PageSize * 4, PageSize * 8, 0, EFalse, ETrue); |
|
433 |
// Test 10 pages free then 20 pages allocated, allocate 256 pages (1MB in most cases). |
|
434 |
if (ManualTest) |
|
435 |
TestFillPhysicalRam(PageSize * 10, PageSize * 30, PageSize * 256, 0, EFalse, EFalse); |
|
436 |
TestFillPhysicalRam(PageSize * 10, PageSize * 30, PageSize * 256, 0, EFalse, ETrue); |
|
437 |
||
438 |
if (CacheSizeAdjustable) |
|
439 |
{// It is possible to adjust the cache size so test phyiscally contiguous |
|
440 |
// allocations discard and move pages when required. |
|
441 |
test.Next(_L("TestFragmentedAllocations with discardable data no true free memory")); |
|
442 |
// Test every other page free. |
|
443 |
TestFillPhysicalRam(PageSize, PageSize * 2, PageSize, 0, ETrue, EFalse); |
|
444 |
if (ManualTest) |
|
445 |
{ |
|
446 |
TestFillPhysicalRam(PageSize, PageSize * 2, PageSize, 0, ETrue, ETrue); |
|
447 |
TestFillPhysicalRam(PageSize, PageSize * 2, PageSize * 2, 0, ETrue, EFalse); |
|
448 |
} |
|
449 |
TestFillPhysicalRam(PageSize, PageSize * 2, PageSize * 2, 0, ETrue, ETrue); |
|
450 |
// Test every 2 pages free. |
|
451 |
TestFillPhysicalRam(PageSize * 2, PageSize * 4, PageSize * 8, 0, ETrue, EFalse); |
|
452 |
if (ManualTest) |
|
453 |
TestFillPhysicalRam(PageSize * 2, PageSize * 4, PageSize * 8, 0, ETrue, ETrue); |
|
454 |
// Test 10 pages free then 20 pages allocated, allocate 256 pages (1MB in most cases). |
|
455 |
if (ManualTest) |
|
456 |
TestFillPhysicalRam(PageSize * 10, PageSize * 30, PageSize * 256, 0, ETrue, EFalse); |
|
457 |
TestFillPhysicalRam(PageSize * 10, PageSize * 30, PageSize * 256, 0, ETrue, ETrue); |
|
458 |
} |
|
459 |
} |
|
460 |
||
461 |
||
0 | 462 |
GLDEF_C TInt E32Main() |
463 |
// |
|
464 |
// Test RAM allocation |
|
465 |
// |
|
466 |
{ |
|
467 |
test.Title(); |
|
468 |
test.Start(_L("Load test LDD")); |
|
469 |
TInt r=User::LoadLogicalDevice(KLddFileName); |
|
470 |
test(r==KErrNone || r==KErrAlreadyExists); |
|
471 |
||
472 |
r=UserHal::PageSizeInBytes(PageSize); |
|
473 |
test(r==KErrNone); |
|
474 |
||
475 |
TInt psz=PageSize; |
|
476 |
PageShift=-1; |
|
477 |
for (; psz; psz>>=1, ++PageShift); |
|
478 |
||
132 | 479 |
TUint currentCacheSize; |
480 |
CacheSizeAdjustable = DPTest::CacheSize(OrigMinCacheSize, OrigMaxCacheSize, currentCacheSize) == KErrNone; |
|
481 |
||
482 |
TUint memodel = UserSvr::HalFunction(EHalGroupKernel, EKernelHalMemModelInfo, NULL, NULL) & EMemModelTypeMask; |
|
483 |
||
484 |
TInt cmdLineLen = User::CommandLineLength(); |
|
485 |
if(cmdLineLen) |
|
486 |
{ |
|
487 |
_LIT(KManual, "manual"); |
|
488 |
RBuf cmdLine; |
|
489 |
test_KErrNone(cmdLine.Create(cmdLineLen)); |
|
490 |
User::CommandLine(cmdLine); |
|
491 |
cmdLine.LowerCase(); |
|
492 |
ManualTest = cmdLine.Find(KManual) != KErrNotFound; |
|
493 |
} |
|
494 |
||
495 |
// Turn off lazy dll unloading so the free ram checking isn't affected. |
|
496 |
RLoader l; |
|
497 |
test(l.Connect()==KErrNone); |
|
498 |
test(l.CancelLazyDllUnload()==KErrNone); |
|
499 |
l.Close(); |
|
500 |
||
0 | 501 |
InitFreeRam=FreeRam(); |
502 |
test.Printf(_L("Free RAM=%08x, Page size=%x, Page shift=%d\n"),InitFreeRam,PageSize,PageShift); |
|
503 |
||
504 |
test.Next(_L("Open test LDD")); |
|
505 |
r=Shadow.Open(); |
|
506 |
test(r==KErrNone); |
|
31
56f325a607ea
Revision: 200951
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
507 |
|
56f325a607ea
Revision: 200951
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
508 |
test.Next(_L("TestAlignedAllocs")); |
0 | 509 |
TestAlignedAllocs(); |
31
56f325a607ea
Revision: 200951
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
510 |
|
56f325a607ea
Revision: 200951
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
0
diff
changeset
|
511 |
test.Next(_L("TestClaimPhys")); |
0 | 512 |
TestClaimPhys(); |
513 |
||
132 | 514 |
if (memodel >= EMemModelTypeFlexible) |
515 |
{ |
|
516 |
test.Next(_L("TestFragmentedAllocation")); |
|
517 |
TestFragmentedAllocation(); |
|
518 |
||
519 |
test.Next(_L("TestMultipleContiguousAllocations")); |
|
520 |
TestMultipleContiguousAllocations(20, PageSize * 16, 0); |
|
521 |
TestMultipleContiguousAllocations(20, PageSize * 16, PageShift + 1); |
|
522 |
TestMultipleContiguousAllocations(20, PageSize * 128, PageShift + 2); |
|
523 |
||
524 |
FragmentMemory(PageSize, PageSize * 2, EFalse, EFalse, EFalse); |
|
525 |
TestMultipleContiguousAllocations(20, PageSize * 128, PageShift + 2); |
|
526 |
UnfragmentMemory(EFalse, EFalse, EFalse); |
|
527 |
||
528 |
test.Next(_L("TestMultipleContiguousAllocations while accessing memory")); |
|
529 |
FragmentMemory(PageSize, PageSize * 2, EFalse, ETrue, EFalse); |
|
530 |
TestMultipleContiguousAllocations(20, PageSize * 128, PageShift + 2); |
|
531 |
UnfragmentMemory(EFalse, ETrue, EFalse); |
|
532 |
FragmentMemory(PageSize, PageSize * 2, ETrue, ETrue, EFalse); |
|
533 |
TestMultipleContiguousAllocations(50, PageSize * 256, PageShift + 5); |
|
534 |
UnfragmentMemory(ETrue, ETrue, EFalse); |
|
535 |
FragmentMemory(PageSize * 16, PageSize * 32, ETrue, ETrue, EFalse); |
|
536 |
TestMultipleContiguousAllocations(10, PageSize * 512, PageShift + 8); |
|
537 |
UnfragmentMemory(ETrue, ETrue, EFalse); |
|
538 |
FragmentMemory(PageSize * 32, PageSize * 64, ETrue, ETrue, EFalse); |
|
539 |
TestMultipleContiguousAllocations(10, PageSize * 1024, PageShift + 10); |
|
540 |
UnfragmentMemory(ETrue, ETrue, EFalse); |
|
541 |
||
542 |
test.Next(_L("TestMultipleContiguousAllocations with repeated movable and discardable allocations")); |
|
543 |
FragmentMemory(PageSize, PageSize * 2, EFalse, EFalse, ETrue); |
|
544 |
TestMultipleContiguousAllocations(20, PageSize * 2, PageShift); |
|
545 |
UnfragmentMemory(EFalse, EFalse, ETrue); |
|
546 |
FragmentMemory(PageSize, PageSize * 2, EFalse, EFalse, ETrue); |
|
547 |
TestMultipleContiguousAllocations(20, PageSize * 128, PageShift + 2); |
|
548 |
UnfragmentMemory(EFalse, EFalse, ETrue); |
|
549 |
FragmentMemory(PageSize, PageSize * 2, ETrue, EFalse, ETrue); |
|
550 |
TestMultipleContiguousAllocations(50, PageSize * 256, PageShift + 5); |
|
551 |
UnfragmentMemory(ETrue, EFalse, ETrue); |
|
552 |
FragmentMemory(PageSize * 16, PageSize * 32, ETrue, EFalse, ETrue); |
|
553 |
TestMultipleContiguousAllocations(20, PageSize * 512, PageShift + 8); |
|
554 |
UnfragmentMemory(ETrue, EFalse, ETrue); |
|
555 |
FragmentMemory(PageSize * 32, PageSize * 64, ETrue, EFalse, ETrue); |
|
556 |
TestMultipleContiguousAllocations(20, PageSize * 1024, PageShift + 10); |
|
557 |
UnfragmentMemory(ETrue, EFalse, ETrue); |
|
558 |
} |
|
559 |
||
0 | 560 |
Shadow.Close(); |
132 | 561 |
test.Printf(_L("Free RAM=%08x at end of test\n"),FreeRam()); |
0 | 562 |
test.End(); |
563 |
return(KErrNone); |
|
564 |
} |