Some heap cleanup
Bug: 19534862
Change-Id: Ia63f489d26ec8813a263ce877bdbbc8c4e8fe5f4
diff --git a/runtime/gc/collector/concurrent_copying.cc b/runtime/gc/collector/concurrent_copying.cc
index ec689f8..8e329d6 100644
--- a/runtime/gc/collector/concurrent_copying.cc
+++ b/runtime/gc/collector/concurrent_copying.cc
@@ -229,7 +229,7 @@
CHECK(thread == self);
Locks::mutator_lock_->AssertExclusiveHeld(self);
cc->region_space_->SetFromSpace(cc->rb_table_, cc->force_evacuate_all_);
- cc->SwapStacks(self);
+ cc->SwapStacks();
if (ConcurrentCopying::kEnableFromSpaceAccountingCheck) {
cc->RecordLiveStackFreezeSize(self);
cc->from_space_num_objects_at_first_pause_ = cc->region_space_->GetObjectsAllocated();
@@ -275,8 +275,8 @@
}
}
-void ConcurrentCopying::SwapStacks(Thread* self) {
- heap_->SwapStacks(self);
+void ConcurrentCopying::SwapStacks() {
+ heap_->SwapStacks();
}
void ConcurrentCopying::RecordLiveStackFreezeSize(Thread* self) {
diff --git a/runtime/gc/collector/concurrent_copying.h b/runtime/gc/collector/concurrent_copying.h
index a4fd71c..f382448 100644
--- a/runtime/gc/collector/concurrent_copying.h
+++ b/runtime/gc/collector/concurrent_copying.h
@@ -172,7 +172,7 @@
mirror::Object* GetFwdPtr(mirror::Object* from_ref)
SHARED_REQUIRES(Locks::mutator_lock_);
void FlipThreadRoots() REQUIRES(!Locks::mutator_lock_);
- void SwapStacks(Thread* self) SHARED_REQUIRES(Locks::mutator_lock_);
+ void SwapStacks() SHARED_REQUIRES(Locks::mutator_lock_);
void RecordLiveStackFreezeSize(Thread* self);
void ComputeUnevacFromSpaceLiveRatio();
void LogFromSpaceRefHolder(mirror::Object* obj, MemberOffset offset)
diff --git a/runtime/gc/collector/mark_compact.cc b/runtime/gc/collector/mark_compact.cc
index 4b2c588..94ffe6e 100644
--- a/runtime/gc/collector/mark_compact.cc
+++ b/runtime/gc/collector/mark_compact.cc
@@ -191,7 +191,7 @@
heap_->RevokeAllThreadLocalAllocationStacks(self);
}
t.NewTiming("SwapStacks");
- heap_->SwapStacks(self);
+ heap_->SwapStacks();
{
WriterMutexLock mu(self, *Locks::heap_bitmap_lock_);
MarkRoots();
diff --git a/runtime/gc/collector/mark_sweep.cc b/runtime/gc/collector/mark_sweep.cc
index 7f2c204..e2bcca2 100644
--- a/runtime/gc/collector/mark_sweep.cc
+++ b/runtime/gc/collector/mark_sweep.cc
@@ -190,7 +190,7 @@
{
TimingLogger::ScopedTiming t2("SwapStacks", GetTimings());
WriterMutexLock mu(self, *Locks::heap_bitmap_lock_);
- heap_->SwapStacks(self);
+ heap_->SwapStacks();
live_stack_freeze_size_ = heap_->GetLiveStack()->Size();
// Need to revoke all the thread local allocation stacks since we just swapped the allocation
// stacks and don't want anybody to allocate into the live stack.
diff --git a/runtime/gc/collector/semi_space.cc b/runtime/gc/collector/semi_space.cc
index 63def24..c11c134 100644
--- a/runtime/gc/collector/semi_space.cc
+++ b/runtime/gc/collector/semi_space.cc
@@ -226,7 +226,7 @@
TimingLogger::ScopedTiming t2("RevokeAllThreadLocalAllocationStacks", GetTimings());
heap_->RevokeAllThreadLocalAllocationStacks(self_);
}
- heap_->SwapStacks(self_);
+ heap_->SwapStacks();
{
WriterMutexLock mu(self_, *Locks::heap_bitmap_lock_);
MarkRoots();
diff --git a/runtime/gc/heap-inl.h b/runtime/gc/heap-inl.h
index cb750eb..b814432 100644
--- a/runtime/gc/heap-inl.h
+++ b/runtime/gc/heap-inl.h
@@ -39,8 +39,10 @@
namespace gc {
template <bool kInstrumented, bool kCheckLargeObject, typename PreFenceVisitor>
-inline mirror::Object* Heap::AllocObjectWithAllocator(Thread* self, mirror::Class* klass,
- size_t byte_count, AllocatorType allocator,
+inline mirror::Object* Heap::AllocObjectWithAllocator(Thread* self,
+ mirror::Class* klass,
+ size_t byte_count,
+ AllocatorType allocator,
const PreFenceVisitor& pre_fence_visitor) {
if (kIsDebugBuild) {
CheckPreconditionsForAllocObject(klass, byte_count);
@@ -209,7 +211,8 @@
}
template <bool kInstrumented, typename PreFenceVisitor>
-inline mirror::Object* Heap::AllocLargeObject(Thread* self, mirror::Class** klass,
+inline mirror::Object* Heap::AllocLargeObject(Thread* self,
+ mirror::Class** klass,
size_t byte_count,
const PreFenceVisitor& pre_fence_visitor) {
// Save and restore the class in case it moves.
@@ -221,11 +224,14 @@
}
template <const bool kInstrumented, const bool kGrow>
-inline mirror::Object* Heap::TryToAllocate(Thread* self, AllocatorType allocator_type,
- size_t alloc_size, size_t* bytes_allocated,
+inline mirror::Object* Heap::TryToAllocate(Thread* self,
+ AllocatorType allocator_type,
+ size_t alloc_size,
+ size_t* bytes_allocated,
size_t* usable_size,
size_t* bytes_tl_bulk_allocated) {
- if (allocator_type != kAllocatorTypeTLAB && allocator_type != kAllocatorTypeRegionTLAB &&
+ if (allocator_type != kAllocatorTypeTLAB &&
+ allocator_type != kAllocatorTypeRegionTLAB &&
allocator_type != kAllocatorTypeRosAlloc &&
UNLIKELY(IsOutOfMemoryOnAllocation<kGrow>(allocator_type, alloc_size))) {
return nullptr;
@@ -390,7 +396,8 @@
// Only if the allocation succeeded, record the time.
if (allocated_obj != nullptr) {
uint64_t allocation_end_time = NanoTime() / kTimeAdjust;
- heap_->total_allocation_time_.FetchAndAddSequentiallyConsistent(allocation_end_time - allocation_start_time_);
+ heap_->total_allocation_time_.FetchAndAddSequentiallyConsistent(
+ allocation_end_time - allocation_start_time_);
}
}
}
@@ -423,7 +430,8 @@
return false;
}
-inline void Heap::CheckConcurrentGC(Thread* self, size_t new_num_bytes_allocated,
+inline void Heap::CheckConcurrentGC(Thread* self,
+ size_t new_num_bytes_allocated,
mirror::Object** obj) {
if (UNLIKELY(new_num_bytes_allocated >= concurrent_start_bytes_)) {
RequestConcurrentGCAndSaveObject(self, false, obj);
diff --git a/runtime/gc/heap.cc b/runtime/gc/heap.cc
index e9d9065..141fed2 100644
--- a/runtime/gc/heap.cc
+++ b/runtime/gc/heap.cc
@@ -113,18 +113,34 @@
// timeout on how long we wait for finalizers to run. b/21544853
static constexpr uint64_t kNativeAllocationFinalizeTimeout = MsToNs(250u);
-Heap::Heap(size_t initial_size, size_t growth_limit, size_t min_free, size_t max_free,
- double target_utilization, double foreground_heap_growth_multiplier,
- size_t capacity, size_t non_moving_space_capacity, const std::string& image_file_name,
- const InstructionSet image_instruction_set, CollectorType foreground_collector_type,
+Heap::Heap(size_t initial_size,
+ size_t growth_limit,
+ size_t min_free,
+ size_t max_free,
+ double target_utilization,
+ double foreground_heap_growth_multiplier,
+ size_t capacity,
+ size_t non_moving_space_capacity,
+ const std::string& image_file_name,
+ const InstructionSet image_instruction_set,
+ CollectorType foreground_collector_type,
CollectorType background_collector_type,
- space::LargeObjectSpaceType large_object_space_type, size_t large_object_threshold,
- size_t parallel_gc_threads, size_t conc_gc_threads, bool low_memory_mode,
- size_t long_pause_log_threshold, size_t long_gc_log_threshold,
- bool ignore_max_footprint, bool use_tlab,
- bool verify_pre_gc_heap, bool verify_pre_sweeping_heap, bool verify_post_gc_heap,
- bool verify_pre_gc_rosalloc, bool verify_pre_sweeping_rosalloc,
- bool verify_post_gc_rosalloc, bool gc_stress_mode,
+ space::LargeObjectSpaceType large_object_space_type,
+ size_t large_object_threshold,
+ size_t parallel_gc_threads,
+ size_t conc_gc_threads,
+ bool low_memory_mode,
+ size_t long_pause_log_threshold,
+ size_t long_gc_log_threshold,
+ bool ignore_max_footprint,
+ bool use_tlab,
+ bool verify_pre_gc_heap,
+ bool verify_pre_sweeping_heap,
+ bool verify_post_gc_heap,
+ bool verify_pre_gc_rosalloc,
+ bool verify_pre_sweeping_rosalloc,
+ bool verify_post_gc_rosalloc,
+ bool gc_stress_mode,
bool use_homogeneous_space_compaction_for_oom,
uint64_t min_interval_homogeneous_space_compaction_by_oom)
: non_moving_space_(nullptr),
@@ -526,8 +542,10 @@
}
}
-MemMap* Heap::MapAnonymousPreferredAddress(const char* name, uint8_t* request_begin,
- size_t capacity, std::string* out_error_str) {
+MemMap* Heap::MapAnonymousPreferredAddress(const char* name,
+ uint8_t* request_begin,
+ size_t capacity,
+ std::string* out_error_str) {
while (true) {
MemMap* map = MemMap::MapAnonymous(name, request_begin, capacity,
PROT_READ | PROT_WRITE, true, false, out_error_str);
@@ -543,9 +561,12 @@
return foreground_collector_type_ == type || background_collector_type_ == type;
}
-space::MallocSpace* Heap::CreateMallocSpaceFromMemMap(MemMap* mem_map, size_t initial_size,
- size_t growth_limit, size_t capacity,
- const char* name, bool can_move_objects) {
+space::MallocSpace* Heap::CreateMallocSpaceFromMemMap(MemMap* mem_map,
+ size_t initial_size,
+ size_t growth_limit,
+ size_t capacity,
+ const char* name,
+ bool can_move_objects) {
space::MallocSpace* malloc_space = nullptr;
if (kUseRosAlloc) {
// Create rosalloc space.
@@ -1494,8 +1515,10 @@
return nullptr;
}
-mirror::Object* Heap::AllocateInternalWithGc(Thread* self, AllocatorType allocator,
- size_t alloc_size, size_t* bytes_allocated,
+mirror::Object* Heap::AllocateInternalWithGc(Thread* self,
+ AllocatorType allocator,
+ size_t alloc_size,
+ size_t* bytes_allocated,
size_t* usable_size,
size_t* bytes_tl_bulk_allocated,
mirror::Class** klass) {
@@ -1694,10 +1717,12 @@
class InstanceCounter {
public:
- InstanceCounter(const std::vector<mirror::Class*>& classes, bool use_is_assignable_from, uint64_t* counts)
+ InstanceCounter(const std::vector<mirror::Class*>& classes,
+ bool use_is_assignable_from,
+ uint64_t* counts)
SHARED_REQUIRES(Locks::mutator_lock_)
- : classes_(classes), use_is_assignable_from_(use_is_assignable_from), counts_(counts) {
- }
+ : classes_(classes), use_is_assignable_from_(use_is_assignable_from), counts_(counts) {}
+
static void Callback(mirror::Object* obj, void* arg)
SHARED_REQUIRES(Locks::mutator_lock_, Locks::heap_bitmap_lock_) {
InstanceCounter* instance_counter = reinterpret_cast<InstanceCounter*>(arg);
@@ -1753,7 +1778,8 @@
DISALLOW_COPY_AND_ASSIGN(InstanceCollector);
};
-void Heap::GetInstances(mirror::Class* c, int32_t max_count,
+void Heap::GetInstances(mirror::Class* c,
+ int32_t max_count,
std::vector<mirror::Object*>& instances) {
InstanceCollector collector(c, max_count, instances);
VisitObjects(&InstanceCollector::Callback, &collector);
@@ -1761,7 +1787,8 @@
class ReferringObjectsFinder {
public:
- ReferringObjectsFinder(mirror::Object* object, int32_t max_count,
+ ReferringObjectsFinder(mirror::Object* object,
+ int32_t max_count,
std::vector<mirror::Object*>& referring_objects)
SHARED_REQUIRES(Locks::mutator_lock_)
: object_(object), max_count_(max_count), referring_objects_(referring_objects) {
@@ -2081,8 +2108,7 @@
// Special compacting collector which uses sub-optimal bin packing to reduce zygote space size.
class ZygoteCompactingCollector FINAL : public collector::SemiSpace {
public:
- explicit ZygoteCompactingCollector(gc::Heap* heap,
- bool is_running_on_memory_tool)
+ explicit ZygoteCompactingCollector(gc::Heap* heap, bool is_running_on_memory_tool)
: SemiSpace(heap, false, "zygote collector"),
bin_live_bitmap_(nullptr),
bin_mark_bitmap_(nullptr),
@@ -2135,10 +2161,9 @@
}
}
- virtual bool ShouldSweepSpace(space::ContinuousSpace* space) const {
+ virtual bool ShouldSweepSpace(space::ContinuousSpace* space ATTRIBUTE_UNUSED) const {
// Don't sweep any spaces since we probably blasted the internal accounting of the free list
// allocator.
- UNUSED(space);
return false;
}
@@ -2380,7 +2405,8 @@
}
}
-collector::GcType Heap::CollectGarbageInternal(collector::GcType gc_type, GcCause gc_cause,
+collector::GcType Heap::CollectGarbageInternal(collector::GcType gc_type,
+ GcCause gc_cause,
bool clear_soft_references) {
Thread* self = Thread::Current();
Runtime* runtime = Runtime::Current();
@@ -2759,8 +2785,7 @@
class VerifyObjectVisitor {
public:
explicit VerifyObjectVisitor(Heap* heap, Atomic<size_t>* fail_count, bool verify_referent)
- : heap_(heap), fail_count_(fail_count), verify_referent_(verify_referent) {
- }
+ : heap_(heap), fail_count_(fail_count), verify_referent_(verify_referent) {}
void operator()(mirror::Object* obj)
SHARED_REQUIRES(Locks::mutator_lock_, Locks::heap_bitmap_lock_) {
@@ -2980,8 +3005,7 @@
return !visitor.Failed();
}
-void Heap::SwapStacks(Thread* self) {
- UNUSED(self);
+void Heap::SwapStacks() {
if (kUseThreadLocalAllocationStack) {
live_stack_->AssertAllZero();
}
@@ -3034,7 +3058,9 @@
return it->second;
}
-void Heap::ProcessCards(TimingLogger* timings, bool use_rem_sets, bool process_alloc_space_cards,
+void Heap::ProcessCards(TimingLogger* timings,
+ bool use_rem_sets,
+ bool process_alloc_space_cards,
bool clear_alloc_space_cards) {
TimingLogger::ScopedTiming t(__FUNCTION__, timings);
// Clear cards and keep track of cards cleared in the mod-union table.
@@ -3094,11 +3120,11 @@
if (verify_missing_card_marks_) {
TimingLogger::ScopedTiming t2("(Paused)PreGcVerifyMissingCardMarks", timings);
ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
- SwapStacks(self);
+ SwapStacks();
// Sort the live stack so that we can quickly binary search it later.
CHECK(VerifyMissingCardMarks()) << "Pre " << gc->GetName()
<< " missing card mark verification failed\n" << DumpSpaces();
- SwapStacks(self);
+ SwapStacks();
}
if (verify_mod_union_table_) {
TimingLogger::ScopedTiming t2("(Paused)PreGcVerifyModUnionTables", timings);
@@ -3119,8 +3145,7 @@
}
}
-void Heap::PrePauseRosAllocVerification(collector::GarbageCollector* gc) {
- UNUSED(gc);
+void Heap::PrePauseRosAllocVerification(collector::GarbageCollector* gc ATTRIBUTE_UNUSED) {
// TODO: Add a new runtime option for this?
if (verify_pre_gc_rosalloc_) {
RosAllocVerification(current_gc_iteration_.GetTimings(), "PreGcRosAllocVerification");
@@ -3486,7 +3511,8 @@
class Heap::CollectorTransitionTask : public HeapTask {
public:
- explicit CollectorTransitionTask(uint64_t target_time) : HeapTask(target_time) { }
+ explicit CollectorTransitionTask(uint64_t target_time) : HeapTask(target_time) {}
+
virtual void Run(Thread* self) OVERRIDE {
gc::Heap* heap = Runtime::Current()->GetHeap();
heap->DoPendingCollectorTransition();
diff --git a/runtime/gc/heap.h b/runtime/gc/heap.h
index 09c18b8..6676049 100644
--- a/runtime/gc/heap.h
+++ b/runtime/gc/heap.h
@@ -96,11 +96,7 @@
class AgeCardVisitor {
public:
uint8_t operator()(uint8_t card) const {
- if (card == accounting::CardTable::kCardDirty) {
- return card - 1;
- } else {
- return 0;
- }
+ return (card == accounting::CardTable::kCardDirty) ? card - 1 : 0;
}
};
@@ -165,20 +161,34 @@
// Create a heap with the requested sizes. The possible empty
// image_file_names names specify Spaces to load based on
// ImageWriter output.
- explicit Heap(size_t initial_size, size_t growth_limit, size_t min_free,
- size_t max_free, double target_utilization,
- double foreground_heap_growth_multiplier, size_t capacity,
+ explicit Heap(size_t initial_size,
+ size_t growth_limit,
+ size_t min_free,
+ size_t max_free,
+ double target_utilization,
+ double foreground_heap_growth_multiplier,
+ size_t capacity,
size_t non_moving_space_capacity,
const std::string& original_image_file_name,
InstructionSet image_instruction_set,
- CollectorType foreground_collector_type, CollectorType background_collector_type,
- space::LargeObjectSpaceType large_object_space_type, size_t large_object_threshold,
- size_t parallel_gc_threads, size_t conc_gc_threads, bool low_memory_mode,
- size_t long_pause_threshold, size_t long_gc_threshold,
- bool ignore_max_footprint, bool use_tlab,
- bool verify_pre_gc_heap, bool verify_pre_sweeping_heap, bool verify_post_gc_heap,
- bool verify_pre_gc_rosalloc, bool verify_pre_sweeping_rosalloc,
- bool verify_post_gc_rosalloc, bool gc_stress_mode,
+ CollectorType foreground_collector_type,
+ CollectorType background_collector_type,
+ space::LargeObjectSpaceType large_object_space_type,
+ size_t large_object_threshold,
+ size_t parallel_gc_threads,
+ size_t conc_gc_threads,
+ bool low_memory_mode,
+ size_t long_pause_threshold,
+ size_t long_gc_threshold,
+ bool ignore_max_footprint,
+ bool use_tlab,
+ bool verify_pre_gc_heap,
+ bool verify_pre_sweeping_heap,
+ bool verify_post_gc_heap,
+ bool verify_pre_gc_rosalloc,
+ bool verify_pre_sweeping_rosalloc,
+ bool verify_post_gc_rosalloc,
+ bool gc_stress_mode,
bool use_homogeneous_space_compaction,
uint64_t min_interval_homogeneous_space_compaction_by_oom);
@@ -186,7 +196,9 @@
// Allocates and initializes storage for an object instance.
template <bool kInstrumented, typename PreFenceVisitor>
- mirror::Object* AllocObject(Thread* self, mirror::Class* klass, size_t num_bytes,
+ mirror::Object* AllocObject(Thread* self,
+ mirror::Class* klass,
+ size_t num_bytes,
const PreFenceVisitor& pre_fence_visitor)
SHARED_REQUIRES(Locks::mutator_lock_)
REQUIRES(!*gc_complete_lock_, !*pending_task_lock_, !*backtrace_lock_,
@@ -196,7 +208,9 @@
}
template <bool kInstrumented, typename PreFenceVisitor>
- mirror::Object* AllocNonMovableObject(Thread* self, mirror::Class* klass, size_t num_bytes,
+ mirror::Object* AllocNonMovableObject(Thread* self,
+ mirror::Class* klass,
+ size_t num_bytes,
const PreFenceVisitor& pre_fence_visitor)
SHARED_REQUIRES(Locks::mutator_lock_)
REQUIRES(!*gc_complete_lock_, !*pending_task_lock_, !*backtrace_lock_,
@@ -206,9 +220,11 @@
}
template <bool kInstrumented, bool kCheckLargeObject, typename PreFenceVisitor>
- ALWAYS_INLINE mirror::Object* AllocObjectWithAllocator(
- Thread* self, mirror::Class* klass, size_t byte_count, AllocatorType allocator,
- const PreFenceVisitor& pre_fence_visitor)
+ ALWAYS_INLINE mirror::Object* AllocObjectWithAllocator(Thread* self,
+ mirror::Class* klass,
+ size_t byte_count,
+ AllocatorType allocator,
+ const PreFenceVisitor& pre_fence_visitor)
SHARED_REQUIRES(Locks::mutator_lock_)
REQUIRES(!*gc_complete_lock_, !*pending_task_lock_, !*backtrace_lock_,
!Roles::uninterruptible_);
@@ -263,8 +279,7 @@
// A weaker test than IsLiveObject or VerifyObject that doesn't require the heap lock,
// and doesn't abort on error, allowing the caller to report more
// meaningful diagnostics.
- bool IsValidObjectAddress(const mirror::Object* obj) const
- SHARED_REQUIRES(Locks::mutator_lock_);
+ bool IsValidObjectAddress(const mirror::Object* obj) const SHARED_REQUIRES(Locks::mutator_lock_);
// Faster alternative to IsHeapAddress since finding if an object is in the large object space is
// very slow.
@@ -273,8 +288,10 @@
// Returns true if 'obj' is a live heap object, false otherwise (including for invalid addresses).
// Requires the heap lock to be held.
- bool IsLiveObjectLocked(mirror::Object* obj, bool search_allocation_stack = true,
- bool search_live_stack = true, bool sorted = false)
+ bool IsLiveObjectLocked(mirror::Object* obj,
+ bool search_allocation_stack = true,
+ bool search_live_stack = true,
+ bool sorted = false)
SHARED_REQUIRES(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
// Returns true if there is any chance that the object (obj) will move.
@@ -298,7 +315,8 @@
// Implements VMDebug.countInstancesOfClass and JDWP VM_InstanceCount.
// The boolean decides whether to use IsAssignableFrom or == when comparing classes.
- void CountInstances(const std::vector<mirror::Class*>& classes, bool use_is_assignable_from,
+ void CountInstances(const std::vector<mirror::Class*>& classes,
+ bool use_is_assignable_from,
uint64_t* counts)
REQUIRES(!Locks::heap_bitmap_lock_, !*gc_complete_lock_)
SHARED_REQUIRES(Locks::mutator_lock_);
@@ -307,7 +325,8 @@
REQUIRES(!Locks::heap_bitmap_lock_, !*gc_complete_lock_)
SHARED_REQUIRES(Locks::mutator_lock_);
// Implements JDWP OR_ReferringObjects.
- void GetReferringObjects(mirror::Object* o, int32_t max_count,
+ void GetReferringObjects(mirror::Object* o,
+ int32_t max_count,
std::vector<mirror::Object*>& referring_objects)
REQUIRES(!Locks::heap_bitmap_lock_, !*gc_complete_lock_)
SHARED_REQUIRES(Locks::mutator_lock_);
@@ -347,8 +366,7 @@
// Blocks the caller until the garbage collector becomes idle and returns the type of GC we
// waited for.
- collector::GcType WaitForGcToComplete(GcCause cause, Thread* self)
- REQUIRES(!*gc_complete_lock_);
+ collector::GcType WaitForGcToComplete(GcCause cause, Thread* self) REQUIRES(!*gc_complete_lock_);
// Update the heap's process state to a new value, may cause compaction to occur.
void UpdateProcessState(ProcessState process_state)
@@ -405,14 +423,17 @@
// Must be called if a field of an Object in the heap changes, and before any GC safe-point.
// The call is not needed if null is stored in the field.
- ALWAYS_INLINE void WriteBarrierField(const mirror::Object* dst, MemberOffset /*offset*/,
- const mirror::Object* /*new_value*/) {
+ ALWAYS_INLINE void WriteBarrierField(const mirror::Object* dst,
+ MemberOffset offset ATTRIBUTE_UNUSED,
+ const mirror::Object* new_value ATTRIBUTE_UNUSED) {
card_table_->MarkCard(dst);
}
// Write barrier for array operations that update many field positions
- ALWAYS_INLINE void WriteBarrierArray(const mirror::Object* dst, int /*start_offset*/,
- size_t /*length TODO: element_count or byte_count?*/) {
+ ALWAYS_INLINE void WriteBarrierArray(const mirror::Object* dst,
+ int start_offset ATTRIBUTE_UNUSED,
+ // TODO: element_count or byte_count?
+ size_t length ATTRIBUTE_UNUSED) {
card_table_->MarkCard(dst);
}
@@ -436,7 +457,8 @@
}
// Returns the number of objects currently allocated.
- size_t GetObjectsAllocated() const REQUIRES(!Locks::heap_bitmap_lock_);
+ size_t GetObjectsAllocated() const
+ REQUIRES(!Locks::heap_bitmap_lock_);
// Returns the total number of objects allocated since the heap was created.
uint64_t GetObjectsAllocatedEver() const;
@@ -540,11 +562,13 @@
accounting::SpaceBitmap<kObjectAlignment>* bitmap2,
accounting::SpaceBitmap<kLargeObjectAlignment>* large_objects,
accounting::ObjectStack* stack)
- SHARED_REQUIRES(Locks::mutator_lock_) REQUIRES(Locks::heap_bitmap_lock_);
+ SHARED_REQUIRES(Locks::mutator_lock_)
+ REQUIRES(Locks::heap_bitmap_lock_);
// Mark the specified allocation stack as live.
void MarkAllocStackAsLive(accounting::ObjectStack* stack)
- SHARED_REQUIRES(Locks::mutator_lock_) REQUIRES(Locks::heap_bitmap_lock_);
+ SHARED_REQUIRES(Locks::mutator_lock_)
+ REQUIRES(Locks::heap_bitmap_lock_);
// Unbind any bound bitmaps.
void UnBindBitmaps() REQUIRES(Locks::heap_bitmap_lock_);
@@ -758,15 +782,20 @@
allocator_type != kAllocatorTypeTLAB;
}
static bool IsMovingGc(CollectorType collector_type) {
- return collector_type == kCollectorTypeSS || collector_type == kCollectorTypeGSS ||
- collector_type == kCollectorTypeCC || collector_type == kCollectorTypeMC ||
+ return
+ collector_type == kCollectorTypeSS ||
+ collector_type == kCollectorTypeGSS ||
+ collector_type == kCollectorTypeCC ||
+ collector_type == kCollectorTypeMC ||
collector_type == kCollectorTypeHomogeneousSpaceCompact;
}
bool ShouldAllocLargeObject(mirror::Class* c, size_t byte_count) const
SHARED_REQUIRES(Locks::mutator_lock_);
- ALWAYS_INLINE void CheckConcurrentGC(Thread* self, size_t new_num_bytes_allocated,
+ ALWAYS_INLINE void CheckConcurrentGC(Thread* self,
+ size_t new_num_bytes_allocated,
mirror::Object** obj)
- SHARED_REQUIRES(Locks::mutator_lock_) REQUIRES(!*pending_task_lock_, !*gc_complete_lock_);
+ SHARED_REQUIRES(Locks::mutator_lock_)
+ REQUIRES(!*pending_task_lock_, !*gc_complete_lock_);
accounting::ObjectStack* GetMarkStack() {
return mark_stack_.get();
@@ -774,22 +803,29 @@
// We don't force this to be inlined since it is a slow path.
template <bool kInstrumented, typename PreFenceVisitor>
- mirror::Object* AllocLargeObject(Thread* self, mirror::Class** klass, size_t byte_count,
+ mirror::Object* AllocLargeObject(Thread* self,
+ mirror::Class** klass,
+ size_t byte_count,
const PreFenceVisitor& pre_fence_visitor)
SHARED_REQUIRES(Locks::mutator_lock_)
REQUIRES(!*gc_complete_lock_, !*pending_task_lock_, !*backtrace_lock_);
// Handles Allocate()'s slow allocation path with GC involved after
// an initial allocation attempt failed.
- mirror::Object* AllocateInternalWithGc(Thread* self, AllocatorType allocator, size_t num_bytes,
- size_t* bytes_allocated, size_t* usable_size,
+ mirror::Object* AllocateInternalWithGc(Thread* self,
+ AllocatorType allocator,
+ size_t num_bytes,
+ size_t* bytes_allocated,
+ size_t* usable_size,
size_t* bytes_tl_bulk_allocated,
mirror::Class** klass)
REQUIRES(!Locks::thread_suspend_count_lock_, !*gc_complete_lock_, !*pending_task_lock_)
SHARED_REQUIRES(Locks::mutator_lock_);
// Allocate into a specific space.
- mirror::Object* AllocateInto(Thread* self, space::AllocSpace* space, mirror::Class* c,
+ mirror::Object* AllocateInto(Thread* self,
+ space::AllocSpace* space,
+ mirror::Class* c,
size_t bytes)
SHARED_REQUIRES(Locks::mutator_lock_);
@@ -800,8 +836,10 @@
// Try to allocate a number of bytes, this function never does any GCs. Needs to be inlined so
// that the switch statement is constant optimized in the entrypoints.
template <const bool kInstrumented, const bool kGrow>
- ALWAYS_INLINE mirror::Object* TryToAllocate(Thread* self, AllocatorType allocator_type,
- size_t alloc_size, size_t* bytes_allocated,
+ ALWAYS_INLINE mirror::Object* TryToAllocate(Thread* self,
+ AllocatorType allocator_type,
+ size_t alloc_size,
+ size_t* bytes_allocated,
size_t* usable_size,
size_t* bytes_tl_bulk_allocated)
SHARED_REQUIRES(Locks::mutator_lock_);
@@ -828,12 +866,14 @@
REQUIRES(!*pending_task_lock_);
void RequestConcurrentGCAndSaveObject(Thread* self, bool force_full, mirror::Object** obj)
- SHARED_REQUIRES(Locks::mutator_lock_) REQUIRES(!*pending_task_lock_);
+ SHARED_REQUIRES(Locks::mutator_lock_)
+ REQUIRES(!*pending_task_lock_);
bool IsGCRequestPending() const;
// Sometimes CollectGarbageInternal decides to run a different Gc than you requested. Returns
// which type of Gc was actually ran.
- collector::GcType CollectGarbageInternal(collector::GcType gc_plan, GcCause gc_cause,
+ collector::GcType CollectGarbageInternal(collector::GcType gc_plan,
+ GcCause gc_cause,
bool clear_soft_references)
REQUIRES(!*gc_complete_lock_, !Locks::heap_bitmap_lock_, !Locks::thread_suspend_count_lock_,
!*pending_task_lock_);
@@ -862,13 +902,18 @@
HomogeneousSpaceCompactResult PerformHomogeneousSpaceCompact() REQUIRES(!*gc_complete_lock_);
// Create the main free list malloc space, either a RosAlloc space or DlMalloc space.
- void CreateMainMallocSpace(MemMap* mem_map, size_t initial_size, size_t growth_limit,
+ void CreateMainMallocSpace(MemMap* mem_map,
+ size_t initial_size,
+ size_t growth_limit,
size_t capacity);
// Create a malloc space based on a mem map. Does not set the space as default.
- space::MallocSpace* CreateMallocSpaceFromMemMap(MemMap* mem_map, size_t initial_size,
- size_t growth_limit, size_t capacity,
- const char* name, bool can_move_objects);
+ space::MallocSpace* CreateMallocSpaceFromMemMap(MemMap* mem_map,
+ size_t initial_size,
+ size_t growth_limit,
+ size_t capacity,
+ const char* name,
+ bool can_move_objects);
// Given the current contents of the alloc space, increase the allowed heap footprint to match
// the target utilization ratio. This should only be called immediately after a full garbage
@@ -883,21 +928,26 @@
SHARED_REQUIRES(Locks::heap_bitmap_lock_);
// Swap the allocation stack with the live stack.
- void SwapStacks(Thread* self) SHARED_REQUIRES(Locks::mutator_lock_);
+ void SwapStacks() SHARED_REQUIRES(Locks::mutator_lock_);
// Clear cards and update the mod union table. When process_alloc_space_cards is true,
// if clear_alloc_space_cards is true, then we clear cards instead of ageing them. We do
// not process the alloc space if process_alloc_space_cards is false.
- void ProcessCards(TimingLogger* timings, bool use_rem_sets, bool process_alloc_space_cards,
+ void ProcessCards(TimingLogger* timings,
+ bool use_rem_sets,
+ bool process_alloc_space_cards,
bool clear_alloc_space_cards);
// Push an object onto the allocation stack.
void PushOnAllocationStack(Thread* self, mirror::Object** obj)
- SHARED_REQUIRES(Locks::mutator_lock_) REQUIRES(!*gc_complete_lock_, !*pending_task_lock_);
+ SHARED_REQUIRES(Locks::mutator_lock_)
+ REQUIRES(!*gc_complete_lock_, !*pending_task_lock_);
void PushOnAllocationStackWithInternalGC(Thread* self, mirror::Object** obj)
- SHARED_REQUIRES(Locks::mutator_lock_) REQUIRES(!*gc_complete_lock_, !*pending_task_lock_);
+ SHARED_REQUIRES(Locks::mutator_lock_)
+ REQUIRES(!*gc_complete_lock_, !*pending_task_lock_);
void PushOnThreadLocalAllocationStackWithInternalGC(Thread* thread, mirror::Object** obj)
- SHARED_REQUIRES(Locks::mutator_lock_) REQUIRES(!*gc_complete_lock_, !*pending_task_lock_);
+ SHARED_REQUIRES(Locks::mutator_lock_)
+ REQUIRES(!*gc_complete_lock_, !*pending_task_lock_);
void ClearConcurrentGCRequest();
void ClearPendingTrim(Thread* self) REQUIRES(!*pending_task_lock_);
@@ -1257,7 +1307,6 @@
friend class VerifyReferenceCardVisitor;
friend class VerifyReferenceVisitor;
friend class VerifyObjectVisitor;
- friend class ScopedHeapFill;
friend class space::SpaceTest;
class AllocationTimer {