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 20 #define _DALVIK_ALLOC_ALLOC 21 22 #include <stddef.h> 23 24 /* 25 * Initialization. 26 */ 27 bool dvmGcStartup(void); 28 bool dvmCreateStockExceptions(void); 29 bool dvmGcStartupAfterZygote(void); 30 void dvmGcShutdown(void); 31 void dvmGcThreadShutdown(void); 32 33 /* 34 * Do any last-minute preparation before we call fork() for the first time. 35 */ 36 bool dvmGcPreZygoteFork(void); 37 38 /* 39 * Basic allocation function. 40 * 41 * The new object will be added to the "tracked alloc" table unless 42 * flags is ALLOC_DONT_TRACK. 43 * 44 * Returns NULL and throws an exception on failure. 45 */ 46 void* dvmMalloc(size_t size, int flags); 47 48 /* 49 * Allocate a new object. 50 * 51 * The new object will be added to the "tracked alloc" table unless 52 * flags is ALLOC_DONT_TRACK. 53 * 54 * Returns NULL and throws an exception on failure. 55 */ 56 Object* dvmAllocObject(ClassObject* clazz, int flags); 57 58 /* flags for dvmMalloc */ 59 enum { 60 ALLOC_DEFAULT = 0x00, 61 ALLOC_DONT_TRACK = 0x01, /* don't add to internal tracking list */ 62 ALLOC_FINALIZABLE = 0x02, /* call finalize() before freeing */ 63 }; 64 65 /* 66 * Call when a request is so far off that we can't call dvmMalloc(). Throws 67 * an exception with the specified message. 68 */ 69 void dvmThrowBadAllocException(const char* msg); 70 71 /* 72 * Track an object reference that is currently only visible internally. 73 * This is called automatically by dvmMalloc() unless ALLOC_DONT_TRACK 74 * is set. 75 * 76 * The "self" argument is allowed as an optimization; it may be NULL. 77 */ 78 void dvmAddTrackedAlloc(Object* obj, Thread* self); 79 80 /* 81 * Remove an object from the internal tracking list. 82 * 83 * Does nothing if "obj" is NULL. 84 * 85 * The "self" argument is allowed as an optimization; it may be NULL. 86 */ 87 void dvmReleaseTrackedAlloc(Object* obj, Thread* self); 88 89 /* 90 * Returns true iff <obj> points to a valid allocated object. 91 */ 92 bool dvmIsValidObject(const Object* obj); 93 94 /* 95 * Create a copy of an object. 96 * 97 * The new object will be added to the "tracked alloc" table. 98 */ 99 Object* dvmCloneObject(Object* obj); 100 101 /* 102 * Validate the object pointer. Returns "false" and throws an exception if 103 * "obj" is null or invalid. 104 * 105 * This may be used in performance critical areas as a null-pointer check; 106 * anything else here should be for debug builds only. In particular, for 107 * "release" builds we want to skip the call to dvmIsValidObject() -- the 108 * classfile validation will screen out code that puts invalid data into 109 * object reference registers. 110 */ 111 INLINE int dvmValidateObject(Object* obj) 112 { 113 if (obj == NULL) { 114 dvmThrowException("Ljava/lang/NullPointerException;", NULL); 115 return false; 116 } 117 #ifdef WITH_EXTRA_OBJECT_VALIDATION 118 if (!dvmIsValidObject(obj)) { 119 dvmAbort(); 120 dvmThrowException("Ljava/lang/InternalError;", 121 "VM detected invalid object ptr"); 122 return false; 123 } 124 #endif 125 #ifndef NDEBUG 126 /* check for heap corruption */ 127 if (obj->clazz == NULL || ((u4) obj->clazz) <= 65536) { 128 dvmAbort(); 129 dvmThrowException("Ljava/lang/InternalError;", 130 "VM detected invalid object class ptr"); 131 return false; 132 } 133 #endif 134 return true; 135 } 136 137 /* 138 * Determine the exact number of GC heap bytes used by an object. (Internal 139 * to heap code except for debugging.) 140 */ 141 size_t dvmObjectSizeInHeap(const Object* obj); 142 143 /* 144 * Gets the current ideal heap utilization, represented as a number 145 * between zero and one. 146 */ 147 float dvmGetTargetHeapUtilization(void); 148 149 /* 150 * Sets the new ideal heap utilization, represented as a number 151 * between zero and one. 152 */ 153 void dvmSetTargetHeapUtilization(float newTarget); 154 155 /* 156 * If set is true, sets the new minimum heap size to size; always 157 * returns the current (or previous) size. If size is zero, 158 * removes the current minimum constraint (if present). 159 */ 160 size_t dvmMinimumHeapSize(size_t size, bool set); 161 162 /* 163 * Updates the internal count of externally-allocated memory. If there's 164 * enough room for that memory, returns true. If not, returns false and 165 * does not update the count. 166 * 167 * May cause a GC as a side-effect. 168 */ 169 bool dvmTrackExternalAllocation(size_t n); 170 171 /* 172 * Reduces the internal count of externally-allocated memory. 173 */ 174 void dvmTrackExternalFree(size_t n); 175 176 /* 177 * Returns the number of externally-allocated bytes being tracked by 178 * dvmTrackExternalAllocation/Free(). 179 */ 180 size_t dvmGetExternalBytesAllocated(void); 181 182 /* 183 * Returns a count of the extant instances of a class. 184 */ 185 size_t dvmCountInstancesOfClass(const ClassObject *clazz); 186 187 #endif /*_DALVIK_ALLOC_ALLOC*/ 188
