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     /* 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