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