Carl Shapiro | 1fb8620 | 2011-06-27 17:43:13 -0700 | [diff] [blame] | 1 | // Copyright 2011 Google Inc. All Rights Reserved. |
Carl Shapiro | 1fb8620 | 2011-06-27 17:43:13 -0700 | [diff] [blame] | 2 | |
| 3 | #ifndef ART_SRC_HEAP_H_ |
| 4 | #define ART_SRC_HEAP_H_ |
| 5 | |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 6 | #include <vector> |
| 7 | |
Brian Carlstrom | 578bbdc | 2011-07-21 14:07:47 -0700 | [diff] [blame] | 8 | #include "globals.h" |
Brian Carlstrom | 578bbdc | 2011-07-21 14:07:47 -0700 | [diff] [blame] | 9 | #include "object_bitmap.h" |
Ian Rogers | 0cfe1fb | 2011-08-26 03:29:44 -0700 | [diff] [blame] | 10 | #include "offsets.h" |
Carl Shapiro | 1fb8620 | 2011-06-27 17:43:13 -0700 | [diff] [blame] | 11 | |
Elliott Hughes | 3e465b1 | 2011-09-02 18:26:12 -0700 | [diff] [blame^] | 12 | #define VERIFY_OBJECT_ENABLED 0 |
| 13 | |
Carl Shapiro | 1fb8620 | 2011-06-27 17:43:13 -0700 | [diff] [blame] | 14 | namespace art { |
| 15 | |
Brian Carlstrom | a40f9bc | 2011-07-26 21:26:07 -0700 | [diff] [blame] | 16 | class Class; |
Elliott Hughes | 410c0c8 | 2011-09-01 17:58:25 -0700 | [diff] [blame] | 17 | class Mutex; |
Brian Carlstrom | a40f9bc | 2011-07-26 21:26:07 -0700 | [diff] [blame] | 18 | class Object; |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 19 | class Space; |
| 20 | class HeapBitmap; |
| 21 | |
Carl Shapiro | 1fb8620 | 2011-06-27 17:43:13 -0700 | [diff] [blame] | 22 | class Heap { |
| 23 | public: |
Brian Carlstrom | 8a43659 | 2011-08-15 21:27:23 -0700 | [diff] [blame] | 24 | static const size_t kInitialSize = 16 * MB; |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 25 | |
Brian Carlstrom | 4a96b60 | 2011-07-26 16:40:23 -0700 | [diff] [blame] | 26 | static const size_t kMaximumSize = 64 * MB; |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 27 | |
Elliott Hughes | 410c0c8 | 2011-09-01 17:58:25 -0700 | [diff] [blame] | 28 | typedef void (RootVisitor)(const Object* root, void* arg); |
Brian Carlstrom | 7e93b50 | 2011-08-04 14:16:22 -0700 | [diff] [blame] | 29 | |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 30 | // Create a heap with the requested sizes. optional boot image may |
| 31 | // be NULL, otherwise it is an image filename created by ImageWriter. |
| 32 | static bool Init(size_t starting_size, size_t maximum_size, const char* boot_image_file_name); |
Carl Shapiro | 61e019d | 2011-07-14 16:53:09 -0700 | [diff] [blame] | 33 | |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 34 | static void Destroy(); |
Brian Carlstrom | a7f4f48 | 2011-07-17 17:01:34 -0700 | [diff] [blame] | 35 | |
Brian Carlstrom | a40f9bc | 2011-07-26 21:26:07 -0700 | [diff] [blame] | 36 | // Allocates and initializes storage for an object instance. |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 37 | static Object* AllocObject(Class* klass, size_t num_bytes); |
Brian Carlstrom | a7f4f48 | 2011-07-17 17:01:34 -0700 | [diff] [blame] | 38 | |
Elliott Hughes | a250199 | 2011-08-26 19:39:54 -0700 | [diff] [blame] | 39 | // Check sanity of given reference. Requires the heap lock. |
Elliott Hughes | 3e465b1 | 2011-09-02 18:26:12 -0700 | [diff] [blame^] | 40 | #if VERIFY_OBJECT_ENABLED |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 41 | static void VerifyObject(const Object *obj); |
Elliott Hughes | 3e465b1 | 2011-09-02 18:26:12 -0700 | [diff] [blame^] | 42 | #else |
| 43 | static void VerifyObject(const Object *obj) {} |
| 44 | #endif |
Ian Rogers | 408f79a | 2011-08-23 18:22:33 -0700 | [diff] [blame] | 45 | |
Ian Rogers | 0cfe1fb | 2011-08-26 03:29:44 -0700 | [diff] [blame] | 46 | // Check sanity of all live references. Requires the heap lock. |
| 47 | static void VerifyHeap(); |
| 48 | |
Elliott Hughes | a250199 | 2011-08-26 19:39:54 -0700 | [diff] [blame] | 49 | // A weaker test than VerifyObject that doesn't require the heap lock, |
| 50 | // and doesn't abort on error, allowing the caller to report more |
| 51 | // meaningful diagnostics. |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 52 | static bool IsHeapAddress(const Object* obj); |
Elliott Hughes | a250199 | 2011-08-26 19:39:54 -0700 | [diff] [blame] | 53 | |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 54 | // Initiates an explicit garbage collection. |
| 55 | static void CollectGarbage(); |
| 56 | |
Elliott Hughes | bf86d04 | 2011-08-31 17:53:14 -0700 | [diff] [blame] | 57 | // Implements java.lang.Runtime.maxMemory. |
| 58 | static int64_t GetMaxMemory(); |
| 59 | // Implements java.lang.Runtime.totalMemory. |
| 60 | static int64_t GetTotalMemory(); |
| 61 | // Implements java.lang.Runtime.freeMemory. |
| 62 | static int64_t GetFreeMemory(); |
| 63 | |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 64 | // Blocks the caller until the garbage collector becomes idle. |
| 65 | static void WaitForConcurrentGcToComplete(); |
| 66 | |
| 67 | static Mutex* GetLock() { |
| 68 | return lock_; |
Carl Shapiro | 5fafe2b | 2011-07-09 15:34:41 -0700 | [diff] [blame] | 69 | } |
Carl Shapiro | 61e019d | 2011-07-14 16:53:09 -0700 | [diff] [blame] | 70 | |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 71 | static const std::vector<Space*>& GetSpaces() { |
| 72 | return spaces_; |
| 73 | } |
Carl Shapiro | 61e019d | 2011-07-14 16:53:09 -0700 | [diff] [blame] | 74 | |
Brian Carlstrom | a663ea5 | 2011-08-19 23:33:41 -0700 | [diff] [blame] | 75 | static Space* GetBootSpace() { |
| 76 | return boot_space_; |
| 77 | } |
| 78 | |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 79 | static HeapBitmap* GetLiveBits() { |
| 80 | return live_bitmap_; |
Carl Shapiro | 744ad05 | 2011-08-06 15:53:36 -0700 | [diff] [blame] | 81 | } |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 82 | |
| 83 | static HeapBitmap* GetMarkBits() { |
| 84 | return mark_bitmap_; |
Carl Shapiro | 744ad05 | 2011-08-06 15:53:36 -0700 | [diff] [blame] | 85 | } |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 86 | |
Ian Rogers | 0cfe1fb | 2011-08-26 03:29:44 -0700 | [diff] [blame] | 87 | static void SetReferenceOffsets(MemberOffset reference_referent_offset, |
| 88 | MemberOffset reference_queue_offset, |
| 89 | MemberOffset reference_queueNext_offset, |
| 90 | MemberOffset reference_pendingNext_offset, |
| 91 | MemberOffset finalizer_reference_zombie_offset) { |
| 92 | CHECK_NE(reference_referent_offset.Uint32Value(), 0U); |
| 93 | CHECK_NE(reference_queue_offset.Uint32Value(), 0U); |
| 94 | CHECK_NE(reference_queueNext_offset.Uint32Value(), 0U); |
| 95 | CHECK_NE(reference_pendingNext_offset.Uint32Value(), 0U); |
| 96 | CHECK_NE(finalizer_reference_zombie_offset.Uint32Value(), 0U); |
Brian Carlstrom | 1f87008 | 2011-08-23 16:02:11 -0700 | [diff] [blame] | 97 | reference_referent_offset_ = reference_referent_offset; |
| 98 | reference_queue_offset_ = reference_queue_offset; |
| 99 | reference_queueNext_offset_ = reference_queueNext_offset; |
| 100 | reference_pendingNext_offset_ = reference_pendingNext_offset; |
| 101 | finalizer_reference_zombie_offset_ = finalizer_reference_zombie_offset; |
| 102 | } |
| 103 | |
Ian Rogers | 0cfe1fb | 2011-08-26 03:29:44 -0700 | [diff] [blame] | 104 | static MemberOffset GetReferenceReferentOffset() { |
| 105 | DCHECK_NE(reference_referent_offset_.Uint32Value(), 0U); |
Brian Carlstrom | 1f87008 | 2011-08-23 16:02:11 -0700 | [diff] [blame] | 106 | return reference_referent_offset_; |
| 107 | } |
| 108 | |
Ian Rogers | 0cfe1fb | 2011-08-26 03:29:44 -0700 | [diff] [blame] | 109 | static MemberOffset GetReferenceQueueOffset() { |
| 110 | DCHECK_NE(reference_queue_offset_.Uint32Value(), 0U); |
Brian Carlstrom | 1f87008 | 2011-08-23 16:02:11 -0700 | [diff] [blame] | 111 | return reference_queue_offset_; |
| 112 | } |
| 113 | |
Ian Rogers | 0cfe1fb | 2011-08-26 03:29:44 -0700 | [diff] [blame] | 114 | static MemberOffset GetReferenceQueueNextOffset() { |
| 115 | DCHECK_NE(reference_queueNext_offset_.Uint32Value(), 0U); |
Brian Carlstrom | 1f87008 | 2011-08-23 16:02:11 -0700 | [diff] [blame] | 116 | return reference_queueNext_offset_; |
| 117 | } |
| 118 | |
Ian Rogers | 0cfe1fb | 2011-08-26 03:29:44 -0700 | [diff] [blame] | 119 | static MemberOffset GetReferencePendingNextOffset() { |
| 120 | DCHECK_NE(reference_pendingNext_offset_.Uint32Value(), 0U); |
Brian Carlstrom | 1f87008 | 2011-08-23 16:02:11 -0700 | [diff] [blame] | 121 | return reference_pendingNext_offset_; |
| 122 | } |
| 123 | |
Ian Rogers | 0cfe1fb | 2011-08-26 03:29:44 -0700 | [diff] [blame] | 124 | static MemberOffset GetFinalizerReferenceZombieOffset() { |
| 125 | DCHECK_NE(finalizer_reference_zombie_offset_.Uint32Value(), 0U); |
Brian Carlstrom | 1f87008 | 2011-08-23 16:02:11 -0700 | [diff] [blame] | 126 | return finalizer_reference_zombie_offset_; |
| 127 | } |
| 128 | |
Ian Rogers | 0cfe1fb | 2011-08-26 03:29:44 -0700 | [diff] [blame] | 129 | static void DisableObjectValidation() { |
| 130 | // TODO: remove this hack necessary for image writing |
| 131 | verify_object_disabled_ = true; |
| 132 | } |
| 133 | |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 134 | private: |
| 135 | // Allocates uninitialized storage. |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 136 | static Object* Allocate(size_t num_bytes); |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 137 | static Object* Allocate(Space* space, size_t num_bytes); |
| 138 | |
| 139 | static void RecordAllocation(Space* space, const Object* object); |
| 140 | static void RecordFree(Space* space, const Object* object); |
Brian Carlstrom | 9cff8e1 | 2011-08-18 16:47:29 -0700 | [diff] [blame] | 141 | static void RecordImageAllocations(Space* space); |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 142 | |
| 143 | static void CollectGarbageInternal(); |
| 144 | |
| 145 | static void GrowForUtilization(); |
| 146 | |
| 147 | static Mutex* lock_; |
| 148 | |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 149 | static std::vector<Space*> spaces_; |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 150 | |
Brian Carlstrom | a663ea5 | 2011-08-19 23:33:41 -0700 | [diff] [blame] | 151 | // Space loaded from an image |
| 152 | static Space* boot_space_; |
| 153 | |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 154 | // default Space for allocations |
| 155 | static Space* alloc_space_; |
| 156 | |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 157 | static HeapBitmap* mark_bitmap_; |
| 158 | |
| 159 | static HeapBitmap* live_bitmap_; |
| 160 | |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 161 | // The maximum size of the heap in bytes. |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 162 | static size_t maximum_size_; |
| 163 | |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 164 | // True while the garbage collector is running. |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 165 | static bool is_gc_running_; |
| 166 | |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 167 | // Number of bytes allocated. Adjusted after each allocation and |
| 168 | // free. |
| 169 | static size_t num_bytes_allocated_; |
| 170 | |
| 171 | // Number of objects allocated. Adjusted after each allocation and |
| 172 | // free. |
| 173 | static size_t num_objects_allocated_; |
| 174 | |
Brian Carlstrom | 1f87008 | 2011-08-23 16:02:11 -0700 | [diff] [blame] | 175 | // offset of java.lang.ref.Reference.referent |
Ian Rogers | 0cfe1fb | 2011-08-26 03:29:44 -0700 | [diff] [blame] | 176 | static MemberOffset reference_referent_offset_; |
Brian Carlstrom | 1f87008 | 2011-08-23 16:02:11 -0700 | [diff] [blame] | 177 | |
| 178 | // offset of java.lang.ref.Reference.queue |
Ian Rogers | 0cfe1fb | 2011-08-26 03:29:44 -0700 | [diff] [blame] | 179 | static MemberOffset reference_queue_offset_; |
Brian Carlstrom | 1f87008 | 2011-08-23 16:02:11 -0700 | [diff] [blame] | 180 | |
| 181 | // offset of java.lang.ref.Reference.queueNext |
Ian Rogers | 0cfe1fb | 2011-08-26 03:29:44 -0700 | [diff] [blame] | 182 | static MemberOffset reference_queueNext_offset_; |
Brian Carlstrom | 1f87008 | 2011-08-23 16:02:11 -0700 | [diff] [blame] | 183 | |
| 184 | // offset of java.lang.ref.Reference.pendingNext |
Ian Rogers | 0cfe1fb | 2011-08-26 03:29:44 -0700 | [diff] [blame] | 185 | static MemberOffset reference_pendingNext_offset_; |
Brian Carlstrom | 1f87008 | 2011-08-23 16:02:11 -0700 | [diff] [blame] | 186 | |
| 187 | // offset of java.lang.ref.FinalizerReference.zombie |
Ian Rogers | 0cfe1fb | 2011-08-26 03:29:44 -0700 | [diff] [blame] | 188 | static MemberOffset finalizer_reference_zombie_offset_; |
| 189 | |
| 190 | static bool verify_object_disabled_; |
Brian Carlstrom | 1f87008 | 2011-08-23 16:02:11 -0700 | [diff] [blame] | 191 | |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 192 | DISALLOW_IMPLICIT_CONSTRUCTORS(Heap); |
| 193 | }; |
| 194 | |
Carl Shapiro | 1fb8620 | 2011-06-27 17:43:13 -0700 | [diff] [blame] | 195 | } // namespace art |
| 196 | |
| 197 | #endif // ART_SRC_HEAP_H_ |