1 /* 2 * Copyright (C) 2008 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 /* 17 * Types and macros used internally by the heap. 18 */ 19 #ifndef _DALVIK_ALLOC_HEAP_INTERNAL 20 #define _DALVIK_ALLOC_HEAP_INTERNAL 21 22 #include <time.h> // for struct timespec 23 24 #include "HeapTable.h" 25 #include "MarkSweep.h" 26 27 struct GcHeap { 28 HeapSource *heapSource; 29 30 /* List of heap objects that will require finalization when 31 * collected. I.e., instance objects 32 * 33 * a) whose class definitions override java.lang.Object.finalize() 34 * 35 * *** AND *** 36 * 37 * b) that have never been finalized. 38 * 39 * Note that this does not exclude non-garbage objects; this 40 * is not the list of pending finalizations, but of objects that 41 * potentially have finalization in their futures. 42 */ 43 LargeHeapRefTable *finalizableRefs; 44 45 /* The list of objects that need to have finalize() called 46 * on themselves. These references are part of the root set. 47 * 48 * This table is protected by gDvm.heapWorkerListLock, which must 49 * be acquired after the heap lock. 50 */ 51 LargeHeapRefTable *pendingFinalizationRefs; 52 53 /* Linked lists of subclass instances of java/lang/ref/Reference 54 * that we find while recursing. The "next" pointers are hidden 55 * in the objects' <code>int Reference.vmData</code> fields. 56 * These lists are cleared and rebuilt each time the GC runs. 57 */ 58 Object *softReferences; 59 Object *weakReferences; 60 Object *phantomReferences; 61 62 /* The list of Reference objects that need to be cleared and/or 63 * enqueued. The bottom two bits of the object pointers indicate 64 * whether they should be cleared and/or enqueued. 65 * 66 * This table is protected by gDvm.heapWorkerListLock, which must 67 * be acquired after the heap lock. 68 */ 69 LargeHeapRefTable *referenceOperations; 70 71 /* If non-null, the method that the HeapWorker is currently 72 * executing. 73 */ 74 Object *heapWorkerCurrentObject; 75 Method *heapWorkerCurrentMethod; 76 77 /* If heapWorkerCurrentObject is non-null, this gives the time when 78 * HeapWorker started executing that method. The time value must come 79 * from dvmGetRelativeTimeUsec(). 80 * 81 * The "Cpu" entry tracks the per-thread CPU timer (when available). 82 */ 83 u8 heapWorkerInterpStartTime; 84 u8 heapWorkerInterpCpuStartTime; 85 86 /* If any fields are non-zero, indicates the next (absolute) time that 87 * the HeapWorker thread should call dvmHeapSourceTrim(). 88 */ 89 struct timespec heapWorkerNextTrim; 90 91 /* The current state of the mark step. 92 * Only valid during a GC. 93 */ 94 GcMarkContext markContext; 95 96 /* GC's card table */ 97 u1* cardTableBase; 98 size_t cardTableLength; 99 100 /* Is the GC running? Used to avoid recursive calls to GC. 101 */ 102 bool gcRunning; 103 104 /* 105 * Debug control values 106 */ 107 108 int ddmHpifWhen; 109 int ddmHpsgWhen; 110 int ddmHpsgWhat; 111 int ddmNhsgWhen; 112 int ddmNhsgWhat; 113 114 #if WITH_HPROF 115 bool hprofDumpOnGc; 116 const char* hprofFileName; 117 int hprofFd; 118 hprof_context_t *hprofContext; 119 int hprofResult; 120 bool hprofDirectToDdms; 121 #endif 122 }; 123 124 bool dvmLockHeap(void); 125 void dvmUnlockHeap(void); 126 void dvmLogGcStats(size_t numFreed, size_t sizeFreed, size_t gcTimeMs); 127 void dvmLogMadviseStats(size_t madvisedSizes[], size_t arrayLen); 128 129 /* 130 * Logging helpers 131 */ 132 133 #define HEAP_LOG_TAG LOG_TAG "-heap" 134 135 #if LOG_NDEBUG 136 #define LOGV_HEAP(...) ((void)0) 137 #define LOGD_HEAP(...) ((void)0) 138 #else 139 #define LOGV_HEAP(...) LOG(LOG_VERBOSE, HEAP_LOG_TAG, __VA_ARGS__) 140 #define LOGD_HEAP(...) LOG(LOG_DEBUG, HEAP_LOG_TAG, __VA_ARGS__) 141 #endif 142 #define LOGI_HEAP(...) LOG(LOG_INFO, HEAP_LOG_TAG, __VA_ARGS__) 143 #define LOGW_HEAP(...) LOG(LOG_WARN, HEAP_LOG_TAG, __VA_ARGS__) 144 #define LOGE_HEAP(...) LOG(LOG_ERROR, HEAP_LOG_TAG, __VA_ARGS__) 145 146 #define QUIET_ZYGOTE_GC 1 147 #if QUIET_ZYGOTE_GC 148 #undef LOGI_HEAP 149 #define LOGI_HEAP(...) \ 150 do { \ 151 if (!gDvm.zygote) { \ 152 LOG(LOG_INFO, HEAP_LOG_TAG, __VA_ARGS__); \ 153 } \ 154 } while (false) 155 #endif 156 157 #define FRACTIONAL_MB(n) (n) / (1024 * 1024), \ 158 ((((n) % (1024 * 1024)) / 1024) * 1000) / 1024 159 #define FRACTIONAL_PCT(n,max) ((n) * 100) / (max), \ 160 (((n) * 1000) / (max)) % 10 161 162 #endif // _DALVIK_ALLOC_HEAP_INTERNAL 163