vm/alloc/HeapInternal.h

   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     /* Set to dvmGetRelativeTimeUsec() whenever a GC begins.
 101      * The value is preserved between GCs, so it can be used
 102      * to determine the time between successive GCs.
 103      * Initialized to zero before the first GC.
 104      */
 105     u8              gcStartTime;
 106
 107     /* Is the GC running?  Used to avoid recursive calls to GC.
 108      */
 109     bool            gcRunning;
 110
 111     /*
 112      * Debug control values
 113      */
 114
 115     int             ddmHpifWhen;
 116     int             ddmHpsgWhen;
 117     int             ddmHpsgWhat;
 118     int             ddmNhsgWhen;
 119     int             ddmNhsgWhat;
 120
 121 #if WITH_HPROF
 122     bool            hprofDumpOnGc;
 123     const char*     hprofFileName;
 124     hprof_context_t *hprofContext;
 125     int             hprofResult;
 126     bool            hprofDirectToDdms;
 127 #endif
 128 };
 129
 130 bool dvmLockHeap(void);
 131 void dvmUnlockHeap(void);
 132 void dvmLogGcStats(size_t numFreed, size_t sizeFreed, size_t gcTimeMs);
 133 void dvmLogMadviseStats(size_t madvisedSizes[], size_t arrayLen);
 134 void dvmHeapSizeChanged(void);
 135
 136 /*
 137  * Logging helpers
 138  */
 139
 140 #define HEAP_LOG_TAG      LOG_TAG "-heap"
 141
 142 #if LOG_NDEBUG
 143 #define LOGV_HEAP(...)    ((void)0)
 144 #define LOGD_HEAP(...)    ((void)0)
 145 #else
 146 #define LOGV_HEAP(...)    LOG(LOG_VERBOSE, HEAP_LOG_TAG, __VA_ARGS__)
 147 #define LOGD_HEAP(...)    LOG(LOG_DEBUG, HEAP_LOG_TAG, __VA_ARGS__)
 148 #endif
 149 #define LOGI_HEAP(...)    LOG(LOG_INFO, HEAP_LOG_TAG, __VA_ARGS__)
 150 #define LOGW_HEAP(...)    LOG(LOG_WARN, HEAP_LOG_TAG, __VA_ARGS__)
 151 #define LOGE_HEAP(...)    LOG(LOG_ERROR, HEAP_LOG_TAG, __VA_ARGS__)
 152
 153 #define QUIET_ZYGOTE_GC 1
 154 #if QUIET_ZYGOTE_GC
 155 #undef LOGI_HEAP
 156 #define LOGI_HEAP(...) \
 157     do { \
 158         if (!gDvm.zygote) { \
 159             LOG(LOG_INFO, HEAP_LOG_TAG, __VA_ARGS__); \
 160         } \
 161     } while (false)
 162 #endif
 163
 164 #define FRACTIONAL_MB(n)    (n) / (1024 * 1024), \
 165                             ((((n) % (1024 * 1024)) / 1024) * 1000) / 1024
 166 #define FRACTIONAL_PCT(n,max)    ((n) * 100) / (max), \
 167                                  (((n) * 1000) / (max)) % 10
 168
 169 #endif  // _DALVIK_ALLOC_HEAP_INTERNAL