Heap.cpp revision 5617ad30c611f373e16bf10c0feec114faef54ef
1f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 2f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Copyright (C) 2008 The Android Open Source Project 3f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 4f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Licensed under the Apache License, Version 2.0 (the "License"); 5f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * you may not use this file except in compliance with the License. 6f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * You may obtain a copy of the License at 7f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 8f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * http://www.apache.org/licenses/LICENSE-2.0 9f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 10f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Unless required by applicable law or agreed to in writing, software 11f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * distributed under the License is distributed on an "AS IS" BASIS, 12f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * See the License for the specific language governing permissions and 14f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * limitations under the License. 15f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 16f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 17f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Garbage-collecting memory allocator. 18f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 19f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include "Dalvik.h" 20962adba4e5db286a36bc8024f5c023bcf6f29312Barry Hayes#include "alloc/HeapBitmap.h" 21962adba4e5db286a36bc8024f5c023bcf6f29312Barry Hayes#include "alloc/Verify.h" 22f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include "alloc/HeapTable.h" 23f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include "alloc/Heap.h" 24f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include "alloc/HeapInternal.h" 25f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include "alloc/DdmHeap.h" 26f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include "alloc/HeapSource.h" 27f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include "alloc/MarkSweep.h" 28f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 29f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include "utils/threads.h" // need Android thread priorities 30f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#define kInvalidPriority 10000 31f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 325a2056ca8c7e7c0ed9f51d68cedbee59cc936685San Mehat#include <cutils/sched_policy.h> 335a2056ca8c7e7c0ed9f51d68cedbee59cc936685San Mehat 34f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include <sys/time.h> 35f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include <sys/resource.h> 36f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include <limits.h> 37f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#include <errno.h> 38f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 391b9b4e4b89e1c682b6684ae5e2a637e4497a67e9Barry Hayesstatic const char* GcReasonStr[] = { 401b9b4e4b89e1c682b6684ae5e2a637e4497a67e9Barry Hayes [GC_FOR_MALLOC] = "GC_FOR_MALLOC", 41ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro [GC_CONCURRENT] = "GC_CONCURRENT", 421b9b4e4b89e1c682b6684ae5e2a637e4497a67e9Barry Hayes [GC_EXPLICIT] = "GC_EXPLICIT", 431b9b4e4b89e1c682b6684ae5e2a637e4497a67e9Barry Hayes [GC_EXTERNAL_ALLOC] = "GC_EXTERNAL_ALLOC", 441b9b4e4b89e1c682b6684ae5e2a637e4497a67e9Barry Hayes [GC_HPROF_DUMP_HEAP] = "GC_HPROF_DUMP_HEAP" 451b9b4e4b89e1c682b6684ae5e2a637e4497a67e9Barry Hayes}; 461b9b4e4b89e1c682b6684ae5e2a637e4497a67e9Barry Hayes 47f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 48f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Initialize the GC heap. 49f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 50f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Returns true if successful, false otherwise. 51f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 52f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectbool dvmHeapStartup() 53f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 54f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project GcHeap *gcHeap; 55f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 56f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#if defined(WITH_ALLOC_LIMITS) 57f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gDvm.checkAllocLimits = false; 58f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gDvm.allocationLimit = -1; 59f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#endif 60f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 61f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gcHeap = dvmHeapSourceStartup(gDvm.heapSizeStart, gDvm.heapSizeMax); 62f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (gcHeap == NULL) { 63f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 64f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 65f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gcHeap->heapWorkerCurrentObject = NULL; 66f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gcHeap->heapWorkerCurrentMethod = NULL; 67f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gcHeap->heapWorkerInterpStartTime = 0LL; 68f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gcHeap->ddmHpifWhen = 0; 69f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gcHeap->ddmHpsgWhen = 0; 70f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gcHeap->ddmHpsgWhat = 0; 71f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gcHeap->ddmNhsgWhen = 0; 72f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gcHeap->ddmNhsgWhat = 0; 73f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#if WITH_HPROF 74f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gcHeap->hprofDumpOnGc = false; 75f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gcHeap->hprofContext = NULL; 76f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#endif 77f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gDvm.gcHeap = gcHeap; 78f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 79f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* Set up the lists and lock we'll use for finalizable 80f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * and reference objects. 81f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 82f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmInitMutex(&gDvm.heapWorkerListLock); 83f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gcHeap->finalizableRefs = NULL; 84f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gcHeap->pendingFinalizationRefs = NULL; 85f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gcHeap->referenceOperations = NULL; 86f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 87f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* Initialize the HeapWorker locks and other state 88f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * that the GC uses. 89f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 90f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmInitializeHeapWorkerState(); 91f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 92f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return true; 93f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 94f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 95ec805eaed940e40212e85b58b163c7649feaca56Carl Shapirobool dvmHeapStartupAfterZygote(void) 96f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 97f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* Update our idea of the last GC start time so that we 98f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * don't use the last time that Zygote happened to GC. 99f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 100f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gDvm.gcHeap->gcStartTime = dvmGetRelativeTimeUsec(); 101ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro return dvmHeapSourceStartupAfterZygote(); 102f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 103f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 104f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectvoid dvmHeapShutdown() 105f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 106f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project//TODO: make sure we're locked 107f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (gDvm.gcHeap != NULL) { 108f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* Tables are allocated on the native heap; 109f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * they need to be cleaned up explicitly. 110f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * The process may stick around, so we don't 111f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * want to leak any native memory. 112f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 113a199eb70871a8c142a723d76b1b08939286a3199Carl Shapiro dvmHeapFreeLargeTable(gDvm.gcHeap->finalizableRefs); 114a199eb70871a8c142a723d76b1b08939286a3199Carl Shapiro gDvm.gcHeap->finalizableRefs = NULL; 115f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 116a199eb70871a8c142a723d76b1b08939286a3199Carl Shapiro dvmHeapFreeLargeTable(gDvm.gcHeap->pendingFinalizationRefs); 117a199eb70871a8c142a723d76b1b08939286a3199Carl Shapiro gDvm.gcHeap->pendingFinalizationRefs = NULL; 118f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 119a199eb70871a8c142a723d76b1b08939286a3199Carl Shapiro dvmHeapFreeLargeTable(gDvm.gcHeap->referenceOperations); 120a199eb70871a8c142a723d76b1b08939286a3199Carl Shapiro gDvm.gcHeap->referenceOperations = NULL; 121f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 122f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* Destroy the heap. Any outstanding pointers 123f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * will point to unmapped memory (unless/until 124a199eb70871a8c142a723d76b1b08939286a3199Carl Shapiro * someone else maps it). This frees gDvm.gcHeap 125f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * as a side-effect. 126f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 127a199eb70871a8c142a723d76b1b08939286a3199Carl Shapiro dvmHeapSourceShutdown(&gDvm.gcHeap); 128f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 129f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 130f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 131f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 132ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro * Shutdown any threads internal to the heap. 133ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro */ 134ec805eaed940e40212e85b58b163c7649feaca56Carl Shapirovoid dvmHeapThreadShutdown(void) 135ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro{ 136ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro dvmHeapSourceThreadShutdown(); 137ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro} 138ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro 139ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro/* 140f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * We've been asked to allocate something we can't, e.g. an array so 1416da743bfe7c60ad873df72a3b6412137c4ac71dcAndy McFadden * large that (length * elementWidth) is larger than 2^31. 142f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 1436da743bfe7c60ad873df72a3b6412137c4ac71dcAndy McFadden * _The Java Programming Language_, 4th edition, says, "you can be sure 1446da743bfe7c60ad873df72a3b6412137c4ac71dcAndy McFadden * that all SoftReferences to softly reachable objects will be cleared 1456da743bfe7c60ad873df72a3b6412137c4ac71dcAndy McFadden * before an OutOfMemoryError is thrown." 1466da743bfe7c60ad873df72a3b6412137c4ac71dcAndy McFadden * 1476da743bfe7c60ad873df72a3b6412137c4ac71dcAndy McFadden * It's unclear whether that holds for all situations where an OOM can 1486da743bfe7c60ad873df72a3b6412137c4ac71dcAndy McFadden * be thrown, or just in the context of an allocation that fails due 1496da743bfe7c60ad873df72a3b6412137c4ac71dcAndy McFadden * to lack of heap space. For simplicity we just throw the exception. 1506da743bfe7c60ad873df72a3b6412137c4ac71dcAndy McFadden * 1516da743bfe7c60ad873df72a3b6412137c4ac71dcAndy McFadden * (OOM due to actually running out of space is handled elsewhere.) 152f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 153f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectvoid dvmThrowBadAllocException(const char* msg) 154f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 1556da743bfe7c60ad873df72a3b6412137c4ac71dcAndy McFadden dvmThrowException("Ljava/lang/OutOfMemoryError;", msg); 156f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 157f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 158f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 159f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Grab the lock, but put ourselves into THREAD_VMWAIT if it looks like 160f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * we're going to have to wait on the mutex. 161f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 162f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectbool dvmLockHeap() 163f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 164980ffb0243a1840ad0a93cfa06dfc02ca6f2d01cCarl Shapiro if (dvmTryLockMutex(&gDvm.gcHeapLock) != 0) { 165f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Thread *self; 166f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project ThreadStatus oldStatus; 167f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 168f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project self = dvmThreadSelf(); 1695617ad30c611f373e16bf10c0feec114faef54efCarl Shapiro oldStatus = dvmChangeStatus(self, THREAD_VMWAIT); 170980ffb0243a1840ad0a93cfa06dfc02ca6f2d01cCarl Shapiro dvmLockMutex(&gDvm.gcHeapLock); 1715617ad30c611f373e16bf10c0feec114faef54efCarl Shapiro dvmChangeStatus(self, oldStatus); 172f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 173f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 174f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return true; 175f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 176f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 177f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectvoid dvmUnlockHeap() 178f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 179f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmUnlockMutex(&gDvm.gcHeapLock); 180f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 181f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 182f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* Pop an object from the list of pending finalizations and 183f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * reference clears/enqueues, and return the object. 184f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * The caller must call dvmReleaseTrackedAlloc() 185f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * on the object when finished. 186f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 187f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Typically only called by the heap worker thread. 188f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 189f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source ProjectObject *dvmGetNextHeapWorkerObject(HeapWorkerOperation *op) 190f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 191f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Object *obj; 192f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project GcHeap *gcHeap = gDvm.gcHeap; 193f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 194f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project assert(op != NULL); 195f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 196f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmLockMutex(&gDvm.heapWorkerListLock); 197f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 198f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project obj = dvmHeapGetNextObjectFromLargeTable(&gcHeap->referenceOperations); 199f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (obj != NULL) { 200646ba0996da817deddb509b2130a6ad432096691Carl Shapiro *op = WORKER_ENQUEUE; 201f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else { 202f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project obj = dvmHeapGetNextObjectFromLargeTable( 203f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project &gcHeap->pendingFinalizationRefs); 204f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (obj != NULL) { 205f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project *op = WORKER_FINALIZE; 206f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 207f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 208f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 209f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (obj != NULL) { 210f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* Don't let the GC collect the object until the 211f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * worker thread is done with it. 212f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 213f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmAddTrackedAlloc(obj, NULL); 214f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 215f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 216f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmUnlockMutex(&gDvm.heapWorkerListLock); 217f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 218f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return obj; 219f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 220f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 221f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* Whenever the effective heap size may have changed, 222f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * this function must be called. 223f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 224f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectvoid dvmHeapSizeChanged() 225f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 226f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 227f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 228f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* Do a full garbage collection, which may grow the 229f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * heap as a side-effect if the live set is large. 230f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 231f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic void gcForMalloc(bool collectSoftReferences) 232f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 233f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#ifdef WITH_PROFILER 234f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (gDvm.allocProf.enabled) { 235f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Thread* self = dvmThreadSelf(); 236f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gDvm.allocProf.gcCount++; 237f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (self != NULL) { 238f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project self->allocProf.gcCount++; 239f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 240f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 241f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#endif 242f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* This may adjust the soft limit as a side-effect. 243f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 244f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGD_HEAP("dvmMalloc initiating GC%s\n", 245f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project collectSoftReferences ? "(collect SoftReferences)" : ""); 2461b9b4e4b89e1c682b6684ae5e2a637e4497a67e9Barry Hayes dvmCollectGarbageInternal(collectSoftReferences, GC_FOR_MALLOC); 247f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 248f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 249f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* Try as hard as possible to allocate some memory. 250f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 2516343bd071555458d0cb071f2eaf15b59b36771bfCarl Shapirostatic void *tryMalloc(size_t size) 252f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 2536343bd071555458d0cb071f2eaf15b59b36771bfCarl Shapiro void *ptr; 254f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 255f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* Don't try too hard if there's no way the allocation is 256f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * going to succeed. We have to collect SoftReferences before 257f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * throwing an OOME, though. 258f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 259f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (size >= gDvm.heapSizeMax) { 260f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGW_HEAP("dvmMalloc(%zu/0x%08zx): " 261f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project "someone's allocating a huge buffer\n", size, size); 2626343bd071555458d0cb071f2eaf15b59b36771bfCarl Shapiro ptr = NULL; 263f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project goto collect_soft_refs; 264f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 265f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 266f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project//TODO: figure out better heuristics 267f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// There will be a lot of churn if someone allocates a bunch of 268f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// big objects in a row, and we hit the frag case each time. 269f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// A full GC for each. 270f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// Maybe we grow the heap in bigger leaps 271f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// Maybe we skip the GC if the size is large and we did one recently 272f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// (number of allocations ago) (watch for thread effects) 273f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// DeflateTest allocs a bunch of ~128k buffers w/in 0-5 allocs of each other 274f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// (or, at least, there are only 0-5 objects swept each time) 275f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 2766343bd071555458d0cb071f2eaf15b59b36771bfCarl Shapiro ptr = dvmHeapSourceAlloc(size); 2776343bd071555458d0cb071f2eaf15b59b36771bfCarl Shapiro if (ptr != NULL) { 2786343bd071555458d0cb071f2eaf15b59b36771bfCarl Shapiro return ptr; 279f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 280f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 281ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro /* 282ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro * The allocation failed. If the GC is running, block until it 283ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro * completes and retry. 284ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro */ 285ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro if (gDvm.gcHeap->gcRunning) { 286ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro /* 287ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro * The GC is concurrently tracing the heap. Release the heap 288ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro * lock, wait for the GC to complete, and retrying allocating. 289ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro */ 290ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro dvmWaitForConcurrentGcToComplete(); 291ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro ptr = dvmHeapSourceAlloc(size); 292ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro if (ptr != NULL) { 293ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro return ptr; 294ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro } 295ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro } 296ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro /* 297ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro * Another failure. Our thread was starved or there may be too 298ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro * many live objects. Try a foreground GC. This will have no 299ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro * effect if the concurrent GC is already running. 300f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 301f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gcForMalloc(false); 3026343bd071555458d0cb071f2eaf15b59b36771bfCarl Shapiro ptr = dvmHeapSourceAlloc(size); 3036343bd071555458d0cb071f2eaf15b59b36771bfCarl Shapiro if (ptr != NULL) { 3046343bd071555458d0cb071f2eaf15b59b36771bfCarl Shapiro return ptr; 305f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 306f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 307f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* Even that didn't work; this is an exceptional state. 308f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Try harder, growing the heap if necessary. 309f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 3106343bd071555458d0cb071f2eaf15b59b36771bfCarl Shapiro ptr = dvmHeapSourceAllocAndGrow(size); 311f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmHeapSizeChanged(); 3126343bd071555458d0cb071f2eaf15b59b36771bfCarl Shapiro if (ptr != NULL) { 313f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project size_t newHeapSize; 314f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 315f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project newHeapSize = dvmHeapSourceGetIdealFootprint(); 316f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project//TODO: may want to grow a little bit more so that the amount of free 317f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// space is equal to the old free space + the utilization slop for 318f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project// the new allocation. 319f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGI_HEAP("Grow heap (frag case) to " 320f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project "%zu.%03zuMB for %zu-byte allocation\n", 321f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project FRACTIONAL_MB(newHeapSize), size); 3226343bd071555458d0cb071f2eaf15b59b36771bfCarl Shapiro return ptr; 323f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 324f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 325f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* Most allocations should have succeeded by now, so the heap 326f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * is really full, really fragmented, or the requested size is 327f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * really big. Do another GC, collecting SoftReferences this 328f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * time. The VM spec requires that all SoftReferences have 329f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * been collected and cleared before throwing an OOME. 330f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 331f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project//TODO: wait for the finalizers from the previous GC to finish 332f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectcollect_soft_refs: 333f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGI_HEAP("Forcing collection of SoftReferences for %zu-byte allocation\n", 334f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project size); 335f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gcForMalloc(true); 3366343bd071555458d0cb071f2eaf15b59b36771bfCarl Shapiro ptr = dvmHeapSourceAllocAndGrow(size); 337f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmHeapSizeChanged(); 3386343bd071555458d0cb071f2eaf15b59b36771bfCarl Shapiro if (ptr != NULL) { 3396343bd071555458d0cb071f2eaf15b59b36771bfCarl Shapiro return ptr; 340f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 341f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project//TODO: maybe wait for finalizers and try one last time 342f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 343f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGE_HEAP("Out of memory on a %zd-byte allocation.\n", size); 344f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project//TODO: tell the HeapSource to dump its state 345f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmDumpThread(dvmThreadSelf(), false); 346f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 347f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return NULL; 348f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 349f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 350f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* Throw an OutOfMemoryError if there's a thread to attach it to. 351f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Avoid recursing. 352f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 353f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * The caller must not be holding the heap lock, or else the allocations 354f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * in dvmThrowException() will deadlock. 355f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 356f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectstatic void throwOOME() 357f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 358f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Thread *self; 359f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 360f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if ((self = dvmThreadSelf()) != NULL) { 361f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* If the current (failing) dvmMalloc() happened as part of thread 362f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * creation/attachment before the thread became part of the root set, 363f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * we can't rely on the thread-local trackedAlloc table, so 364f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * we can't keep track of a real allocated OOME object. But, since 365f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * the thread is in the process of being created, it won't have 366f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * a useful stack anyway, so we may as well make things easier 367f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * by throwing the (stackless) pre-built OOME. 368f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 369f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (dvmIsOnThreadList(self) && !self->throwingOOME) { 370f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* Let ourselves know that we tried to throw an OOM 371f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * error in the normal way in case we run out of 372f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * memory trying to allocate it inside dvmThrowException(). 373f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 374f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project self->throwingOOME = true; 375f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 376f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* Don't include a description string; 377f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * one fewer allocation. 378f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 379f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmThrowException("Ljava/lang/OutOfMemoryError;", NULL); 380f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else { 381f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 382f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * This thread has already tried to throw an OutOfMemoryError, 383f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * which probably means that we're running out of memory 384f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * while recursively trying to throw. 385f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 386f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * To avoid any more allocation attempts, "throw" a pre-built 387f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * OutOfMemoryError object (which won't have a useful stack trace). 388f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 389f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Note that since this call can't possibly allocate anything, 390f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * we don't care about the state of self->throwingOOME 391f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * (which will usually already be set). 392f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 393f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmSetException(self, gDvm.outOfMemoryObj); 394f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 395f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* We're done with the possible recursion. 396f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 397f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project self->throwingOOME = false; 398f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 399f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 400f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 401f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 402f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Allocate storage on the GC heap. We guarantee 8-byte alignment. 403f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 404f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * The new storage is zeroed out. 405f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 406f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Note that, in rare cases, this could get called while a GC is in 407f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * progress. If a non-VM thread tries to attach itself through JNI, 408f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * it will need to allocate some objects. If this becomes annoying to 409f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * deal with, we can block it at the source, but holding the allocation 410f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * mutex should be enough. 411f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 412f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * In rare circumstances (JNI AttachCurrentThread) we can be called 413f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * from a non-VM thread. 414f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 415f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Use ALLOC_DONT_TRACK when we either don't want to track an allocation 416f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * (because it's being done for the interpreter "new" operation and will 417f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * be part of the root set immediately) or we can't (because this allocation 418f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * is for a brand new thread). 419f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 420f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Returns NULL and throws an exception on failure. 421f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 422f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * TODO: don't do a GC if the debugger thinks all threads are suspended 423f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 424f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectvoid* dvmMalloc(size_t size, int flags) 425f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 426f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project GcHeap *gcHeap = gDvm.gcHeap; 427f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project void *ptr; 428f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 429f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#if defined(WITH_ALLOC_LIMITS) 430f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 431f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * See if they've exceeded the allocation limit for this thread. 432f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 433f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * A limit value of -1 means "no limit". 434f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 435f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * This is enabled at compile time because it requires us to do a 436f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * TLS lookup for the Thread pointer. This has enough of a performance 437f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * impact that we don't want to do it if we don't have to. (Now that 438f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * we're using gDvm.checkAllocLimits we may want to reconsider this, 439f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * but it's probably still best to just compile the check out of 440f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * production code -- one less thing to hit on every allocation.) 441f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 442f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (gDvm.checkAllocLimits) { 443f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Thread* self = dvmThreadSelf(); 444f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (self != NULL) { 445f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project int count = self->allocLimit; 446f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (count > 0) { 447f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project self->allocLimit--; 448f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else if (count == 0) { 449f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* fail! */ 450f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project assert(!gDvm.initializing); 451f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project self->allocLimit = -1; 452f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmThrowException("Ldalvik/system/AllocationLimitError;", 453f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project "thread allocation limit exceeded"); 454f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return NULL; 455f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 456f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 457f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 458f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 459f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (gDvm.allocationLimit >= 0) { 460f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project assert(!gDvm.initializing); 461f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gDvm.allocationLimit = -1; 462f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmThrowException("Ldalvik/system/AllocationLimitError;", 463f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project "global allocation limit exceeded"); 464f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return NULL; 465f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 466f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#endif 467f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 468f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmLockHeap(); 469f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 470f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* Try as hard as possible to allocate some memory. 471f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 4726343bd071555458d0cb071f2eaf15b59b36771bfCarl Shapiro ptr = tryMalloc(size); 4736343bd071555458d0cb071f2eaf15b59b36771bfCarl Shapiro if (ptr != NULL) { 474f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* We've got the memory. 475f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 476f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if ((flags & ALLOC_FINALIZABLE) != 0) { 477f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* This object is an instance of a class that 478f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * overrides finalize(). Add it to the finalizable list. 479f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 480f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (!dvmHeapAddRefToLargeTable(&gcHeap->finalizableRefs, 4816343bd071555458d0cb071f2eaf15b59b36771bfCarl Shapiro (Object *)ptr)) 482f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project { 483f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGE_HEAP("dvmMalloc(): no room for any more " 484f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project "finalizable objects\n"); 485f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmAbort(); 486f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 487f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 488f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 489f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#ifdef WITH_PROFILER 490f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (gDvm.allocProf.enabled) { 491f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Thread* self = dvmThreadSelf(); 492f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gDvm.allocProf.allocCount++; 493f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gDvm.allocProf.allocSize += size; 494f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (self != NULL) { 495f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project self->allocProf.allocCount++; 496f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project self->allocProf.allocSize += size; 497f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 498f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 499f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#endif 500f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else { 501f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* The allocation failed. 502f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 503f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 504f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#ifdef WITH_PROFILER 505f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (gDvm.allocProf.enabled) { 506f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project Thread* self = dvmThreadSelf(); 507f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gDvm.allocProf.failedAllocCount++; 508f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gDvm.allocProf.failedAllocSize += size; 509f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (self != NULL) { 510f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project self->allocProf.failedAllocCount++; 511f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project self->allocProf.failedAllocSize += size; 512f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 513f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 514f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#endif 515f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 516f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 517f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmUnlockHeap(); 518f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 519f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (ptr != NULL) { 520f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* 521d4f78d3a764e6aa8f7174c78f537c016dac7f7ecBarry Hayes * If caller hasn't asked us not to track it, add it to the 522d4f78d3a764e6aa8f7174c78f537c016dac7f7ecBarry Hayes * internal tracking list. 523f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 524d4f78d3a764e6aa8f7174c78f537c016dac7f7ecBarry Hayes if ((flags & ALLOC_DONT_TRACK) == 0) { 525f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmAddTrackedAlloc(ptr, NULL); 526f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 527f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else { 528c3b92b26df6416d3179e865adccb283ee4170ab1Ben Cheng /* 529f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * The allocation failed; throw an OutOfMemoryError. 530f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 531f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project throwOOME(); 532f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 533f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 534f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return ptr; 535f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 536f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 537f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 538f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Returns true iff <obj> points to a valid allocated object. 539f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 540f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectbool dvmIsValidObject(const Object* obj) 541f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 542f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* Don't bother if it's NULL or not 8-byte aligned. 543f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 5446343bd071555458d0cb071f2eaf15b59b36771bfCarl Shapiro if (obj != NULL && ((uintptr_t)obj & (8-1)) == 0) { 545f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* Even if the heap isn't locked, this shouldn't return 546f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * any false negatives. The only mutation that could 547f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * be happening is allocation, which means that another 548f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * thread could be in the middle of a read-modify-write 549f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * to add a new bit for a new object. However, that 550f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * RMW will have completed by the time any other thread 551f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * could possibly see the new pointer, so there is no 552f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * danger of dvmIsValidObject() being called on a valid 553f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * pointer whose bit isn't set. 554f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 555f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Freeing will only happen during the sweep phase, which 556f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * only happens while the heap is locked. 557f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 5586343bd071555458d0cb071f2eaf15b59b36771bfCarl Shapiro return dvmHeapSourceContains(obj); 559f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 560f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return false; 561f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 562f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 563364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes/* 564364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes * Returns true iff <obj> points to a word-aligned address within Heap 565364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes * address space. 566364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes */ 567364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayesbool dvmIsValidObjectAddress(const void* ptr) 568364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes{ 569364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes /* Don't bother if it's not 4-byte aligned. 570364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes */ 571364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes if (((uintptr_t)ptr & (4-1)) == 0) { 572364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes return dvmHeapSourceContainsAddress(ptr); 573364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes } 574364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes return false; 575364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes} 576364f9d924cbd9d392744a66f80cc084c3d80caf0Barry Hayes 577f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectsize_t dvmObjectSizeInHeap(const Object *obj) 578f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 5796343bd071555458d0cb071f2eaf15b59b36771bfCarl Shapiro return dvmHeapSourceChunkSize(obj); 580f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 581f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 582f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 583962adba4e5db286a36bc8024f5c023bcf6f29312Barry Hayes * Scan every live object in the heap, holding the locks. 584962adba4e5db286a36bc8024f5c023bcf6f29312Barry Hayes */ 585962adba4e5db286a36bc8024f5c023bcf6f29312Barry Hayesstatic void verifyHeap() 586962adba4e5db286a36bc8024f5c023bcf6f29312Barry Hayes{ 587962adba4e5db286a36bc8024f5c023bcf6f29312Barry Hayes // TODO: check the locks. 588962adba4e5db286a36bc8024f5c023bcf6f29312Barry Hayes HeapBitmap *liveBits = dvmHeapSourceGetLiveBits(); 589962adba4e5db286a36bc8024f5c023bcf6f29312Barry Hayes dvmVerifyBitmap(liveBits); 590962adba4e5db286a36bc8024f5c023bcf6f29312Barry Hayes} 591962adba4e5db286a36bc8024f5c023bcf6f29312Barry Hayes 592962adba4e5db286a36bc8024f5c023bcf6f29312Barry Hayes/* 593f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Initiate garbage collection. 594f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 595f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * NOTES: 596f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * - If we don't hold gDvm.threadListLock, it's possible for a thread to 597f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * be added to the thread list while we work. The thread should NOT 598f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * start executing, so this is only interesting when we start chasing 599f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * thread stacks. (Before we do so, grab the lock.) 600f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 601f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * We are not allowed to GC when the debugger has suspended the VM, which 602f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * is awkward because debugger requests can cause allocations. The easiest 603f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * way to enforce this is to refuse to GC on an allocation made by the 604f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * JDWP thread -- we have to expand the heap or fail. 605f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 6062954074adc6a9793f38c0c58d03ec1dc057406ebCarl Shapirovoid dvmCollectGarbageInternal(bool clearSoftRefs, GcReason reason) 607f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 608f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project GcHeap *gcHeap = gDvm.gcHeap; 609f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project u8 now; 610f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project s8 timeSinceLastGc; 611f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project s8 gcElapsedTime; 612f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project int numFreed; 613f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project size_t sizeFreed; 614d25566d9278e6424e521f4b7148ac31480e60c5cCarl Shapiro GcMode gcMode; 615ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro int oldThreadPriority = kInvalidPriority; 616f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 617f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* The heap lock must be held. 618f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 619f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 620f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (gcHeap->gcRunning) { 621f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGW_HEAP("Attempted recursive GC\n"); 622f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project return; 623f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 624d25566d9278e6424e521f4b7148ac31480e60c5cCarl Shapiro gcMode = (reason == GC_FOR_MALLOC) ? GC_PARTIAL : GC_FULL; 625f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gcHeap->gcRunning = true; 626f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project now = dvmGetRelativeTimeUsec(); 627f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (gcHeap->gcStartTime != 0) { 628f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project timeSinceLastGc = (now - gcHeap->gcStartTime) / 1000; 629f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else { 630f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project timeSinceLastGc = 0; 631f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 632f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gcHeap->gcStartTime = now; 633f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 6341b9b4e4b89e1c682b6684ae5e2a637e4497a67e9Barry Hayes LOGV_HEAP("%s starting -- suspending threads\n", GcReasonStr[reason]); 635f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 636f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmSuspendAllThreads(SUSPEND_FOR_GC); 637f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 638ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro /* 639ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro * If we are not marking concurrently raise the priority of the 640ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro * thread performing the garbage collection. 641f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 642ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro if (reason != GC_CONCURRENT) { 643ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro /* Get the priority (the "nice" value) of the current thread. The 644ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro * getpriority() call can legitimately return -1, so we have to 645ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro * explicitly test errno. 646f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 647ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro errno = 0; 648ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro int priorityResult = getpriority(PRIO_PROCESS, 0); 649ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro if (errno != 0) { 650ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro LOGI_HEAP("getpriority(self) failed: %s\n", strerror(errno)); 651ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro } else if (priorityResult > ANDROID_PRIORITY_NORMAL) { 652ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro /* Current value is numerically greater than "normal", which 653ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro * in backward UNIX terms means lower priority. 654ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro */ 655256fc159a267859c18e11e1d15fd7d97a59757c6San Mehat 656ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro if (priorityResult >= ANDROID_PRIORITY_BACKGROUND) { 657ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro set_sched_policy(dvmGetSysThreadId(), SP_FOREGROUND); 658ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro } 659256fc159a267859c18e11e1d15fd7d97a59757c6San Mehat 660ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro if (setpriority(PRIO_PROCESS, 0, ANDROID_PRIORITY_NORMAL) != 0) { 661ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro LOGI_HEAP("Unable to elevate priority from %d to %d\n", 662ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro priorityResult, ANDROID_PRIORITY_NORMAL); 663ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro } else { 664ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro /* priority elevated; save value so we can restore it later */ 665ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro LOGD_HEAP("Elevating priority from %d to %d\n", 666ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro priorityResult, ANDROID_PRIORITY_NORMAL); 667ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro oldThreadPriority = priorityResult; 668ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro } 669f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 670f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 671f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 672f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* Wait for the HeapWorker thread to block. 673f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * (It may also already be suspended in interp code, 674f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * in which case it's not holding heapWorkerLock.) 675f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 676f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmLockMutex(&gDvm.heapWorkerLock); 677f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 678f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* Make sure that the HeapWorker thread hasn't become 679f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * wedged inside interp code. If it has, this call will 680f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * print a message and abort the VM. 681f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 682f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmAssertHeapWorkerThreadRunning(); 683f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 684f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* Lock the pendingFinalizationRefs list. 685f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 686f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Acquire the lock after suspending so the finalizer 687f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * thread can't block in the RUNNING state while 688f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * we try to suspend. 689f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 690f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmLockMutex(&gDvm.heapWorkerListLock); 691f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 692962adba4e5db286a36bc8024f5c023bcf6f29312Barry Hayes if (gDvm.preVerify) { 693962adba4e5db286a36bc8024f5c023bcf6f29312Barry Hayes LOGV_HEAP("Verifying heap before GC"); 694962adba4e5db286a36bc8024f5c023bcf6f29312Barry Hayes verifyHeap(); 695962adba4e5db286a36bc8024f5c023bcf6f29312Barry Hayes } 696962adba4e5db286a36bc8024f5c023bcf6f29312Barry Hayes 697f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#ifdef WITH_PROFILER 698f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmMethodTraceGCBegin(); 699f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#endif 700f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 701f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#if WITH_HPROF 702f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 703f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* Set DUMP_HEAP_ON_DDMS_UPDATE to 1 to enable heap dumps 704f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * whenever DDMS requests a heap update (HPIF chunk). 705f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * The output files will appear in /data/misc, which must 706f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * already exist. 707f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * You must define "WITH_HPROF := true" in your buildspec.mk 708f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * and recompile libdvm for this to work. 709f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 710f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * To enable stack traces for each allocation, define 711f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * "WITH_HPROF_STACK := true" in buildspec.mk. This option slows down 712f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * allocations and also requires 8 additional bytes per object on the 713f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * GC heap. 714f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 715f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#define DUMP_HEAP_ON_DDMS_UPDATE 0 716f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#if DUMP_HEAP_ON_DDMS_UPDATE 717f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gcHeap->hprofDumpOnGc |= (gcHeap->ddmHpifWhen != 0); 718f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#endif 719f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 720f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (gcHeap->hprofDumpOnGc) { 721f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project char nameBuf[128]; 722f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 72399409883d9c4c0ffb49b070ce307bb33a9dfe9f1The Android Open Source Project gcHeap->hprofResult = -1; 72499409883d9c4c0ffb49b070ce307bb33a9dfe9f1The Android Open Source Project 725f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (gcHeap->hprofFileName == NULL) { 726f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* no filename was provided; invent one */ 727f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project sprintf(nameBuf, "/data/misc/heap-dump-tm%d-pid%d.hprof", 728f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project (int) time(NULL), (int) getpid()); 729f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gcHeap->hprofFileName = nameBuf; 730f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 7316bf992c9d51f1e12aa37fe4c791c156402a9b79bAndy McFadden gcHeap->hprofContext = hprofStartup(gcHeap->hprofFileName, 7326bf992c9d51f1e12aa37fe4c791c156402a9b79bAndy McFadden gcHeap->hprofDirectToDdms); 733f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (gcHeap->hprofContext != NULL) { 734f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project hprofStartHeapDump(gcHeap->hprofContext); 735f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 736f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gcHeap->hprofDumpOnGc = false; 737f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gcHeap->hprofFileName = NULL; 738f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 739f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#endif 740f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 741f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (timeSinceLastGc < 10000) { 742f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGD_HEAP("GC! (%dms since last GC)\n", 743f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project (int)timeSinceLastGc); 744f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } else { 745f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGD_HEAP("GC! (%d sec since last GC)\n", 746f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project (int)(timeSinceLastGc / 1000)); 747f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 748f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 749f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* Set up the marking context. 750f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 751d25566d9278e6424e521f4b7148ac31480e60c5cCarl Shapiro if (!dvmHeapBeginMarkStep(gcMode)) { 75299409883d9c4c0ffb49b070ce307bb33a9dfe9f1The Android Open Source Project LOGE_HEAP("dvmHeapBeginMarkStep failed; aborting\n"); 75399409883d9c4c0ffb49b070ce307bb33a9dfe9f1The Android Open Source Project dvmAbort(); 75499409883d9c4c0ffb49b070ce307bb33a9dfe9f1The Android Open Source Project } 755f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 756f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* Mark the set of objects that are strongly reachable from the roots. 757f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 758f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGD_HEAP("Marking..."); 759f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmHeapMarkRootSet(); 760f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 761f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* dvmHeapScanMarkedObjects() will build the lists of known 762f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * instances of the Reference classes. 763f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 764f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gcHeap->softReferences = NULL; 765f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gcHeap->weakReferences = NULL; 766f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gcHeap->phantomReferences = NULL; 767f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 768ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro if (reason == GC_CONCURRENT) { 769ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro /* 770ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro * Resume threads while tracing from the roots. We unlock the 771ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro * heap to allow mutator threads to allocate from free space. 772ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro */ 773ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro dvmUnlockHeap(); 774ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro dvmResumeAllThreads(SUSPEND_FOR_GC); 775ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro } 776ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro 777f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* Recursively mark any objects that marked objects point to strongly. 778f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * If we're not collecting soft references, soft-reachable 779f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * objects will also be marked. 780f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 781f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGD_HEAP("Recursing..."); 782f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmHeapScanMarkedObjects(); 783f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 784ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro if (reason == GC_CONCURRENT) { 785ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro /* 786ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro * Re-acquire the heap lock and perform the final thread 787ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro * suspension. 788ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro */ 789ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro dvmLockHeap(); 790ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro dvmSuspendAllThreads(SUSPEND_FOR_GC); 791ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro /* 792ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro * As no barrier intercepts root updates, we conservatively 793ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro * assume all roots may be gray and re-mark them. 794ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro */ 795ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro dvmHeapMarkRootSet(); 796ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro /* 797ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro * Recursively mark gray objects pointed to by the roots or by 798ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro * heap objects dirtied during the concurrent mark. 799ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro */ 800ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro dvmMarkDirtyObjects(); 801ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro } 802ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro 803f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* All strongly-reachable objects have now been marked. 804f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 8052954074adc6a9793f38c0c58d03ec1dc057406ebCarl Shapiro LOGD_HEAP("Handling soft references..."); 8062954074adc6a9793f38c0c58d03ec1dc057406ebCarl Shapiro if (!clearSoftRefs) { 8072954074adc6a9793f38c0c58d03ec1dc057406ebCarl Shapiro dvmHandleSoftRefs(&gcHeap->softReferences); 8082954074adc6a9793f38c0c58d03ec1dc057406ebCarl Shapiro } 8092954074adc6a9793f38c0c58d03ec1dc057406ebCarl Shapiro dvmClearWhiteRefs(&gcHeap->softReferences); 8102954074adc6a9793f38c0c58d03ec1dc057406ebCarl Shapiro 811f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGD_HEAP("Handling weak references..."); 8122954074adc6a9793f38c0c58d03ec1dc057406ebCarl Shapiro dvmClearWhiteRefs(&gcHeap->weakReferences); 813f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 814f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* Once all weak-reachable objects have been taken 815f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * care of, any remaining unmarked objects can be finalized. 816f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 817f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGD_HEAP("Finding finalizations..."); 818f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmHeapScheduleFinalizations(); 819f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 8202954074adc6a9793f38c0c58d03ec1dc057406ebCarl Shapiro LOGD_HEAP("Handling f-reachable soft references..."); 8212954074adc6a9793f38c0c58d03ec1dc057406ebCarl Shapiro dvmClearWhiteRefs(&gcHeap->softReferences); 8222954074adc6a9793f38c0c58d03ec1dc057406ebCarl Shapiro 8232954074adc6a9793f38c0c58d03ec1dc057406ebCarl Shapiro LOGD_HEAP("Handling f-reachable weak references..."); 8242954074adc6a9793f38c0c58d03ec1dc057406ebCarl Shapiro dvmClearWhiteRefs(&gcHeap->weakReferences); 8252954074adc6a9793f38c0c58d03ec1dc057406ebCarl Shapiro 826f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* Any remaining objects that are not pending finalization 827f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * could be phantom-reachable. This will mark any phantom-reachable 828f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * objects, as well as enqueue their references. 829f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 830f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGD_HEAP("Handling phantom references..."); 8312954074adc6a9793f38c0c58d03ec1dc057406ebCarl Shapiro dvmClearWhiteRefs(&gcHeap->phantomReferences); 832f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 833f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#ifdef WITH_DEADLOCK_PREDICTION 834f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmDumpMonitorInfo("before sweep"); 835f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#endif 836f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGD_HEAP("Sweeping..."); 837d25566d9278e6424e521f4b7148ac31480e60c5cCarl Shapiro dvmHeapSweepUnmarkedObjects(gcMode, &numFreed, &sizeFreed); 838f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#ifdef WITH_DEADLOCK_PREDICTION 839f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmDumpMonitorInfo("after sweep"); 840f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#endif 841f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 842f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGD_HEAP("Cleaning up..."); 843f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmHeapFinishMarkStep(); 844f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 845f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGD_HEAP("Done."); 846f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 847f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* Now's a good time to adjust the heap size, since 848f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * we know what our utilization is. 849f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 850f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * This doesn't actually resize any memory; 851f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * it just lets the heap grow more when necessary. 852f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 853f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmHeapSourceGrowForUtilization(); 854f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmHeapSizeChanged(); 855f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 856f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#if WITH_HPROF 857f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (gcHeap->hprofContext != NULL) { 858f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project hprofFinishHeapDump(gcHeap->hprofContext); 859f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project//TODO: write a HEAP_SUMMARY record 86099409883d9c4c0ffb49b070ce307bb33a9dfe9f1The Android Open Source Project if (hprofShutdown(gcHeap->hprofContext)) 86199409883d9c4c0ffb49b070ce307bb33a9dfe9f1The Android Open Source Project gcHeap->hprofResult = 0; /* indicate success */ 862f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gcHeap->hprofContext = NULL; 863f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 864f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#endif 865f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 866f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project /* Now that we've freed up the GC heap, return any large 867f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * free chunks back to the system. They'll get paged back 868f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * in the next time they're used. Don't do it immediately, 869f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * though; if the process is still allocating a bunch of 870f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * memory, we'll be taking a ton of page faults that we don't 871f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * necessarily need to. 872f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 873f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Cancel any old scheduled trims, and schedule a new one. 874f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 875f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmScheduleHeapSourceTrim(5); // in seconds 876f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 877f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#ifdef WITH_PROFILER 878f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmMethodTraceGCEnd(); 879f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#endif 880962adba4e5db286a36bc8024f5c023bcf6f29312Barry Hayes LOGV_HEAP("GC finished"); 881962adba4e5db286a36bc8024f5c023bcf6f29312Barry Hayes 882962adba4e5db286a36bc8024f5c023bcf6f29312Barry Hayes if (gDvm.postVerify) { 883962adba4e5db286a36bc8024f5c023bcf6f29312Barry Hayes LOGV_HEAP("Verifying heap after GC"); 884962adba4e5db286a36bc8024f5c023bcf6f29312Barry Hayes verifyHeap(); 885962adba4e5db286a36bc8024f5c023bcf6f29312Barry Hayes } 886f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 887f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gcHeap->gcRunning = false; 888f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 889962adba4e5db286a36bc8024f5c023bcf6f29312Barry Hayes LOGV_HEAP("Resuming threads"); 890f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmUnlockMutex(&gDvm.heapWorkerListLock); 891f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmUnlockMutex(&gDvm.heapWorkerLock); 892f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 893c3b92b26df6416d3179e865adccb283ee4170ab1Ben Cheng#if defined(WITH_JIT) 894c3b92b26df6416d3179e865adccb283ee4170ab1Ben Cheng /* 895c3b92b26df6416d3179e865adccb283ee4170ab1Ben Cheng * Patching a chaining cell is very cheap as it only updates 4 words. It's 896c3b92b26df6416d3179e865adccb283ee4170ab1Ben Cheng * the overhead of stopping all threads and synchronizing the I/D cache 897c3b92b26df6416d3179e865adccb283ee4170ab1Ben Cheng * that makes it expensive. 898c3b92b26df6416d3179e865adccb283ee4170ab1Ben Cheng * 899c3b92b26df6416d3179e865adccb283ee4170ab1Ben Cheng * Therefore we batch those work orders in a queue and go through them 900c3b92b26df6416d3179e865adccb283ee4170ab1Ben Cheng * when threads are suspended for GC. 901c3b92b26df6416d3179e865adccb283ee4170ab1Ben Cheng */ 902c3b92b26df6416d3179e865adccb283ee4170ab1Ben Cheng dvmCompilerPerformSafePointChecks(); 903c3b92b26df6416d3179e865adccb283ee4170ab1Ben Cheng#endif 904c3b92b26df6416d3179e865adccb283ee4170ab1Ben Cheng 905f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmResumeAllThreads(SUSPEND_FOR_GC); 906ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro 907ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro if (reason == GC_CONCURRENT) { 908ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro /* 909ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro * Wake-up any threads that blocked after a failed allocation 910ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro * request. 911ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro */ 912ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro dvmBroadcastCond(&gDvm.gcHeapCond); 913ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro } 914ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro 915ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro if (reason != GC_CONCURRENT) { 916ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro if (oldThreadPriority != kInvalidPriority) { 917ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro if (setpriority(PRIO_PROCESS, 0, oldThreadPriority) != 0) { 918ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro LOGW_HEAP("Unable to reset priority to %d: %s\n", 919ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro oldThreadPriority, strerror(errno)); 920ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro } else { 921ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro LOGD_HEAP("Reset priority to %d\n", oldThreadPriority); 922ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro } 923256fc159a267859c18e11e1d15fd7d97a59757c6San Mehat 924ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro if (oldThreadPriority >= ANDROID_PRIORITY_BACKGROUND) { 925ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro set_sched_policy(dvmGetSysThreadId(), SP_BACKGROUND); 926ec805eaed940e40212e85b58b163c7649feaca56Carl Shapiro } 927256fc159a267859c18e11e1d15fd7d97a59757c6San Mehat } 928f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 929f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gcElapsedTime = (dvmGetRelativeTimeUsec() - gcHeap->gcStartTime) / 1000; 9303136413fae48cee04095236a945e41782d6d10bcBarry Hayes LOGD("%s freed %d objects / %zd bytes in %dms\n", 9313136413fae48cee04095236a945e41782d6d10bcBarry Hayes GcReasonStr[reason], numFreed, sizeFreed, (int)gcElapsedTime); 932f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmLogGcStats(numFreed, sizeFreed, gcElapsedTime); 933f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 934f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (gcHeap->ddmHpifWhen != 0) { 935f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGD_HEAP("Sending VM heap info to DDM\n"); 936f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmDdmSendHeapInfo(gcHeap->ddmHpifWhen, false); 937f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 938f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (gcHeap->ddmHpsgWhen != 0) { 939f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGD_HEAP("Dumping VM heap to DDM\n"); 940f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmDdmSendHeapSegments(false, false); 941f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 942f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (gcHeap->ddmNhsgWhen != 0) { 943f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project LOGD_HEAP("Dumping native heap to DDM\n"); 944f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmDdmSendHeapSegments(false, true); 945f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 946f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 947f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 948ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapirovoid dvmWaitForConcurrentGcToComplete(void) 949ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro{ 950ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro Thread *self = dvmThreadSelf(); 951ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro ThreadStatus oldStatus; 952ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro assert(self != NULL); 953ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro oldStatus = dvmChangeStatus(self, THREAD_VMWAIT); 954ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro dvmWaitCond(&gDvm.gcHeapCond, &gDvm.gcHeapLock); 955ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro dvmChangeStatus(self, oldStatus); 956ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro} 957ec47e2e081dcd43dca10d5e2c6856f73e94b0460Carl Shapiro 958f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#if WITH_HPROF 959f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project/* 960f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * Perform garbage collection, writing heap information to the specified file. 961f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * 962f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project * If "fileName" is NULL, a suitable name will be generated automatically. 96399409883d9c4c0ffb49b070ce307bb33a9dfe9f1The Android Open Source Project * 96499409883d9c4c0ffb49b070ce307bb33a9dfe9f1The Android Open Source Project * Returns 0 on success, or an error code on failure. 965f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project */ 9666bf992c9d51f1e12aa37fe4c791c156402a9b79bAndy McFaddenint hprofDumpHeap(const char* fileName, bool directToDdms) 967f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 96899409883d9c4c0ffb49b070ce307bb33a9dfe9f1The Android Open Source Project int result; 96999409883d9c4c0ffb49b070ce307bb33a9dfe9f1The Android Open Source Project 970f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmLockMutex(&gDvm.gcHeapLock); 971f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 972f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gDvm.gcHeap->hprofDumpOnGc = true; 973f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project gDvm.gcHeap->hprofFileName = fileName; 9746bf992c9d51f1e12aa37fe4c791c156402a9b79bAndy McFadden gDvm.gcHeap->hprofDirectToDdms = directToDdms; 9751b9b4e4b89e1c682b6684ae5e2a637e4497a67e9Barry Hayes dvmCollectGarbageInternal(false, GC_HPROF_DUMP_HEAP); 97699409883d9c4c0ffb49b070ce307bb33a9dfe9f1The Android Open Source Project result = gDvm.gcHeap->hprofResult; 977f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 978f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project dvmUnlockMutex(&gDvm.gcHeapLock); 97999409883d9c4c0ffb49b070ce307bb33a9dfe9f1The Android Open Source Project 98099409883d9c4c0ffb49b070ce307bb33a9dfe9f1The Android Open Source Project return result; 981f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 982f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project 983f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Projectvoid dvmHeapSetHprofGcScanState(hprof_heap_tag_t state, u4 threadSerialNumber) 984f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project{ 985f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project if (gDvm.gcHeap->hprofContext != NULL) { 986f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project hprofSetGcScanState(gDvm.gcHeap->hprofContext, state, 987f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project threadSerialNumber); 988f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project } 989f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project} 990f6c387128427e121477c1b32ad35cdcaa5101ba3The Android Open Source Project#endif 991