blob: 6b2ea7144d2798fc4380df5fd53e6958b3ccd2f2 [file] [log] [blame]
Carl Shapiro69759ea2011-07-21 18:13:35 -07001// Copyright 2011 Google Inc. All Rights Reserved.
Carl Shapiro69759ea2011-07-21 18:13:35 -07002
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07003#include "heap.h"
Carl Shapiro58551df2011-07-24 03:09:51 -07004
Brian Carlstrom58ae9412011-10-04 00:56:06 -07005#include <limits>
Carl Shapiro58551df2011-07-24 03:09:51 -07006#include <vector>
7
Ian Rogers5d76c432011-10-31 21:42:49 -07008#include "card_table.h"
Elliott Hughes767a1472011-10-26 18:49:02 -07009#include "debugger.h"
Brian Carlstrom9cff8e12011-08-18 16:47:29 -070010#include "image.h"
Carl Shapiro58551df2011-07-24 03:09:51 -070011#include "mark_sweep.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070012#include "object.h"
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080013#include "object_utils.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070014#include "space.h"
Carl Shapiro58551df2011-07-24 03:09:51 -070015#include "stl_util.h"
Elliott Hughes8d768a92011-09-14 16:35:25 -070016#include "thread_list.h"
Elliott Hughes767a1472011-10-26 18:49:02 -070017#include "timing_logger.h"
18#include "UniquePtr.h"
Carl Shapiro69759ea2011-07-21 18:13:35 -070019
20namespace art {
21
Brian Carlstrom6b4ef022011-10-23 14:59:04 -070022bool Heap::is_verbose_heap_ = false;
23
24bool Heap::is_verbose_gc_ = false;
25
Carl Shapiro58551df2011-07-24 03:09:51 -070026std::vector<Space*> Heap::spaces_;
Carl Shapiro69759ea2011-07-21 18:13:35 -070027
Brian Carlstrom4a289ed2011-08-16 17:17:49 -070028Space* Heap::alloc_space_ = NULL;
Carl Shapiro69759ea2011-07-21 18:13:35 -070029
30size_t Heap::maximum_size_ = 0;
31
jeffhaoc1160702011-10-27 15:48:45 -070032size_t Heap::growth_size_ = 0;
33
Carl Shapiro58551df2011-07-24 03:09:51 -070034size_t Heap::num_bytes_allocated_ = 0;
35
36size_t Heap::num_objects_allocated_ = 0;
37
Carl Shapiro69759ea2011-07-21 18:13:35 -070038bool Heap::is_gc_running_ = false;
39
40HeapBitmap* Heap::mark_bitmap_ = NULL;
41
42HeapBitmap* Heap::live_bitmap_ = NULL;
43
Ian Rogers5d76c432011-10-31 21:42:49 -070044CardTable* Heap::card_table_ = NULL;
45
46bool Heap::card_marking_disabled_ = false;
47
Elliott Hughesadb460d2011-10-05 17:02:34 -070048Class* Heap::java_lang_ref_FinalizerReference_ = NULL;
49Class* Heap::java_lang_ref_ReferenceQueue_ = NULL;
50
Ian Rogers0cfe1fb2011-08-26 03:29:44 -070051MemberOffset Heap::reference_referent_offset_ = MemberOffset(0);
52MemberOffset Heap::reference_queue_offset_ = MemberOffset(0);
53MemberOffset Heap::reference_queueNext_offset_ = MemberOffset(0);
54MemberOffset Heap::reference_pendingNext_offset_ = MemberOffset(0);
55MemberOffset Heap::finalizer_reference_zombie_offset_ = MemberOffset(0);
Brian Carlstrom1f870082011-08-23 16:02:11 -070056
Brian Carlstrom395520e2011-09-25 19:35:00 -070057float Heap::target_utilization_ = 0.5;
58
Elliott Hughes92b3b562011-09-08 16:32:26 -070059Mutex* Heap::lock_ = NULL;
60
Elliott Hughes9d5ccec2011-09-19 13:19:50 -070061bool Heap::verify_objects_ = false;
62
Brian Carlstrom6b4ef022011-10-23 14:59:04 -070063void Heap::Init(bool is_verbose_heap, bool is_verbose_gc,
jeffhaoc1160702011-10-27 15:48:45 -070064 size_t initial_size, size_t maximum_size, size_t growth_size,
Brian Carlstrom58ae9412011-10-04 00:56:06 -070065 const std::vector<std::string>& image_file_names) {
Brian Carlstrom6b4ef022011-10-23 14:59:04 -070066 is_verbose_heap_ = is_verbose_heap;
67 is_verbose_gc_ = is_verbose_gc;
68
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -070069 const Runtime* runtime = Runtime::Current();
Elliott Hughes352a4242011-10-31 15:15:21 -070070 if (Heap::IsVerboseHeap() || runtime->IsVerboseStartup()) {
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -070071 LOG(INFO) << "Heap::Init entering";
72 }
73
Brian Carlstrom58ae9412011-10-04 00:56:06 -070074 // bounds of all spaces for allocating live and mark bitmaps
75 // there will be at least one space (the alloc space),
jeffhao39da0352011-11-04 14:58:55 -070076 // so set base to max, and limit and min to start
Brian Carlstrom58ae9412011-10-04 00:56:06 -070077 byte* base = reinterpret_cast<byte*>(std::numeric_limits<uintptr_t>::max());
Ian Rogers5d76c432011-10-31 21:42:49 -070078 byte* max = reinterpret_cast<byte*>(std::numeric_limits<uintptr_t>::min());
jeffhao39da0352011-11-04 14:58:55 -070079 byte* limit = reinterpret_cast<byte*>(std::numeric_limits<uintptr_t>::min());
Brian Carlstrom4a289ed2011-08-16 17:17:49 -070080
Brian Carlstrom58ae9412011-10-04 00:56:06 -070081 byte* requested_base = NULL;
Brian Carlstrom69b15fb2011-09-03 12:25:21 -070082 std::vector<Space*> image_spaces;
83 for (size_t i = 0; i < image_file_names.size(); i++) {
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -070084 Space* space = Space::CreateFromImage(image_file_names[i]);
Brian Carlstrom69b15fb2011-09-03 12:25:21 -070085 if (space == NULL) {
Elliott Hughesbe759c62011-09-08 19:38:21 -070086 LOG(FATAL) << "Failed to create space from " << image_file_names[i];
Brian Carlstrom69b15fb2011-09-03 12:25:21 -070087 }
88 image_spaces.push_back(space);
89 spaces_.push_back(space);
Brian Carlstrome24fa612011-09-29 00:53:55 -070090 byte* oat_limit_addr = space->GetImageHeader().GetOatLimitAddr();
Brian Carlstrom58ae9412011-10-04 00:56:06 -070091 if (oat_limit_addr > requested_base) {
92 requested_base = reinterpret_cast<byte*>(RoundUp(reinterpret_cast<uintptr_t>(oat_limit_addr),
93 kPageSize));
94 }
95 base = std::min(base, space->GetBase());
Ian Rogers5d76c432011-10-31 21:42:49 -070096 max = std::max(max, space->GetMax());
jeffhao39da0352011-11-04 14:58:55 -070097 limit = std::max(limit, space->GetLimit());
Brian Carlstrom69b15fb2011-09-03 12:25:21 -070098 }
99
jeffhaoc1160702011-10-27 15:48:45 -0700100 alloc_space_ = Space::Create("alloc space", initial_size, maximum_size, growth_size, requested_base);
Elliott Hughes307f75d2011-10-12 18:04:40 -0700101 if (alloc_space_ == NULL) {
Elliott Hughesbe759c62011-09-08 19:38:21 -0700102 LOG(FATAL) << "Failed to create alloc space";
Carl Shapiro69759ea2011-07-21 18:13:35 -0700103 }
Elliott Hughes307f75d2011-10-12 18:04:40 -0700104 base = std::min(base, alloc_space_->GetBase());
Ian Rogers5d76c432011-10-31 21:42:49 -0700105 max = std::max(max, alloc_space_->GetMax());
jeffhao39da0352011-11-04 14:58:55 -0700106 limit = std::max(limit, alloc_space_->GetLimit());
Ian Rogers5d76c432011-10-31 21:42:49 -0700107 DCHECK_LT(base, max);
jeffhao39da0352011-11-04 14:58:55 -0700108 DCHECK_LT(base, limit);
Ian Rogers5d76c432011-10-31 21:42:49 -0700109 size_t num_bytes = max - base;
jeffhao39da0352011-11-04 14:58:55 -0700110 size_t limit_bytes = limit - base;
Carl Shapiro69759ea2011-07-21 18:13:35 -0700111
112 // Allocate the initial live bitmap.
Elliott Hughes6c9c06d2011-11-07 16:43:47 -0800113 UniquePtr<HeapBitmap> live_bitmap(HeapBitmap::Create("dalvik-bitmap-1", base, num_bytes));
Elliott Hughes90a33692011-08-30 13:27:07 -0700114 if (live_bitmap.get() == NULL) {
Elliott Hughesbe759c62011-09-08 19:38:21 -0700115 LOG(FATAL) << "Failed to create live bitmap";
Carl Shapiro69759ea2011-07-21 18:13:35 -0700116 }
117
118 // Allocate the initial mark bitmap.
Elliott Hughes6c9c06d2011-11-07 16:43:47 -0800119 UniquePtr<HeapBitmap> mark_bitmap(HeapBitmap::Create("dalvik-bitmap-2", base, num_bytes));
Elliott Hughes90a33692011-08-30 13:27:07 -0700120 if (mark_bitmap.get() == NULL) {
Elliott Hughesbe759c62011-09-08 19:38:21 -0700121 LOG(FATAL) << "Failed to create mark bitmap";
Carl Shapiro69759ea2011-07-21 18:13:35 -0700122 }
123
Elliott Hughes6c9c06d2011-11-07 16:43:47 -0800124 // Allocate the card table.
jeffhao39da0352011-11-04 14:58:55 -0700125 UniquePtr<CardTable> card_table(CardTable::Create(base, num_bytes, limit_bytes));
Ian Rogers5d76c432011-10-31 21:42:49 -0700126 if (card_table.get() == NULL) {
127 LOG(FATAL) << "Failed to create card table";
128 }
129
Elliott Hughes307f75d2011-10-12 18:04:40 -0700130 spaces_.push_back(alloc_space_);
Carl Shapiro69759ea2011-07-21 18:13:35 -0700131 maximum_size_ = maximum_size;
jeffhaoc1160702011-10-27 15:48:45 -0700132 growth_size_ = growth_size;
Carl Shapiro69759ea2011-07-21 18:13:35 -0700133 live_bitmap_ = live_bitmap.release();
134 mark_bitmap_ = mark_bitmap.release();
Ian Rogers5d76c432011-10-31 21:42:49 -0700135 card_table_ = card_table.release();
Carl Shapiro69759ea2011-07-21 18:13:35 -0700136
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700137 num_bytes_allocated_ = 0;
138 num_objects_allocated_ = 0;
139
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700140 // Make image objects live (after live_bitmap_ is set)
Brian Carlstrom69b15fb2011-09-03 12:25:21 -0700141 for (size_t i = 0; i < image_spaces.size(); i++) {
142 RecordImageAllocations(image_spaces[i]);
143 }
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700144
Elliott Hughes85d15452011-09-16 17:33:01 -0700145 Heap::EnableObjectValidation();
146
Elliott Hughes92b3b562011-09-08 16:32:26 -0700147 // It's still to early to take a lock because there are no threads yet,
148 // but we can create the heap lock now. We don't create it earlier to
149 // make it clear that you can't use locks during heap initialization.
Elliott Hughes8daa0922011-09-11 13:46:25 -0700150 lock_ = new Mutex("Heap lock");
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700151
Elliott Hughes352a4242011-10-31 15:15:21 -0700152 if (Heap::IsVerboseHeap() || runtime->IsVerboseStartup()) {
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700153 LOG(INFO) << "Heap::Init exiting";
154 }
Carl Shapiro69759ea2011-07-21 18:13:35 -0700155}
156
157void Heap::Destroy() {
Elliott Hughes92b3b562011-09-08 16:32:26 -0700158 ScopedHeapLock lock;
Carl Shapiro58551df2011-07-24 03:09:51 -0700159 STLDeleteElements(&spaces_);
Brian Carlstrom4a289ed2011-08-16 17:17:49 -0700160 if (mark_bitmap_ != NULL) {
161 delete mark_bitmap_;
162 mark_bitmap_ = NULL;
163 }
164 if (live_bitmap_ != NULL) {
165 delete live_bitmap_;
166 }
167 live_bitmap_ = NULL;
Carl Shapiro69759ea2011-07-21 18:13:35 -0700168}
169
Elliott Hughes418dfe72011-10-06 18:56:27 -0700170Object* Heap::AllocObject(Class* klass, size_t byte_count) {
171 {
172 ScopedHeapLock lock;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800173 DCHECK(klass == NULL || (klass->IsClassClass() && byte_count >= sizeof(Class)) ||
174 (klass->IsVariableSize() || klass->GetObjectSize() == byte_count) ||
175 ClassHelper(klass).GetDescriptor().empty());
Elliott Hughes418dfe72011-10-06 18:56:27 -0700176 DCHECK_GE(byte_count, sizeof(Object));
177 Object* obj = AllocateLocked(byte_count);
178 if (obj != NULL) {
179 obj->SetClass(klass);
Elliott Hughes545a0642011-11-08 19:10:03 -0800180 if (Dbg::IsAllocTrackingEnabled()) {
181 Dbg::RecordAllocation(klass, byte_count);
182 }
Elliott Hughes418dfe72011-10-06 18:56:27 -0700183 return obj;
184 }
Carl Shapiro58551df2011-07-24 03:09:51 -0700185 }
Elliott Hughes418dfe72011-10-06 18:56:27 -0700186
187 Thread::Current()->ThrowOutOfMemoryError(klass, byte_count);
188 return NULL;
Carl Shapiro58551df2011-07-24 03:09:51 -0700189}
190
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700191bool Heap::IsHeapAddress(const Object* obj) {
Elliott Hughes92b3b562011-09-08 16:32:26 -0700192 // Note: we deliberately don't take the lock here, and mustn't test anything that would
193 // require taking the lock.
Elliott Hughes6a5bd492011-10-28 14:33:57 -0700194 if (obj == NULL || !IsAligned<kObjectAlignment>(obj)) {
Elliott Hughesa2501992011-08-26 19:39:54 -0700195 return false;
196 }
197 // TODO
198 return true;
199}
200
Elliott Hughes6a5bd492011-10-28 14:33:57 -0700201bool Heap::IsLiveObjectLocked(const Object* obj) {
202 lock_->AssertHeld();
203 return IsHeapAddress(obj) && live_bitmap_->Test(obj);
204}
205
Elliott Hughes3e465b12011-09-02 18:26:12 -0700206#if VERIFY_OBJECT_ENABLED
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700207void Heap::VerifyObject(const Object* obj) {
Elliott Hughes85d15452011-09-16 17:33:01 -0700208 if (!verify_objects_) {
209 return;
210 }
Elliott Hughes92b3b562011-09-08 16:32:26 -0700211 ScopedHeapLock lock;
212 Heap::VerifyObjectLocked(obj);
213}
214#endif
215
216void Heap::VerifyObjectLocked(const Object* obj) {
Elliott Hughes8daa0922011-09-11 13:46:25 -0700217 lock_->AssertHeld();
Elliott Hughes85d15452011-09-16 17:33:01 -0700218 if (obj != NULL) {
Elliott Hughes06b37d92011-10-16 11:51:29 -0700219 if (!IsAligned<kObjectAlignment>(obj)) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700220 LOG(FATAL) << "Object isn't aligned: " << obj;
221 } else if (!live_bitmap_->Test(obj)) {
222 // TODO: we don't hold a lock here as it is assumed the live bit map
223 // isn't changing if the mutator is running.
224 LOG(FATAL) << "Object is dead: " << obj;
225 }
226 // Ignore early dawn of the universe verifications
Brian Carlstromdbc05252011-09-09 01:59:59 -0700227 if (num_objects_allocated_ > 10) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700228 const byte* raw_addr = reinterpret_cast<const byte*>(obj) +
229 Object::ClassOffset().Int32Value();
230 const Class* c = *reinterpret_cast<Class* const *>(raw_addr);
231 if (c == NULL) {
232 LOG(FATAL) << "Null class" << " in object: " << obj;
Elliott Hughes06b37d92011-10-16 11:51:29 -0700233 } else if (!IsAligned<kObjectAlignment>(c)) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700234 LOG(FATAL) << "Class isn't aligned: " << c << " in object: " << obj;
235 } else if (!live_bitmap_->Test(c)) {
236 LOG(FATAL) << "Class of object is dead: " << c << " in object: " << obj;
237 }
238 // Check obj.getClass().getClass() == obj.getClass().getClass().getClass()
Ian Rogersad25ac52011-10-04 19:13:33 -0700239 // Note: we don't use the accessors here as they have internal sanity checks
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700240 // that we don't want to run
241 raw_addr = reinterpret_cast<const byte*>(c) +
242 Object::ClassOffset().Int32Value();
243 const Class* c_c = *reinterpret_cast<Class* const *>(raw_addr);
244 raw_addr = reinterpret_cast<const byte*>(c_c) +
245 Object::ClassOffset().Int32Value();
246 const Class* c_c_c = *reinterpret_cast<Class* const *>(raw_addr);
247 CHECK_EQ(c_c, c_c_c);
248 }
249 }
250}
251
Brian Carlstrom78128a62011-09-15 17:21:19 -0700252void Heap::VerificationCallback(Object* obj, void* arg) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700253 DCHECK(obj != NULL);
Elliott Hughes92b3b562011-09-08 16:32:26 -0700254 Heap::VerifyObjectLocked(obj);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700255}
256
257void Heap::VerifyHeap() {
Elliott Hughes92b3b562011-09-08 16:32:26 -0700258 ScopedHeapLock lock;
259 live_bitmap_->Walk(Heap::VerificationCallback, NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700260}
261
Elliott Hughes92b3b562011-09-08 16:32:26 -0700262void Heap::RecordAllocationLocked(Space* space, const Object* obj) {
263#ifndef NDEBUG
264 if (Runtime::Current()->IsStarted()) {
Elliott Hughes8daa0922011-09-11 13:46:25 -0700265 lock_->AssertHeld();
Elliott Hughes92b3b562011-09-08 16:32:26 -0700266 }
267#endif
Carl Shapiro58551df2011-07-24 03:09:51 -0700268 size_t size = space->AllocationSize(obj);
269 DCHECK_NE(size, 0u);
270 num_bytes_allocated_ += size;
271 num_objects_allocated_ += 1;
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700272
273 if (Runtime::Current()->HasStatsEnabled()) {
274 RuntimeStats* global_stats = Runtime::Current()->GetStats();
275 RuntimeStats* thread_stats = Thread::Current()->GetStats();
276 ++global_stats->allocated_objects;
277 ++thread_stats->allocated_objects;
278 global_stats->allocated_bytes += size;
279 thread_stats->allocated_bytes += size;
280 }
281
Carl Shapiro58551df2011-07-24 03:09:51 -0700282 live_bitmap_->Set(obj);
283}
284
Elliott Hughes307f75d2011-10-12 18:04:40 -0700285void Heap::RecordFreeLocked(size_t freed_objects, size_t freed_bytes) {
Elliott Hughes8daa0922011-09-11 13:46:25 -0700286 lock_->AssertHeld();
Elliott Hughes307f75d2011-10-12 18:04:40 -0700287
288 if (freed_objects < num_objects_allocated_) {
289 num_objects_allocated_ -= freed_objects;
290 } else {
291 num_objects_allocated_ = 0;
292 }
293 if (freed_bytes < num_bytes_allocated_) {
294 num_bytes_allocated_ -= freed_bytes;
Carl Shapiro58551df2011-07-24 03:09:51 -0700295 } else {
296 num_bytes_allocated_ = 0;
297 }
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700298
299 if (Runtime::Current()->HasStatsEnabled()) {
300 RuntimeStats* global_stats = Runtime::Current()->GetStats();
301 RuntimeStats* thread_stats = Thread::Current()->GetStats();
302 ++global_stats->freed_objects;
303 ++thread_stats->freed_objects;
Elliott Hughes307f75d2011-10-12 18:04:40 -0700304 global_stats->freed_bytes += freed_bytes;
305 thread_stats->freed_bytes += freed_bytes;
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700306 }
Carl Shapiro58551df2011-07-24 03:09:51 -0700307}
308
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700309void Heap::RecordImageAllocations(Space* space) {
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700310 const Runtime* runtime = Runtime::Current();
Elliott Hughes352a4242011-10-31 15:15:21 -0700311 if (Heap::IsVerboseHeap() || runtime->IsVerboseStartup()) {
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700312 LOG(INFO) << "Heap::RecordImageAllocations entering";
313 }
Elliott Hughes92b3b562011-09-08 16:32:26 -0700314 DCHECK(!Runtime::Current()->IsStarted());
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700315 CHECK(space != NULL);
316 CHECK(live_bitmap_ != NULL);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700317 byte* current = space->GetBase() + RoundUp(sizeof(ImageHeader), kObjectAlignment);
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700318 while (current < space->GetLimit()) {
Elliott Hughes06b37d92011-10-16 11:51:29 -0700319 DCHECK_ALIGNED(current, kObjectAlignment);
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700320 const Object* obj = reinterpret_cast<const Object*>(current);
321 live_bitmap_->Set(obj);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700322 current += RoundUp(obj->SizeOf(), kObjectAlignment);
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700323 }
Elliott Hughes352a4242011-10-31 15:15:21 -0700324 if (Heap::IsVerboseHeap() || runtime->IsVerboseStartup()) {
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700325 LOG(INFO) << "Heap::RecordImageAllocations exiting";
326 }
Brian Carlstrom9cff8e12011-08-18 16:47:29 -0700327}
328
Elliott Hughes92b3b562011-09-08 16:32:26 -0700329Object* Heap::AllocateLocked(size_t size) {
Elliott Hughes8daa0922011-09-11 13:46:25 -0700330 lock_->AssertHeld();
Brian Carlstrom4a289ed2011-08-16 17:17:49 -0700331 DCHECK(alloc_space_ != NULL);
332 Space* space = alloc_space_;
Elliott Hughes92b3b562011-09-08 16:32:26 -0700333 Object* obj = AllocateLocked(space, size);
Carl Shapiro58551df2011-07-24 03:09:51 -0700334 if (obj != NULL) {
Elliott Hughes92b3b562011-09-08 16:32:26 -0700335 RecordAllocationLocked(space, obj);
Carl Shapiro58551df2011-07-24 03:09:51 -0700336 }
337 return obj;
338}
339
Elliott Hughes92b3b562011-09-08 16:32:26 -0700340Object* Heap::AllocateLocked(Space* space, size_t size) {
Elliott Hughes8daa0922011-09-11 13:46:25 -0700341 lock_->AssertHeld();
Elliott Hughes92b3b562011-09-08 16:32:26 -0700342
Brian Carlstromb82b6872011-10-26 17:18:07 -0700343 // Since allocation can cause a GC which will need to SuspendAll,
344 // make sure all allocators are in the kRunnable state.
345 DCHECK_EQ(Thread::Current()->GetState(), Thread::kRunnable);
346
Carl Shapiro69759ea2011-07-21 18:13:35 -0700347 // Fail impossible allocations. TODO: collect soft references.
jeffhaoc1160702011-10-27 15:48:45 -0700348 if (size > growth_size_) {
Carl Shapiro69759ea2011-07-21 18:13:35 -0700349 return NULL;
350 }
351
Carl Shapiro58551df2011-07-24 03:09:51 -0700352 Object* ptr = space->AllocWithoutGrowth(size);
Carl Shapiro69759ea2011-07-21 18:13:35 -0700353 if (ptr != NULL) {
354 return ptr;
355 }
356
357 // The allocation failed. If the GC is running, block until it
358 // completes and retry.
359 if (is_gc_running_) {
360 // The GC is concurrently tracing the heap. Release the heap
361 // lock, wait for the GC to complete, and retrying allocating.
362 WaitForConcurrentGcToComplete();
Carl Shapiro58551df2011-07-24 03:09:51 -0700363 ptr = space->AllocWithoutGrowth(size);
Carl Shapiro69759ea2011-07-21 18:13:35 -0700364 if (ptr != NULL) {
365 return ptr;
366 }
367 }
368
369 // Another failure. Our thread was starved or there may be too many
370 // live objects. Try a foreground GC. This will have no effect if
371 // the concurrent GC is already running.
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700372 if (Runtime::Current()->HasStatsEnabled()) {
373 ++Runtime::Current()->GetStats()->gc_for_alloc_count;
374 ++Thread::Current()->GetStats()->gc_for_alloc_count;
375 }
Carl Shapiro58551df2011-07-24 03:09:51 -0700376 CollectGarbageInternal();
377 ptr = space->AllocWithoutGrowth(size);
Carl Shapiro69759ea2011-07-21 18:13:35 -0700378 if (ptr != NULL) {
379 return ptr;
380 }
381
382 // Even that didn't work; this is an exceptional state.
383 // Try harder, growing the heap if necessary.
Carl Shapiro58551df2011-07-24 03:09:51 -0700384 ptr = space->AllocWithGrowth(size);
Carl Shapiro69759ea2011-07-21 18:13:35 -0700385 if (ptr != NULL) {
386 //size_t new_footprint = dvmHeapSourceGetIdealFootprint();
Shih-wei Liao7f1caab2011-10-06 12:11:04 -0700387 size_t new_footprint = space->GetMaxAllowedFootprint();
Elliott Hughes418dfe72011-10-06 18:56:27 -0700388 // OLD-TODO: may want to grow a little bit more so that the amount of
Carl Shapiro58551df2011-07-24 03:09:51 -0700389 // free space is equal to the old free space + the
390 // utilization slop for the new allocation.
Elliott Hughes352a4242011-10-31 15:15:21 -0700391 if (Heap::IsVerboseGc()) {
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700392 LOG(INFO) << "Grow heap (frag case) to " << new_footprint / MB
Brian Carlstromf28bc5b2011-10-26 01:15:03 -0700393 << " for " << size << "-byte allocation";
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700394 }
Carl Shapiro69759ea2011-07-21 18:13:35 -0700395 return ptr;
396 }
397
398 // Most allocations should have succeeded by now, so the heap is
399 // really full, really fragmented, or the requested size is really
400 // big. Do another GC, collecting SoftReferences this time. The VM
401 // spec requires that all SoftReferences have been collected and
402 // cleared before throwing an OOME.
403
Elliott Hughes418dfe72011-10-06 18:56:27 -0700404 // OLD-TODO: wait for the finalizers from the previous GC to finish
Elliott Hughes352a4242011-10-31 15:15:21 -0700405 if (Heap::IsVerboseGc()) {
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700406 LOG(INFO) << "Forcing collection of SoftReferences for "
407 << size << "-byte allocation";
408 }
Carl Shapiro58551df2011-07-24 03:09:51 -0700409 CollectGarbageInternal();
410 ptr = space->AllocWithGrowth(size);
Carl Shapiro69759ea2011-07-21 18:13:35 -0700411 if (ptr != NULL) {
412 return ptr;
413 }
Carl Shapiro69759ea2011-07-21 18:13:35 -0700414
Carl Shapiro69759ea2011-07-21 18:13:35 -0700415 LOG(ERROR) << "Out of memory on a " << size << " byte allocation";
416
Carl Shapiro58551df2011-07-24 03:09:51 -0700417 // TODO: tell the HeapSource to dump its state
418 // TODO: dump stack traces for all threads
Carl Shapiro69759ea2011-07-21 18:13:35 -0700419
Carl Shapiro69759ea2011-07-21 18:13:35 -0700420 return NULL;
421}
422
Elliott Hughesbf86d042011-08-31 17:53:14 -0700423int64_t Heap::GetMaxMemory() {
jeffhaoc1160702011-10-27 15:48:45 -0700424 return growth_size_;
Elliott Hughesbf86d042011-08-31 17:53:14 -0700425}
426
427int64_t Heap::GetTotalMemory() {
Elliott Hughes7162ad92011-10-27 14:08:42 -0700428 return alloc_space_->Size();
Elliott Hughesbf86d042011-08-31 17:53:14 -0700429}
430
431int64_t Heap::GetFreeMemory() {
Elliott Hughes7162ad92011-10-27 14:08:42 -0700432 return alloc_space_->Size() - num_bytes_allocated_;
Elliott Hughesbf86d042011-08-31 17:53:14 -0700433}
434
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700435class InstanceCounter {
436 public:
437 InstanceCounter(Class* c, bool count_assignable)
438 : class_(c), count_assignable_(count_assignable), count_(0) {
439 }
440
441 size_t GetCount() {
442 return count_;
443 }
444
445 static void Callback(Object* o, void* arg) {
446 reinterpret_cast<InstanceCounter*>(arg)->VisitInstance(o);
447 }
448
449 private:
450 void VisitInstance(Object* o) {
451 Class* instance_class = o->GetClass();
452 if (count_assignable_) {
453 if (instance_class == class_) {
454 ++count_;
455 }
456 } else {
457 if (instance_class != NULL && class_->IsAssignableFrom(instance_class)) {
458 ++count_;
459 }
460 }
461 }
462
463 Class* class_;
464 bool count_assignable_;
465 size_t count_;
466};
467
468int64_t Heap::CountInstances(Class* c, bool count_assignable) {
469 ScopedHeapLock lock;
470 InstanceCounter counter(c, count_assignable);
471 live_bitmap_->Walk(InstanceCounter::Callback, &counter);
472 return counter.GetCount();
473}
474
Carl Shapiro69759ea2011-07-21 18:13:35 -0700475void Heap::CollectGarbage() {
Elliott Hughes92b3b562011-09-08 16:32:26 -0700476 ScopedHeapLock lock;
Carl Shapiro58551df2011-07-24 03:09:51 -0700477 CollectGarbageInternal();
Carl Shapiro69759ea2011-07-21 18:13:35 -0700478}
479
480void Heap::CollectGarbageInternal() {
Elliott Hughes8daa0922011-09-11 13:46:25 -0700481 lock_->AssertHeld();
Carl Shapiro58551df2011-07-24 03:09:51 -0700482
Elliott Hughes8d768a92011-09-14 16:35:25 -0700483 ThreadList* thread_list = Runtime::Current()->GetThreadList();
484 thread_list->SuspendAll();
Elliott Hughes83df2ac2011-10-11 16:37:54 -0700485
486 size_t initial_size = num_bytes_allocated_;
Elliott Hughes307f75d2011-10-12 18:04:40 -0700487 TimingLogger timings("CollectGarbageInternal");
Elliott Hughes83df2ac2011-10-11 16:37:54 -0700488 uint64_t t0 = NanoTime();
Elliott Hughesadb460d2011-10-05 17:02:34 -0700489 Object* cleared_references = NULL;
Carl Shapiro58551df2011-07-24 03:09:51 -0700490 {
491 MarkSweep mark_sweep;
Elliott Hughes307f75d2011-10-12 18:04:40 -0700492 timings.AddSplit("ctor");
Carl Shapiro58551df2011-07-24 03:09:51 -0700493
494 mark_sweep.Init();
Elliott Hughes307f75d2011-10-12 18:04:40 -0700495 timings.AddSplit("Init");
Carl Shapiro58551df2011-07-24 03:09:51 -0700496
497 mark_sweep.MarkRoots();
Elliott Hughes307f75d2011-10-12 18:04:40 -0700498 timings.AddSplit("MarkRoots");
Carl Shapiro58551df2011-07-24 03:09:51 -0700499
Ian Rogers5d76c432011-10-31 21:42:49 -0700500 mark_sweep.ScanDirtyImageRoots();
501 timings.AddSplit("DirtyImageRoots");
502
503 // Roots are marked on the bitmap and the mark_stack is empty
504 DCHECK(mark_sweep.IsMarkStackEmpty());
Carl Shapiro58551df2011-07-24 03:09:51 -0700505
506 // TODO: if concurrent
507 // unlock heap
Elliott Hughes8d768a92011-09-14 16:35:25 -0700508 // thread_list->ResumeAll();
Carl Shapiro58551df2011-07-24 03:09:51 -0700509
Ian Rogers5d76c432011-10-31 21:42:49 -0700510 // Recursively mark all bits set in the non-image mark bitmap
Carl Shapiro58551df2011-07-24 03:09:51 -0700511 mark_sweep.RecursiveMark();
Elliott Hughes307f75d2011-10-12 18:04:40 -0700512 timings.AddSplit("RecursiveMark");
Carl Shapiro58551df2011-07-24 03:09:51 -0700513
514 // TODO: if concurrent
515 // lock heap
Elliott Hughes8d768a92011-09-14 16:35:25 -0700516 // thread_list->SuspendAll();
Carl Shapiro58551df2011-07-24 03:09:51 -0700517 // re-mark root set
518 // scan dirty objects
519
520 mark_sweep.ProcessReferences(false);
Elliott Hughes307f75d2011-10-12 18:04:40 -0700521 timings.AddSplit("ProcessReferences");
Carl Shapiro58551df2011-07-24 03:09:51 -0700522
Elliott Hughes2da50362011-10-10 16:57:08 -0700523 // TODO: if concurrent
524 // swap bitmaps
Carl Shapiro58551df2011-07-24 03:09:51 -0700525
526 mark_sweep.Sweep();
Elliott Hughes307f75d2011-10-12 18:04:40 -0700527 timings.AddSplit("Sweep");
Elliott Hughesadb460d2011-10-05 17:02:34 -0700528
529 cleared_references = mark_sweep.GetClearedReferences();
Carl Shapiro58551df2011-07-24 03:09:51 -0700530 }
531
532 GrowForUtilization();
Elliott Hughes307f75d2011-10-12 18:04:40 -0700533 timings.AddSplit("GrowForUtilization");
Elliott Hughes83df2ac2011-10-11 16:37:54 -0700534 uint64_t t1 = NanoTime();
Elliott Hughes8d768a92011-09-14 16:35:25 -0700535 thread_list->ResumeAll();
Elliott Hughesadb460d2011-10-05 17:02:34 -0700536
537 EnqueueClearedReferences(&cleared_references);
Elliott Hughes83df2ac2011-10-11 16:37:54 -0700538
539 // TODO: somehow make the specific GC implementation (here MarkSweep) responsible for logging.
540 size_t bytes_freed = initial_size - num_bytes_allocated_;
541 bool is_small = (bytes_freed > 0 && bytes_freed < 1024);
542 size_t kib_freed = (bytes_freed > 0 ? std::max(bytes_freed/1024, 1U) : 0);
543
Elliott Hughes7162ad92011-10-27 14:08:42 -0700544 size_t total = GetTotalMemory();
545 size_t percentFree = 100 - static_cast<size_t>(100.0f * float(num_bytes_allocated_) / total);
Elliott Hughes83df2ac2011-10-11 16:37:54 -0700546
547 uint32_t duration = (t1 - t0)/1000/1000;
Elliott Hughesaaed81d2011-11-07 15:11:47 -0800548 bool gc_was_particularly_slow = (duration > 100); // TODO: crank this down for concurrent.
549 if (Heap::IsVerboseGc() || gc_was_particularly_slow) {
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700550 LOG(INFO) << "GC freed " << (is_small ? "<" : "") << kib_freed << "KiB, "
551 << percentFree << "% free "
Elliott Hughes7162ad92011-10-27 14:08:42 -0700552 << (num_bytes_allocated_/1024) << "KiB/" << (total/1024) << "KiB, "
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700553 << "paused " << duration << "ms";
554 }
Elliott Hughes767a1472011-10-26 18:49:02 -0700555 Dbg::GcDidFinish();
Elliott Hughes352a4242011-10-31 15:15:21 -0700556 if (Heap::IsVerboseHeap()) {
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700557 timings.Dump();
558 }
Carl Shapiro69759ea2011-07-21 18:13:35 -0700559}
560
561void Heap::WaitForConcurrentGcToComplete() {
Elliott Hughes8daa0922011-09-11 13:46:25 -0700562 lock_->AssertHeld();
Carl Shapiro69759ea2011-07-21 18:13:35 -0700563}
564
Elliott Hughes6a5bd492011-10-28 14:33:57 -0700565void Heap::WalkHeap(void(*callback)(const void*, size_t, const void*, size_t, void*), void* arg) {
566 typedef std::vector<Space*>::iterator It; // C++0x auto.
567 for (It it = spaces_.begin(); it != spaces_.end(); ++it) {
568 (*it)->Walk(callback, arg);
569 }
570}
571
Shih-wei Liao8c2f6412011-10-03 22:58:14 -0700572/* Terminology:
573 * 1. Footprint: Capacity we allocate from system.
574 * 2. Active space: a.k.a. alloc_space_.
575 * 3. Soft footprint: external allocation + spaces footprint + active space footprint
576 * 4. Overhead: soft footprint excluding active.
577 *
Shih-wei Liao7f1caab2011-10-06 12:11:04 -0700578 * Layout: (The spaces below might not be contiguous, but are lumped together to depict size.)
579 * |----------------------spaces footprint--------- --------------|----active space footprint----|
Shih-wei Liao8c2f6412011-10-03 22:58:14 -0700580 * |--active space allocated--|
581 * |--------------------soft footprint (include active)--------------------------------------|
582 * |----------------soft footprint excluding active---------------|
583 * |------------soft limit-------...|
584 * |------------------------------------ideal footprint-----------------------------------------...|
585 *
586 */
587
588// Sets the maximum number of bytes that the heap is allowed to
589// allocate from the system. Clamps to the appropriate maximum
590// value.
591// Old spaces will count against the ideal size.
592//
593void Heap::SetIdealFootprint(size_t max_allowed_footprint)
594{
jeffhaoc1160702011-10-27 15:48:45 -0700595 if (max_allowed_footprint > Heap::growth_size_) {
Elliott Hughes352a4242011-10-31 15:15:21 -0700596 if (Heap::IsVerboseGc()) {
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700597 LOG(INFO) << "Clamp target GC heap from " << max_allowed_footprint
jeffhaoc1160702011-10-27 15:48:45 -0700598 << " to " << Heap::growth_size_;
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700599 }
jeffhaoc1160702011-10-27 15:48:45 -0700600 max_allowed_footprint = Heap::growth_size_;
Shih-wei Liao8c2f6412011-10-03 22:58:14 -0700601 }
602
Shih-wei Liao7f1caab2011-10-06 12:11:04 -0700603 alloc_space_->SetMaxAllowedFootprint(max_allowed_footprint);
Shih-wei Liao8c2f6412011-10-03 22:58:14 -0700604}
605
Shih-wei Liao7f1caab2011-10-06 12:11:04 -0700606// kHeapIdealFree is the ideal maximum free size, when we grow the heap for
607// utlization.
608static const size_t kHeapIdealFree = 2 * MB;
609// kHeapMinFree guarantees that you always have at least 512 KB free, when
610// you grow for utilization, regardless of target utilization ratio.
Shih-wei Liao8c2f6412011-10-03 22:58:14 -0700611static const size_t kHeapMinFree = kHeapIdealFree / 4;
612
613// Given the current contents of the active space, increase the allowed
Carl Shapiro69759ea2011-07-21 18:13:35 -0700614// heap footprint to match the target utilization ratio. This should
615// only be called immediately after a full garbage collection.
Shih-wei Liao8c2f6412011-10-03 22:58:14 -0700616//
Carl Shapiro69759ea2011-07-21 18:13:35 -0700617void Heap::GrowForUtilization() {
Elliott Hughes8daa0922011-09-11 13:46:25 -0700618 lock_->AssertHeld();
Shih-wei Liao8c2f6412011-10-03 22:58:14 -0700619
620 // We know what our utilization is at this moment.
621 // This doesn't actually resize any memory. It just lets the heap grow more
622 // when necessary.
Elliott Hughes362f9bc2011-10-17 18:56:41 -0700623 size_t target_size(num_bytes_allocated_ / Heap::GetTargetHeapUtilization());
Shih-wei Liao8c2f6412011-10-03 22:58:14 -0700624
625 if (target_size > num_bytes_allocated_ + kHeapIdealFree) {
626 target_size = num_bytes_allocated_ + kHeapIdealFree;
627 } else if (target_size < num_bytes_allocated_ + kHeapMinFree) {
628 target_size = num_bytes_allocated_ + kHeapMinFree;
629 }
630
631 SetIdealFootprint(target_size);
Carl Shapiro69759ea2011-07-21 18:13:35 -0700632}
633
jeffhaoc1160702011-10-27 15:48:45 -0700634void Heap::ClearGrowthLimit() {
635 ScopedHeapLock lock;
636 WaitForConcurrentGcToComplete();
637 CHECK_GE(maximum_size_, growth_size_);
638 growth_size_ = maximum_size_;
639 alloc_space_->ClearGrowthLimit();
jeffhao39da0352011-11-04 14:58:55 -0700640 card_table_->ClearGrowthLimit();
jeffhaoc1160702011-10-27 15:48:45 -0700641}
642
Brian Carlstrom24a3c2e2011-10-17 18:07:52 -0700643pid_t Heap::GetLockOwner() {
Elliott Hughesaccd83d2011-10-17 14:25:58 -0700644 return lock_->GetOwner();
645}
646
Elliott Hughes92b3b562011-09-08 16:32:26 -0700647void Heap::Lock() {
Brian Carlstromfad71432011-10-16 20:25:10 -0700648 // Grab the lock, but put ourselves into Thread::kVmWait if it looks
649 // like we're going to have to wait on the mutex. This prevents
650 // deadlock if another thread is calling CollectGarbageInternal,
651 // since they will have the heap lock and be waiting for mutators to
652 // suspend.
653 if (!lock_->TryLock()) {
654 ScopedThreadStateChange tsc(Thread::Current(), Thread::kVmWait);
655 lock_->Lock();
656 }
Elliott Hughes92b3b562011-09-08 16:32:26 -0700657}
658
659void Heap::Unlock() {
660 lock_->Unlock();
661}
662
Elliott Hughesadb460d2011-10-05 17:02:34 -0700663void Heap::SetWellKnownClasses(Class* java_lang_ref_FinalizerReference,
664 Class* java_lang_ref_ReferenceQueue) {
665 java_lang_ref_FinalizerReference_ = java_lang_ref_FinalizerReference;
666 java_lang_ref_ReferenceQueue_ = java_lang_ref_ReferenceQueue;
667 CHECK(java_lang_ref_FinalizerReference_ != NULL);
668 CHECK(java_lang_ref_ReferenceQueue_ != NULL);
669}
670
671void Heap::SetReferenceOffsets(MemberOffset reference_referent_offset,
672 MemberOffset reference_queue_offset,
673 MemberOffset reference_queueNext_offset,
674 MemberOffset reference_pendingNext_offset,
675 MemberOffset finalizer_reference_zombie_offset) {
676 reference_referent_offset_ = reference_referent_offset;
677 reference_queue_offset_ = reference_queue_offset;
678 reference_queueNext_offset_ = reference_queueNext_offset;
679 reference_pendingNext_offset_ = reference_pendingNext_offset;
680 finalizer_reference_zombie_offset_ = finalizer_reference_zombie_offset;
681 CHECK_NE(reference_referent_offset_.Uint32Value(), 0U);
682 CHECK_NE(reference_queue_offset_.Uint32Value(), 0U);
683 CHECK_NE(reference_queueNext_offset_.Uint32Value(), 0U);
684 CHECK_NE(reference_pendingNext_offset_.Uint32Value(), 0U);
685 CHECK_NE(finalizer_reference_zombie_offset_.Uint32Value(), 0U);
686}
687
688Object* Heap::GetReferenceReferent(Object* reference) {
689 DCHECK(reference != NULL);
690 DCHECK_NE(reference_referent_offset_.Uint32Value(), 0U);
691 return reference->GetFieldObject<Object*>(reference_referent_offset_, true);
692}
693
694void Heap::ClearReferenceReferent(Object* reference) {
695 DCHECK(reference != NULL);
696 DCHECK_NE(reference_referent_offset_.Uint32Value(), 0U);
697 reference->SetFieldObject(reference_referent_offset_, NULL, true);
698}
699
700// Returns true if the reference object has not yet been enqueued.
701bool Heap::IsEnqueuable(const Object* ref) {
702 DCHECK(ref != NULL);
703 const Object* queue = ref->GetFieldObject<Object*>(reference_queue_offset_, false);
704 const Object* queue_next = ref->GetFieldObject<Object*>(reference_queueNext_offset_, false);
705 return (queue != NULL) && (queue_next == NULL);
706}
707
708void Heap::EnqueueReference(Object* ref, Object** cleared_reference_list) {
709 DCHECK(ref != NULL);
710 CHECK(ref->GetFieldObject<Object*>(reference_queue_offset_, false) != NULL);
711 CHECK(ref->GetFieldObject<Object*>(reference_queueNext_offset_, false) == NULL);
712 EnqueuePendingReference(ref, cleared_reference_list);
713}
714
715void Heap::EnqueuePendingReference(Object* ref, Object** list) {
716 DCHECK(ref != NULL);
717 DCHECK(list != NULL);
718
719 if (*list == NULL) {
720 ref->SetFieldObject(reference_pendingNext_offset_, ref, false);
721 *list = ref;
722 } else {
723 Object* head = (*list)->GetFieldObject<Object*>(reference_pendingNext_offset_, false);
724 ref->SetFieldObject(reference_pendingNext_offset_, head, false);
725 (*list)->SetFieldObject(reference_pendingNext_offset_, ref, false);
726 }
727}
728
729Object* Heap::DequeuePendingReference(Object** list) {
730 DCHECK(list != NULL);
731 DCHECK(*list != NULL);
732 Object* head = (*list)->GetFieldObject<Object*>(reference_pendingNext_offset_, false);
733 Object* ref;
734 if (*list == head) {
735 ref = *list;
736 *list = NULL;
737 } else {
738 Object* next = head->GetFieldObject<Object*>(reference_pendingNext_offset_, false);
739 (*list)->SetFieldObject(reference_pendingNext_offset_, next, false);
740 ref = head;
741 }
742 ref->SetFieldObject(reference_pendingNext_offset_, NULL, false);
743 return ref;
744}
745
Ian Rogers5d4bdc22011-11-02 22:15:43 -0700746void Heap::AddFinalizerReference(Thread* self, Object* object) {
747 ScopedThreadStateChange tsc(self, Thread::kRunnable);
Elliott Hughesadb460d2011-10-05 17:02:34 -0700748 static Method* FinalizerReference_add =
749 java_lang_ref_FinalizerReference_->FindDirectMethod("add", "(Ljava/lang/Object;)V");
750 DCHECK(FinalizerReference_add != NULL);
751 Object* args[] = { object };
Ian Rogers5d4bdc22011-11-02 22:15:43 -0700752 FinalizerReference_add->Invoke(self, NULL, reinterpret_cast<byte*>(&args), NULL);
Elliott Hughesadb460d2011-10-05 17:02:34 -0700753}
754
755void Heap::EnqueueClearedReferences(Object** cleared) {
756 DCHECK(cleared != NULL);
757 if (*cleared != NULL) {
758 static Method* ReferenceQueue_add =
759 java_lang_ref_ReferenceQueue_->FindDirectMethod("add", "(Ljava/lang/ref/Reference;)V");
760 DCHECK(ReferenceQueue_add != NULL);
761
762 Thread* self = Thread::Current();
763 ScopedThreadStateChange tsc(self, Thread::kRunnable);
764 Object* args[] = { *cleared };
765 ReferenceQueue_add->Invoke(self, NULL, reinterpret_cast<byte*>(&args), NULL);
766 *cleared = NULL;
767 }
768}
769
Carl Shapiro69759ea2011-07-21 18:13:35 -0700770} // namespace art