/* * Copyright (C) 2008 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "Dalvik.h" #include "alloc/clz.h" #include "alloc/HeapBitmap.h" #include "alloc/HeapInternal.h" #include "alloc/HeapSource.h" #include "alloc/MarkSweep.h" #include "alloc/Visit.h" #include <limits.h> // for ULONG_MAX #include <sys/mman.h> // for madvise(), mmap() #include <errno.h> #define GC_LOG_TAG LOG_TAG "-gc" #if LOG_NDEBUG #define LOGV_GC(...) ((void)0) #define LOGD_GC(...) ((void)0) #else #define LOGV_GC(...) LOG(LOG_VERBOSE, GC_LOG_TAG, __VA_ARGS__) #define LOGD_GC(...) LOG(LOG_DEBUG, GC_LOG_TAG, __VA_ARGS__) #endif #define LOGI_GC(...) LOG(LOG_INFO, GC_LOG_TAG, __VA_ARGS__) #define LOGW_GC(...) LOG(LOG_WARN, GC_LOG_TAG, __VA_ARGS__) #define LOGE_GC(...) LOG(LOG_ERROR, GC_LOG_TAG, __VA_ARGS__) #define LOG_SCAN(...) LOGV_GC("SCAN: " __VA_ARGS__) #define ALIGN_UP(x, n) (((size_t)(x) + (n) - 1) & ~((n) - 1)) #define ALIGN_UP_TO_PAGE_SIZE(p) ALIGN_UP(p, SYSTEM_PAGE_SIZE) /* Do not cast the result of this to a boolean; the only set bit * may be > 1<<8. */ static inline long isMarked(const void *obj, const GcMarkContext *ctx) { return dvmHeapBitmapIsObjectBitSet(ctx->bitmap, obj); } static bool createMarkStack(GcMarkStack *stack) { const Object **limit; const char *name; size_t size; /* Create a stack big enough for the worst possible case, * where the heap is perfectly full of the smallest object. * TODO: be better about memory usage; use a smaller stack with * overflow detection and recovery. */ size = dvmHeapSourceGetIdealFootprint() * sizeof(Object*) / (sizeof(Object) + HEAP_SOURCE_CHUNK_OVERHEAD); size = ALIGN_UP_TO_PAGE_SIZE(size); name = "dalvik-mark-stack"; limit = dvmAllocRegion(size, PROT_READ | PROT_WRITE, name); if (limit == NULL) { LOGE_GC("Could not mmap %zd-byte ashmem region '%s'", size, name); return false; } stack->limit = limit; stack->base = (const Object **)((uintptr_t)limit + size); stack->top = stack->base; return true; } static void destroyMarkStack(GcMarkStack *stack) { munmap((char *)stack->limit, (uintptr_t)stack->base - (uintptr_t)stack->limit); memset(stack, 0, sizeof(*stack)); } #define MARK_STACK_PUSH(stack, obj) \ do { \ *--(stack).top = (obj); \ } while (false) bool dvmHeapBeginMarkStep(GcMode mode) { GcMarkContext *ctx = &gDvm.gcHeap->markContext; if (!createMarkStack(&ctx->stack)) { return false; } ctx->finger = NULL; ctx->immuneLimit = dvmHeapSourceGetImmuneLimit(mode); return true; } static long setAndReturnMarkBit(GcMarkContext *ctx, const void *obj) { return dvmHeapBitmapSetAndReturnObjectBit(ctx->bitmap, obj); } static void markObjectNonNull(const Object *obj, GcMarkContext *ctx, bool checkFinger) { assert(ctx != NULL); assert(obj != NULL); assert(dvmIsValidObject(obj)); if (obj < (Object *)ctx->immuneLimit) { assert(isMarked(obj, ctx)); return; } if (!setAndReturnMarkBit(ctx, obj)) { /* This object was not previously marked. */ if (checkFinger && (void *)obj < ctx->finger) { /* This object will need to go on the mark stack. */ MARK_STACK_PUSH(ctx->stack, obj); } #if WITH_HPROF if (gDvm.gcHeap->hprofContext != NULL) { hprofMarkRootObject(gDvm.gcHeap->hprofContext, obj, 0); } #endif } } /* Used to mark objects when recursing. Recursion is done by moving * the finger across the bitmaps in address order and marking child * objects. Any newly-marked objects whose addresses are lower than * the finger won't be visited by the bitmap scan, so those objects * need to be added to the mark stack. */ static void markObject(const Object *obj, GcMarkContext *ctx) { if (obj != NULL) { markObjectNonNull(obj, ctx, true); } } /* If the object hasn't already been marked, mark it and * schedule it to be scanned for references. * * obj may not be NULL. The macro dvmMarkObject() should * be used in situations where a reference may be NULL. * * This function may only be called when marking the root * set. When recursing, use the internal markObject(). */ void dvmMarkObjectNonNull(const Object *obj) { assert(obj != NULL); markObjectNonNull(obj, &gDvm.gcHeap->markContext, false); } /* Mark the set of root objects. * * Things we need to scan: * - System classes defined by root classloader * - For each thread: * - Interpreted stack, from top to "curFrame" * - Dalvik registers (args + local vars) * - JNI local references * - Automatic VM local references (TrackedAlloc) * - Associated Thread/VMThread object * - ThreadGroups (could track & start with these instead of working * upward from Threads) * - Exception currently being thrown, if present * - JNI global references * - Interned string table * - Primitive classes * - Special objects * - gDvm.outOfMemoryObj * - Objects allocated with ALLOC_NO_GC * - Objects pending finalization (but not yet finalized) * - Objects in debugger object registry * * Don't need: * - Native stack (for in-progress stuff in the VM) * - The TrackedAlloc stuff watches all native VM references. */ void dvmHeapMarkRootSet() { GcHeap *gcHeap = gDvm.gcHeap; HPROF_SET_GC_SCAN_STATE(HPROF_ROOT_STICKY_CLASS, 0); LOG_SCAN("immune objects"); dvmMarkImmuneObjects(gcHeap->markContext.immuneLimit); LOG_SCAN("root class loader\n"); dvmGcScanRootClassLoader(); LOG_SCAN("primitive classes\n"); dvmGcScanPrimitiveClasses(); /* dvmGcScanRootThreadGroups() sets a bunch of * different scan states internally. */ HPROF_CLEAR_GC_SCAN_STATE(); LOG_SCAN("root thread groups\n"); dvmGcScanRootThreadGroups(); HPROF_SET_GC_SCAN_STATE(HPROF_ROOT_INTERNED_STRING, 0); LOG_SCAN("interned strings\n"); dvmGcScanInternedStrings(); HPROF_SET_GC_SCAN_STATE(HPROF_ROOT_JNI_GLOBAL, 0); LOG_SCAN("JNI global refs\n"); dvmGcMarkJniGlobalRefs(); HPROF_SET_GC_SCAN_STATE(HPROF_ROOT_REFERENCE_CLEANUP, 0); LOG_SCAN("pending reference operations\n"); dvmHeapMarkLargeTableRefs(gcHeap->referenceOperations); HPROF_SET_GC_SCAN_STATE(HPROF_ROOT_FINALIZING, 0); LOG_SCAN("pending finalizations\n"); dvmHeapMarkLargeTableRefs(gcHeap->pendingFinalizationRefs); HPROF_SET_GC_SCAN_STATE(HPROF_ROOT_DEBUGGER, 0); LOG_SCAN("debugger refs\n"); dvmGcMarkDebuggerRefs(); HPROF_SET_GC_SCAN_STATE(HPROF_ROOT_VM_INTERNAL, 0); /* Mark any special objects we have sitting around. */ LOG_SCAN("special objects\n"); dvmMarkObjectNonNull(gDvm.outOfMemoryObj); dvmMarkObjectNonNull(gDvm.internalErrorObj); dvmMarkObjectNonNull(gDvm.noClassDefFoundErrorObj); //TODO: scan object references sitting in gDvm; use pointer begin & end HPROF_CLEAR_GC_SCAN_STATE(); } /* * Callback applied to root references. If the root location contains * a white reference it is pushed on the mark stack and grayed. */ static void markObjectVisitor(void *addr, void *arg) { Object *obj; assert(addr != NULL); assert(arg != NULL); obj = *(Object **)addr; if (obj != NULL) { markObjectNonNull(obj, arg, true); } } /* * Grays all references in the roots. */ void dvmHeapReMarkRootSet(void) { GcMarkContext *ctx = &gDvm.gcHeap->markContext; assert(ctx->finger == (void *)ULONG_MAX); dvmVisitRoots(markObjectVisitor, ctx); } /* * Nothing past this point is allowed to use dvmMarkObject() or * dvmMarkObjectNonNull(), which are for root-marking only. * Scanning/recursion must use markObject(), which takes the finger * into account. */ #undef dvmMarkObject #define dvmMarkObject __dont_use_dvmMarkObject__ #define dvmMarkObjectNonNull __dont_use_dvmMarkObjectNonNull__ /* * Scans instance fields. */ static void scanInstanceFields(const Object *obj, GcMarkContext *ctx) { assert(obj != NULL); assert(obj->clazz != NULL); assert(ctx != NULL); if (obj->clazz->refOffsets != CLASS_WALK_SUPER) { unsigned int refOffsets = obj->clazz->refOffsets; while (refOffsets != 0) { const int rshift = CLZ(refOffsets); refOffsets &= ~(CLASS_HIGH_BIT >> rshift); markObject(dvmGetFieldObject((Object*)obj, CLASS_OFFSET_FROM_CLZ(rshift)), ctx); } } else { ClassObject *clazz; int i; for (clazz = obj->clazz; clazz != NULL; clazz = clazz->super) { InstField *field = clazz->ifields; for (i = 0; i < clazz->ifieldRefCount; ++i, ++field) { void *addr = BYTE_OFFSET((Object *)obj, field->byteOffset); markObject(((JValue *)addr)->l, ctx); } } } } /* * Scans the header, static field references, and interface * pointers of a class object. */ static void scanClassObject(const ClassObject *obj, GcMarkContext *ctx) { int i; assert(obj != NULL); assert(obj->obj.clazz == gDvm.classJavaLangClass); assert(ctx != NULL); markObject((Object *)obj->obj.clazz, ctx); if (IS_CLASS_FLAG_SET(obj, CLASS_ISARRAY)) { markObject((Object *)obj->elementClass, ctx); } /* Do super and the interfaces contain Objects and not dex idx values? */ if (obj->status > CLASS_IDX) { markObject((Object *)obj->super, ctx); } markObject(obj->classLoader, ctx); /* Scan static field references. */ for (i = 0; i < obj->sfieldCount; ++i) { char ch = obj->sfields[i].field.signature[0]; if (ch == '[' || ch == 'L') { markObject(obj->sfields[i].value.l, ctx); } } /* Scan the instance fields. */ scanInstanceFields((const Object *)obj, ctx); /* Scan interface references. */ if (obj->status > CLASS_IDX) { for (i = 0; i < obj->interfaceCount; ++i) { markObject((Object *)obj->interfaces[i], ctx); } } } /* * Scans the header of all array objects. If the array object is * specialized to a reference type, scans the array data as well. */ static void scanArrayObject(const ArrayObject *obj, GcMarkContext *ctx) { size_t i; assert(obj != NULL); assert(obj->obj.clazz != NULL); assert(ctx != NULL); /* Scan the class object reference. */ markObject((Object *)obj->obj.clazz, ctx); if (IS_CLASS_FLAG_SET(obj->obj.clazz, CLASS_ISOBJECTARRAY)) { /* Scan the array contents. */ Object **contents = (Object **)obj->contents; for (i = 0; i < obj->length; ++i) { markObject(contents[i], ctx); } } } /* * Returns class flags relating to Reference subclasses. */ static int referenceClassFlags(const Object *obj) { int flags = CLASS_ISREFERENCE | CLASS_ISWEAKREFERENCE | CLASS_ISPHANTOMREFERENCE; return GET_CLASS_FLAG_GROUP(obj->clazz, flags); } /* * Returns true if the object derives from SoftReference. */ static bool isSoftReference(const Object *obj) { return referenceClassFlags(obj) == CLASS_ISREFERENCE; } /* * Returns true if the object derives from WeakReference. */ static bool isWeakReference(const Object *obj) { return referenceClassFlags(obj) & CLASS_ISWEAKREFERENCE; } /* * Returns true if the object derives from PhantomReference. */ static bool isPhantomReference(const Object *obj) { return referenceClassFlags(obj) & CLASS_ISPHANTOMREFERENCE; } /* * Adds a reference to the tail of a circular queue of references. */ static void enqueuePendingReference(Object *ref, Object **list) { size_t offset; assert(ref != NULL); assert(list != NULL); offset = gDvm.offJavaLangRefReference_pendingNext; if (*list == NULL) { dvmSetFieldObject(ref, offset, ref); *list = ref; } else { Object *head = dvmGetFieldObject(*list, offset); dvmSetFieldObject(ref, offset, head); dvmSetFieldObject(*list, offset, ref); } } /* * Removes the reference at the head of a circular queue of * references. */ static Object *dequeuePendingReference(Object **list) { Object *ref, *head; size_t offset; assert(list != NULL); assert(*list != NULL); offset = gDvm.offJavaLangRefReference_pendingNext; head = dvmGetFieldObject(*list, offset); if (*list == head) { ref = *list; *list = NULL; } else { Object *next = dvmGetFieldObject(head, offset); dvmSetFieldObject(*list, offset, next); ref = head; } dvmSetFieldObject(ref, offset, NULL); return ref; } /* * Process the "referent" field in a java.lang.ref.Reference. If the * referent has not yet been marked, put it on the appropriate list in * the gcHeap for later processing. */ static void delayReferenceReferent(Object *obj, GcMarkContext *ctx) { GcHeap *gcHeap = gDvm.gcHeap; Object *pending, *referent; size_t pendingNextOffset, referentOffset; assert(obj != NULL); assert(obj->clazz != NULL); assert(IS_CLASS_FLAG_SET(obj->clazz, CLASS_ISREFERENCE)); assert(ctx != NULL); pendingNextOffset = gDvm.offJavaLangRefReference_pendingNext; referentOffset = gDvm.offJavaLangRefReference_referent; pending = dvmGetFieldObject(obj, pendingNextOffset); referent = dvmGetFieldObject(obj, referentOffset); if (pending == NULL && referent != NULL && !isMarked(referent, ctx)) { Object **list = NULL; if (isSoftReference(obj)) { list = &gcHeap->softReferences; } else if (isWeakReference(obj)) { list = &gcHeap->weakReferences; } else if (isPhantomReference(obj)) { list = &gcHeap->phantomReferences; } assert(list != NULL); enqueuePendingReference(obj, list); } } /* * Scans the header and field references of a data object. */ static void scanDataObject(DataObject *obj, GcMarkContext *ctx) { assert(obj != NULL); assert(obj->obj.clazz != NULL); assert(ctx != NULL); /* Scan the class object. */ markObject((Object *)obj->obj.clazz, ctx); /* Scan the instance fields. */ scanInstanceFields((const Object *)obj, ctx); if (IS_CLASS_FLAG_SET(obj->obj.clazz, CLASS_ISREFERENCE)) { delayReferenceReferent((Object *)obj, ctx); } } /* * Scans an object reference. Determines the type of the reference * and dispatches to a specialized scanning routine. */ static void scanObject(const Object *obj, GcMarkContext *ctx) { assert(obj != NULL); assert(ctx != NULL); assert(obj->clazz != NULL); #if WITH_HPROF if (gDvm.gcHeap->hprofContext != NULL) { hprofDumpHeapObject(gDvm.gcHeap->hprofContext, obj); } #endif /* Dispatch a type-specific scan routine. */ if (obj->clazz == gDvm.classJavaLangClass) { scanClassObject((ClassObject *)obj, ctx); } else if (IS_CLASS_FLAG_SET(obj->clazz, CLASS_ISARRAY)) { scanArrayObject((ArrayObject *)obj, ctx); } else { scanDataObject((DataObject *)obj, ctx); } } static void processMarkStack(GcMarkContext *ctx) { const Object **const base = ctx->stack.base; /* Scan anything that's on the mark stack. * We can't use the bitmaps anymore, so use * a finger that points past the end of them. */ ctx->finger = (void *)ULONG_MAX; while (ctx->stack.top != base) { scanObject(*ctx->stack.top++, ctx); } } static size_t objectSize(const Object *obj) { assert(dvmIsValidObject(obj)); assert(dvmIsValidObject((Object *)obj->clazz)); if (IS_CLASS_FLAG_SET(obj->clazz, CLASS_ISARRAY)) { return dvmArrayObjectSize((ArrayObject *)obj); } else if (obj->clazz == gDvm.classJavaLangClass) { return dvmClassObjectSize((ClassObject *)obj); } else { return obj->clazz->objectSize; } } /* * Scans forward to the header of the next marked object between start * and limit. Returns NULL if no marked objects are in that region. */ static Object *nextGrayObject(u1 *base, u1 *limit, HeapBitmap *markBits) { u1 *ptr; assert(base < limit); assert(limit - base <= GC_CARD_SIZE); for (ptr = base; ptr < limit; ptr += HB_OBJECT_ALIGNMENT) { if (dvmHeapBitmapIsObjectBitSet(markBits, ptr)) return (Object *)ptr; } return NULL; } /* * Scan the card table looking for objects that have been grayed by * the mutator. */ static void scanGrayObjects(GcMarkContext *ctx) { GcHeap *h = gDvm.gcHeap; HeapBitmap *markBits, *liveBits; u1 *card, *baseCard, *limitCard; size_t footprint; markBits = ctx->bitmap; liveBits = dvmHeapSourceGetLiveBits(); footprint = dvmHeapSourceGetValue(HS_FOOTPRINT, NULL, 0); baseCard = &h->cardTableBase[0]; limitCard = dvmCardFromAddr((u1 *)dvmHeapSourceGetBase() + footprint); assert(limitCard <= &h->cardTableBase[h->cardTableLength]); for (card = baseCard; card != limitCard; ++card) { if (*card == GC_CARD_DIRTY) { /* * The card is dirty. Scan all of the objects that * intersect with the card address. */ u1 *addr = dvmAddrFromCard(card); /* * Scan through all black objects that start on the * current card. */ u1 *limit = addr + GC_CARD_SIZE; u1 *next = addr; while (next < limit) { Object *obj = nextGrayObject(next, limit, markBits); if (obj == NULL) break; scanObject(obj, ctx); next = (u1*)obj + ALIGN_UP(objectSize(obj), HB_OBJECT_ALIGNMENT); } } } } /* * Callback for scanning each object in the bitmap. The finger is set * to the address corresponding to the lowest address in the next word * of bits in the bitmap. */ static void scanBitmapCallback(void *addr, void *finger, void *arg) { GcMarkContext *ctx = arg; ctx->finger = (void *)finger; scanObject(addr, ctx); } /* Given bitmaps with the root set marked, find and mark all * reachable objects. When this returns, the entire set of * live objects will be marked and the mark stack will be empty. */ void dvmHeapScanMarkedObjects(void) { GcMarkContext *ctx = &gDvm.gcHeap->markContext; assert(ctx->finger == NULL); /* The bitmaps currently have bits set for the root set. * Walk across the bitmaps and scan each object. */ dvmHeapBitmapScanWalk(ctx->bitmap, scanBitmapCallback, ctx); /* We've walked the mark bitmaps. Scan anything that's * left on the mark stack. */ processMarkStack(ctx); LOG_SCAN("done with marked objects\n"); } void dvmHeapReScanMarkedObjects(void) { GcMarkContext *ctx = &gDvm.gcHeap->markContext; /* * The finger must have been set to the maximum value to ensure * that gray objects will be pushed onto the mark stack. */ assert(ctx->finger == (void *)ULONG_MAX); scanGrayObjects(ctx); processMarkStack(ctx); } /* * Clear the referent field. */ static void clearReference(Object *reference) { size_t offset = gDvm.offJavaLangRefReference_referent; dvmSetFieldObject(reference, offset, NULL); } /* * Returns true if the reference was registered with a reference queue * and has not yet been enqueued. */ static bool isEnqueuable(const Object *reference) { Object *queue = dvmGetFieldObject(reference, gDvm.offJavaLangRefReference_queue); Object *queueNext = dvmGetFieldObject(reference, gDvm.offJavaLangRefReference_queueNext); return queue != NULL && queueNext == NULL; } /* * Schedules a reference to be appended to its reference queue. */ static void enqueueReference(Object *ref) { assert(ref != NULL); assert(dvmGetFieldObject(ref, gDvm.offJavaLangRefReference_queue) != NULL); assert(dvmGetFieldObject(ref, gDvm.offJavaLangRefReference_queueNext) == NULL); if (!dvmHeapAddRefToLargeTable(&gDvm.gcHeap->referenceOperations, ref)) { LOGE_HEAP("enqueueReference(): no room for any more " "reference operations\n"); dvmAbort(); } } /* * Walks the reference list marking any references subject to the * reference clearing policy. References with a black referent are * removed from the list. References with white referents biased * toward saving are blackened and also removed from the list. */ void dvmHandleSoftRefs(Object **list) { GcMarkContext *ctx; Object *ref, *referent; Object *clear; size_t referentOffset; size_t counter; bool marked; ctx = &gDvm.gcHeap->markContext; referentOffset = gDvm.offJavaLangRefReference_referent; clear = NULL; counter = 0; while (*list != NULL) { ref = dequeuePendingReference(list); referent = dvmGetFieldObject(ref, referentOffset); assert(referent != NULL); marked = isMarked(referent, ctx); if (!marked && ((++counter) & 1)) { /* Referent is white and biased toward saving, mark it. */ markObject(referent, ctx); marked = true; } if (!marked) { /* Referent is white, queue it for clearing. */ enqueuePendingReference(ref, &clear); } } *list = clear; /* * Restart the mark with the newly black references added to the * root set. */ processMarkStack(ctx); } /* * Unlink the reference list clearing references objects with white * referents. Cleared references registered to a reference queue are * scheduled for appending by the heap worker thread. */ void dvmClearWhiteRefs(Object **list) { GcMarkContext *ctx; Object *ref, *referent; size_t referentOffset; bool doSignal; ctx = &gDvm.gcHeap->markContext; referentOffset = gDvm.offJavaLangRefReference_referent; doSignal = false; while (*list != NULL) { ref = dequeuePendingReference(list); referent = dvmGetFieldObject(ref, referentOffset); assert(referent != NULL); if (!isMarked(referent, ctx)) { /* Referent is white, clear it. */ clearReference(ref); if (isEnqueuable(ref)) { enqueueReference(ref); doSignal = true; } } } /* * If we cleared a reference with a reference queue we must notify * the heap worker to append the reference. */ if (doSignal) { dvmSignalHeapWorker(false); } assert(*list == NULL); } /* Find unreachable objects that need to be finalized, * and schedule them for finalization. */ void dvmHeapScheduleFinalizations() { HeapRefTable newPendingRefs; LargeHeapRefTable *finRefs = gDvm.gcHeap->finalizableRefs; Object **ref; Object **lastRef; size_t totalPendCount; GcMarkContext *ctx = &gDvm.gcHeap->markContext; /* * All reachable objects have been marked. * Any unmarked finalizable objects need to be finalized. */ /* Create a table that the new pending refs will * be added to. */ if (!dvmHeapInitHeapRefTable(&newPendingRefs)) { //TODO: mark all finalizable refs and hope that // we can schedule them next time. Watch out, // because we may be expecting to free up space // by calling finalizers. LOGE_GC("dvmHeapScheduleFinalizations(): no room for " "pending finalizations\n"); dvmAbort(); } /* Walk through finalizableRefs and move any unmarked references * to the list of new pending refs. */ totalPendCount = 0; while (finRefs != NULL) { Object **gapRef; size_t newPendCount = 0; gapRef = ref = finRefs->refs.table; lastRef = finRefs->refs.nextEntry; while (ref < lastRef) { if (!isMarked(*ref, ctx)) { if (!dvmHeapAddToHeapRefTable(&newPendingRefs, *ref)) { //TODO: add the current table and allocate // a new, smaller one. LOGE_GC("dvmHeapScheduleFinalizations(): " "no room for any more pending finalizations: %zd\n", dvmHeapNumHeapRefTableEntries(&newPendingRefs)); dvmAbort(); } newPendCount++; } else { /* This ref is marked, so will remain on finalizableRefs. */ if (newPendCount > 0) { /* Copy it up to fill the holes. */ *gapRef++ = *ref; } else { /* No holes yet; don't bother copying. */ gapRef++; } } ref++; } finRefs->refs.nextEntry = gapRef; //TODO: if the table is empty when we're done, free it. totalPendCount += newPendCount; finRefs = finRefs->next; } LOGD_GC("dvmHeapScheduleFinalizations(): %zd finalizers triggered.\n", totalPendCount); if (totalPendCount == 0) { /* No objects required finalization. * Free the empty temporary table. */ dvmClearReferenceTable(&newPendingRefs); return; } /* Add the new pending refs to the main list. */ if (!dvmHeapAddTableToLargeTable(&gDvm.gcHeap->pendingFinalizationRefs, &newPendingRefs)) { LOGE_GC("dvmHeapScheduleFinalizations(): can't insert new " "pending finalizations\n"); dvmAbort(); } //TODO: try compacting the main list with a memcpy loop /* Mark the refs we just moved; we don't want them or their * children to get swept yet. */ ref = newPendingRefs.table; lastRef = newPendingRefs.nextEntry; assert(ref < lastRef); HPROF_SET_GC_SCAN_STATE(HPROF_ROOT_FINALIZING, 0); while (ref < lastRef) { assert(*ref != NULL); markObject(*ref, ctx); ref++; } HPROF_CLEAR_GC_SCAN_STATE(); processMarkStack(ctx); dvmSignalHeapWorker(false); } void dvmHeapFinishMarkStep() { GcMarkContext *ctx; ctx = &gDvm.gcHeap->markContext; /* The mark bits are now not needed. */ dvmHeapSourceZeroMarkBitmap(); /* Clean up everything else associated with the marking process. */ destroyMarkStack(&ctx->stack); ctx->finger = NULL; } typedef struct { size_t numObjects; size_t numBytes; bool isConcurrent; } SweepContext; static void sweepBitmapCallback(size_t numPtrs, void **ptrs, void *arg) { SweepContext *ctx = arg; if (ctx->isConcurrent) { dvmLockHeap(); } ctx->numBytes += dvmHeapSourceFreeList(numPtrs, ptrs); ctx->numObjects += numPtrs; if (ctx->isConcurrent) { dvmUnlockHeap(); } } /* * Returns true if the given object is unmarked. This assumes that * the bitmaps have not yet been swapped. */ static int isUnmarkedObject(void *object) { return !isMarked((void *)((uintptr_t)object & ~(HB_OBJECT_ALIGNMENT-1)), &gDvm.gcHeap->markContext); } /* * Process all the internal system structures that behave like * weakly-held objects. */ void dvmHeapSweepSystemWeaks(void) { dvmGcDetachDeadInternedStrings(isUnmarkedObject); dvmSweepMonitorList(&gDvm.monitorList, isUnmarkedObject); } /* * Walk through the list of objects that haven't been marked and free * them. Assumes the bitmaps have been swapped. */ void dvmHeapSweepUnmarkedObjects(GcMode mode, bool isConcurrent, size_t *numObjects, size_t *numBytes) { HeapBitmap currMark[HEAP_SOURCE_MAX_HEAP_COUNT]; HeapBitmap currLive[HEAP_SOURCE_MAX_HEAP_COUNT]; SweepContext ctx; size_t numBitmaps, numSweepBitmaps; size_t i; numBitmaps = dvmHeapSourceGetNumHeaps(); dvmHeapSourceGetObjectBitmaps(currLive, currMark, numBitmaps); if (mode == GC_PARTIAL) { numSweepBitmaps = 1; assert((uintptr_t)gDvm.gcHeap->markContext.immuneLimit == currLive[0].base); } else { numSweepBitmaps = numBitmaps; } ctx.numObjects = ctx.numBytes = 0; ctx.isConcurrent = isConcurrent; for (i = 0; i < numSweepBitmaps; i++) { HeapBitmap* prevLive = &currMark[i]; HeapBitmap* prevMark = &currLive[i]; dvmHeapBitmapSweepWalk(prevLive, prevMark, sweepBitmapCallback, &ctx); } *numObjects = ctx.numObjects; *numBytes = ctx.numBytes; if (gDvm.allocProf.enabled) { gDvm.allocProf.freeCount += ctx.numObjects; gDvm.allocProf.freeSize += ctx.numBytes; } }