1 /* |
|
2 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 // INCLUDE FILES |
|
20 #include "loadgen_memoryeat.h" |
|
21 #include "loadgen_utils.h" |
|
22 #include "loadgen.hrh" |
|
23 #include "loadgen_traces.h" |
|
24 #include <loadgen.rsg> |
|
25 |
|
26 #include <e32math.h> |
|
27 |
|
28 _LIT(KThreadName, "MemEat %d"); |
|
29 _LIT(KChunkName, "LoadGen %d"); |
|
30 _LIT(KFilePath, "%c:\\system\\temp\\LoadGen-%d_%d.$$$"); |
|
31 |
|
32 // currently can only handle 2GB |
|
33 const TInt64 KMaxEatSize = 2147483647; |
|
34 |
|
35 const TInt KDefaultStart = 50; |
|
36 const TInt KDefaultPeriod = 5000000; |
|
37 |
|
38 // ===================================== MEMBER FUNCTIONS ===================================== |
|
39 |
|
40 CMemoryEat* CMemoryEat::NewL(TMemoryEatAttributes& aAttributes, TInt aReferenceNumber) |
|
41 { |
|
42 CMemoryEat* self = new(ELeave) CMemoryEat(aAttributes, aReferenceNumber); |
|
43 CleanupStack::PushL(self); |
|
44 self->ConstructL(); |
|
45 CleanupStack::Pop(self); |
|
46 return self; |
|
47 } |
|
48 |
|
49 // -------------------------------------------------------------------------------------------- |
|
50 |
|
51 CMemoryEat::~CMemoryEat() |
|
52 { |
|
53 Close(); |
|
54 } |
|
55 |
|
56 // -------------------------------------------------------------------------------------------- |
|
57 |
|
58 CMemoryEat::CMemoryEat(TMemoryEatAttributes& aAttributes, TInt aReferenceNumber) : iAttributes(aAttributes) |
|
59 { |
|
60 iAttributes.iId = aReferenceNumber; |
|
61 } |
|
62 |
|
63 // -------------------------------------------------------------------------------------------- |
|
64 |
|
65 void CMemoryEat::ConstructL() |
|
66 { |
|
67 CLoadBase::ConstructL(); |
|
68 |
|
69 iType = ELoadGenCmdNewLoadEatMemory; |
|
70 |
|
71 TBuf<64> threadName; |
|
72 threadName.Format(KThreadName, iAttributes.iId); |
|
73 |
|
74 // create a thread |
|
75 User::LeaveIfError(iThread.Create(threadName, ThreadFunction, KDefaultStackSize*2, KMinHeapSize, 32*1024*KMinHeapSize, (TAny*) &iAttributes )); |
|
76 |
|
77 // set priority of the thread |
|
78 SetPriority(); |
|
79 } |
|
80 |
|
81 // -------------------------------------------------------------------------------------------- |
|
82 |
|
83 TInt CMemoryEat::ThreadFunction(TAny* aThreadArg) |
|
84 { |
|
85 CTrapCleanup* pC = CTrapCleanup::New(); |
|
86 CActiveScheduler* pS = new CActiveScheduler; |
|
87 CActiveScheduler::Install(pS); |
|
88 |
|
89 // start memory eat, pass pointer to arguments |
|
90 GenerateLoad(*((TMemoryEatAttributes*) aThreadArg)); |
|
91 |
|
92 delete pS; |
|
93 delete pC; |
|
94 |
|
95 return KErrNone; |
|
96 } |
|
97 |
|
98 // -------------------------------------------------------------------------------------------- |
|
99 |
|
100 void CMemoryEat::GenerateLoad(TMemoryEatAttributes& aAttributes) |
|
101 { |
|
102 CMemoryEatManager* memoryEatManager = NULL; |
|
103 TRAPD(err, memoryEatManager = CMemoryEatManager::NewL(aAttributes)); |
|
104 if (err == KErrNone) CActiveScheduler::Start(); |
|
105 delete memoryEatManager; |
|
106 } |
|
107 |
|
108 // -------------------------------------------------------------------------------------------- |
|
109 |
|
110 void CMemoryEat::Resume() |
|
111 { |
|
112 CLoadBase::Resume(); |
|
113 |
|
114 iThread.Resume(); |
|
115 } |
|
116 |
|
117 // -------------------------------------------------------------------------------------------- |
|
118 |
|
119 void CMemoryEat::Suspend() |
|
120 { |
|
121 CLoadBase::Suspend(); |
|
122 |
|
123 iThread.Suspend(); |
|
124 } |
|
125 |
|
126 // -------------------------------------------------------------------------------------------- |
|
127 |
|
128 void CMemoryEat::SetPriority() |
|
129 { |
|
130 CLoadBase::SetPriority(); |
|
131 |
|
132 iThread.SetPriority(CLoadGenUtils::SettingItemToThreadPriority(iAttributes.iPriority)); |
|
133 } |
|
134 |
|
135 // -------------------------------------------------------------------------------------------- |
|
136 |
|
137 void CMemoryEat::Close() |
|
138 { |
|
139 CLoadBase::Close(); |
|
140 |
|
141 if (iThread.ExitReason() == 0) // check if the thread is still alive |
|
142 { |
|
143 // signal the thread that it needs to close |
|
144 iThread.RequestComplete(iAttributes.iDeathStatus, KErrCancel); |
|
145 |
|
146 // wait the thread to die |
|
147 TRequestStatus waiter; |
|
148 iThread.Logon(waiter); |
|
149 User::WaitForRequest(waiter); |
|
150 iThread.Close(); |
|
151 } |
|
152 } |
|
153 |
|
154 // -------------------------------------------------------------------------------------------- |
|
155 |
|
156 TPtrC CMemoryEat::Description() |
|
157 { |
|
158 TBuf<256> buf; |
|
159 TBuf<16> prioBuf; |
|
160 CLoadGenUtils::SettingItemToThreadDescription(iAttributes.iPriority, prioBuf); |
|
161 TBuf<16> srcBuf; |
|
162 CLoadGenUtils::SettingItemToSourceDescription(iAttributes.iSource, srcBuf); |
|
163 |
|
164 if (iAttributes.iType == EMemoryEatTypeMemoryToEat) |
|
165 { |
|
166 _LIT(KMemoryEatEntryMemoryToEat, "[%d] MemEat src=%S prio=%S type=MemToEat amount=%LDB buf=%dB idle=%dms"); |
|
167 |
|
168 buf.Format(KMemoryEatEntryMemoryToEat, iAttributes.iId, &srcBuf, &prioBuf, iAttributes.iAmount, iAttributes.iBuffer, iAttributes.iIdle); |
|
169 } |
|
170 else if (iAttributes.iType == EMemoryEatTypeMemoryToBeLeft) |
|
171 { |
|
172 _LIT(KMemoryEatEntryMemoryToBeLeft, "[%d] MemEat src=%S prio=%S type=MemToBeLeft amount=%LDB buf=%dB idle=%dms"); |
|
173 |
|
174 buf.Format(KMemoryEatEntryMemoryToBeLeft, iAttributes.iId, &srcBuf, &prioBuf, iAttributes.iAmount, iAttributes.iBuffer, iAttributes.iIdle); |
|
175 } |
|
176 |
|
177 else if (iAttributes.iType == EMemoryEatTypeWavy) |
|
178 { |
|
179 _LIT(KMemoryEatEntryRandom, "[%d] MemEat src=%S prio=%S type=Random min=%LDB max=%LDB buf=%dB idle=%dms"); |
|
180 |
|
181 buf.Format(KMemoryEatEntryRandom, iAttributes.iId, &srcBuf, &prioBuf, iAttributes.iRandomMin, iAttributes.iRandomMax, iAttributes.iBuffer, iAttributes.iIdle); |
|
182 } |
|
183 |
|
184 return TPtrC(buf); |
|
185 } |
|
186 |
|
187 // -------------------------------------------------------------------------------------------- |
|
188 // -------------------------------------------------------------------------------------------- |
|
189 |
|
190 CMemoryEatManager* CMemoryEatManager::NewL(TMemoryEatAttributes& aAttributes) |
|
191 { |
|
192 CMemoryEatManager* self = new(ELeave) CMemoryEatManager(aAttributes); |
|
193 CleanupStack::PushL(self); |
|
194 self->ConstructL(); |
|
195 CleanupStack::Pop(); |
|
196 return self; |
|
197 } |
|
198 |
|
199 // -------------------------------------------------------------------------------------------- |
|
200 |
|
201 CMemoryEatManager::CMemoryEatManager(TMemoryEatAttributes& aAttributes) : |
|
202 CActive(EPriorityStandard), iAttributes(aAttributes) |
|
203 { |
|
204 } |
|
205 |
|
206 // -------------------------------------------------------------------------------------------- |
|
207 |
|
208 CMemoryEatManager::~CMemoryEatManager() |
|
209 { |
|
210 Cancel(); |
|
211 DestroyMemoryEat(); |
|
212 } |
|
213 |
|
214 // -------------------------------------------------------------------------------------------- |
|
215 |
|
216 void CMemoryEatManager::ConstructL() |
|
217 { |
|
218 CActiveScheduler::Add(this); |
|
219 |
|
220 // set the status as pending |
|
221 iStatus = KRequestPending; |
|
222 SetActive(); |
|
223 |
|
224 // set the death status pointer point to the request status of this ao |
|
225 iAttributes.iDeathStatus = &iStatus; |
|
226 |
|
227 // init |
|
228 InitMemoryEatL(); |
|
229 |
|
230 // start timer |
|
231 iPeriodicTimer = CPeriodic::NewL(CActive::EPriorityStandard); |
|
232 iPeriodicTimer->Start(KDefaultStart, KDefaultPeriod, TCallBack(PeriodicTimerCallBack, this)); |
|
233 } |
|
234 |
|
235 // -------------------------------------------------------------------------------------------- |
|
236 |
|
237 void CMemoryEatManager::RunL() |
|
238 { |
|
239 // request status has completed by the main thread meaning that we need to stop now |
|
240 CActiveScheduler::Stop(); |
|
241 } |
|
242 |
|
243 // -------------------------------------------------------------------------------------------- |
|
244 |
|
245 void CMemoryEatManager::DoCancel() |
|
246 { |
|
247 } |
|
248 |
|
249 // -------------------------------------------------------------------------------------------- |
|
250 |
|
251 TInt CMemoryEatManager::PeriodicTimerCallBack(TAny* aAny) |
|
252 { |
|
253 TInt result = KErrNone; |
|
254 CMemoryEatManager* self = static_cast<CMemoryEatManager*>( aAny ); |
|
255 |
|
256 self->iPeriodicTimer->Cancel(); |
|
257 TRAP( result, self->EatMemoryL() ); |
|
258 |
|
259 return result; |
|
260 } |
|
261 |
|
262 // -------------------------------------------------------------------------------------------- |
|
263 |
|
264 void CMemoryEatManager::InitMemoryEatL() |
|
265 { |
|
266 // create a chunk for RAM |
|
267 if (iAttributes.iSource == EMemoryEatSourceTypeRAM) |
|
268 { |
|
269 TBuf<64> chunkName; |
|
270 chunkName.Format(KChunkName, iAttributes.iId); |
|
271 |
|
272 // set max size of the chunk to be size of the RAM memory |
|
273 TMemoryInfoV1Buf ramMemory; |
|
274 UserHal::MemoryInfo(ramMemory); |
|
275 |
|
276 User::LeaveIfError( iEatChunk.CreateGlobal(chunkName, 0, ramMemory().iMaxFreeRamInBytes-1, EOwnerThread) ); |
|
277 } |
|
278 |
|
279 // create a temporary file to disk |
|
280 else |
|
281 { |
|
282 // connect to RFs |
|
283 User::LeaveIfError( iFs.Connect() ); |
|
284 |
|
285 iFilesCounter = 0; |
|
286 |
|
287 TFileName eatFileName; |
|
288 eatFileName.Format( KFilePath, 'B'+iAttributes.iSource, iAttributes.iId, 1 ); |
|
289 |
|
290 iFs.MkDirAll( eatFileName ); |
|
291 User::LeaveIfError( iEatFile.Replace( iFs, eatFileName, EFileWrite ) ); |
|
292 iFilesCounter++; |
|
293 } |
|
294 |
|
295 iWavyEatMoreMemory = ETrue; |
|
296 } |
|
297 |
|
298 // -------------------------------------------------------------------------------------------- |
|
299 |
|
300 void CMemoryEatManager::DestroyMemoryEat() |
|
301 { |
|
302 if (iAttributes.iSource == EMemoryEatSourceTypeRAM) |
|
303 { |
|
304 iEatChunk.Adjust(0); |
|
305 iEatChunk.Close(); |
|
306 } |
|
307 else |
|
308 { |
|
309 // close current file |
|
310 |
|
311 iEatFile.Flush(); |
|
312 iEatFile.Close(); |
|
313 |
|
314 // delete created files |
|
315 for ( TInt k = 1; k <= iFilesCounter; k++ ) |
|
316 { |
|
317 TFileName eatFileName; |
|
318 eatFileName.Format( KFilePath, 'B'+iAttributes.iSource, iAttributes.iId, k ); |
|
319 iFs.Delete( eatFileName ); |
|
320 } |
|
321 iFs.Close(); |
|
322 } |
|
323 } |
|
324 |
|
325 // -------------------------------------------------------------------------------------------- |
|
326 |
|
327 void CMemoryEatManager::EatMemoryL() |
|
328 { |
|
329 // get current sizes |
|
330 TInt64 eatSizeNow(0); |
|
331 TInt sizeNow(0); |
|
332 TInt64 freeSystemMemory(0); |
|
333 |
|
334 if (iAttributes.iSource == EMemoryEatSourceTypeRAM) |
|
335 { |
|
336 eatSizeNow = iEatChunk.Size(); // get current chunk size |
|
337 } |
|
338 else |
|
339 { |
|
340 User::LeaveIfError( iEatFile.Size( sizeNow ) ); |
|
341 if ( iFilesCounter > 1) |
|
342 { |
|
343 eatSizeNow += sizeNow + ( ( iFilesCounter - 1 ) * KMaxEatSize ); |
|
344 } |
|
345 else |
|
346 { |
|
347 eatSizeNow = sizeNow ; |
|
348 } |
|
349 } |
|
350 LOGSTRING2("Loadgen:EatMemoryL eatSizeNow = %d", eatSizeNow ); |
|
351 |
|
352 freeSystemMemory = ReadFreeMemory(); |
|
353 |
|
354 // eat until specific amount of memory at most amount of buffer at a time |
|
355 if (iAttributes.iType == EMemoryEatTypeMemoryToEat) |
|
356 { |
|
357 // grow partial buffer to match exact amount |
|
358 if ( ( iAttributes.iAmount - eatSizeNow >= 0 && |
|
359 iAttributes.iAmount - eatSizeNow < iAttributes.iBuffer ) ) |
|
360 { |
|
361 DoEatMemoryL( eatSizeNow + ( iAttributes.iAmount - eatSizeNow ) ); |
|
362 } |
|
363 |
|
364 // grow full buffer |
|
365 else if ( eatSizeNow < iAttributes.iAmount ) |
|
366 { |
|
367 DoEatMemoryL( eatSizeNow + iAttributes.iBuffer ); |
|
368 } |
|
369 // shrink partial buffer to match exact amount |
|
370 else if (eatSizeNow - iAttributes.iAmount >= 0 && eatSizeNow - iAttributes.iAmount < iAttributes.iBuffer) |
|
371 { |
|
372 DoEatMemoryL(eatSizeNow - (eatSizeNow - iAttributes.iAmount)); |
|
373 } |
|
374 |
|
375 // shrink full buffer |
|
376 else if (eatSizeNow > iAttributes.iAmount) |
|
377 { |
|
378 DoEatMemoryL(eatSizeNow - iAttributes.iBuffer); |
|
379 } |
|
380 } |
|
381 |
|
382 |
|
383 // eat until specific amount of free memory has been reached at most amount of buffer at a time |
|
384 else if (iAttributes.iType == EMemoryEatTypeMemoryToBeLeft) |
|
385 { |
|
386 // grow partial buffer to match exact amount |
|
387 if (freeSystemMemory - iAttributes.iAmount >= 0 && freeSystemMemory - iAttributes.iAmount < iAttributes.iBuffer) |
|
388 { |
|
389 DoEatMemoryL(eatSizeNow + (freeSystemMemory - iAttributes.iAmount)); |
|
390 } |
|
391 |
|
392 // grow full buffer |
|
393 else if (freeSystemMemory > iAttributes.iAmount) |
|
394 { |
|
395 DoEatMemoryL(eatSizeNow + iAttributes.iBuffer); |
|
396 } |
|
397 |
|
398 // shrink partial buffer to match exact amount |
|
399 if (iAttributes.iAmount - freeSystemMemory >= 0 && iAttributes.iAmount - freeSystemMemory < iAttributes.iBuffer) |
|
400 { |
|
401 DoEatMemoryL(eatSizeNow - (iAttributes.iAmount - freeSystemMemory)); |
|
402 } |
|
403 |
|
404 // shrink full buffer |
|
405 else if (freeSystemMemory < iAttributes.iAmount) |
|
406 { |
|
407 DoEatMemoryL(eatSizeNow - iAttributes.iBuffer); |
|
408 } |
|
409 } |
|
410 |
|
411 // wavy memory eat |
|
412 else if (iAttributes.iType == EMemoryEatTypeWavy) |
|
413 { |
|
414 // grow to max value if not under it |
|
415 if (freeSystemMemory > iAttributes.iRandomMax) |
|
416 { |
|
417 DoEatMemoryL(eatSizeNow + (freeSystemMemory - iAttributes.iRandomMax) + iAttributes.iBuffer); |
|
418 iWavyEatMoreMemory = ETrue; // change direction |
|
419 } |
|
420 |
|
421 // shrink to min value if not below it |
|
422 else if (freeSystemMemory < iAttributes.iRandomMin) |
|
423 { |
|
424 DoEatMemoryL(eatSizeNow - (iAttributes.iRandomMin - freeSystemMemory) - iAttributes.iBuffer); |
|
425 iWavyEatMoreMemory = EFalse; // change direction |
|
426 } |
|
427 |
|
428 // grow or shrink |
|
429 else |
|
430 { |
|
431 if (iWavyEatMoreMemory) |
|
432 { |
|
433 // grow partial buffer to match exact amount |
|
434 if (freeSystemMemory - iAttributes.iRandomMin >= 0 && freeSystemMemory - iAttributes.iRandomMin < iAttributes.iBuffer) |
|
435 { |
|
436 DoEatMemoryL(eatSizeNow + (freeSystemMemory - iAttributes.iRandomMin)); |
|
437 iWavyEatMoreMemory = EFalse; // change direction since limit reached |
|
438 } |
|
439 |
|
440 // grow full buffer |
|
441 else |
|
442 { |
|
443 DoEatMemoryL(eatSizeNow + iAttributes.iBuffer); |
|
444 } |
|
445 } |
|
446 |
|
447 else // shrink |
|
448 { |
|
449 // shrink partial buffer to match exact amount |
|
450 if (iAttributes.iRandomMax - freeSystemMemory >= 0 && iAttributes.iRandomMax - freeSystemMemory < iAttributes.iBuffer) |
|
451 { |
|
452 DoEatMemoryL(eatSizeNow - (iAttributes.iRandomMax - freeSystemMemory)); |
|
453 iWavyEatMoreMemory = ETrue; // change direction since limit reached |
|
454 } |
|
455 |
|
456 // shrink full buffer |
|
457 else |
|
458 { |
|
459 DoEatMemoryL(eatSizeNow - iAttributes.iBuffer); |
|
460 } |
|
461 } |
|
462 } |
|
463 } |
|
464 |
|
465 |
|
466 // call timer |
|
467 iPeriodicTimer->Start(CLoadGenUtils::MilliSecondsToMicroSeconds(iAttributes.iIdle, iAttributes.iRandomVariance), KDefaultPeriod, TCallBack(PeriodicTimerCallBack, this)); |
|
468 } |
|
469 |
|
470 // -------------------------------------------------------------------------------------------- |
|
471 |
|
472 void CMemoryEatManager::DoEatMemoryL( TInt64 aNewSize ) |
|
473 { |
|
474 // check that new size is in valid range |
|
475 if (aNewSize < 0) |
|
476 { |
|
477 aNewSize = 0; |
|
478 } |
|
479 LOGSTRING2("Loadgen::DoEatMemoryL aNewSize = %d", aNewSize ); |
|
480 // set new size |
|
481 if (iAttributes.iSource == EMemoryEatSourceTypeRAM) |
|
482 { |
|
483 TInt err = iEatChunk.Adjust( aNewSize ); |
|
484 } |
|
485 else |
|
486 { |
|
487 HandleEatMemoryL( aNewSize ); |
|
488 } |
|
489 } |
|
490 |
|
491 // -------------------------------------------------------------------------------------------- |
|
492 |
|
493 void CMemoryEatManager::HandleEatMemoryL( TInt64 aNewSize ) |
|
494 { |
|
495 // current size = open file size + full files sizes |
|
496 TInt currentFileSize = 0; |
|
497 User::LeaveIfError( iEatFile.Size( currentFileSize ) ); |
|
498 TInt64 currentSize = currentFileSize + ( ( iFilesCounter - 1 ) * KMaxEatSize ); |
|
499 |
|
500 if ( aNewSize > currentSize ) // increasing |
|
501 { |
|
502 AllocMemoryL( aNewSize ); |
|
503 } |
|
504 else if ( aNewSize < currentSize )//decreasing |
|
505 { |
|
506 FreeMemoryL( aNewSize ); |
|
507 } |
|
508 } |
|
509 |
|
510 // -------------------------------------------------------------------------------------------- |
|
511 void CMemoryEatManager::AllocMemoryL( TInt64 aNewSize ) |
|
512 { |
|
513 LOGSTRING("Loadgen: CMemoryEatManager::AllocMemoryL =>"); |
|
514 // size of the file that remains open |
|
515 TInt64 sizeLeft = aNewSize % KMaxEatSize; |
|
516 // amount of the files that is needed |
|
517 TInt64 filesNeeded = aNewSize / KMaxEatSize; |
|
518 if ( sizeLeft > 0 ) |
|
519 { |
|
520 filesNeeded++; |
|
521 } |
|
522 |
|
523 if ( filesNeeded > iFilesCounter ) |
|
524 { |
|
525 // update current file size to 2 GB |
|
526 User::LeaveIfError( iEatFile.SetSize( KMaxEatSize ) ); |
|
527 // close current file |
|
528 iEatFile.Flush(); |
|
529 iEatFile.Close(); |
|
530 |
|
531 // open new file |
|
532 TFileName eatFileName; |
|
533 eatFileName.Format( KFilePath, 'B'+iAttributes.iSource, iAttributes.iId, ++iFilesCounter ); |
|
534 |
|
535 iFs.MkDirAll( eatFileName ); |
|
536 User::LeaveIfError( iEatFile.Replace( iFs, eatFileName, EFileWrite ) ); |
|
537 |
|
538 } |
|
539 User::LeaveIfError( iEatFile.SetSize( sizeLeft ) ); |
|
540 LOGSTRING("Loadgen: CMemoryEatManager::AllocMemoryL <="); |
|
541 } |
|
542 |
|
543 // -------------------------------------------------------------------------------------------- |
|
544 void CMemoryEatManager::FreeMemoryL( TInt64 aNewSize ) |
|
545 { |
|
546 LOGSTRING("Loadgen: CMemoryEatManager::FreeMemoryL =>"); |
|
547 // size of the file that remains open |
|
548 TInt sizeLeft = aNewSize % KMaxEatSize; |
|
549 |
|
550 LOGSTRING2("Loadgen: sizeLeft = %d ", sizeLeft ); |
|
551 // amount of the files that is needed |
|
552 TInt filesNeeded = aNewSize / KMaxEatSize; |
|
553 |
|
554 if ( filesNeeded == 0 ) |
|
555 { |
|
556 filesNeeded = 1; |
|
557 } |
|
558 |
|
559 if ( iFilesCounter > 1 && filesNeeded < iFilesCounter ) |
|
560 { |
|
561 TFileName eatFileName; |
|
562 |
|
563 // close current open file |
|
564 iEatFile.Flush(); |
|
565 iEatFile.Close(); |
|
566 // remove file |
|
567 eatFileName.Format( KFilePath, 'B'+iAttributes.iSource, iAttributes.iId, iFilesCounter-- ); |
|
568 iFs.Delete( eatFileName ); |
|
569 |
|
570 // remove files not needed |
|
571 while ( iFilesCounter > filesNeeded ) |
|
572 { |
|
573 eatFileName.Format( KFilePath, 'B'+iAttributes.iSource, iAttributes.iId, iFilesCounter-- ); |
|
574 iFs.Delete( eatFileName ); |
|
575 } |
|
576 |
|
577 // open new file |
|
578 eatFileName.Format( KFilePath, 'B'+iAttributes.iSource, iAttributes.iId, iFilesCounter ); |
|
579 User::LeaveIfError( iEatFile.Open( iFs, eatFileName, EFileWrite ) ); |
|
580 } |
|
581 User::LeaveIfError( iEatFile.SetSize( sizeLeft ) ); |
|
582 LOGSTRING("Loadgen: CMemoryEatManager::FreeMemoryL <="); |
|
583 } |
|
584 |
|
585 // -------------------------------------------------------------------------------------------- |
|
586 TInt64 CMemoryEatManager::ReadFreeMemory() |
|
587 { |
|
588 if ( iAttributes.iSource == EMemoryEatSourceTypeRAM ) |
|
589 { |
|
590 TMemoryInfoV1Buf ramMemory; |
|
591 UserHal::MemoryInfo( ramMemory ); // get available RAM |
|
592 return (TInt64)ramMemory().iFreeRamInBytes; |
|
593 } |
|
594 else |
|
595 { |
|
596 TVolumeInfo volumeInfo; |
|
597 iFs.Volume( volumeInfo, iAttributes.iSource + 1 ); // get available disk |
|
598 return volumeInfo.iFree; |
|
599 } |
|
600 } |
|
601 // -------------------------------------------------------------------------------------------- |
|
602 |
|
603 // End of File |
|