vm/alloc/Alloc.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  * Garbage-collecting allocator.
  18  */
  19 #ifndef DALVIK_ALLOC_ALLOC_H_
  20 #define DALVIK_ALLOC_ALLOC_H_
  21
  22 #include <stddef.h>
  23
  24 /* flags for dvmMalloc */
  25 enum {
  26     ALLOC_DEFAULT = 0x00,
  27     ALLOC_DONT_TRACK = 0x01,  /* don't add to internal tracking list */
  28     ALLOC_NON_MOVING = 0x02,
  29 };
  30
  31 /*
  32  * Initialization.
  33  */
  34 bool dvmGcStartup(void);
  35 bool dvmCreateStockExceptions(void);
  36 bool dvmGcStartupAfterZygote(void);
  37 void dvmGcShutdown(void);
  38 void dvmGcThreadShutdown(void);
  39 bool dvmGcStartupClasses(void);
  40
  41 /*
  42  * Do any last-minute preparation before we call fork() for the first time.
  43  */
  44 bool dvmGcPreZygoteFork(void);
  45
  46 /*
  47  * Basic allocation function.
  48  *
  49  * The new object will be added to the "tracked alloc" table unless
  50  * flags is ALLOC_DONT_TRACK.
  51  *
  52  * Returns NULL and throws an exception on failure.
  53  */
  54 void* dvmMalloc(size_t size, int flags);
  55
  56 /*
  57  * Allocate a new object.
  58  *
  59  * The new object will be added to the "tracked alloc" table unless
  60  * flags is ALLOC_DONT_TRACK.
  61  *
  62  * Returns NULL and throws an exception on failure.
  63  */
  64 extern "C" Object* dvmAllocObject(ClassObject* clazz, int flags);
  65
  66 /*
  67  * Track an object reference that is currently only visible internally.
  68  * This is called automatically by dvmMalloc() unless ALLOC_DONT_TRACK
  69  * is set.
  70  *
  71  * The "self" argument is allowed as an optimization; it may be NULL.
  72  */
  73 extern "C" void dvmAddTrackedAlloc(Object* obj, Thread* self);
  74
  75 /*
  76  * Remove an object from the internal tracking list.
  77  *
  78  * Does nothing if "obj" is NULL.
  79  *
  80  * The "self" argument is allowed as an optimization; it may be NULL.
  81  */
  82 extern "C" void dvmReleaseTrackedAlloc(Object* obj, Thread* self);
  83
  84 /*
  85  * Returns true iff <obj> points to a zygote allocated object.
  86  */
  87 bool dvmIsZygoteObject(const Object* obj);
  88
  89 /*
  90  * Create a copy of an object.
  91  *
  92  * Returns NULL and throws an exception on failure.
  93  */
  94 Object* dvmCloneObject(Object* obj, int flags);
  95
  96 /*
  97  * Make the object finalizable.
  98  */
  99 extern "C" void dvmSetFinalizable(Object* obj);
 100
 101 /*
 102  * Determine the exact number of GC heap bytes used by an object.  (Internal
 103  * to heap code except for debugging.)
 104  */
 105 size_t dvmObjectSizeInHeap(const Object* obj);
 106
 107 /*
 108  * Gets the current ideal heap utilization, represented as a number
 109  * between zero and one.
 110  */
 111 float dvmGetTargetHeapUtilization(void);
 112
 113 /*
 114  * Sets the new ideal heap utilization, represented as a number
 115  * between zero and one.
 116  */
 117 void dvmSetTargetHeapUtilization(float newTarget);
 118
 119 /*
 120  * Initiate garbage collection.
 121  *
 122  * This usually happens automatically, but can also be caused by
 123  * Runtime.gc().
 124  */
 125 void dvmCollectGarbage(void);
 126
 127 /*
 128  * Calls System.runFinalization().
 129  */
 130 void dvmRunFinalization();
 131
 132 /*
 133  * Returns a count of the direct instances of a class.
 134  */
 135 size_t dvmCountInstancesOfClass(const ClassObject *clazz);
 136
 137 /*
 138  * Returns a count of the instances of a class and its subclasses.
 139  */
 140 size_t dvmCountAssignableInstancesOfClass(const ClassObject *clazz);
 141
 142 /*
 143  * Removes any growth limits from the heap.
 144  */
 145 void dvmClearGrowthLimit(void);
 146
 147 /*
 148  * Returns true if the address is aligned appropriately for a heap object.
 149  * Does not require the caller to hold the heap lock, and does not take the
 150  * heap lock internally.
 151  */
 152 bool dvmIsHeapAddress(void *address);
 153
 154 bool dvmIsNonMovingObject(const Object* object);
 155
 156 #endif  // DALVIK_ALLOC_ALLOC_H_