blob: ccfa9cf0df7887607c3e9e0964902ba36fbbe412 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
|
/*
* Copyright (C) 2012 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ART_RUNTIME_GC_COLLECTOR_GARBAGE_COLLECTOR_H_
#define ART_RUNTIME_GC_COLLECTOR_GARBAGE_COLLECTOR_H_
#include "base/histogram.h"
#include "base/mutex.h"
#include "base/timing_logger.h"
#include "gc/collector_type.h"
#include "gc/gc_cause.h"
#include "gc_type.h"
#include <stdint.h>
#include <vector>
namespace art {
namespace gc {
class Heap;
namespace collector {
class GarbageCollector {
public:
GarbageCollector(Heap* heap, const std::string& name);
virtual ~GarbageCollector() { }
const char* GetName() const {
return name_.c_str();
}
virtual GcType GetGcType() const = 0;
virtual CollectorType GetCollectorType() const = 0;
// Run the garbage collector.
void Run(GcCause gc_cause, bool clear_soft_references);
Heap* GetHeap() const {
return heap_;
}
// Returns how long the mutators were paused in nanoseconds.
const std::vector<uint64_t>& GetPauseTimes() const {
return pause_times_;
}
// Returns how long the GC took to complete in nanoseconds.
uint64_t GetDurationNs() const {
return duration_ns_;
}
void RegisterPause(uint64_t nano_length);
TimingLogger& GetTimings() {
return timings_;
}
const CumulativeLogger& GetCumulativeTimings() const {
return cumulative_timings_;
}
void ResetCumulativeStatistics();
// Swap the live and mark bitmaps of spaces that are active for the collector. For partial GC,
// this is the allocation space, for full GC then we swap the zygote bitmaps too.
void SwapBitmaps() EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
size_t GetFreedBytes() const {
return freed_bytes_;
}
size_t GetFreedLargeObjectBytes() const {
return freed_large_object_bytes_;
}
size_t GetFreedObjects() const {
return freed_objects_;
}
size_t GetFreedLargeObjects() const {
return freed_large_objects_;
}
uint64_t GetTotalPausedTimeNs() const {
return pause_histogram_.Sum();
}
uint64_t GetTotalFreedBytes() const {
return total_freed_bytes_;
}
uint64_t GetTotalFreedObjects() const {
return total_freed_objects_;
}
const Histogram<uint64_t>& GetPauseHistogram() const {
return pause_histogram_;
}
// Returns the estimated throughput in bytes / second.
uint64_t GetEstimatedMeanThroughput() const;
// Returns the estimated throughput of the last GC iteration.
uint64_t GetEstimatedLastIterationThroughput() const;
// Returns how many GC iterations have been run.
size_t GetIterations() const {
return GetCumulativeTimings().GetIterations();
}
protected:
// The initial phase. Done without mutators paused.
virtual void InitializePhase() = 0;
// Mark all reachable objects, done concurrently.
virtual void MarkingPhase() = 0;
// Only called for concurrent GCs.
virtual void PausePhase();
// Called with mutators running.
virtual void ReclaimPhase() = 0;
// Called after the GC is finished. Done without mutators paused.
virtual void FinishPhase() = 0;
// Revoke all the thread-local buffers.
virtual void RevokeAllThreadLocalBuffers() = 0;
static constexpr size_t kPauseBucketSize = 500;
static constexpr size_t kPauseBucketCount = 32;
Heap* const heap_;
std::string name_;
GcCause gc_cause_;
bool clear_soft_references_;
uint64_t duration_ns_;
TimingLogger timings_;
// Cumulative statistics.
Histogram<uint64_t> pause_histogram_;
uint64_t total_time_ns_;
uint64_t total_freed_objects_;
uint64_t total_freed_bytes_;
// Single GC statitstics.
AtomicInteger freed_bytes_;
AtomicInteger freed_large_object_bytes_;
AtomicInteger freed_objects_;
AtomicInteger freed_large_objects_;
CumulativeLogger cumulative_timings_;
std::vector<uint64_t> pause_times_;
};
} // namespace collector
} // namespace gc
} // namespace art
#endif // ART_RUNTIME_GC_COLLECTOR_GARBAGE_COLLECTOR_H_
|
