1 /*
2  * Copyright (C) 2012 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 #include <stdio.h>
18 
19 #include "garbage_collector.h"
20 
21 #include "base/dumpable.h"
22 #include "base/histogram-inl.h"
23 #include "base/logging.h"
24 #include "base/mutex-inl.h"
25 #include "base/systrace.h"
26 #include "base/time_utils.h"
27 #include "gc/accounting/heap_bitmap.h"
28 #include "gc/space/large_object_space.h"
29 #include "gc/space/space-inl.h"
30 #include "thread-inl.h"
31 #include "thread_list.h"
32 #include "utils.h"
33 
34 namespace art {
35 namespace gc {
36 namespace collector {
37 
Iteration()38 Iteration::Iteration()
39     : duration_ns_(0), timings_("GC iteration timing logger", true, VLOG_IS_ON(heap)) {
40   Reset(kGcCauseBackground, false);  // Reset to some place holder values.
41 }
42 
Reset(GcCause gc_cause,bool clear_soft_references)43 void Iteration::Reset(GcCause gc_cause, bool clear_soft_references) {
44   timings_.Reset();
45   pause_times_.clear();
46   duration_ns_ = 0;
47   clear_soft_references_ = clear_soft_references;
48   gc_cause_ = gc_cause;
49   freed_ = ObjectBytePair();
50   freed_los_ = ObjectBytePair();
51   freed_bytes_revoke_ = 0;
52 }
53 
GetEstimatedThroughput() const54 uint64_t Iteration::GetEstimatedThroughput() const {
55   // Add 1ms to prevent possible division by 0.
56   return (static_cast<uint64_t>(freed_.bytes) * 1000) / (NsToMs(GetDurationNs()) + 1);
57 }
58 
GarbageCollector(Heap * heap,const std::string & name)59 GarbageCollector::GarbageCollector(Heap* heap, const std::string& name)
60     : heap_(heap),
61       name_(name),
62       pause_histogram_((name_ + " paused").c_str(), kPauseBucketSize, kPauseBucketCount),
63       cumulative_timings_(name),
64       pause_histogram_lock_("pause histogram lock", kDefaultMutexLevel, true) {
65   ResetCumulativeStatistics();
66 }
67 
RegisterPause(uint64_t nano_length)68 void GarbageCollector::RegisterPause(uint64_t nano_length) {
69   GetCurrentIteration()->pause_times_.push_back(nano_length);
70 }
71 
ResetCumulativeStatistics()72 void GarbageCollector::ResetCumulativeStatistics() {
73   cumulative_timings_.Reset();
74   total_time_ns_ = 0;
75   total_freed_objects_ = 0;
76   total_freed_bytes_ = 0;
77   MutexLock mu(Thread::Current(), pause_histogram_lock_);
78   pause_histogram_.Reset();
79 }
80 
Run(GcCause gc_cause,bool clear_soft_references)81 void GarbageCollector::Run(GcCause gc_cause, bool clear_soft_references) {
82   ScopedTrace trace(StringPrintf("%s %s GC", PrettyCause(gc_cause), GetName()));
83   Thread* self = Thread::Current();
84   uint64_t start_time = NanoTime();
85   Iteration* current_iteration = GetCurrentIteration();
86   current_iteration->Reset(gc_cause, clear_soft_references);
87   RunPhases();  // Run all the GC phases.
88   // Add the current timings to the cumulative timings.
89   cumulative_timings_.AddLogger(*GetTimings());
90   // Update cumulative statistics with how many bytes the GC iteration freed.
91   total_freed_objects_ += current_iteration->GetFreedObjects() +
92       current_iteration->GetFreedLargeObjects();
93   total_freed_bytes_ += current_iteration->GetFreedBytes() +
94       current_iteration->GetFreedLargeObjectBytes();
95   uint64_t end_time = NanoTime();
96   current_iteration->SetDurationNs(end_time - start_time);
97   if (Locks::mutator_lock_->IsExclusiveHeld(self)) {
98     // The entire GC was paused, clear the fake pauses which might be in the pause times and add
99     // the whole GC duration.
100     current_iteration->pause_times_.clear();
101     RegisterPause(current_iteration->GetDurationNs());
102   }
103   total_time_ns_ += current_iteration->GetDurationNs();
104   for (uint64_t pause_time : current_iteration->GetPauseTimes()) {
105     MutexLock mu(self, pause_histogram_lock_);
106     pause_histogram_.AdjustAndAddValue(pause_time);
107   }
108 }
109 
SwapBitmaps()110 void GarbageCollector::SwapBitmaps() {
111   TimingLogger::ScopedTiming t(__FUNCTION__, GetTimings());
112   // Swap the live and mark bitmaps for each alloc space. This is needed since sweep re-swaps
113   // these bitmaps. The bitmap swapping is an optimization so that we do not need to clear the live
114   // bits of dead objects in the live bitmap.
115   const GcType gc_type = GetGcType();
116   for (const auto& space : GetHeap()->GetContinuousSpaces()) {
117     // We never allocate into zygote spaces.
118     if (space->GetGcRetentionPolicy() == space::kGcRetentionPolicyAlwaysCollect ||
119         (gc_type == kGcTypeFull &&
120          space->GetGcRetentionPolicy() == space::kGcRetentionPolicyFullCollect)) {
121       accounting::ContinuousSpaceBitmap* live_bitmap = space->GetLiveBitmap();
122       accounting::ContinuousSpaceBitmap* mark_bitmap = space->GetMarkBitmap();
123       if (live_bitmap != nullptr && live_bitmap != mark_bitmap) {
124         heap_->GetLiveBitmap()->ReplaceBitmap(live_bitmap, mark_bitmap);
125         heap_->GetMarkBitmap()->ReplaceBitmap(mark_bitmap, live_bitmap);
126         CHECK(space->IsContinuousMemMapAllocSpace());
127         space->AsContinuousMemMapAllocSpace()->SwapBitmaps();
128       }
129     }
130   }
131   for (const auto& disc_space : GetHeap()->GetDiscontinuousSpaces()) {
132     space::LargeObjectSpace* space = disc_space->AsLargeObjectSpace();
133     accounting::LargeObjectBitmap* live_set = space->GetLiveBitmap();
134     accounting::LargeObjectBitmap* mark_set = space->GetMarkBitmap();
135     heap_->GetLiveBitmap()->ReplaceLargeObjectBitmap(live_set, mark_set);
136     heap_->GetMarkBitmap()->ReplaceLargeObjectBitmap(mark_set, live_set);
137     space->SwapBitmaps();
138   }
139 }
140 
GetEstimatedMeanThroughput() const141 uint64_t GarbageCollector::GetEstimatedMeanThroughput() const {
142   // Add 1ms to prevent possible division by 0.
143   return (total_freed_bytes_ * 1000) / (NsToMs(GetCumulativeTimings().GetTotalNs()) + 1);
144 }
145 
ResetMeasurements()146 void GarbageCollector::ResetMeasurements() {
147   {
148     MutexLock mu(Thread::Current(), pause_histogram_lock_);
149     pause_histogram_.Reset();
150   }
151   cumulative_timings_.Reset();
152   total_time_ns_ = 0;
153   total_freed_objects_ = 0;
154   total_freed_bytes_ = 0;
155 }
156 
ScopedPause(GarbageCollector * collector)157 GarbageCollector::ScopedPause::ScopedPause(GarbageCollector* collector)
158     : start_time_(NanoTime()), collector_(collector) {
159   Runtime::Current()->GetThreadList()->SuspendAll(__FUNCTION__);
160 }
161 
~ScopedPause()162 GarbageCollector::ScopedPause::~ScopedPause() {
163   collector_->RegisterPause(NanoTime() - start_time_);
164   Runtime::Current()->GetThreadList()->ResumeAll();
165 }
166 
167 // Returns the current GC iteration and assocated info.
GetCurrentIteration()168 Iteration* GarbageCollector::GetCurrentIteration() {
169   return heap_->GetCurrentGcIteration();
170 }
GetCurrentIteration() const171 const Iteration* GarbageCollector::GetCurrentIteration() const {
172   return heap_->GetCurrentGcIteration();
173 }
174 
RecordFree(const ObjectBytePair & freed)175 void GarbageCollector::RecordFree(const ObjectBytePair& freed) {
176   GetCurrentIteration()->freed_.Add(freed);
177   heap_->RecordFree(freed.objects, freed.bytes);
178 }
RecordFreeLOS(const ObjectBytePair & freed)179 void GarbageCollector::RecordFreeLOS(const ObjectBytePair& freed) {
180   GetCurrentIteration()->freed_los_.Add(freed);
181   heap_->RecordFree(freed.objects, freed.bytes);
182 }
183 
GetTotalPausedTimeNs()184 uint64_t GarbageCollector::GetTotalPausedTimeNs() {
185   MutexLock mu(Thread::Current(), pause_histogram_lock_);
186   return pause_histogram_.AdjustedSum();
187 }
188 
DumpPerformanceInfo(std::ostream & os)189 void GarbageCollector::DumpPerformanceInfo(std::ostream& os) {
190   const CumulativeLogger& logger = GetCumulativeTimings();
191   const size_t iterations = logger.GetIterations();
192   if (iterations == 0) {
193     return;
194   }
195   os << Dumpable<CumulativeLogger>(logger);
196   const uint64_t total_ns = logger.GetTotalNs();
197   double seconds = NsToMs(logger.GetTotalNs()) / 1000.0;
198   const uint64_t freed_bytes = GetTotalFreedBytes();
199   const uint64_t freed_objects = GetTotalFreedObjects();
200   {
201     MutexLock mu(Thread::Current(), pause_histogram_lock_);
202     if (pause_histogram_.SampleSize() > 0) {
203       Histogram<uint64_t>::CumulativeData cumulative_data;
204       pause_histogram_.CreateHistogram(&cumulative_data);
205       pause_histogram_.PrintConfidenceIntervals(os, 0.99, cumulative_data);
206     }
207   }
208   os << GetName() << " total time: " << PrettyDuration(total_ns)
209      << " mean time: " << PrettyDuration(total_ns / iterations) << "\n"
210      << GetName() << " freed: " << freed_objects
211      << " objects with total size " << PrettySize(freed_bytes) << "\n"
212      << GetName() << " throughput: " << freed_objects / seconds << "/s / "
213      << PrettySize(freed_bytes / seconds) << "/s\n";
214 }
215 
216 }  // namespace collector
217 }  // namespace gc
218 }  // namespace art
219