heap.h revision 0a9dc05e704bfd033bac2aa38a4fc6f6b8e6cf93
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#ifndef ART_RUNTIME_GC_HEAP_H_ 18#define ART_RUNTIME_GC_HEAP_H_ 19 20#include <iosfwd> 21#include <string> 22#include <vector> 23 24#include "atomic_integer.h" 25#include "base/timing_logger.h" 26#include "gc/accounting/atomic_stack.h" 27#include "gc/accounting/gc_allocator.h" 28#include "gc/accounting/card_table.h" 29#include "gc/collector/gc_type.h" 30#include "globals.h" 31#include "gtest/gtest.h" 32#include "locks.h" 33#include "offsets.h" 34#include "safe_map.h" 35#include "thread_pool.h" 36 37namespace art { 38 39class ConditionVariable; 40class Mutex; 41class StackVisitor; 42class Thread; 43class TimingLogger; 44 45namespace mirror { 46 class Class; 47 class Object; 48} // namespace mirror 49 50namespace gc { 51namespace accounting { 52 class HeapBitmap; 53 class ModUnionTable; 54 class SpaceSetMap; 55} // namespace accounting 56 57namespace collector { 58 class GarbageCollector; 59 class MarkSweep; 60} // namespace collector 61 62namespace space { 63 class AllocSpace; 64 class DiscontinuousSpace; 65 class DlMallocSpace; 66 class ImageSpace; 67 class LargeObjectSpace; 68 class Space; 69 class SpaceTest; 70} // namespace space 71 72class AgeCardVisitor { 73 public: 74 byte operator()(byte card) const { 75 if (card == accounting::CardTable::kCardDirty) { 76 return card - 1; 77 } else { 78 return 0; 79 } 80 } 81}; 82 83// What caused the GC? 84enum GcCause { 85 // GC triggered by a failed allocation. Thread doing allocation is blocked waiting for GC before 86 // retrying allocation. 87 kGcCauseForAlloc, 88 // A background GC trying to ensure there is free memory ahead of allocations. 89 kGcCauseBackground, 90 // An explicit System.gc() call. 91 kGcCauseExplicit, 92}; 93std::ostream& operator<<(std::ostream& os, const GcCause& policy); 94 95// How we want to sanity check the heap's correctness. 96enum HeapVerificationMode { 97 kHeapVerificationNotPermitted, // Too early in runtime start-up for heap to be verified. 98 kNoHeapVerification, // Production default. 99 kVerifyAllFast, // Sanity check all heap accesses with quick(er) tests. 100 kVerifyAll // Sanity check all heap accesses. 101}; 102const HeapVerificationMode kDesiredHeapVerification = kNoHeapVerification; 103 104// This comes from ActivityManager and needs to be kept in sync. 105enum ProcessState { 106 PROCESS_STATE_PERSISTENT = 0, 107 PROCESS_STATE_PERSISTENT_UI = 1, 108 PROCESS_STATE_TOP = 2, 109 PROCESS_STATE_IMPORTANT_FOREGROUND = 3, 110 PROCESS_STATE_IMPORTANT_BACKGROUND = 4, 111 PROCESS_STATE_BACKUP = 5, 112 PROCESS_STATE_HEAVY_WEIGHT = 6, 113 PROCESS_STATE_SERVICE = 7, 114 PROCESS_STATE_RECEIVER = 8, 115 PROCESS_STATE_HOME = 9, 116 PROCESS_STATE_LAST_ACTIVITY = 10, 117 PROCESS_STATE_CACHED_ACTIVITY = 11, 118 PROCESS_STATE_CACHED_ACTIVITY_CLIENT = 12, 119 PROCESS_STATE_CACHED_EMPTY = 13, 120}; 121 122class Heap { 123 public: 124 static const size_t kDefaultInitialSize = 2 * MB; 125 static const size_t kDefaultMaximumSize = 32 * MB; 126 static const size_t kDefaultMaxFree = 2 * MB; 127 static const size_t kDefaultMinFree = kDefaultMaxFree / 4; 128 129 // Default target utilization. 130 static const double kDefaultTargetUtilization; 131 132 // Used so that we don't overflow the allocation time atomic integer. 133 static const size_t kTimeAdjust = 1024; 134 135 // Create a heap with the requested sizes. The possible empty 136 // image_file_names names specify Spaces to load based on 137 // ImageWriter output. 138 explicit Heap(size_t initial_size, size_t growth_limit, size_t min_free, 139 size_t max_free, double target_utilization, size_t capacity, 140 const std::string& original_image_file_name, bool concurrent_gc, 141 size_t num_gc_threads); 142 143 ~Heap(); 144 145 // Allocates and initializes storage for an object instance. 146 mirror::Object* AllocObject(Thread* self, mirror::Class* klass, size_t num_bytes) 147 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 148 149 void RegisterNativeAllocation(int bytes) 150 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 151 void RegisterNativeFree(int bytes) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 152 153 // The given reference is believed to be to an object in the Java heap, check the soundness of it. 154 void VerifyObjectImpl(const mirror::Object* o); 155 void VerifyObject(const mirror::Object* o) { 156 if (o != NULL && this != NULL && verify_object_mode_ > kNoHeapVerification) { 157 VerifyObjectImpl(o); 158 } 159 } 160 161 // Check sanity of all live references. 162 void VerifyHeap() LOCKS_EXCLUDED(Locks::heap_bitmap_lock_); 163 bool VerifyHeapReferences() 164 EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_); 165 bool VerifyMissingCardMarks() 166 EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_) 167 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 168 169 // A weaker test than IsLiveObject or VerifyObject that doesn't require the heap lock, 170 // and doesn't abort on error, allowing the caller to report more 171 // meaningful diagnostics. 172 bool IsHeapAddress(const mirror::Object* obj); 173 174 // Returns true if 'obj' is a live heap object, false otherwise (including for invalid addresses). 175 // Requires the heap lock to be held. 176 bool IsLiveObjectLocked(const mirror::Object* obj) 177 SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_); 178 179 // Initiates an explicit garbage collection. 180 void CollectGarbage(bool clear_soft_references) LOCKS_EXCLUDED(Locks::mutator_lock_); 181 182 // Does a concurrent GC, should only be called by the GC daemon thread 183 // through runtime. 184 void ConcurrentGC(Thread* self) LOCKS_EXCLUDED(Locks::runtime_shutdown_lock_); 185 186 // Implements VMDebug.countInstancesOfClass and JDWP VM_InstanceCount. 187 // The boolean decides whether to use IsAssignableFrom or == when comparing classes. 188 void CountInstances(const std::vector<mirror::Class*>& classes, bool use_is_assignable_from, 189 uint64_t* counts) 190 LOCKS_EXCLUDED(Locks::heap_bitmap_lock_) 191 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 192 // Implements JDWP RT_Instances. 193 void GetInstances(mirror::Class* c, int32_t max_count, std::vector<mirror::Object*>& instances) 194 LOCKS_EXCLUDED(Locks::heap_bitmap_lock_) 195 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 196 // Implements JDWP OR_ReferringObjects. 197 void GetReferringObjects(mirror::Object* o, int32_t max_count, std::vector<mirror::Object*>& referring_objects) 198 LOCKS_EXCLUDED(Locks::heap_bitmap_lock_) 199 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 200 201 // Removes the growth limit on the alloc space so it may grow to its maximum capacity. Used to 202 // implement dalvik.system.VMRuntime.clearGrowthLimit. 203 void ClearGrowthLimit(); 204 205 // Target ideal heap utilization ratio, implements 206 // dalvik.system.VMRuntime.getTargetHeapUtilization. 207 double GetTargetHeapUtilization() const { 208 return target_utilization_; 209 } 210 211 // Data structure memory usage tracking. 212 void RegisterGCAllocation(size_t bytes); 213 void RegisterGCDeAllocation(size_t bytes); 214 215 // Set target ideal heap utilization ratio, implements 216 // dalvik.system.VMRuntime.setTargetHeapUtilization. 217 void SetTargetHeapUtilization(float target); 218 219 // For the alloc space, sets the maximum number of bytes that the heap is allowed to allocate 220 // from the system. Doesn't allow the space to exceed its growth limit. 221 void SetIdealFootprint(size_t max_allowed_footprint); 222 223 // Blocks the caller until the garbage collector becomes idle and returns 224 // true if we waited for the GC to complete. 225 collector::GcType WaitForConcurrentGcToComplete(Thread* self) LOCKS_EXCLUDED(gc_complete_lock_); 226 227 const std::vector<space::ContinuousSpace*>& GetContinuousSpaces() const { 228 return continuous_spaces_; 229 } 230 231 const std::vector<space::DiscontinuousSpace*>& GetDiscontinuousSpaces() const { 232 return discontinuous_spaces_; 233 } 234 235 void SetReferenceOffsets(MemberOffset reference_referent_offset, 236 MemberOffset reference_queue_offset, 237 MemberOffset reference_queueNext_offset, 238 MemberOffset reference_pendingNext_offset, 239 MemberOffset finalizer_reference_zombie_offset); 240 241 mirror::Object* GetReferenceReferent(mirror::Object* reference); 242 void ClearReferenceReferent(mirror::Object* reference) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 243 244 // Returns true if the reference object has not yet been enqueued. 245 bool IsEnqueuable(const mirror::Object* ref); 246 void EnqueueReference(mirror::Object* ref, mirror::Object** list) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 247 void EnqueuePendingReference(mirror::Object* ref, mirror::Object** list) 248 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 249 mirror::Object* DequeuePendingReference(mirror::Object** list) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 250 251 MemberOffset GetReferencePendingNextOffset() { 252 DCHECK_NE(reference_pendingNext_offset_.Uint32Value(), 0U); 253 return reference_pendingNext_offset_; 254 } 255 256 MemberOffset GetFinalizerReferenceZombieOffset() { 257 DCHECK_NE(finalizer_reference_zombie_offset_.Uint32Value(), 0U); 258 return finalizer_reference_zombie_offset_; 259 } 260 261 // Enable verification of object references when the runtime is sufficiently initialized. 262 void EnableObjectValidation() { 263 verify_object_mode_ = kDesiredHeapVerification; 264 if (verify_object_mode_ > kNoHeapVerification) { 265 VerifyHeap(); 266 } 267 } 268 269 // Disable object reference verification for image writing. 270 void DisableObjectValidation() { 271 verify_object_mode_ = kHeapVerificationNotPermitted; 272 } 273 274 // Other checks may be performed if we know the heap should be in a sane state. 275 bool IsObjectValidationEnabled() const { 276 return kDesiredHeapVerification > kNoHeapVerification && 277 verify_object_mode_ > kHeapVerificationNotPermitted; 278 } 279 280 void RecordFree(size_t freed_objects, size_t freed_bytes); 281 282 // Must be called if a field of an Object in the heap changes, and before any GC safe-point. 283 // The call is not needed if NULL is stored in the field. 284 void WriteBarrierField(const mirror::Object* dst, MemberOffset /*offset*/, const mirror::Object* /*new_value*/) { 285 card_table_->MarkCard(dst); 286 } 287 288 // Write barrier for array operations that update many field positions 289 void WriteBarrierArray(const mirror::Object* dst, int /*start_offset*/, 290 size_t /*length TODO: element_count or byte_count?*/) { 291 card_table_->MarkCard(dst); 292 } 293 294 accounting::CardTable* GetCardTable() const { 295 return card_table_.get(); 296 } 297 298 void AddFinalizerReference(Thread* self, mirror::Object* object); 299 300 // Returns the number of bytes currently allocated. 301 size_t GetBytesAllocated() const { 302 return num_bytes_allocated_; 303 } 304 305 // Returns the number of objects currently allocated. 306 size_t GetObjectsAllocated() const; 307 308 // Returns the total number of objects allocated since the heap was created. 309 size_t GetObjectsAllocatedEver() const; 310 311 // Returns the total number of bytes allocated since the heap was created. 312 size_t GetBytesAllocatedEver() const; 313 314 // Returns the total number of objects freed since the heap was created. 315 size_t GetObjectsFreedEver() const { 316 return total_objects_freed_ever_; 317 } 318 319 // Returns the total number of bytes freed since the heap was created. 320 size_t GetBytesFreedEver() const { 321 return total_bytes_freed_ever_; 322 } 323 324 // Implements java.lang.Runtime.maxMemory, returning the maximum amount of memory a program can 325 // consume. For a regular VM this would relate to the -Xmx option and would return -1 if no Xmx 326 // were specified. Android apps start with a growth limit (small heap size) which is 327 // cleared/extended for large apps. 328 int64_t GetMaxMemory() const { 329 return growth_limit_; 330 } 331 332 // Implements java.lang.Runtime.totalMemory, returning the amount of memory consumed by an 333 // application. 334 int64_t GetTotalMemory() const { 335 // TODO: we use the footprint limit here which is conservative wrt number of pages really used. 336 // We could implement a more accurate count across all spaces. 337 return max_allowed_footprint_; 338 } 339 340 // Implements java.lang.Runtime.freeMemory. 341 int64_t GetFreeMemory() const { 342 return GetTotalMemory() - num_bytes_allocated_; 343 } 344 345 // Get the space that corresponds to an object's address. Current implementation searches all 346 // spaces in turn. If fail_ok is false then failing to find a space will cause an abort. 347 // TODO: consider using faster data structure like binary tree. 348 space::ContinuousSpace* FindContinuousSpaceFromObject(const mirror::Object*, bool fail_ok) const; 349 space::DiscontinuousSpace* FindDiscontinuousSpaceFromObject(const mirror::Object*, 350 bool fail_ok) const; 351 space::Space* FindSpaceFromObject(const mirror::Object*, bool fail_ok) const; 352 353 void DumpForSigQuit(std::ostream& os); 354 355 size_t Trim(); 356 357 accounting::HeapBitmap* GetLiveBitmap() SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_) { 358 return live_bitmap_.get(); 359 } 360 361 accounting::HeapBitmap* GetMarkBitmap() SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_) { 362 return mark_bitmap_.get(); 363 } 364 365 accounting::ObjectStack* GetLiveStack() SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_) { 366 return live_stack_.get(); 367 } 368 369 void PreZygoteFork() LOCKS_EXCLUDED(Locks::heap_bitmap_lock_); 370 371 // Mark and empty stack. 372 void FlushAllocStack() 373 EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_); 374 375 // Mark all the objects in the allocation stack in the specified bitmap. 376 void MarkAllocStack(accounting::SpaceBitmap* bitmap, accounting::SpaceSetMap* large_objects, 377 accounting::ObjectStack* stack) 378 EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_); 379 380 // Unmark all the objects in the allocation stack in the specified bitmap. 381 void UnMarkAllocStack(accounting::SpaceBitmap* bitmap, accounting::SpaceSetMap* large_objects, 382 accounting::ObjectStack* stack) 383 EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_); 384 385 // Update and mark mod union table based on gc type. 386 void UpdateAndMarkModUnion(collector::MarkSweep* mark_sweep, base::NewTimingLogger& timings, 387 collector::GcType gc_type) 388 EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_); 389 390 // Update process state to let the heap know which type of GC to do. 391 void UpdateProcessState(ProcessState process_state); 392 393 // DEPRECATED: Should remove in "near" future when support for multiple image spaces is added. 394 // Assumes there is only one image space. 395 space::ImageSpace* GetImageSpace() const; 396 397 space::DlMallocSpace* GetAllocSpace() const { 398 return alloc_space_; 399 } 400 401 space::LargeObjectSpace* GetLargeObjectsSpace() const { 402 return large_object_space_; 403 } 404 405 void DumpSpaces(); 406 407 // GC performance measuring 408 void DumpGcPerformanceInfo(std::ostream& os); 409 410 // Thread pool. 411 void CreateThreadPool(); 412 void DeleteThreadPool(); 413 ThreadPool* GetThreadPool() { 414 return thread_pool_.get(); 415 } 416 417 private: 418 // Allocates uninitialized storage. Passing in a null space tries to place the object in the 419 // large object space. 420 mirror::Object* Allocate(Thread* self, space::AllocSpace* space, size_t num_bytes) 421 LOCKS_EXCLUDED(Locks::thread_suspend_count_lock_) 422 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 423 424 // Try to allocate a number of bytes, this function never does any GCs. 425 mirror::Object* TryToAllocate(Thread* self, space::AllocSpace* space, size_t alloc_size, bool grow) 426 LOCKS_EXCLUDED(Locks::thread_suspend_count_lock_) 427 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 428 429 // Pushes a list of cleared references out to the managed heap. 430 void EnqueueClearedReferences(mirror::Object** cleared_references); 431 432 void RequestHeapTrim() LOCKS_EXCLUDED(Locks::runtime_shutdown_lock_); 433 void RequestConcurrentGC(Thread* self) LOCKS_EXCLUDED(Locks::runtime_shutdown_lock_); 434 bool IsGCRequestPending() const; 435 436 void RecordAllocation(size_t size, mirror::Object* object) 437 LOCKS_EXCLUDED(GlobalSynchronization::heap_bitmap_lock_) 438 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 439 440 // Sometimes CollectGarbageInternal decides to run a different Gc than you requested. Returns 441 // which type of Gc was actually ran. 442 collector::GcType CollectGarbageInternal(collector::GcType gc_plan, GcCause gc_cause, 443 bool clear_soft_references) 444 LOCKS_EXCLUDED(gc_complete_lock_, 445 Locks::heap_bitmap_lock_, 446 Locks::thread_suspend_count_lock_); 447 448 void PreGcVerification(collector::GarbageCollector* gc); 449 void PreSweepingGcVerification(collector::GarbageCollector* gc) 450 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 451 void PostGcVerification(collector::GarbageCollector* gc); 452 453 // Update the watermark for the native allocated bytes based on the current number of native 454 // bytes allocated and the target utilization ratio. 455 void UpdateMaxNativeFootprint(); 456 457 // Given the current contents of the alloc space, increase the allowed heap footprint to match 458 // the target utilization ratio. This should only be called immediately after a full garbage 459 // collection. 460 void GrowForUtilization(collector::GcType gc_type, uint64_t gc_duration); 461 462 size_t GetPercentFree(); 463 464 void AddContinuousSpace(space::ContinuousSpace* space) LOCKS_EXCLUDED(Locks::heap_bitmap_lock_); 465 void AddDiscontinuousSpace(space::DiscontinuousSpace* space) 466 LOCKS_EXCLUDED(Locks::heap_bitmap_lock_); 467 468 // No thread saftey analysis since we call this everywhere and it is impossible to find a proper 469 // lock ordering for it. 470 void VerifyObjectBody(const mirror::Object *obj) NO_THREAD_SAFETY_ANALYSIS; 471 472 static void VerificationCallback(mirror::Object* obj, void* arg) 473 SHARED_LOCKS_REQUIRED(GlobalSychronization::heap_bitmap_lock_); 474 475 // Swap the allocation stack with the live stack. 476 void SwapStacks(); 477 478 // Clear cards and update the mod union table. 479 void ProcessCards(base::NewTimingLogger& timings); 480 481 // All-known continuous spaces, where objects lie within fixed bounds. 482 std::vector<space::ContinuousSpace*> continuous_spaces_; 483 484 // All-known discontinuous spaces, where objects may be placed throughout virtual memory. 485 std::vector<space::DiscontinuousSpace*> discontinuous_spaces_; 486 487 // The allocation space we are currently allocating into. 488 space::DlMallocSpace* alloc_space_; 489 490 // The large object space we are currently allocating into. 491 space::LargeObjectSpace* large_object_space_; 492 493 // The card table, dirtied by the write barrier. 494 UniquePtr<accounting::CardTable> card_table_; 495 496 // The mod-union table remembers all of the references from the image space to the alloc / 497 // zygote spaces to allow the card table to be cleared. 498 UniquePtr<accounting::ModUnionTable> image_mod_union_table_; 499 500 // This table holds all of the references from the zygote space to the alloc space. 501 UniquePtr<accounting::ModUnionTable> zygote_mod_union_table_; 502 503 // What kind of concurrency behavior is the runtime after? True for concurrent mark sweep GC, 504 // false for stop-the-world mark sweep. 505 const bool concurrent_gc_; 506 507 // How many GC threads we may use for garbage collection. 508 const bool num_gc_threads_; 509 510 // If we have a zygote space. 511 bool have_zygote_space_; 512 513 // Guards access to the state of GC, associated conditional variable is used to signal when a GC 514 // completes. 515 Mutex* gc_complete_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER; 516 UniquePtr<ConditionVariable> gc_complete_cond_ GUARDED_BY(gc_complete_lock_); 517 518 // Mutex held when adding references to reference queues. 519 // TODO: move to a UniquePtr, currently annotalysis is confused that UniquePtr isn't lockable. 520 Mutex* reference_queue_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER; 521 522 // True while the garbage collector is running. 523 volatile bool is_gc_running_ GUARDED_BY(gc_complete_lock_); 524 525 // Last Gc type we ran. Used by WaitForConcurrentGc to know which Gc was waited on. 526 volatile collector::GcType last_gc_type_ GUARDED_BY(gc_complete_lock_); 527 collector::GcType next_gc_type_; 528 529 // Maximum size that the heap can reach. 530 const size_t capacity_; 531 // The size the heap is limited to. This is initially smaller than capacity, but for largeHeap 532 // programs it is "cleared" making it the same as capacity. 533 size_t growth_limit_; 534 // When the number of bytes allocated exceeds the footprint TryAllocate returns NULL indicating 535 // a GC should be triggered. 536 size_t max_allowed_footprint_; 537 // The watermark at which a concurrent GC is requested by registerNativeAllocation. 538 size_t native_footprint_gc_watermark_; 539 // The watermark at which a GC is performed inside of registerNativeAllocation. 540 size_t native_footprint_limit_; 541 542 // When num_bytes_allocated_ exceeds this amount then a concurrent GC should be requested so that 543 // it completes ahead of an allocation failing. 544 size_t concurrent_start_bytes_; 545 546 // Since the heap was created, how many bytes have been freed. 547 size_t total_bytes_freed_ever_; 548 549 // Since the heap was created, how many objects have been freed. 550 size_t total_objects_freed_ever_; 551 552 // Primitive objects larger than this size are put in the large object space. 553 const size_t large_object_threshold_; 554 555 // Number of bytes allocated. Adjusted after each allocation and free. 556 AtomicInteger num_bytes_allocated_; 557 558 // Bytes which are allocated and managed by native code but still need to be accounted for. 559 AtomicInteger native_bytes_allocated_; 560 561 // Current process state, updated by activity manager. 562 ProcessState process_state_; 563 564 // Data structure GC overhead. 565 AtomicInteger gc_memory_overhead_; 566 567 // Heap verification flags. 568 const bool verify_missing_card_marks_; 569 const bool verify_system_weaks_; 570 const bool verify_pre_gc_heap_; 571 const bool verify_post_gc_heap_; 572 const bool verify_mod_union_table_; 573 574 // Parallel GC data structures. 575 UniquePtr<ThreadPool> thread_pool_; 576 577 // Sticky mark bits GC has some overhead, so if we have less a few megabytes of AllocSpace then 578 // it's probably better to just do a partial GC. 579 const size_t min_alloc_space_size_for_sticky_gc_; 580 581 // Minimum remaining size for sticky GC. Since sticky GC doesn't free up as much memory as a 582 // normal GC, it is important to not use it when we are almost out of memory. 583 const size_t min_remaining_space_for_sticky_gc_; 584 585 // The last time a heap trim occurred. 586 uint64_t last_trim_time_ms_; 587 588 // The nanosecond time at which the last GC ended. 589 uint64_t last_gc_time_ns_; 590 591 // How many bytes were allocated at the end of the last GC. 592 uint64_t last_gc_size_; 593 594 // Estimated allocation rate (bytes / second). Computed between the time of the last GC cycle 595 // and the start of the current one. 596 uint64_t allocation_rate_; 597 598 // For a GC cycle, a bitmap that is set corresponding to the 599 UniquePtr<accounting::HeapBitmap> live_bitmap_ GUARDED_BY(Locks::heap_bitmap_lock_); 600 UniquePtr<accounting::HeapBitmap> mark_bitmap_ GUARDED_BY(Locks::heap_bitmap_lock_); 601 602 // Mark stack that we reuse to avoid re-allocating the mark stack. 603 UniquePtr<accounting::ObjectStack> mark_stack_; 604 605 // Allocation stack, new allocations go here so that we can do sticky mark bits. This enables us 606 // to use the live bitmap as the old mark bitmap. 607 const size_t max_allocation_stack_size_; 608 bool is_allocation_stack_sorted_; 609 UniquePtr<accounting::ObjectStack> allocation_stack_; 610 611 // Second allocation stack so that we can process allocation with the heap unlocked. 612 UniquePtr<accounting::ObjectStack> live_stack_; 613 614 // offset of java.lang.ref.Reference.referent 615 MemberOffset reference_referent_offset_; 616 617 // offset of java.lang.ref.Reference.queue 618 MemberOffset reference_queue_offset_; 619 620 // offset of java.lang.ref.Reference.queueNext 621 MemberOffset reference_queueNext_offset_; 622 623 // offset of java.lang.ref.Reference.pendingNext 624 MemberOffset reference_pendingNext_offset_; 625 626 // offset of java.lang.ref.FinalizerReference.zombie 627 MemberOffset finalizer_reference_zombie_offset_; 628 629 // Minimum free guarantees that you always have at least min_free_ free bytes after growing for 630 // utilization, regardless of target utilization ratio. 631 size_t min_free_; 632 633 // The ideal maximum free size, when we grow the heap for utilization. 634 size_t max_free_; 635 636 // Target ideal heap utilization ratio 637 double target_utilization_; 638 639 // Total time which mutators are paused or waiting for GC to complete. 640 uint64_t total_wait_time_; 641 642 // Total number of objects allocated in microseconds. 643 const bool measure_allocation_time_; 644 AtomicInteger total_allocation_time_; 645 646 // The current state of heap verification, may be enabled or disabled. 647 HeapVerificationMode verify_object_mode_; 648 649 std::vector<collector::MarkSweep*> mark_sweep_collectors_; 650 651 friend class collector::MarkSweep; 652 friend class VerifyReferenceCardVisitor; 653 friend class VerifyReferenceVisitor; 654 friend class VerifyObjectVisitor; 655 friend class ScopedHeapLock; 656 friend class space::SpaceTest; 657 658 DISALLOW_IMPLICIT_CONSTRUCTORS(Heap); 659}; 660 661} // namespace gc 662} // namespace art 663 664#endif // ART_RUNTIME_GC_HEAP_H_ 665