Elliott Hughes | 9d5ccec | 2011-09-19 13:19:50 -0700 | [diff] [blame] | 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 | */ |
Carl Shapiro | 1fb8620 | 2011-06-27 17:43:13 -0700 | [diff] [blame] | 16 | |
Brian Carlstrom | fc0e321 | 2013-07-17 14:40:12 -0700 | [diff] [blame] | 17 | #ifndef ART_RUNTIME_GC_HEAP_H_ |
| 18 | #define ART_RUNTIME_GC_HEAP_H_ |
Carl Shapiro | 1fb8620 | 2011-06-27 17:43:13 -0700 | [diff] [blame] | 19 | |
Elliott Hughes | c967f78 | 2012-04-16 10:23:15 -0700 | [diff] [blame] | 20 | #include <iosfwd> |
Elliott Hughes | b3bd5f0 | 2012-03-08 21:05:27 -0800 | [diff] [blame] | 21 | #include <string> |
Mathieu Chartier | 3100080 | 2015-06-14 14:14:37 -0700 | [diff] [blame] | 22 | #include <unordered_set> |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 23 | #include <vector> |
| 24 | |
Ian Rogers | b0fa5dc | 2014-04-28 16:47:08 -0700 | [diff] [blame] | 25 | #include "allocator_type.h" |
Ian Rogers | d582fa4 | 2014-11-05 23:46:43 -0800 | [diff] [blame] | 26 | #include "arch/instruction_set.h" |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 27 | #include "atomic.h" |
Vladimir Marko | 80afd02 | 2015-05-19 18:08:00 +0100 | [diff] [blame] | 28 | #include "base/time_utils.h" |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 29 | #include "gc/accounting/atomic_stack.h" |
| 30 | #include "gc/accounting/card_table.h" |
Hiroshi Yamauchi | 2cd334a | 2015-01-09 14:03:35 -0800 | [diff] [blame] | 31 | #include "gc/accounting/read_barrier_table.h" |
Hiroshi Yamauchi | 6f4ffe4 | 2014-01-13 12:30:44 -0800 | [diff] [blame] | 32 | #include "gc/gc_cause.h" |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 33 | #include "gc/collector/gc_type.h" |
Mathieu Chartier | 0de9f73 | 2013-11-22 17:58:48 -0800 | [diff] [blame] | 34 | #include "gc/collector_type.h" |
Mathieu Chartier | 2dbe627 | 2014-09-16 10:43:23 -0700 | [diff] [blame] | 35 | #include "gc/space/large_object_space.h" |
Brian Carlstrom | 578bbdc | 2011-07-21 14:07:47 -0700 | [diff] [blame] | 36 | #include "globals.h" |
Mathieu Chartier | 83c8ee0 | 2014-01-28 14:50:23 -0800 | [diff] [blame] | 37 | #include "object_callbacks.h" |
Ian Rogers | 0cfe1fb | 2011-08-26 03:29:44 -0700 | [diff] [blame] | 38 | #include "offsets.h" |
Mathieu Chartier | b062fdd | 2012-07-03 09:51:48 -0700 | [diff] [blame] | 39 | #include "safe_map.h" |
Mathieu Chartier | 4e30541 | 2014-02-19 10:54:44 -0800 | [diff] [blame] | 40 | #include "verify_object.h" |
Carl Shapiro | 1fb8620 | 2011-06-27 17:43:13 -0700 | [diff] [blame] | 41 | |
| 42 | namespace art { |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 43 | |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 44 | class ConditionVariable; |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 45 | class Mutex; |
Ian Rogers | 40e3bac | 2012-11-20 00:09:14 -0800 | [diff] [blame] | 46 | class StackVisitor; |
Mathieu Chartier | 5301cd2 | 2012-05-31 12:11:36 -0700 | [diff] [blame] | 47 | class Thread; |
Mathieu Chartier | 3cf2253 | 2015-07-09 15:15:09 -0700 | [diff] [blame] | 48 | class ThreadPool; |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 49 | class TimingLogger; |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 50 | |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 51 | namespace mirror { |
| 52 | class Class; |
| 53 | class Object; |
| 54 | } // namespace mirror |
| 55 | |
| 56 | namespace gc { |
Mathieu Chartier | 78f7b4c | 2014-05-06 10:57:27 -0700 | [diff] [blame] | 57 | |
Man Cao | 8c2ff64 | 2015-05-27 17:25:30 -0700 | [diff] [blame] | 58 | class AllocRecordObjectMap; |
Mathieu Chartier | 78f7b4c | 2014-05-06 10:57:27 -0700 | [diff] [blame] | 59 | class ReferenceProcessor; |
Mathieu Chartier | a5eae69 | 2014-12-17 17:56:03 -0800 | [diff] [blame] | 60 | class TaskProcessor; |
Mathieu Chartier | 78f7b4c | 2014-05-06 10:57:27 -0700 | [diff] [blame] | 61 | |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 62 | namespace accounting { |
| 63 | class HeapBitmap; |
| 64 | class ModUnionTable; |
Hiroshi Yamauchi | 38e68e9 | 2014-03-07 13:59:08 -0800 | [diff] [blame] | 65 | class RememberedSet; |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 66 | } // namespace accounting |
| 67 | |
| 68 | namespace collector { |
Hiroshi Yamauchi | d5307ec | 2014-03-27 21:07:51 -0700 | [diff] [blame] | 69 | class ConcurrentCopying; |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 70 | class GarbageCollector; |
Mathieu Chartier | 52e4b43 | 2014-06-10 11:22:31 -0700 | [diff] [blame] | 71 | class MarkCompact; |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 72 | class MarkSweep; |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 73 | class SemiSpace; |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 74 | } // namespace collector |
| 75 | |
Zuo Wang | f37a88b | 2014-07-10 04:26:41 -0700 | [diff] [blame] | 76 | namespace allocator { |
| 77 | class RosAlloc; |
| 78 | } // namespace allocator |
| 79 | |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 80 | namespace space { |
| 81 | class AllocSpace; |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 82 | class BumpPointerSpace; |
Mathieu Chartier | e4cab17 | 2014-08-19 18:24:04 -0700 | [diff] [blame] | 83 | class ContinuousMemMapAllocSpace; |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 84 | class DiscontinuousSpace; |
| 85 | class DlMallocSpace; |
| 86 | class ImageSpace; |
| 87 | class LargeObjectSpace; |
Hiroshi Yamauchi | cf58d4a | 2013-09-26 14:21:22 -0700 | [diff] [blame] | 88 | class MallocSpace; |
Hiroshi Yamauchi | 2cd334a | 2015-01-09 14:03:35 -0800 | [diff] [blame] | 89 | class RegionSpace; |
Hiroshi Yamauchi | cf58d4a | 2013-09-26 14:21:22 -0700 | [diff] [blame] | 90 | class RosAllocSpace; |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 91 | class Space; |
| 92 | class SpaceTest; |
Mathieu Chartier | e4cab17 | 2014-08-19 18:24:04 -0700 | [diff] [blame] | 93 | class ZygoteSpace; |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 94 | } // namespace space |
Mathieu Chartier | b062fdd | 2012-07-03 09:51:48 -0700 | [diff] [blame] | 95 | |
Mathieu Chartier | d22d548 | 2012-11-06 17:14:12 -0800 | [diff] [blame] | 96 | class AgeCardVisitor { |
| 97 | public: |
Ian Rogers | 1373595 | 2014-10-08 12:43:28 -0700 | [diff] [blame] | 98 | uint8_t operator()(uint8_t card) const { |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 99 | return (card == accounting::CardTable::kCardDirty) ? card - 1 : 0; |
Mathieu Chartier | d22d548 | 2012-11-06 17:14:12 -0800 | [diff] [blame] | 100 | } |
| 101 | }; |
| 102 | |
Zuo Wang | f37a88b | 2014-07-10 04:26:41 -0700 | [diff] [blame] | 103 | enum HomogeneousSpaceCompactResult { |
| 104 | // Success. |
| 105 | kSuccess, |
| 106 | // Reject due to disabled moving GC. |
| 107 | kErrorReject, |
| 108 | // System is shutting down. |
| 109 | kErrorVMShuttingDown, |
| 110 | }; |
| 111 | |
Hiroshi Yamauchi | cf58d4a | 2013-09-26 14:21:22 -0700 | [diff] [blame] | 112 | // If true, use rosalloc/RosAllocSpace instead of dlmalloc/DlMallocSpace |
Hiroshi Yamauchi | d31fb97 | 2013-11-19 11:08:27 -0800 | [diff] [blame] | 113 | static constexpr bool kUseRosAlloc = true; |
Hiroshi Yamauchi | cf58d4a | 2013-09-26 14:21:22 -0700 | [diff] [blame] | 114 | |
Hiroshi Yamauchi | f5b0e20 | 2014-02-11 17:02:22 -0800 | [diff] [blame] | 115 | // If true, use thread-local allocation stack. |
| 116 | static constexpr bool kUseThreadLocalAllocationStack = true; |
| 117 | |
Mathieu Chartier | ca2a24d | 2013-11-25 15:12:12 -0800 | [diff] [blame] | 118 | // The process state passed in from the activity manager, used to determine when to do trimming |
| 119 | // and compaction. |
| 120 | enum ProcessState { |
| 121 | kProcessStateJankPerceptible = 0, |
| 122 | kProcessStateJankImperceptible = 1, |
| 123 | }; |
Mathieu Chartier | e6da9af | 2013-12-16 11:54:42 -0800 | [diff] [blame] | 124 | std::ostream& operator<<(std::ostream& os, const ProcessState& process_state); |
Mathieu Chartier | ca2a24d | 2013-11-25 15:12:12 -0800 | [diff] [blame] | 125 | |
Ian Rogers | 50b35e2 | 2012-10-04 10:09:15 -0700 | [diff] [blame] | 126 | class Heap { |
Carl Shapiro | 1fb8620 | 2011-06-27 17:43:13 -0700 | [diff] [blame] | 127 | public: |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 128 | // If true, measure the total allocation time. |
Hiroshi Yamauchi | 5ccd498 | 2014-03-11 12:19:04 -0700 | [diff] [blame] | 129 | static constexpr size_t kDefaultStartingSize = kPageSize; |
Mathieu Chartier | 720ef76 | 2013-08-17 14:46:54 -0700 | [diff] [blame] | 130 | static constexpr size_t kDefaultInitialSize = 2 * MB; |
Mathieu Chartier | 2f4f0a3 | 2014-07-10 17:50:34 -0700 | [diff] [blame] | 131 | static constexpr size_t kDefaultMaximumSize = 256 * MB; |
Mathieu Chartier | 6a7824d | 2014-08-22 14:53:04 -0700 | [diff] [blame] | 132 | static constexpr size_t kDefaultNonMovingSpaceCapacity = 64 * MB; |
Mathieu Chartier | 720ef76 | 2013-08-17 14:46:54 -0700 | [diff] [blame] | 133 | static constexpr size_t kDefaultMaxFree = 2 * MB; |
| 134 | static constexpr size_t kDefaultMinFree = kDefaultMaxFree / 4; |
Mathieu Chartier | 2775ee4 | 2013-08-20 17:43:47 -0700 | [diff] [blame] | 135 | static constexpr size_t kDefaultLongPauseLogThreshold = MsToNs(5); |
| 136 | static constexpr size_t kDefaultLongGCLogThreshold = MsToNs(100); |
Mathieu Chartier | 692fafd | 2013-11-29 17:24:40 -0800 | [diff] [blame] | 137 | static constexpr size_t kDefaultTLABSize = 256 * KB; |
Mathieu Chartier | 720ef76 | 2013-08-17 14:46:54 -0700 | [diff] [blame] | 138 | static constexpr double kDefaultTargetUtilization = 0.5; |
Mathieu Chartier | 2f8da3e | 2014-04-15 15:37:02 -0700 | [diff] [blame] | 139 | static constexpr double kDefaultHeapGrowthMultiplier = 2.0; |
Mathieu Chartier | 2dbe627 | 2014-09-16 10:43:23 -0700 | [diff] [blame] | 140 | // Primitive arrays larger than this size are put in the large object space. |
| 141 | static constexpr size_t kDefaultLargeObjectThreshold = 3 * kPageSize; |
Mathieu Chartier | 10d6886 | 2015-04-15 14:21:33 -0700 | [diff] [blame] | 142 | // Whether or not parallel GC is enabled. If not, then we never create the thread pool. |
| 143 | static constexpr bool kDefaultEnableParallelGC = false; |
Igor Murashkin | 446ba4b | 2015-02-04 15:11:27 -0800 | [diff] [blame] | 144 | |
Mathieu Chartier | 2dbe627 | 2014-09-16 10:43:23 -0700 | [diff] [blame] | 145 | // Whether or not we use the free list large object space. Only use it if USE_ART_LOW_4G_ALLOCATOR |
| 146 | // since this means that we have to use the slow msync loop in MemMap::MapAnonymous. |
Mathieu Chartier | 2dbe627 | 2014-09-16 10:43:23 -0700 | [diff] [blame] | 147 | static constexpr space::LargeObjectSpaceType kDefaultLargeObjectSpaceType = |
Igor Murashkin | 446ba4b | 2015-02-04 15:11:27 -0800 | [diff] [blame] | 148 | USE_ART_LOW_4G_ALLOCATOR ? |
| 149 | space::LargeObjectSpaceType::kFreeList |
| 150 | : space::LargeObjectSpaceType::kMap; |
| 151 | |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 152 | // Used so that we don't overflow the allocation time atomic integer. |
Mathieu Chartier | 720ef76 | 2013-08-17 14:46:54 -0700 | [diff] [blame] | 153 | static constexpr size_t kTimeAdjust = 1024; |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 154 | |
Mathieu Chartier | 7bf52d2 | 2014-03-13 14:46:09 -0700 | [diff] [blame] | 155 | // How often we allow heap trimming to happen (nanoseconds). |
Mathieu Chartier | a5f9de0 | 2014-02-28 16:48:42 -0800 | [diff] [blame] | 156 | static constexpr uint64_t kHeapTrimWait = MsToNs(5000); |
Mathieu Chartier | 7bf52d2 | 2014-03-13 14:46:09 -0700 | [diff] [blame] | 157 | // How long we wait after a transition request to perform a collector transition (nanoseconds). |
| 158 | static constexpr uint64_t kCollectorTransitionWait = MsToNs(5000); |
Mathieu Chartier | a5f9de0 | 2014-02-28 16:48:42 -0800 | [diff] [blame] | 159 | |
Brian Carlstrom | 58ae941 | 2011-10-04 00:56:06 -0700 | [diff] [blame] | 160 | // Create a heap with the requested sizes. The possible empty |
| 161 | // image_file_names names specify Spaces to load based on |
| 162 | // ImageWriter output. |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 163 | explicit Heap(size_t initial_size, |
| 164 | size_t growth_limit, |
| 165 | size_t min_free, |
| 166 | size_t max_free, |
| 167 | double target_utilization, |
| 168 | double foreground_heap_growth_multiplier, |
| 169 | size_t capacity, |
Mathieu Chartier | 6a7824d | 2014-08-22 14:53:04 -0700 | [diff] [blame] | 170 | size_t non_moving_space_capacity, |
Mathieu Chartier | e6da9af | 2013-12-16 11:54:42 -0800 | [diff] [blame] | 171 | const std::string& original_image_file_name, |
Brian Carlstrom | 2afe494 | 2014-05-19 10:25:33 -0700 | [diff] [blame] | 172 | InstructionSet image_instruction_set, |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 173 | CollectorType foreground_collector_type, |
| 174 | CollectorType background_collector_type, |
| 175 | space::LargeObjectSpaceType large_object_space_type, |
| 176 | size_t large_object_threshold, |
| 177 | size_t parallel_gc_threads, |
| 178 | size_t conc_gc_threads, |
| 179 | bool low_memory_mode, |
| 180 | size_t long_pause_threshold, |
| 181 | size_t long_gc_threshold, |
| 182 | bool ignore_max_footprint, |
| 183 | bool use_tlab, |
| 184 | bool verify_pre_gc_heap, |
| 185 | bool verify_pre_sweeping_heap, |
| 186 | bool verify_post_gc_heap, |
| 187 | bool verify_pre_gc_rosalloc, |
| 188 | bool verify_pre_sweeping_rosalloc, |
| 189 | bool verify_post_gc_rosalloc, |
| 190 | bool gc_stress_mode, |
Mathieu Chartier | 3100080 | 2015-06-14 14:14:37 -0700 | [diff] [blame] | 191 | bool use_homogeneous_space_compaction, |
Zuo Wang | f37a88b | 2014-07-10 04:26:41 -0700 | [diff] [blame] | 192 | uint64_t min_interval_homogeneous_space_compaction_by_oom); |
Carl Shapiro | 61e019d | 2011-07-14 16:53:09 -0700 | [diff] [blame] | 193 | |
Elliott Hughes | b3bd5f0 | 2012-03-08 21:05:27 -0800 | [diff] [blame] | 194 | ~Heap(); |
Brian Carlstrom | a7f4f48 | 2011-07-17 17:01:34 -0700 | [diff] [blame] | 195 | |
Brian Carlstrom | a40f9bc | 2011-07-26 21:26:07 -0700 | [diff] [blame] | 196 | // Allocates and initializes storage for an object instance. |
Hiroshi Yamauchi | 4cd662e | 2014-04-03 16:28:10 -0700 | [diff] [blame] | 197 | template <bool kInstrumented, typename PreFenceVisitor> |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 198 | mirror::Object* AllocObject(Thread* self, |
| 199 | mirror::Class* klass, |
| 200 | size_t num_bytes, |
Hiroshi Yamauchi | 4cd662e | 2014-04-03 16:28:10 -0700 | [diff] [blame] | 201 | const PreFenceVisitor& pre_fence_visitor) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 202 | SHARED_REQUIRES(Locks::mutator_lock_) |
Mathieu Chartier | 4e2cb09 | 2015-07-22 16:17:51 -0700 | [diff] [blame] | 203 | REQUIRES(!*gc_complete_lock_, !*pending_task_lock_, !*backtrace_lock_, |
| 204 | !Roles::uninterruptible_) { |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 205 | return AllocObjectWithAllocator<kInstrumented, true>( |
| 206 | self, klass, num_bytes, GetCurrentAllocator(), pre_fence_visitor); |
Hiroshi Yamauchi | 3b4c189 | 2013-09-12 21:33:12 -0700 | [diff] [blame] | 207 | } |
Ian Rogers | 6fac447 | 2014-02-25 17:01:10 -0800 | [diff] [blame] | 208 | |
Hiroshi Yamauchi | 4cd662e | 2014-04-03 16:28:10 -0700 | [diff] [blame] | 209 | template <bool kInstrumented, typename PreFenceVisitor> |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 210 | mirror::Object* AllocNonMovableObject(Thread* self, |
| 211 | mirror::Class* klass, |
| 212 | size_t num_bytes, |
Hiroshi Yamauchi | 4cd662e | 2014-04-03 16:28:10 -0700 | [diff] [blame] | 213 | const PreFenceVisitor& pre_fence_visitor) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 214 | SHARED_REQUIRES(Locks::mutator_lock_) |
Mathieu Chartier | 4e2cb09 | 2015-07-22 16:17:51 -0700 | [diff] [blame] | 215 | REQUIRES(!*gc_complete_lock_, !*pending_task_lock_, !*backtrace_lock_, |
| 216 | !Roles::uninterruptible_) { |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 217 | return AllocObjectWithAllocator<kInstrumented, true>( |
| 218 | self, klass, num_bytes, GetCurrentNonMovingAllocator(), pre_fence_visitor); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 219 | } |
Ian Rogers | 6fac447 | 2014-02-25 17:01:10 -0800 | [diff] [blame] | 220 | |
Hiroshi Yamauchi | 4cd662e | 2014-04-03 16:28:10 -0700 | [diff] [blame] | 221 | template <bool kInstrumented, bool kCheckLargeObject, typename PreFenceVisitor> |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 222 | ALWAYS_INLINE mirror::Object* AllocObjectWithAllocator(Thread* self, |
| 223 | mirror::Class* klass, |
| 224 | size_t byte_count, |
| 225 | AllocatorType allocator, |
| 226 | const PreFenceVisitor& pre_fence_visitor) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 227 | SHARED_REQUIRES(Locks::mutator_lock_) |
Mathieu Chartier | 4e2cb09 | 2015-07-22 16:17:51 -0700 | [diff] [blame] | 228 | REQUIRES(!*gc_complete_lock_, !*pending_task_lock_, !*backtrace_lock_, |
| 229 | !Roles::uninterruptible_); |
Mathieu Chartier | cbb2d20 | 2013-11-14 17:45:16 -0800 | [diff] [blame] | 230 | |
| 231 | AllocatorType GetCurrentAllocator() const { |
| 232 | return current_allocator_; |
| 233 | } |
| 234 | |
| 235 | AllocatorType GetCurrentNonMovingAllocator() const { |
| 236 | return current_non_moving_allocator_; |
| 237 | } |
Hiroshi Yamauchi | 3b4c189 | 2013-09-12 21:33:12 -0700 | [diff] [blame] | 238 | |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 239 | // Visit all of the live objects in the heap. |
Mathieu Chartier | 83c8ee0 | 2014-01-28 14:50:23 -0800 | [diff] [blame] | 240 | void VisitObjects(ObjectCallback callback, void* arg) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 241 | SHARED_REQUIRES(Locks::mutator_lock_) |
| 242 | REQUIRES(!Locks::heap_bitmap_lock_, !*gc_complete_lock_); |
Hiroshi Yamauchi | 2cd334a | 2015-01-09 14:03:35 -0800 | [diff] [blame] | 243 | void VisitObjectsPaused(ObjectCallback callback, void* arg) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 244 | REQUIRES(Locks::mutator_lock_, !Locks::heap_bitmap_lock_, !*gc_complete_lock_); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 245 | |
Mathieu Chartier | c645f1d | 2014-03-06 18:11:53 -0800 | [diff] [blame] | 246 | void CheckPreconditionsForAllocObject(mirror::Class* c, size_t byte_count) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 247 | SHARED_REQUIRES(Locks::mutator_lock_); |
Brian Carlstrom | a7f4f48 | 2011-07-17 17:01:34 -0700 | [diff] [blame] | 248 | |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 249 | void RegisterNativeAllocation(JNIEnv* env, size_t bytes) |
| 250 | REQUIRES(!*gc_complete_lock_, !*pending_task_lock_); |
| 251 | void RegisterNativeFree(JNIEnv* env, size_t bytes) |
| 252 | REQUIRES(!*gc_complete_lock_, !*pending_task_lock_); |
Mathieu Chartier | 987ccff | 2013-07-08 11:05:21 -0700 | [diff] [blame] | 253 | |
Mathieu Chartier | 5048223 | 2013-11-21 11:48:14 -0800 | [diff] [blame] | 254 | // Change the allocator, updates entrypoints. |
Mathieu Chartier | d889178 | 2014-03-02 13:28:37 -0800 | [diff] [blame] | 255 | void ChangeAllocator(AllocatorType allocator) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 256 | REQUIRES(Locks::mutator_lock_, !Locks::runtime_shutdown_lock_); |
Mathieu Chartier | 5048223 | 2013-11-21 11:48:14 -0800 | [diff] [blame] | 257 | |
Mathieu Chartier | e6da9af | 2013-12-16 11:54:42 -0800 | [diff] [blame] | 258 | // Transition the garbage collector during runtime, may copy objects from one space to another. |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 259 | void TransitionCollector(CollectorType collector_type) REQUIRES(!*gc_complete_lock_); |
Mathieu Chartier | e6da9af | 2013-12-16 11:54:42 -0800 | [diff] [blame] | 260 | |
Mathieu Chartier | 0de9f73 | 2013-11-22 17:58:48 -0800 | [diff] [blame] | 261 | // Change the collector to be one of the possible options (MS, CMS, SS). |
Mathieu Chartier | d889178 | 2014-03-02 13:28:37 -0800 | [diff] [blame] | 262 | void ChangeCollector(CollectorType collector_type) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 263 | REQUIRES(Locks::mutator_lock_); |
Mathieu Chartier | 0de9f73 | 2013-11-22 17:58:48 -0800 | [diff] [blame] | 264 | |
Ian Rogers | 04d7aa9 | 2013-03-16 14:29:17 -0700 | [diff] [blame] | 265 | // The given reference is believed to be to an object in the Java heap, check the soundness of it. |
Mathieu Chartier | 4e30541 | 2014-02-19 10:54:44 -0800 | [diff] [blame] | 266 | // TODO: NO_THREAD_SAFETY_ANALYSIS since we call this everywhere and it is impossible to find a |
| 267 | // proper lock ordering for it. |
| 268 | void VerifyObjectBody(mirror::Object* o) NO_THREAD_SAFETY_ANALYSIS; |
Ian Rogers | 408f79a | 2011-08-23 18:22:33 -0700 | [diff] [blame] | 269 | |
Ian Rogers | 04d7aa9 | 2013-03-16 14:29:17 -0700 | [diff] [blame] | 270 | // Check sanity of all live references. |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 271 | void VerifyHeap() REQUIRES(!Locks::heap_bitmap_lock_); |
Mathieu Chartier | 8ab7e78 | 2014-05-19 16:55:27 -0700 | [diff] [blame] | 272 | // Returns how many failures occured. |
| 273 | size_t VerifyHeapReferences(bool verify_referents = true) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 274 | REQUIRES(Locks::mutator_lock_, !*gc_complete_lock_); |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 275 | bool VerifyMissingCardMarks() |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 276 | REQUIRES(Locks::heap_bitmap_lock_, Locks::mutator_lock_); |
Ian Rogers | 0cfe1fb | 2011-08-26 03:29:44 -0700 | [diff] [blame] | 277 | |
Elliott Hughes | 6a5bd49 | 2011-10-28 14:33:57 -0700 | [diff] [blame] | 278 | // A weaker test than IsLiveObject or VerifyObject that doesn't require the heap lock, |
Elliott Hughes | a250199 | 2011-08-26 19:39:54 -0700 | [diff] [blame] | 279 | // and doesn't abort on error, allowing the caller to report more |
| 280 | // meaningful diagnostics. |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 281 | bool IsValidObjectAddress(const mirror::Object* obj) const SHARED_REQUIRES(Locks::mutator_lock_); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 282 | |
Mathieu Chartier | d68ac70 | 2014-02-11 14:50:51 -0800 | [diff] [blame] | 283 | // Faster alternative to IsHeapAddress since finding if an object is in the large object space is |
| 284 | // very slow. |
| 285 | bool IsNonDiscontinuousSpaceHeapAddress(const mirror::Object* obj) const |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 286 | SHARED_REQUIRES(Locks::mutator_lock_); |
Elliott Hughes | b3bd5f0 | 2012-03-08 21:05:27 -0800 | [diff] [blame] | 287 | |
Elliott Hughes | 6a5bd49 | 2011-10-28 14:33:57 -0700 | [diff] [blame] | 288 | // Returns true if 'obj' is a live heap object, false otherwise (including for invalid addresses). |
| 289 | // Requires the heap lock to be held. |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 290 | bool IsLiveObjectLocked(mirror::Object* obj, |
| 291 | bool search_allocation_stack = true, |
| 292 | bool search_live_stack = true, |
| 293 | bool sorted = false) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 294 | SHARED_REQUIRES(Locks::heap_bitmap_lock_, Locks::mutator_lock_); |
Elliott Hughes | a250199 | 2011-08-26 19:39:54 -0700 | [diff] [blame] | 295 | |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 296 | // Returns true if there is any chance that the object (obj) will move. |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 297 | bool IsMovableObject(const mirror::Object* obj) const SHARED_REQUIRES(Locks::mutator_lock_); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 298 | |
Mathieu Chartier | 1d27b34 | 2014-01-28 12:51:09 -0800 | [diff] [blame] | 299 | // Enables us to compacting GC until objects are released. |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 300 | void IncrementDisableMovingGC(Thread* self) REQUIRES(!*gc_complete_lock_); |
| 301 | void DecrementDisableMovingGC(Thread* self) REQUIRES(!*gc_complete_lock_); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 302 | |
Mathieu Chartier | 4aeec17 | 2014-03-27 16:09:46 -0700 | [diff] [blame] | 303 | // Clear all of the mark bits, doesn't clear bitmaps which have the same live bits as mark bits. |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 304 | void ClearMarkedObjects() REQUIRES(Locks::heap_bitmap_lock_); |
Mathieu Chartier | 4aeec17 | 2014-03-27 16:09:46 -0700 | [diff] [blame] | 305 | |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 306 | // Initiates an explicit garbage collection. |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 307 | void CollectGarbage(bool clear_soft_references) |
| 308 | REQUIRES(!*gc_complete_lock_, !*pending_task_lock_); |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 309 | |
Mathieu Chartier | 7664f5c | 2012-06-08 18:15:32 -0700 | [diff] [blame] | 310 | // Does a concurrent GC, should only be called by the GC daemon thread |
| 311 | // through runtime. |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 312 | void ConcurrentGC(Thread* self, bool force_full) |
| 313 | REQUIRES(!Locks::runtime_shutdown_lock_, !*gc_complete_lock_, !*pending_task_lock_); |
Mathieu Chartier | 7664f5c | 2012-06-08 18:15:32 -0700 | [diff] [blame] | 314 | |
Elliott Hughes | ec0f83d | 2013-01-15 16:54:08 -0800 | [diff] [blame] | 315 | // Implements VMDebug.countInstancesOfClass and JDWP VM_InstanceCount. |
| 316 | // The boolean decides whether to use IsAssignableFrom or == when comparing classes. |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 317 | void CountInstances(const std::vector<mirror::Class*>& classes, |
| 318 | bool use_is_assignable_from, |
Elliott Hughes | ec0f83d | 2013-01-15 16:54:08 -0800 | [diff] [blame] | 319 | uint64_t* counts) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 320 | REQUIRES(!Locks::heap_bitmap_lock_, !*gc_complete_lock_) |
| 321 | SHARED_REQUIRES(Locks::mutator_lock_); |
Elliott Hughes | 3b78c94 | 2013-01-15 17:35:41 -0800 | [diff] [blame] | 322 | // Implements JDWP RT_Instances. |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 323 | void GetInstances(mirror::Class* c, int32_t max_count, std::vector<mirror::Object*>& instances) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 324 | REQUIRES(!Locks::heap_bitmap_lock_, !*gc_complete_lock_) |
| 325 | SHARED_REQUIRES(Locks::mutator_lock_); |
Elliott Hughes | 0cbaff5 | 2013-01-16 15:28:01 -0800 | [diff] [blame] | 326 | // Implements JDWP OR_ReferringObjects. |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 327 | void GetReferringObjects(mirror::Object* o, |
| 328 | int32_t max_count, |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 329 | std::vector<mirror::Object*>& referring_objects) |
| 330 | REQUIRES(!Locks::heap_bitmap_lock_, !*gc_complete_lock_) |
| 331 | SHARED_REQUIRES(Locks::mutator_lock_); |
Elliott Hughes | 9d5ccec | 2011-09-19 13:19:50 -0700 | [diff] [blame] | 332 | |
Ian Rogers | 3bb17a6 | 2012-01-27 23:56:44 -0800 | [diff] [blame] | 333 | // Removes the growth limit on the alloc space so it may grow to its maximum capacity. Used to |
| 334 | // implement dalvik.system.VMRuntime.clearGrowthLimit. |
Elliott Hughes | b3bd5f0 | 2012-03-08 21:05:27 -0800 | [diff] [blame] | 335 | void ClearGrowthLimit(); |
jeffhao | c116070 | 2011-10-27 15:48:45 -0700 | [diff] [blame] | 336 | |
Mathieu Chartier | 379d09f | 2015-01-08 11:28:13 -0800 | [diff] [blame] | 337 | // Make the current growth limit the new maximum capacity, unmaps pages at the end of spaces |
| 338 | // which will never be used. Used to implement dalvik.system.VMRuntime.clampGrowthLimit. |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 339 | void ClampGrowthLimit() REQUIRES(!Locks::heap_bitmap_lock_); |
Mathieu Chartier | 379d09f | 2015-01-08 11:28:13 -0800 | [diff] [blame] | 340 | |
Ian Rogers | 30fab40 | 2012-01-23 15:43:46 -0800 | [diff] [blame] | 341 | // Target ideal heap utilization ratio, implements |
| 342 | // dalvik.system.VMRuntime.getTargetHeapUtilization. |
Mathieu Chartier | 0051be6 | 2012-10-12 17:47:11 -0700 | [diff] [blame] | 343 | double GetTargetHeapUtilization() const { |
| 344 | return target_utilization_; |
| 345 | } |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 346 | |
Mathieu Chartier | 0a9dc05 | 2013-07-25 11:01:28 -0700 | [diff] [blame] | 347 | // Data structure memory usage tracking. |
| 348 | void RegisterGCAllocation(size_t bytes); |
| 349 | void RegisterGCDeAllocation(size_t bytes); |
| 350 | |
Mathieu Chartier | 1b54f9c | 2014-04-30 16:45:02 -0700 | [diff] [blame] | 351 | // Set the heap's private space pointers to be the same as the space based on it's type. Public |
| 352 | // due to usage by tests. |
| 353 | void SetSpaceAsDefault(space::ContinuousSpace* continuous_space) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 354 | REQUIRES(!Locks::heap_bitmap_lock_); |
| 355 | void AddSpace(space::Space* space) REQUIRES(!Locks::heap_bitmap_lock_); |
| 356 | void RemoveSpace(space::Space* space) REQUIRES(!Locks::heap_bitmap_lock_); |
Mathieu Chartier | 73d1e17 | 2014-04-11 17:53:48 -0700 | [diff] [blame] | 357 | |
Ian Rogers | 30fab40 | 2012-01-23 15:43:46 -0800 | [diff] [blame] | 358 | // Set target ideal heap utilization ratio, implements |
| 359 | // dalvik.system.VMRuntime.setTargetHeapUtilization. |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 360 | void SetTargetHeapUtilization(float target); |
Ian Rogers | 3bb17a6 | 2012-01-27 23:56:44 -0800 | [diff] [blame] | 361 | |
| 362 | // For the alloc space, sets the maximum number of bytes that the heap is allowed to allocate |
| 363 | // from the system. Doesn't allow the space to exceed its growth limit. |
Elliott Hughes | b3bd5f0 | 2012-03-08 21:05:27 -0800 | [diff] [blame] | 364 | void SetIdealFootprint(size_t max_allowed_footprint); |
Elliott Hughes | 7ede61e | 2011-09-14 18:18:06 -0700 | [diff] [blame] | 365 | |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 366 | // Blocks the caller until the garbage collector becomes idle and returns the type of GC we |
| 367 | // waited for. |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 368 | collector::GcType WaitForGcToComplete(GcCause cause, Thread* self) REQUIRES(!*gc_complete_lock_); |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 369 | |
Mathieu Chartier | ca2a24d | 2013-11-25 15:12:12 -0800 | [diff] [blame] | 370 | // Update the heap's process state to a new value, may cause compaction to occur. |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 371 | void UpdateProcessState(ProcessState process_state) |
| 372 | REQUIRES(!*pending_task_lock_, !*gc_complete_lock_); |
Mathieu Chartier | ca2a24d | 2013-11-25 15:12:12 -0800 | [diff] [blame] | 373 | |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 374 | const std::vector<space::ContinuousSpace*>& GetContinuousSpaces() const { |
| 375 | return continuous_spaces_; |
Mathieu Chartier | 2b82db4 | 2012-11-14 17:29:05 -0800 | [diff] [blame] | 376 | } |
| 377 | |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 378 | const std::vector<space::DiscontinuousSpace*>& GetDiscontinuousSpaces() const { |
| 379 | return discontinuous_spaces_; |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 380 | } |
Carl Shapiro | 61e019d | 2011-07-14 16:53:09 -0700 | [diff] [blame] | 381 | |
Mathieu Chartier | 10fb83a | 2014-06-15 15:15:43 -0700 | [diff] [blame] | 382 | const collector::Iteration* GetCurrentGcIteration() const { |
| 383 | return ¤t_gc_iteration_; |
| 384 | } |
| 385 | collector::Iteration* GetCurrentGcIteration() { |
| 386 | return ¤t_gc_iteration_; |
| 387 | } |
| 388 | |
Ian Rogers | 04d7aa9 | 2013-03-16 14:29:17 -0700 | [diff] [blame] | 389 | // Enable verification of object references when the runtime is sufficiently initialized. |
Elliott Hughes | b3bd5f0 | 2012-03-08 21:05:27 -0800 | [diff] [blame] | 390 | void EnableObjectValidation() { |
Mathieu Chartier | 4e30541 | 2014-02-19 10:54:44 -0800 | [diff] [blame] | 391 | verify_object_mode_ = kVerifyObjectSupport; |
| 392 | if (verify_object_mode_ > kVerifyObjectModeDisabled) { |
Ian Rogers | 04d7aa9 | 2013-03-16 14:29:17 -0700 | [diff] [blame] | 393 | VerifyHeap(); |
| 394 | } |
Elliott Hughes | 85d1545 | 2011-09-16 17:33:01 -0700 | [diff] [blame] | 395 | } |
| 396 | |
Ian Rogers | 04d7aa9 | 2013-03-16 14:29:17 -0700 | [diff] [blame] | 397 | // Disable object reference verification for image writing. |
Elliott Hughes | b3bd5f0 | 2012-03-08 21:05:27 -0800 | [diff] [blame] | 398 | void DisableObjectValidation() { |
Mathieu Chartier | 4e30541 | 2014-02-19 10:54:44 -0800 | [diff] [blame] | 399 | verify_object_mode_ = kVerifyObjectModeDisabled; |
Ian Rogers | 0cfe1fb | 2011-08-26 03:29:44 -0700 | [diff] [blame] | 400 | } |
| 401 | |
Ian Rogers | 04d7aa9 | 2013-03-16 14:29:17 -0700 | [diff] [blame] | 402 | // Other checks may be performed if we know the heap should be in a sane state. |
Ian Rogers | 23435d0 | 2012-09-24 11:23:12 -0700 | [diff] [blame] | 403 | bool IsObjectValidationEnabled() const { |
Mathieu Chartier | 4e30541 | 2014-02-19 10:54:44 -0800 | [diff] [blame] | 404 | return verify_object_mode_ > kVerifyObjectModeDisabled; |
Ian Rogers | 23435d0 | 2012-09-24 11:23:12 -0700 | [diff] [blame] | 405 | } |
| 406 | |
Mathieu Chartier | e0a53e9 | 2013-08-05 10:17:40 -0700 | [diff] [blame] | 407 | // Returns true if low memory mode is enabled. |
| 408 | bool IsLowMemoryMode() const { |
| 409 | return low_memory_mode_; |
| 410 | } |
| 411 | |
Mathieu Chartier | 2f8da3e | 2014-04-15 15:37:02 -0700 | [diff] [blame] | 412 | // Returns the heap growth multiplier, this affects how much we grow the heap after a GC. |
| 413 | // Scales heap growth, min free, and max free. |
| 414 | double HeapGrowthMultiplier() const; |
| 415 | |
Mathieu Chartier | e6da9af | 2013-12-16 11:54:42 -0800 | [diff] [blame] | 416 | // Freed bytes can be negative in cases where we copy objects from a compacted space to a |
| 417 | // free-list backed space. |
Mathieu Chartier | e76e70f | 2014-05-02 16:35:37 -0700 | [diff] [blame] | 418 | void RecordFree(uint64_t freed_objects, int64_t freed_bytes); |
Brian Carlstrom | 693267a | 2011-09-06 09:25:34 -0700 | [diff] [blame] | 419 | |
Hiroshi Yamauchi | 4460a84 | 2015-03-09 11:57:48 -0700 | [diff] [blame] | 420 | // Record the bytes freed by thread-local buffer revoke. |
| 421 | void RecordFreeRevoke(); |
| 422 | |
Elliott Hughes | 5ea047b | 2011-09-13 14:38:18 -0700 | [diff] [blame] | 423 | // Must be called if a field of an Object in the heap changes, and before any GC safe-point. |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 424 | // The call is not needed if null is stored in the field. |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 425 | ALWAYS_INLINE void WriteBarrierField(const mirror::Object* dst, |
| 426 | MemberOffset offset ATTRIBUTE_UNUSED, |
| 427 | const mirror::Object* new_value ATTRIBUTE_UNUSED) { |
Mathieu Chartier | e35517a | 2012-10-30 18:49:55 -0700 | [diff] [blame] | 428 | card_table_->MarkCard(dst); |
Ian Rogers | 5d76c43 | 2011-10-31 21:42:49 -0700 | [diff] [blame] | 429 | } |
| 430 | |
| 431 | // Write barrier for array operations that update many field positions |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 432 | ALWAYS_INLINE void WriteBarrierArray(const mirror::Object* dst, |
| 433 | int start_offset ATTRIBUTE_UNUSED, |
| 434 | // TODO: element_count or byte_count? |
| 435 | size_t length ATTRIBUTE_UNUSED) { |
Mathieu Chartier | e35517a | 2012-10-30 18:49:55 -0700 | [diff] [blame] | 436 | card_table_->MarkCard(dst); |
Ian Rogers | 5d76c43 | 2011-10-31 21:42:49 -0700 | [diff] [blame] | 437 | } |
| 438 | |
Mathieu Chartier | 2d2621a | 2014-10-23 16:48:06 -0700 | [diff] [blame] | 439 | ALWAYS_INLINE void WriteBarrierEveryFieldOf(const mirror::Object* obj) { |
Mathieu Chartier | 0732d59 | 2013-11-06 11:02:50 -0800 | [diff] [blame] | 440 | card_table_->MarkCard(obj); |
| 441 | } |
| 442 | |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 443 | accounting::CardTable* GetCardTable() const { |
Mathieu Chartier | cc236d7 | 2012-07-20 10:29:05 -0700 | [diff] [blame] | 444 | return card_table_.get(); |
Ian Rogers | 5d76c43 | 2011-10-31 21:42:49 -0700 | [diff] [blame] | 445 | } |
| 446 | |
Hiroshi Yamauchi | 2cd334a | 2015-01-09 14:03:35 -0800 | [diff] [blame] | 447 | accounting::ReadBarrierTable* GetReadBarrierTable() const { |
| 448 | return rb_table_.get(); |
| 449 | } |
| 450 | |
Mathieu Chartier | 8668c3c | 2014-04-24 16:48:11 -0700 | [diff] [blame] | 451 | void AddFinalizerReference(Thread* self, mirror::Object** object); |
Elliott Hughes | adb460d | 2011-10-05 17:02:34 -0700 | [diff] [blame] | 452 | |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 453 | // Returns the number of bytes currently allocated. |
| 454 | size_t GetBytesAllocated() const { |
Ian Rogers | 3e5cf30 | 2014-05-20 16:40:37 -0700 | [diff] [blame] | 455 | return num_bytes_allocated_.LoadSequentiallyConsistent(); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 456 | } |
| 457 | |
| 458 | // Returns the number of objects currently allocated. |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 459 | size_t GetObjectsAllocated() const |
| 460 | REQUIRES(!Locks::heap_bitmap_lock_); |
Mathieu Chartier | 7664f5c | 2012-06-08 18:15:32 -0700 | [diff] [blame] | 461 | |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 462 | // Returns the total number of objects allocated since the heap was created. |
Mathieu Chartier | dd162fb | 2014-08-06 17:06:33 -0700 | [diff] [blame] | 463 | uint64_t GetObjectsAllocatedEver() const; |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 464 | |
| 465 | // Returns the total number of bytes allocated since the heap was created. |
Mathieu Chartier | dd162fb | 2014-08-06 17:06:33 -0700 | [diff] [blame] | 466 | uint64_t GetBytesAllocatedEver() const; |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 467 | |
| 468 | // Returns the total number of objects freed since the heap was created. |
Mathieu Chartier | dd162fb | 2014-08-06 17:06:33 -0700 | [diff] [blame] | 469 | uint64_t GetObjectsFreedEver() const { |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 470 | return total_objects_freed_ever_; |
| 471 | } |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 472 | |
| 473 | // Returns the total number of bytes freed since the heap was created. |
Mathieu Chartier | dd162fb | 2014-08-06 17:06:33 -0700 | [diff] [blame] | 474 | uint64_t GetBytesFreedEver() const { |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 475 | return total_bytes_freed_ever_; |
| 476 | } |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 477 | |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 478 | // Implements java.lang.Runtime.maxMemory, returning the maximum amount of memory a program can |
| 479 | // consume. For a regular VM this would relate to the -Xmx option and would return -1 if no Xmx |
| 480 | // were specified. Android apps start with a growth limit (small heap size) which is |
| 481 | // cleared/extended for large apps. |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 482 | size_t GetMaxMemory() const { |
Mathieu Chartier | dd162fb | 2014-08-06 17:06:33 -0700 | [diff] [blame] | 483 | // There is some race conditions in the allocation code that can cause bytes allocated to |
| 484 | // become larger than growth_limit_ in rare cases. |
| 485 | return std::max(GetBytesAllocated(), growth_limit_); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 486 | } |
| 487 | |
Mathieu Chartier | dd162fb | 2014-08-06 17:06:33 -0700 | [diff] [blame] | 488 | // Implements java.lang.Runtime.totalMemory, returning approximate amount of memory currently |
| 489 | // consumed by an application. |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 490 | size_t GetTotalMemory() const; |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 491 | |
Mathieu Chartier | dd162fb | 2014-08-06 17:06:33 -0700 | [diff] [blame] | 492 | // Returns approximately how much free memory we have until the next GC happens. |
| 493 | size_t GetFreeMemoryUntilGC() const { |
| 494 | return max_allowed_footprint_ - GetBytesAllocated(); |
| 495 | } |
| 496 | |
| 497 | // Returns approximately how much free memory we have until the next OOME happens. |
| 498 | size_t GetFreeMemoryUntilOOME() const { |
| 499 | return growth_limit_ - GetBytesAllocated(); |
| 500 | } |
| 501 | |
| 502 | // Returns how much free memory we have until we need to grow the heap to perform an allocation. |
| 503 | // Similar to GetFreeMemoryUntilGC. Implements java.lang.Runtime.freeMemory. |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 504 | size_t GetFreeMemory() const { |
Mathieu Chartier | 146b187 | 2014-06-27 09:57:12 -0700 | [diff] [blame] | 505 | size_t byte_allocated = num_bytes_allocated_.LoadSequentiallyConsistent(); |
Mathieu Chartier | dd162fb | 2014-08-06 17:06:33 -0700 | [diff] [blame] | 506 | size_t total_memory = GetTotalMemory(); |
| 507 | // Make sure we don't get a negative number. |
| 508 | return total_memory - std::min(total_memory, byte_allocated); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 509 | } |
| 510 | |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 511 | // get the space that corresponds to an object's address. Current implementation searches all |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 512 | // spaces in turn. If fail_ok is false then failing to find a space will cause an abort. |
| 513 | // TODO: consider using faster data structure like binary tree. |
| 514 | space::ContinuousSpace* FindContinuousSpaceFromObject(const mirror::Object*, bool fail_ok) const; |
| 515 | space::DiscontinuousSpace* FindDiscontinuousSpaceFromObject(const mirror::Object*, |
| 516 | bool fail_ok) const; |
| 517 | space::Space* FindSpaceFromObject(const mirror::Object*, bool fail_ok) const; |
Mathieu Chartier | b062fdd | 2012-07-03 09:51:48 -0700 | [diff] [blame] | 518 | |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 519 | void DumpForSigQuit(std::ostream& os) REQUIRES(!*gc_complete_lock_); |
Mathieu Chartier | a5f9de0 | 2014-02-28 16:48:42 -0800 | [diff] [blame] | 520 | |
Mathieu Chartier | a5eae69 | 2014-12-17 17:56:03 -0800 | [diff] [blame] | 521 | // Do a pending collector transition. |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 522 | void DoPendingCollectorTransition() REQUIRES(!*gc_complete_lock_); |
Mathieu Chartier | a5f9de0 | 2014-02-28 16:48:42 -0800 | [diff] [blame] | 523 | |
Mathieu Chartier | a5eae69 | 2014-12-17 17:56:03 -0800 | [diff] [blame] | 524 | // Deflate monitors, ... and trim the spaces. |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 525 | void Trim(Thread* self) REQUIRES(!*gc_complete_lock_); |
Mathieu Chartier | b062fdd | 2012-07-03 09:51:48 -0700 | [diff] [blame] | 526 | |
Hiroshi Yamauchi | cf58d4a | 2013-09-26 14:21:22 -0700 | [diff] [blame] | 527 | void RevokeThreadLocalBuffers(Thread* thread); |
Hiroshi Yamauchi | c93c530 | 2014-03-20 16:15:37 -0700 | [diff] [blame] | 528 | void RevokeRosAllocThreadLocalBuffers(Thread* thread); |
Hiroshi Yamauchi | cf58d4a | 2013-09-26 14:21:22 -0700 | [diff] [blame] | 529 | void RevokeAllThreadLocalBuffers(); |
Ian Rogers | 68d8b42 | 2014-07-17 11:09:10 -0700 | [diff] [blame] | 530 | void AssertThreadLocalBuffersAreRevoked(Thread* thread); |
Hiroshi Yamauchi | c93c530 | 2014-03-20 16:15:37 -0700 | [diff] [blame] | 531 | void AssertAllBumpPointerSpaceThreadLocalBuffersAreRevoked(); |
Mathieu Chartier | 6f365cc | 2014-04-23 12:42:27 -0700 | [diff] [blame] | 532 | void RosAllocVerification(TimingLogger* timings, const char* name) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 533 | REQUIRES(Locks::mutator_lock_); |
Hiroshi Yamauchi | a4adbfd | 2014-02-04 18:12:17 -0800 | [diff] [blame] | 534 | |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 535 | accounting::HeapBitmap* GetLiveBitmap() SHARED_REQUIRES(Locks::heap_bitmap_lock_) { |
Mathieu Chartier | b062fdd | 2012-07-03 09:51:48 -0700 | [diff] [blame] | 536 | return live_bitmap_.get(); |
| 537 | } |
| 538 | |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 539 | accounting::HeapBitmap* GetMarkBitmap() SHARED_REQUIRES(Locks::heap_bitmap_lock_) { |
Mathieu Chartier | b062fdd | 2012-07-03 09:51:48 -0700 | [diff] [blame] | 540 | return mark_bitmap_.get(); |
| 541 | } |
| 542 | |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 543 | accounting::ObjectStack* GetLiveStack() SHARED_REQUIRES(Locks::heap_bitmap_lock_) { |
Mathieu Chartier | 2b82db4 | 2012-11-14 17:29:05 -0800 | [diff] [blame] | 544 | return live_stack_.get(); |
| 545 | } |
| 546 | |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 547 | void PreZygoteFork() NO_THREAD_SAFETY_ANALYSIS; |
Mathieu Chartier | cc236d7 | 2012-07-20 10:29:05 -0700 | [diff] [blame] | 548 | |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 549 | // Mark and empty stack. |
| 550 | void FlushAllocStack() |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 551 | SHARED_REQUIRES(Locks::mutator_lock_) |
| 552 | REQUIRES(Locks::heap_bitmap_lock_); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 553 | |
Hiroshi Yamauchi | 90d7068 | 2014-02-20 16:17:30 -0800 | [diff] [blame] | 554 | // Revoke all the thread-local allocation stacks. |
Mathieu Chartier | c22c59e | 2014-02-24 15:16:06 -0800 | [diff] [blame] | 555 | void RevokeAllThreadLocalAllocationStacks(Thread* self) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 556 | REQUIRES(Locks::mutator_lock_, !Locks::runtime_shutdown_lock_, !Locks::thread_list_lock_); |
Hiroshi Yamauchi | 90d7068 | 2014-02-20 16:17:30 -0800 | [diff] [blame] | 557 | |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 558 | // Mark all the objects in the allocation stack in the specified bitmap. |
Mathieu Chartier | a8e8f9c | 2014-04-09 14:51:05 -0700 | [diff] [blame] | 559 | // TODO: Refactor? |
| 560 | void MarkAllocStack(accounting::SpaceBitmap<kObjectAlignment>* bitmap1, |
| 561 | accounting::SpaceBitmap<kObjectAlignment>* bitmap2, |
Mathieu Chartier | bbd695c | 2014-04-16 09:48:48 -0700 | [diff] [blame] | 562 | accounting::SpaceBitmap<kLargeObjectAlignment>* large_objects, |
| 563 | accounting::ObjectStack* stack) |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 564 | SHARED_REQUIRES(Locks::mutator_lock_) |
| 565 | REQUIRES(Locks::heap_bitmap_lock_); |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 566 | |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 567 | // Mark the specified allocation stack as live. |
| 568 | void MarkAllocStackAsLive(accounting::ObjectStack* stack) |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 569 | SHARED_REQUIRES(Locks::mutator_lock_) |
| 570 | REQUIRES(Locks::heap_bitmap_lock_); |
Mathieu Chartier | 8235331 | 2013-07-18 10:47:51 -0700 | [diff] [blame] | 571 | |
Mathieu Chartier | a1602f2 | 2014-01-13 17:19:19 -0800 | [diff] [blame] | 572 | // Unbind any bound bitmaps. |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 573 | void UnBindBitmaps() REQUIRES(Locks::heap_bitmap_lock_); |
Mathieu Chartier | a1602f2 | 2014-01-13 17:19:19 -0800 | [diff] [blame] | 574 | |
Mathieu Chartier | b062fdd | 2012-07-03 09:51:48 -0700 | [diff] [blame] | 575 | // DEPRECATED: Should remove in "near" future when support for multiple image spaces is added. |
Mathieu Chartier | cc236d7 | 2012-07-20 10:29:05 -0700 | [diff] [blame] | 576 | // Assumes there is only one image space. |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 577 | space::ImageSpace* GetImageSpace() const; |
| 578 | |
Mathieu Chartier | 6a7824d | 2014-08-22 14:53:04 -0700 | [diff] [blame] | 579 | // Permenantly disable moving garbage collection. |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 580 | void DisableMovingGc() REQUIRES(!*gc_complete_lock_); |
Mathieu Chartier | 6dda898 | 2014-03-06 11:11:48 -0800 | [diff] [blame] | 581 | |
Mathieu Chartier | e6da9af | 2013-12-16 11:54:42 -0800 | [diff] [blame] | 582 | space::DlMallocSpace* GetDlMallocSpace() const { |
| 583 | return dlmalloc_space_; |
| 584 | } |
| 585 | |
| 586 | space::RosAllocSpace* GetRosAllocSpace() const { |
| 587 | return rosalloc_space_; |
| 588 | } |
| 589 | |
Zuo Wang | f37a88b | 2014-07-10 04:26:41 -0700 | [diff] [blame] | 590 | // Return the corresponding rosalloc space. |
| 591 | space::RosAllocSpace* GetRosAllocSpace(gc::allocator::RosAlloc* rosalloc) const; |
| 592 | |
Hiroshi Yamauchi | cf58d4a | 2013-09-26 14:21:22 -0700 | [diff] [blame] | 593 | space::MallocSpace* GetNonMovingSpace() const { |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 594 | return non_moving_space_; |
Mathieu Chartier | e0f0cb3 | 2012-08-28 11:26:00 -0700 | [diff] [blame] | 595 | } |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 596 | |
| 597 | space::LargeObjectSpace* GetLargeObjectsSpace() const { |
| 598 | return large_object_space_; |
| 599 | } |
| 600 | |
Hiroshi Yamauchi | 05e713a | 2014-01-09 13:24:51 -0800 | [diff] [blame] | 601 | // Returns the free list space that may contain movable objects (the |
| 602 | // one that's not the non-moving space), either rosalloc_space_ or |
| 603 | // dlmalloc_space_. |
| 604 | space::MallocSpace* GetPrimaryFreeListSpace() { |
| 605 | if (kUseRosAlloc) { |
| 606 | DCHECK(rosalloc_space_ != nullptr); |
| 607 | // reinterpret_cast is necessary as the space class hierarchy |
| 608 | // isn't known (#included) yet here. |
| 609 | return reinterpret_cast<space::MallocSpace*>(rosalloc_space_); |
| 610 | } else { |
| 611 | DCHECK(dlmalloc_space_ != nullptr); |
| 612 | return reinterpret_cast<space::MallocSpace*>(dlmalloc_space_); |
| 613 | } |
| 614 | } |
| 615 | |
Mathieu Chartier | 4c13a3f | 2014-07-14 14:57:16 -0700 | [diff] [blame] | 616 | std::string DumpSpaces() const WARN_UNUSED; |
| 617 | void DumpSpaces(std::ostream& stream) const; |
Elliott Hughes | f834936 | 2012-06-18 15:00:06 -0700 | [diff] [blame] | 618 | |
Mathieu Chartier | 15d3402 | 2014-02-26 17:16:38 -0800 | [diff] [blame] | 619 | // Dump object should only be used by the signal handler. |
| 620 | void DumpObject(std::ostream& stream, mirror::Object* obj) NO_THREAD_SAFETY_ANALYSIS; |
| 621 | // Safe version of pretty type of which check to make sure objects are heap addresses. |
| 622 | std::string SafeGetClassDescriptor(mirror::Class* klass) NO_THREAD_SAFETY_ANALYSIS; |
| 623 | std::string SafePrettyTypeOf(mirror::Object* obj) NO_THREAD_SAFETY_ANALYSIS; |
| 624 | |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 625 | // GC performance measuring |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 626 | void DumpGcPerformanceInfo(std::ostream& os) REQUIRES(!*gc_complete_lock_); |
| 627 | void ResetGcPerformanceInfo() REQUIRES(!*gc_complete_lock_); |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 628 | |
Mathieu Chartier | 2775ee4 | 2013-08-20 17:43:47 -0700 | [diff] [blame] | 629 | // Returns true if we currently care about pause times. |
| 630 | bool CareAboutPauseTimes() const { |
Mathieu Chartier | ca2a24d | 2013-11-25 15:12:12 -0800 | [diff] [blame] | 631 | return process_state_ == kProcessStateJankPerceptible; |
Mathieu Chartier | 2775ee4 | 2013-08-20 17:43:47 -0700 | [diff] [blame] | 632 | } |
| 633 | |
Mathieu Chartier | 02b6a78 | 2012-10-26 13:51:26 -0700 | [diff] [blame] | 634 | // Thread pool. |
| 635 | void CreateThreadPool(); |
| 636 | void DeleteThreadPool(); |
| 637 | ThreadPool* GetThreadPool() { |
| 638 | return thread_pool_.get(); |
| 639 | } |
Mathieu Chartier | 2775ee4 | 2013-08-20 17:43:47 -0700 | [diff] [blame] | 640 | size_t GetParallelGCThreadCount() const { |
| 641 | return parallel_gc_threads_; |
| 642 | } |
| 643 | size_t GetConcGCThreadCount() const { |
| 644 | return conc_gc_threads_; |
| 645 | } |
Mathieu Chartier | 11409ae | 2013-09-23 11:49:36 -0700 | [diff] [blame] | 646 | accounting::ModUnionTable* FindModUnionTableFromSpace(space::Space* space); |
| 647 | void AddModUnionTable(accounting::ModUnionTable* mod_union_table); |
Mathieu Chartier | 02b6a78 | 2012-10-26 13:51:26 -0700 | [diff] [blame] | 648 | |
Hiroshi Yamauchi | 38e68e9 | 2014-03-07 13:59:08 -0800 | [diff] [blame] | 649 | accounting::RememberedSet* FindRememberedSetFromSpace(space::Space* space); |
| 650 | void AddRememberedSet(accounting::RememberedSet* remembered_set); |
Mathieu Chartier | 5189e24 | 2014-07-24 11:11:05 -0700 | [diff] [blame] | 651 | // Also deletes the remebered set. |
Hiroshi Yamauchi | 38e68e9 | 2014-03-07 13:59:08 -0800 | [diff] [blame] | 652 | void RemoveRememberedSet(space::Space* space); |
| 653 | |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 654 | bool IsCompilingBoot() const; |
| 655 | bool HasImageSpace() const; |
| 656 | |
Mathieu Chartier | 78f7b4c | 2014-05-06 10:57:27 -0700 | [diff] [blame] | 657 | ReferenceProcessor* GetReferenceProcessor() { |
Mathieu Chartier | 3cf2253 | 2015-07-09 15:15:09 -0700 | [diff] [blame] | 658 | return reference_processor_.get(); |
Mathieu Chartier | 78f7b4c | 2014-05-06 10:57:27 -0700 | [diff] [blame] | 659 | } |
Mathieu Chartier | a5eae69 | 2014-12-17 17:56:03 -0800 | [diff] [blame] | 660 | TaskProcessor* GetTaskProcessor() { |
| 661 | return task_processor_.get(); |
| 662 | } |
Mathieu Chartier | 78f7b4c | 2014-05-06 10:57:27 -0700 | [diff] [blame] | 663 | |
Mathieu Chartier | e4cab17 | 2014-08-19 18:24:04 -0700 | [diff] [blame] | 664 | bool HasZygoteSpace() const { |
| 665 | return zygote_space_ != nullptr; |
| 666 | } |
| 667 | |
Hiroshi Yamauchi | 2cd334a | 2015-01-09 14:03:35 -0800 | [diff] [blame] | 668 | collector::ConcurrentCopying* ConcurrentCopyingCollector() { |
| 669 | return concurrent_copying_collector_; |
| 670 | } |
| 671 | |
| 672 | CollectorType CurrentCollectorType() { |
| 673 | return collector_type_; |
| 674 | } |
| 675 | |
| 676 | bool IsGcConcurrentAndMoving() const { |
| 677 | if (IsGcConcurrent() && IsMovingGc(collector_type_)) { |
| 678 | // Assume no transition when a concurrent moving collector is used. |
| 679 | DCHECK_EQ(collector_type_, foreground_collector_type_); |
| 680 | DCHECK_EQ(foreground_collector_type_, background_collector_type_) |
| 681 | << "Assume no transition such that collector_type_ won't change"; |
| 682 | return true; |
| 683 | } |
| 684 | return false; |
| 685 | } |
| 686 | |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 687 | bool IsMovingGCDisabled(Thread* self) REQUIRES(!*gc_complete_lock_) { |
Hiroshi Yamauchi | 2cd334a | 2015-01-09 14:03:35 -0800 | [diff] [blame] | 688 | MutexLock mu(self, *gc_complete_lock_); |
| 689 | return disable_moving_gc_count_ > 0; |
| 690 | } |
| 691 | |
Mathieu Chartier | a5eae69 | 2014-12-17 17:56:03 -0800 | [diff] [blame] | 692 | // Request an asynchronous trim. |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 693 | void RequestTrim(Thread* self) REQUIRES(!*pending_task_lock_); |
Mathieu Chartier | a5eae69 | 2014-12-17 17:56:03 -0800 | [diff] [blame] | 694 | |
| 695 | // Request asynchronous GC. |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 696 | void RequestConcurrentGC(Thread* self, bool force_full) REQUIRES(!*pending_task_lock_); |
Mathieu Chartier | 079101a | 2014-12-15 14:23:10 -0800 | [diff] [blame] | 697 | |
Mathieu Chartier | dfe3083 | 2015-03-06 15:28:34 -0800 | [diff] [blame] | 698 | // Whether or not we may use a garbage collector, used so that we only create collectors we need. |
| 699 | bool MayUseCollector(CollectorType type) const; |
| 700 | |
Hiroshi Yamauchi | 4460a84 | 2015-03-09 11:57:48 -0700 | [diff] [blame] | 701 | // Used by tests to reduce timinig-dependent flakiness in OOME behavior. |
| 702 | void SetMinIntervalHomogeneousSpaceCompactionByOom(uint64_t interval) { |
| 703 | min_interval_homogeneous_space_compaction_by_oom_ = interval; |
| 704 | } |
| 705 | |
Hiroshi Yamauchi | a1c9f01 | 2015-04-02 10:18:12 -0700 | [diff] [blame] | 706 | // Helpers for android.os.Debug.getRuntimeStat(). |
| 707 | uint64_t GetGcCount() const; |
| 708 | uint64_t GetGcTime() const; |
| 709 | uint64_t GetBlockingGcCount() const; |
| 710 | uint64_t GetBlockingGcTime() const; |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 711 | void DumpGcCountRateHistogram(std::ostream& os) const REQUIRES(!*gc_complete_lock_); |
| 712 | void DumpBlockingGcCountRateHistogram(std::ostream& os) const REQUIRES(!*gc_complete_lock_); |
Hiroshi Yamauchi | a1c9f01 | 2015-04-02 10:18:12 -0700 | [diff] [blame] | 713 | |
Man Cao | 8c2ff64 | 2015-05-27 17:25:30 -0700 | [diff] [blame] | 714 | // Allocation tracking support |
| 715 | // Callers to this function use double-checked locking to ensure safety on allocation_records_ |
| 716 | bool IsAllocTrackingEnabled() const { |
| 717 | return alloc_tracking_enabled_.LoadRelaxed(); |
| 718 | } |
| 719 | |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 720 | void SetAllocTrackingEnabled(bool enabled) REQUIRES(Locks::alloc_tracker_lock_) { |
Man Cao | 8c2ff64 | 2015-05-27 17:25:30 -0700 | [diff] [blame] | 721 | alloc_tracking_enabled_.StoreRelaxed(enabled); |
| 722 | } |
| 723 | |
| 724 | AllocRecordObjectMap* GetAllocationRecords() const |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 725 | REQUIRES(Locks::alloc_tracker_lock_) { |
Man Cao | 8c2ff64 | 2015-05-27 17:25:30 -0700 | [diff] [blame] | 726 | return allocation_records_.get(); |
| 727 | } |
| 728 | |
| 729 | void SetAllocationRecords(AllocRecordObjectMap* records) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 730 | REQUIRES(Locks::alloc_tracker_lock_); |
Man Cao | 8c2ff64 | 2015-05-27 17:25:30 -0700 | [diff] [blame] | 731 | |
Man Cao | 1ed11b9 | 2015-06-11 22:47:35 -0700 | [diff] [blame] | 732 | void VisitAllocationRecords(RootVisitor* visitor) const |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 733 | SHARED_REQUIRES(Locks::mutator_lock_) |
| 734 | REQUIRES(!Locks::alloc_tracker_lock_); |
Man Cao | 1ed11b9 | 2015-06-11 22:47:35 -0700 | [diff] [blame] | 735 | |
Mathieu Chartier | 9750995 | 2015-07-13 14:35:43 -0700 | [diff] [blame] | 736 | void SweepAllocationRecords(IsMarkedVisitor* visitor) const |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 737 | SHARED_REQUIRES(Locks::mutator_lock_) |
| 738 | REQUIRES(!Locks::alloc_tracker_lock_); |
Man Cao | 42c3c33 | 2015-06-23 16:38:25 -0700 | [diff] [blame] | 739 | |
| 740 | void DisallowNewAllocationRecords() const |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 741 | SHARED_REQUIRES(Locks::mutator_lock_) |
| 742 | REQUIRES(!Locks::alloc_tracker_lock_); |
Man Cao | 42c3c33 | 2015-06-23 16:38:25 -0700 | [diff] [blame] | 743 | |
| 744 | void AllowNewAllocationRecords() const |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 745 | SHARED_REQUIRES(Locks::mutator_lock_) |
| 746 | REQUIRES(!Locks::alloc_tracker_lock_); |
Man Cao | 42c3c33 | 2015-06-23 16:38:25 -0700 | [diff] [blame] | 747 | |
Mathieu Chartier | 5116837 | 2015-08-12 16:40:32 -0700 | [diff] [blame^] | 748 | void DisableGCForShutdown() REQUIRES(!*gc_complete_lock_); |
| 749 | |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 750 | private: |
Mathieu Chartier | a5eae69 | 2014-12-17 17:56:03 -0800 | [diff] [blame] | 751 | class ConcurrentGCTask; |
| 752 | class CollectorTransitionTask; |
| 753 | class HeapTrimTask; |
| 754 | |
Hiroshi Yamauchi | e4d9987 | 2015-02-26 12:53:45 -0800 | [diff] [blame] | 755 | // Compact source space to target space. Returns the collector used. |
| 756 | collector::GarbageCollector* Compact(space::ContinuousMemMapAllocSpace* target_space, |
| 757 | space::ContinuousMemMapAllocSpace* source_space, |
| 758 | GcCause gc_cause) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 759 | REQUIRES(Locks::mutator_lock_); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 760 | |
Hiroshi Yamauchi | e4d9987 | 2015-02-26 12:53:45 -0800 | [diff] [blame] | 761 | void LogGC(GcCause gc_cause, collector::GarbageCollector* collector); |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 762 | void FinishGC(Thread* self, collector::GcType gc_type) REQUIRES(!*gc_complete_lock_); |
Mathieu Chartier | e6da9af | 2013-12-16 11:54:42 -0800 | [diff] [blame] | 763 | |
Mathieu Chartier | b363f66 | 2014-07-16 13:28:58 -0700 | [diff] [blame] | 764 | // Create a mem map with a preferred base address. |
Ian Rogers | 1373595 | 2014-10-08 12:43:28 -0700 | [diff] [blame] | 765 | static MemMap* MapAnonymousPreferredAddress(const char* name, uint8_t* request_begin, |
Ian Rogers | 6a3c1fc | 2014-10-31 00:33:20 -0700 | [diff] [blame] | 766 | size_t capacity, std::string* out_error_str); |
Mathieu Chartier | b363f66 | 2014-07-16 13:28:58 -0700 | [diff] [blame] | 767 | |
Zuo Wang | f37a88b | 2014-07-10 04:26:41 -0700 | [diff] [blame] | 768 | bool SupportHSpaceCompaction() const { |
Mathieu Chartier | b363f66 | 2014-07-16 13:28:58 -0700 | [diff] [blame] | 769 | // Returns true if we can do hspace compaction |
Zuo Wang | f37a88b | 2014-07-10 04:26:41 -0700 | [diff] [blame] | 770 | return main_space_backup_ != nullptr; |
| 771 | } |
| 772 | |
Mathieu Chartier | 692fafd | 2013-11-29 17:24:40 -0800 | [diff] [blame] | 773 | static ALWAYS_INLINE bool AllocatorHasAllocationStack(AllocatorType allocator_type) { |
| 774 | return |
| 775 | allocator_type != kAllocatorTypeBumpPointer && |
Hiroshi Yamauchi | 2cd334a | 2015-01-09 14:03:35 -0800 | [diff] [blame] | 776 | allocator_type != kAllocatorTypeTLAB && |
| 777 | allocator_type != kAllocatorTypeRegion && |
| 778 | allocator_type != kAllocatorTypeRegionTLAB; |
Mathieu Chartier | cbb2d20 | 2013-11-14 17:45:16 -0800 | [diff] [blame] | 779 | } |
Mathieu Chartier | 692fafd | 2013-11-29 17:24:40 -0800 | [diff] [blame] | 780 | static ALWAYS_INLINE bool AllocatorMayHaveConcurrentGC(AllocatorType allocator_type) { |
Hiroshi Yamauchi | 2cd334a | 2015-01-09 14:03:35 -0800 | [diff] [blame] | 781 | return |
| 782 | allocator_type != kAllocatorTypeBumpPointer && |
| 783 | allocator_type != kAllocatorTypeTLAB; |
Mathieu Chartier | cbb2d20 | 2013-11-14 17:45:16 -0800 | [diff] [blame] | 784 | } |
Mathieu Chartier | 31f4414 | 2014-04-08 14:40:03 -0700 | [diff] [blame] | 785 | static bool IsMovingGc(CollectorType collector_type) { |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 786 | return |
| 787 | collector_type == kCollectorTypeSS || |
| 788 | collector_type == kCollectorTypeGSS || |
| 789 | collector_type == kCollectorTypeCC || |
| 790 | collector_type == kCollectorTypeMC || |
Zuo Wang | f37a88b | 2014-07-10 04:26:41 -0700 | [diff] [blame] | 791 | collector_type == kCollectorTypeHomogeneousSpaceCompact; |
Mathieu Chartier | 9be9a7a | 2014-01-24 14:07:33 -0800 | [diff] [blame] | 792 | } |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 793 | bool ShouldAllocLargeObject(mirror::Class* c, size_t byte_count) const |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 794 | SHARED_REQUIRES(Locks::mutator_lock_); |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 795 | ALWAYS_INLINE void CheckConcurrentGC(Thread* self, |
| 796 | size_t new_num_bytes_allocated, |
Mathieu Chartier | f517f1a | 2014-03-06 15:52:27 -0800 | [diff] [blame] | 797 | mirror::Object** obj) |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 798 | SHARED_REQUIRES(Locks::mutator_lock_) |
| 799 | REQUIRES(!*pending_task_lock_, !*gc_complete_lock_); |
Hiroshi Yamauchi | 50b2928 | 2013-07-30 13:58:37 -0700 | [diff] [blame] | 800 | |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 801 | accounting::ObjectStack* GetMarkStack() { |
| 802 | return mark_stack_.get(); |
| 803 | } |
| 804 | |
Mathieu Chartier | 692fafd | 2013-11-29 17:24:40 -0800 | [diff] [blame] | 805 | // We don't force this to be inlined since it is a slow path. |
Mathieu Chartier | c528dba | 2013-11-26 12:00:11 -0800 | [diff] [blame] | 806 | template <bool kInstrumented, typename PreFenceVisitor> |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 807 | mirror::Object* AllocLargeObject(Thread* self, |
| 808 | mirror::Class** klass, |
| 809 | size_t byte_count, |
Mathieu Chartier | c528dba | 2013-11-26 12:00:11 -0800 | [diff] [blame] | 810 | const PreFenceVisitor& pre_fence_visitor) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 811 | SHARED_REQUIRES(Locks::mutator_lock_) |
| 812 | REQUIRES(!*gc_complete_lock_, !*pending_task_lock_, !*backtrace_lock_); |
Mathieu Chartier | c528dba | 2013-11-26 12:00:11 -0800 | [diff] [blame] | 813 | |
Hiroshi Yamauchi | 50b2928 | 2013-07-30 13:58:37 -0700 | [diff] [blame] | 814 | // Handles Allocate()'s slow allocation path with GC involved after |
| 815 | // an initial allocation attempt failed. |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 816 | mirror::Object* AllocateInternalWithGc(Thread* self, |
| 817 | AllocatorType allocator, |
| 818 | size_t num_bytes, |
| 819 | size_t* bytes_allocated, |
| 820 | size_t* usable_size, |
Hiroshi Yamauchi | 4460a84 | 2015-03-09 11:57:48 -0700 | [diff] [blame] | 821 | size_t* bytes_tl_bulk_allocated, |
Ian Rogers | 6fac447 | 2014-02-25 17:01:10 -0800 | [diff] [blame] | 822 | mirror::Class** klass) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 823 | REQUIRES(!Locks::thread_suspend_count_lock_, !*gc_complete_lock_, !*pending_task_lock_) |
| 824 | SHARED_REQUIRES(Locks::mutator_lock_); |
Mathieu Chartier | a639903 | 2012-06-11 18:49:50 -0700 | [diff] [blame] | 825 | |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 826 | // Allocate into a specific space. |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 827 | mirror::Object* AllocateInto(Thread* self, |
| 828 | space::AllocSpace* space, |
| 829 | mirror::Class* c, |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 830 | size_t bytes) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 831 | SHARED_REQUIRES(Locks::mutator_lock_); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 832 | |
Mathieu Chartier | 31f4414 | 2014-04-08 14:40:03 -0700 | [diff] [blame] | 833 | // Need to do this with mutators paused so that somebody doesn't accidentally allocate into the |
| 834 | // wrong space. |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 835 | void SwapSemiSpaces() REQUIRES(Locks::mutator_lock_); |
Mathieu Chartier | 31f4414 | 2014-04-08 14:40:03 -0700 | [diff] [blame] | 836 | |
Mathieu Chartier | cbb2d20 | 2013-11-14 17:45:16 -0800 | [diff] [blame] | 837 | // Try to allocate a number of bytes, this function never does any GCs. Needs to be inlined so |
| 838 | // that the switch statement is constant optimized in the entrypoints. |
Mathieu Chartier | c528dba | 2013-11-26 12:00:11 -0800 | [diff] [blame] | 839 | template <const bool kInstrumented, const bool kGrow> |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 840 | ALWAYS_INLINE mirror::Object* TryToAllocate(Thread* self, |
| 841 | AllocatorType allocator_type, |
| 842 | size_t alloc_size, |
| 843 | size_t* bytes_allocated, |
Hiroshi Yamauchi | 4460a84 | 2015-03-09 11:57:48 -0700 | [diff] [blame] | 844 | size_t* usable_size, |
| 845 | size_t* bytes_tl_bulk_allocated) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 846 | SHARED_REQUIRES(Locks::mutator_lock_); |
Hiroshi Yamauchi | cf58d4a | 2013-09-26 14:21:22 -0700 | [diff] [blame] | 847 | |
Hiroshi Yamauchi | 654dd48 | 2014-07-09 12:54:32 -0700 | [diff] [blame] | 848 | void ThrowOutOfMemoryError(Thread* self, size_t byte_count, AllocatorType allocator_type) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 849 | SHARED_REQUIRES(Locks::mutator_lock_); |
Mathieu Chartier | 692fafd | 2013-11-29 17:24:40 -0800 | [diff] [blame] | 850 | |
| 851 | template <bool kGrow> |
Hiroshi Yamauchi | eb1e929 | 2014-08-06 12:41:15 -0700 | [diff] [blame] | 852 | ALWAYS_INLINE bool IsOutOfMemoryOnAllocation(AllocatorType allocator_type, size_t alloc_size); |
Hiroshi Yamauchi | 50b2928 | 2013-07-30 13:58:37 -0700 | [diff] [blame] | 853 | |
Mathieu Chartier | 15d3402 | 2014-02-26 17:16:38 -0800 | [diff] [blame] | 854 | // Returns true if the address passed in is within the address range of a continuous space. |
| 855 | bool IsValidContinuousSpaceObjectAddress(const mirror::Object* obj) const |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 856 | SHARED_REQUIRES(Locks::mutator_lock_); |
Mathieu Chartier | 15d3402 | 2014-02-26 17:16:38 -0800 | [diff] [blame] | 857 | |
Mathieu Chartier | b5de3bb | 2015-06-05 13:21:05 -0700 | [diff] [blame] | 858 | // Run the finalizers. If timeout is non zero, then we use the VMRuntime version. |
| 859 | void RunFinalization(JNIEnv* env, uint64_t timeout); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 860 | |
| 861 | // Blocks the caller until the garbage collector becomes idle and returns the type of GC we |
| 862 | // waited for. |
Mathieu Chartier | 89a201e | 2014-05-02 10:27:26 -0700 | [diff] [blame] | 863 | collector::GcType WaitForGcToCompleteLocked(GcCause cause, Thread* self) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 864 | REQUIRES(gc_complete_lock_); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 865 | |
Mathieu Chartier | 7bf52d2 | 2014-03-13 14:46:09 -0700 | [diff] [blame] | 866 | void RequestCollectorTransition(CollectorType desired_collector_type, uint64_t delta_time) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 867 | REQUIRES(!*pending_task_lock_); |
Mathieu Chartier | a5eae69 | 2014-12-17 17:56:03 -0800 | [diff] [blame] | 868 | |
Hiroshi Yamauchi | 0ae9899 | 2015-05-01 14:33:19 -0700 | [diff] [blame] | 869 | void RequestConcurrentGCAndSaveObject(Thread* self, bool force_full, mirror::Object** obj) |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 870 | SHARED_REQUIRES(Locks::mutator_lock_) |
| 871 | REQUIRES(!*pending_task_lock_); |
Mathieu Chartier | 987ccff | 2013-07-08 11:05:21 -0700 | [diff] [blame] | 872 | bool IsGCRequestPending() const; |
Elliott Hughes | 8cf5bc0 | 2012-02-02 16:32:16 -0800 | [diff] [blame] | 873 | |
Mathieu Chartier | 866fb2a | 2012-09-10 10:47:49 -0700 | [diff] [blame] | 874 | // Sometimes CollectGarbageInternal decides to run a different Gc than you requested. Returns |
| 875 | // which type of Gc was actually ran. |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 876 | collector::GcType CollectGarbageInternal(collector::GcType gc_plan, |
| 877 | GcCause gc_cause, |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 878 | bool clear_soft_references) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 879 | REQUIRES(!*gc_complete_lock_, !Locks::heap_bitmap_lock_, !Locks::thread_suspend_count_lock_, |
| 880 | !*pending_task_lock_); |
Mathieu Chartier | 2b82db4 | 2012-11-14 17:29:05 -0800 | [diff] [blame] | 881 | |
Mathieu Chartier | 6f365cc | 2014-04-23 12:42:27 -0700 | [diff] [blame] | 882 | void PreGcVerification(collector::GarbageCollector* gc) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 883 | REQUIRES(!Locks::mutator_lock_, !*gc_complete_lock_); |
Mathieu Chartier | 6f365cc | 2014-04-23 12:42:27 -0700 | [diff] [blame] | 884 | void PreGcVerificationPaused(collector::GarbageCollector* gc) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 885 | REQUIRES(Locks::mutator_lock_, !*gc_complete_lock_); |
Mathieu Chartier | 6f365cc | 2014-04-23 12:42:27 -0700 | [diff] [blame] | 886 | void PrePauseRosAllocVerification(collector::GarbageCollector* gc) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 887 | REQUIRES(Locks::mutator_lock_); |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 888 | void PreSweepingGcVerification(collector::GarbageCollector* gc) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 889 | REQUIRES(Locks::mutator_lock_, !Locks::heap_bitmap_lock_, !*gc_complete_lock_); |
Mathieu Chartier | ad2541a | 2013-10-25 10:05:23 -0700 | [diff] [blame] | 890 | void PostGcVerification(collector::GarbageCollector* gc) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 891 | REQUIRES(!Locks::mutator_lock_, !*gc_complete_lock_); |
Mathieu Chartier | 6f365cc | 2014-04-23 12:42:27 -0700 | [diff] [blame] | 892 | void PostGcVerificationPaused(collector::GarbageCollector* gc) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 893 | REQUIRES(Locks::mutator_lock_, !*gc_complete_lock_); |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 894 | |
Mathieu Chartier | 987ccff | 2013-07-08 11:05:21 -0700 | [diff] [blame] | 895 | // Update the watermark for the native allocated bytes based on the current number of native |
| 896 | // bytes allocated and the target utilization ratio. |
| 897 | void UpdateMaxNativeFootprint(); |
| 898 | |
Mathieu Chartier | afe4998 | 2014-03-27 10:55:04 -0700 | [diff] [blame] | 899 | // Find a collector based on GC type. |
| 900 | collector::GarbageCollector* FindCollectorByGcType(collector::GcType gc_type); |
| 901 | |
Zuo Wang | f37a88b | 2014-07-10 04:26:41 -0700 | [diff] [blame] | 902 | // Create a new alloc space and compact default alloc space to it. |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 903 | HomogeneousSpaceCompactResult PerformHomogeneousSpaceCompact() REQUIRES(!*gc_complete_lock_); |
Zuo Wang | f37a88b | 2014-07-10 04:26:41 -0700 | [diff] [blame] | 904 | |
| 905 | // Create the main free list malloc space, either a RosAlloc space or DlMalloc space. |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 906 | void CreateMainMallocSpace(MemMap* mem_map, |
| 907 | size_t initial_size, |
| 908 | size_t growth_limit, |
Mathieu Chartier | 31f4414 | 2014-04-08 14:40:03 -0700 | [diff] [blame] | 909 | size_t capacity); |
| 910 | |
Zuo Wang | f37a88b | 2014-07-10 04:26:41 -0700 | [diff] [blame] | 911 | // Create a malloc space based on a mem map. Does not set the space as default. |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 912 | space::MallocSpace* CreateMallocSpaceFromMemMap(MemMap* mem_map, |
| 913 | size_t initial_size, |
| 914 | size_t growth_limit, |
| 915 | size_t capacity, |
| 916 | const char* name, |
| 917 | bool can_move_objects); |
Zuo Wang | f37a88b | 2014-07-10 04:26:41 -0700 | [diff] [blame] | 918 | |
Ian Rogers | 3bb17a6 | 2012-01-27 23:56:44 -0800 | [diff] [blame] | 919 | // Given the current contents of the alloc space, increase the allowed heap footprint to match |
| 920 | // the target utilization ratio. This should only be called immediately after a full garbage |
Mathieu Chartier | e2c2f6e | 2014-12-16 18:49:31 -0800 | [diff] [blame] | 921 | // collection. bytes_allocated_before_gc is used to measure bytes / second for the period which |
| 922 | // the GC was run. |
| 923 | void GrowForUtilization(collector::GarbageCollector* collector_ran, |
| 924 | uint64_t bytes_allocated_before_gc = 0); |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 925 | |
Mathieu Chartier | 637e348 | 2012-08-17 10:41:32 -0700 | [diff] [blame] | 926 | size_t GetPercentFree(); |
Elliott Hughes | c967f78 | 2012-04-16 10:23:15 -0700 | [diff] [blame] | 927 | |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 928 | static void VerificationCallback(mirror::Object* obj, void* arg) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 929 | SHARED_REQUIRES(Locks::heap_bitmap_lock_); |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 930 | |
Mathieu Chartier | e0f0cb3 | 2012-08-28 11:26:00 -0700 | [diff] [blame] | 931 | // Swap the allocation stack with the live stack. |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 932 | void SwapStacks() SHARED_REQUIRES(Locks::mutator_lock_); |
Hiroshi Yamauchi | f5b0e20 | 2014-02-11 17:02:22 -0800 | [diff] [blame] | 933 | |
Lei Li | 4add3b4 | 2015-01-15 11:55:26 +0800 | [diff] [blame] | 934 | // Clear cards and update the mod union table. When process_alloc_space_cards is true, |
| 935 | // if clear_alloc_space_cards is true, then we clear cards instead of ageing them. We do |
| 936 | // not process the alloc space if process_alloc_space_cards is false. |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 937 | void ProcessCards(TimingLogger* timings, |
| 938 | bool use_rem_sets, |
| 939 | bool process_alloc_space_cards, |
Lei Li | 4add3b4 | 2015-01-15 11:55:26 +0800 | [diff] [blame] | 940 | bool clear_alloc_space_cards); |
Mathieu Chartier | 7469ebf | 2012-09-24 16:28:36 -0700 | [diff] [blame] | 941 | |
Hiroshi Yamauchi | f5b0e20 | 2014-02-11 17:02:22 -0800 | [diff] [blame] | 942 | // Push an object onto the allocation stack. |
Hiroshi Yamauchi | 4cd662e | 2014-04-03 16:28:10 -0700 | [diff] [blame] | 943 | void PushOnAllocationStack(Thread* self, mirror::Object** obj) |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 944 | SHARED_REQUIRES(Locks::mutator_lock_) |
| 945 | REQUIRES(!*gc_complete_lock_, !*pending_task_lock_); |
Mathieu Chartier | c179016 | 2014-05-23 10:54:50 -0700 | [diff] [blame] | 946 | void PushOnAllocationStackWithInternalGC(Thread* self, mirror::Object** obj) |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 947 | SHARED_REQUIRES(Locks::mutator_lock_) |
| 948 | REQUIRES(!*gc_complete_lock_, !*pending_task_lock_); |
Mathieu Chartier | c179016 | 2014-05-23 10:54:50 -0700 | [diff] [blame] | 949 | void PushOnThreadLocalAllocationStackWithInternalGC(Thread* thread, mirror::Object** obj) |
Mathieu Chartier | a4f6af9 | 2015-08-11 17:35:25 -0700 | [diff] [blame] | 950 | SHARED_REQUIRES(Locks::mutator_lock_) |
| 951 | REQUIRES(!*gc_complete_lock_, !*pending_task_lock_); |
Hiroshi Yamauchi | f5b0e20 | 2014-02-11 17:02:22 -0800 | [diff] [blame] | 952 | |
Mathieu Chartier | a5eae69 | 2014-12-17 17:56:03 -0800 | [diff] [blame] | 953 | void ClearConcurrentGCRequest(); |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 954 | void ClearPendingTrim(Thread* self) REQUIRES(!*pending_task_lock_); |
| 955 | void ClearPendingCollectorTransition(Thread* self) REQUIRES(!*pending_task_lock_); |
Mathieu Chartier | a5eae69 | 2014-12-17 17:56:03 -0800 | [diff] [blame] | 956 | |
Hiroshi Yamauchi | 3e41780 | 2014-03-20 12:03:02 -0700 | [diff] [blame] | 957 | // What kind of concurrency behavior is the runtime after? Currently true for concurrent mark |
| 958 | // sweep GC, false for other GC types. |
| 959 | bool IsGcConcurrent() const ALWAYS_INLINE { |
Hiroshi Yamauchi | d5307ec | 2014-03-27 21:07:51 -0700 | [diff] [blame] | 960 | return collector_type_ == kCollectorTypeCMS || collector_type_ == kCollectorTypeCC; |
Hiroshi Yamauchi | 3e41780 | 2014-03-20 12:03:02 -0700 | [diff] [blame] | 961 | } |
| 962 | |
Mathieu Chartier | a5eae69 | 2014-12-17 17:56:03 -0800 | [diff] [blame] | 963 | // Trim the managed and native spaces by releasing unused memory back to the OS. |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 964 | void TrimSpaces(Thread* self) REQUIRES(!*gc_complete_lock_); |
Mathieu Chartier | a5eae69 | 2014-12-17 17:56:03 -0800 | [diff] [blame] | 965 | |
| 966 | // Trim 0 pages at the end of reference tables. |
| 967 | void TrimIndirectReferenceTables(Thread* self); |
| 968 | |
Hiroshi Yamauchi | 2cd334a | 2015-01-09 14:03:35 -0800 | [diff] [blame] | 969 | void VisitObjectsInternal(ObjectCallback callback, void* arg) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 970 | SHARED_REQUIRES(Locks::mutator_lock_) |
| 971 | REQUIRES(!Locks::heap_bitmap_lock_, !*gc_complete_lock_); |
Hiroshi Yamauchi | 2cd334a | 2015-01-09 14:03:35 -0800 | [diff] [blame] | 972 | void VisitObjectsInternalRegionSpace(ObjectCallback callback, void* arg) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 973 | REQUIRES(Locks::mutator_lock_, !Locks::heap_bitmap_lock_, !*gc_complete_lock_); |
Hiroshi Yamauchi | 2cd334a | 2015-01-09 14:03:35 -0800 | [diff] [blame] | 974 | |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 975 | void UpdateGcCountRateHistograms() REQUIRES(gc_complete_lock_); |
Hiroshi Yamauchi | a1c9f01 | 2015-04-02 10:18:12 -0700 | [diff] [blame] | 976 | |
Mathieu Chartier | 3100080 | 2015-06-14 14:14:37 -0700 | [diff] [blame] | 977 | // GC stress mode attempts to do one GC per unique backtrace. |
| 978 | void CheckGcStressMode(Thread* self, mirror::Object** obj) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 979 | SHARED_REQUIRES(Locks::mutator_lock_) |
| 980 | REQUIRES(!*gc_complete_lock_, !*pending_task_lock_, !*backtrace_lock_); |
Mathieu Chartier | 3100080 | 2015-06-14 14:14:37 -0700 | [diff] [blame] | 981 | |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 982 | // All-known continuous spaces, where objects lie within fixed bounds. |
| 983 | std::vector<space::ContinuousSpace*> continuous_spaces_; |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 984 | |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 985 | // All-known discontinuous spaces, where objects may be placed throughout virtual memory. |
| 986 | std::vector<space::DiscontinuousSpace*> discontinuous_spaces_; |
Mathieu Chartier | d8195f1 | 2012-10-05 12:21:28 -0700 | [diff] [blame] | 987 | |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 988 | // All-known alloc spaces, where objects may be or have been allocated. |
| 989 | std::vector<space::AllocSpace*> alloc_spaces_; |
| 990 | |
| 991 | // A space where non-movable objects are allocated, when compaction is enabled it contains |
| 992 | // Classes, ArtMethods, ArtFields, and non moving objects. |
Hiroshi Yamauchi | cf58d4a | 2013-09-26 14:21:22 -0700 | [diff] [blame] | 993 | space::MallocSpace* non_moving_space_; |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 994 | |
Mathieu Chartier | e6da9af | 2013-12-16 11:54:42 -0800 | [diff] [blame] | 995 | // Space which we use for the kAllocatorTypeROSAlloc. |
| 996 | space::RosAllocSpace* rosalloc_space_; |
| 997 | |
| 998 | // Space which we use for the kAllocatorTypeDlMalloc. |
| 999 | space::DlMallocSpace* dlmalloc_space_; |
| 1000 | |
Mathieu Chartier | fc5b528 | 2014-01-09 16:15:36 -0800 | [diff] [blame] | 1001 | // The main space is the space which the GC copies to and from on process state updates. This |
| 1002 | // space is typically either the dlmalloc_space_ or the rosalloc_space_. |
| 1003 | space::MallocSpace* main_space_; |
| 1004 | |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 1005 | // The large object space we are currently allocating into. |
| 1006 | space::LargeObjectSpace* large_object_space_; |
| 1007 | |
| 1008 | // The card table, dirtied by the write barrier. |
Ian Rogers | 700a402 | 2014-05-19 16:49:03 -0700 | [diff] [blame] | 1009 | std::unique_ptr<accounting::CardTable> card_table_; |
Brian Carlstrom | 4a289ed | 2011-08-16 17:17:49 -0700 | [diff] [blame] | 1010 | |
Hiroshi Yamauchi | 2cd334a | 2015-01-09 14:03:35 -0800 | [diff] [blame] | 1011 | std::unique_ptr<accounting::ReadBarrierTable> rb_table_; |
| 1012 | |
Mathieu Chartier | 11409ae | 2013-09-23 11:49:36 -0700 | [diff] [blame] | 1013 | // A mod-union table remembers all of the references from the it's space to other spaces. |
Mathieu Chartier | bad0267 | 2014-08-25 13:08:22 -0700 | [diff] [blame] | 1014 | AllocationTrackingSafeMap<space::Space*, accounting::ModUnionTable*, kAllocatorTagHeap> |
| 1015 | mod_union_tables_; |
Mathieu Chartier | cc236d7 | 2012-07-20 10:29:05 -0700 | [diff] [blame] | 1016 | |
Hiroshi Yamauchi | 38e68e9 | 2014-03-07 13:59:08 -0800 | [diff] [blame] | 1017 | // A remembered set remembers all of the references from the it's space to the target space. |
Mathieu Chartier | bad0267 | 2014-08-25 13:08:22 -0700 | [diff] [blame] | 1018 | AllocationTrackingSafeMap<space::Space*, accounting::RememberedSet*, kAllocatorTagHeap> |
| 1019 | remembered_sets_; |
Hiroshi Yamauchi | 38e68e9 | 2014-03-07 13:59:08 -0800 | [diff] [blame] | 1020 | |
Mathieu Chartier | 0de9f73 | 2013-11-22 17:58:48 -0800 | [diff] [blame] | 1021 | // The current collector type. |
| 1022 | CollectorType collector_type_; |
Mathieu Chartier | 31f4414 | 2014-04-08 14:40:03 -0700 | [diff] [blame] | 1023 | // Which collector we use when the app is in the foreground. |
| 1024 | CollectorType foreground_collector_type_; |
Mathieu Chartier | e6da9af | 2013-12-16 11:54:42 -0800 | [diff] [blame] | 1025 | // Which collector we will use when the app is notified of a transition to background. |
| 1026 | CollectorType background_collector_type_; |
Mathieu Chartier | a5f9de0 | 2014-02-28 16:48:42 -0800 | [diff] [blame] | 1027 | // Desired collector type, heap trimming daemon transitions the heap if it is != collector_type_. |
| 1028 | CollectorType desired_collector_type_; |
| 1029 | |
Mathieu Chartier | a5eae69 | 2014-12-17 17:56:03 -0800 | [diff] [blame] | 1030 | // Lock which guards pending tasks. |
| 1031 | Mutex* pending_task_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER; |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1032 | |
Mathieu Chartier | 2775ee4 | 2013-08-20 17:43:47 -0700 | [diff] [blame] | 1033 | // How many GC threads we may use for paused parts of garbage collection. |
| 1034 | const size_t parallel_gc_threads_; |
| 1035 | |
| 1036 | // How many GC threads we may use for unpaused parts of garbage collection. |
| 1037 | const size_t conc_gc_threads_; |
Mathieu Chartier | 63a5434 | 2013-07-23 13:17:59 -0700 | [diff] [blame] | 1038 | |
Mathieu Chartier | e0a53e9 | 2013-08-05 10:17:40 -0700 | [diff] [blame] | 1039 | // Boolean for if we are in low memory mode. |
| 1040 | const bool low_memory_mode_; |
| 1041 | |
Mathieu Chartier | 2775ee4 | 2013-08-20 17:43:47 -0700 | [diff] [blame] | 1042 | // If we get a pause longer than long pause log threshold, then we print out the GC after it |
| 1043 | // finishes. |
| 1044 | const size_t long_pause_log_threshold_; |
| 1045 | |
| 1046 | // If we get a GC longer than long GC log threshold, then we print out the GC after it finishes. |
| 1047 | const size_t long_gc_log_threshold_; |
| 1048 | |
| 1049 | // If we ignore the max footprint it lets the heap grow until it hits the heap capacity, this is |
| 1050 | // useful for benchmarking since it reduces time spent in GC to a low %. |
| 1051 | const bool ignore_max_footprint_; |
| 1052 | |
Mathieu Chartier | 8e4a96d | 2014-05-21 10:44:32 -0700 | [diff] [blame] | 1053 | // Lock which guards zygote space creation. |
| 1054 | Mutex zygote_creation_lock_; |
| 1055 | |
Mathieu Chartier | e4cab17 | 2014-08-19 18:24:04 -0700 | [diff] [blame] | 1056 | // Non-null iff we have a zygote space. Doesn't contain the large objects allocated before |
| 1057 | // zygote space creation. |
| 1058 | space::ZygoteSpace* zygote_space_; |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1059 | |
Mathieu Chartier | bd0a653 | 2014-02-27 11:14:21 -0800 | [diff] [blame] | 1060 | // Minimum allocation size of large object. |
| 1061 | size_t large_object_threshold_; |
| 1062 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1063 | // Guards access to the state of GC, associated conditional variable is used to signal when a GC |
| 1064 | // completes. |
| 1065 | Mutex* gc_complete_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER; |
Ian Rogers | 700a402 | 2014-05-19 16:49:03 -0700 | [diff] [blame] | 1066 | std::unique_ptr<ConditionVariable> gc_complete_cond_ GUARDED_BY(gc_complete_lock_); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1067 | |
Mathieu Chartier | 78f7b4c | 2014-05-06 10:57:27 -0700 | [diff] [blame] | 1068 | // Reference processor; |
Mathieu Chartier | 3cf2253 | 2015-07-09 15:15:09 -0700 | [diff] [blame] | 1069 | std::unique_ptr<ReferenceProcessor> reference_processor_; |
Mathieu Chartier | 02b6a78 | 2012-10-26 13:51:26 -0700 | [diff] [blame] | 1070 | |
Mathieu Chartier | a5eae69 | 2014-12-17 17:56:03 -0800 | [diff] [blame] | 1071 | // Task processor, proxies heap trim requests to the daemon threads. |
| 1072 | std::unique_ptr<TaskProcessor> task_processor_; |
| 1073 | |
Carl Shapiro | 58551df | 2011-07-24 03:09:51 -0700 | [diff] [blame] | 1074 | // True while the garbage collector is running. |
Mathieu Chartier | d5a89ee | 2014-01-31 09:55:13 -0800 | [diff] [blame] | 1075 | volatile CollectorType collector_type_running_ GUARDED_BY(gc_complete_lock_); |
Mathieu Chartier | 866fb2a | 2012-09-10 10:47:49 -0700 | [diff] [blame] | 1076 | |
| 1077 | // Last Gc type we ran. Used by WaitForConcurrentGc to know which Gc was waited on. |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 1078 | volatile collector::GcType last_gc_type_ GUARDED_BY(gc_complete_lock_); |
Mathieu Chartier | bdd0fb9 | 2013-07-02 10:16:15 -0700 | [diff] [blame] | 1079 | collector::GcType next_gc_type_; |
Mathieu Chartier | 1c23e1e | 2012-10-12 14:14:11 -0700 | [diff] [blame] | 1080 | |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 1081 | // Maximum size that the heap can reach. |
Mathieu Chartier | 379d09f | 2015-01-08 11:28:13 -0800 | [diff] [blame] | 1082 | size_t capacity_; |
Mathieu Chartier | 2775ee4 | 2013-08-20 17:43:47 -0700 | [diff] [blame] | 1083 | |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 1084 | // The size the heap is limited to. This is initially smaller than capacity, but for largeHeap |
| 1085 | // programs it is "cleared" making it the same as capacity. |
Mathieu Chartier | 2fde533 | 2012-09-14 14:51:54 -0700 | [diff] [blame] | 1086 | size_t growth_limit_; |
Mathieu Chartier | 2775ee4 | 2013-08-20 17:43:47 -0700 | [diff] [blame] | 1087 | |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 1088 | // When the number of bytes allocated exceeds the footprint TryAllocate returns null indicating |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 1089 | // a GC should be triggered. |
Mathieu Chartier | 1c23e1e | 2012-10-12 14:14:11 -0700 | [diff] [blame] | 1090 | size_t max_allowed_footprint_; |
Mathieu Chartier | 2775ee4 | 2013-08-20 17:43:47 -0700 | [diff] [blame] | 1091 | |
Mathieu Chartier | 987ccff | 2013-07-08 11:05:21 -0700 | [diff] [blame] | 1092 | // The watermark at which a concurrent GC is requested by registerNativeAllocation. |
| 1093 | size_t native_footprint_gc_watermark_; |
Mathieu Chartier | 2775ee4 | 2013-08-20 17:43:47 -0700 | [diff] [blame] | 1094 | |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 1095 | // Whether or not we need to run finalizers in the next native allocation. |
| 1096 | bool native_need_to_run_finalization_; |
| 1097 | |
Mathieu Chartier | c39e342 | 2013-08-07 16:41:36 -0700 | [diff] [blame] | 1098 | // Whether or not we currently care about pause times. |
Mathieu Chartier | ca2a24d | 2013-11-25 15:12:12 -0800 | [diff] [blame] | 1099 | ProcessState process_state_; |
Mathieu Chartier | c39e342 | 2013-08-07 16:41:36 -0700 | [diff] [blame] | 1100 | |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 1101 | // When num_bytes_allocated_ exceeds this amount then a concurrent GC should be requested so that |
| 1102 | // it completes ahead of an allocation failing. |
Mathieu Chartier | 0051be6 | 2012-10-12 17:47:11 -0700 | [diff] [blame] | 1103 | size_t concurrent_start_bytes_; |
Mathieu Chartier | 1c23e1e | 2012-10-12 14:14:11 -0700 | [diff] [blame] | 1104 | |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 1105 | // Since the heap was created, how many bytes have been freed. |
Mathieu Chartier | dd162fb | 2014-08-06 17:06:33 -0700 | [diff] [blame] | 1106 | uint64_t total_bytes_freed_ever_; |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 1107 | |
| 1108 | // Since the heap was created, how many objects have been freed. |
Mathieu Chartier | dd162fb | 2014-08-06 17:06:33 -0700 | [diff] [blame] | 1109 | uint64_t total_objects_freed_ever_; |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 1110 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1111 | // Number of bytes allocated. Adjusted after each allocation and free. |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 1112 | Atomic<size_t> num_bytes_allocated_; |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1113 | |
Mathieu Chartier | 987ccff | 2013-07-08 11:05:21 -0700 | [diff] [blame] | 1114 | // Bytes which are allocated and managed by native code but still need to be accounted for. |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 1115 | Atomic<size_t> native_bytes_allocated_; |
Mathieu Chartier | 987ccff | 2013-07-08 11:05:21 -0700 | [diff] [blame] | 1116 | |
Hiroshi Yamauchi | 4460a84 | 2015-03-09 11:57:48 -0700 | [diff] [blame] | 1117 | // Number of bytes freed by thread local buffer revokes. This will |
| 1118 | // cancel out the ahead-of-time bulk counting of bytes allocated in |
| 1119 | // rosalloc thread-local buffers. It is temporarily accumulated |
| 1120 | // here to be subtracted from num_bytes_allocated_ later at the next |
| 1121 | // GC. |
| 1122 | Atomic<size_t> num_bytes_freed_revoke_; |
| 1123 | |
Mathieu Chartier | 10fb83a | 2014-06-15 15:15:43 -0700 | [diff] [blame] | 1124 | // Info related to the current or previous GC iteration. |
| 1125 | collector::Iteration current_gc_iteration_; |
| 1126 | |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1127 | // Heap verification flags. |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1128 | const bool verify_missing_card_marks_; |
| 1129 | const bool verify_system_weaks_; |
| 1130 | const bool verify_pre_gc_heap_; |
Mathieu Chartier | 6f365cc | 2014-04-23 12:42:27 -0700 | [diff] [blame] | 1131 | const bool verify_pre_sweeping_heap_; |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1132 | const bool verify_post_gc_heap_; |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1133 | const bool verify_mod_union_table_; |
Hiroshi Yamauchi | a4adbfd | 2014-02-04 18:12:17 -0800 | [diff] [blame] | 1134 | bool verify_pre_gc_rosalloc_; |
Mathieu Chartier | 6f365cc | 2014-04-23 12:42:27 -0700 | [diff] [blame] | 1135 | bool verify_pre_sweeping_rosalloc_; |
Hiroshi Yamauchi | a4adbfd | 2014-02-04 18:12:17 -0800 | [diff] [blame] | 1136 | bool verify_post_gc_rosalloc_; |
Mathieu Chartier | 3100080 | 2015-06-14 14:14:37 -0700 | [diff] [blame] | 1137 | const bool gc_stress_mode_; |
Hiroshi Yamauchi | a4adbfd | 2014-02-04 18:12:17 -0800 | [diff] [blame] | 1138 | |
| 1139 | // RAII that temporarily disables the rosalloc verification during |
| 1140 | // the zygote fork. |
| 1141 | class ScopedDisableRosAllocVerification { |
| 1142 | private: |
Mathieu Chartier | 6f365cc | 2014-04-23 12:42:27 -0700 | [diff] [blame] | 1143 | Heap* const heap_; |
| 1144 | const bool orig_verify_pre_gc_; |
| 1145 | const bool orig_verify_pre_sweeping_; |
| 1146 | const bool orig_verify_post_gc_; |
| 1147 | |
Hiroshi Yamauchi | a4adbfd | 2014-02-04 18:12:17 -0800 | [diff] [blame] | 1148 | public: |
| 1149 | explicit ScopedDisableRosAllocVerification(Heap* heap) |
| 1150 | : heap_(heap), |
| 1151 | orig_verify_pre_gc_(heap_->verify_pre_gc_rosalloc_), |
Mathieu Chartier | 6f365cc | 2014-04-23 12:42:27 -0700 | [diff] [blame] | 1152 | orig_verify_pre_sweeping_(heap_->verify_pre_sweeping_rosalloc_), |
Hiroshi Yamauchi | a4adbfd | 2014-02-04 18:12:17 -0800 | [diff] [blame] | 1153 | orig_verify_post_gc_(heap_->verify_post_gc_rosalloc_) { |
| 1154 | heap_->verify_pre_gc_rosalloc_ = false; |
Mathieu Chartier | 6f365cc | 2014-04-23 12:42:27 -0700 | [diff] [blame] | 1155 | heap_->verify_pre_sweeping_rosalloc_ = false; |
Hiroshi Yamauchi | a4adbfd | 2014-02-04 18:12:17 -0800 | [diff] [blame] | 1156 | heap_->verify_post_gc_rosalloc_ = false; |
| 1157 | } |
| 1158 | ~ScopedDisableRosAllocVerification() { |
| 1159 | heap_->verify_pre_gc_rosalloc_ = orig_verify_pre_gc_; |
Mathieu Chartier | 6f365cc | 2014-04-23 12:42:27 -0700 | [diff] [blame] | 1160 | heap_->verify_pre_sweeping_rosalloc_ = orig_verify_pre_sweeping_; |
Hiroshi Yamauchi | a4adbfd | 2014-02-04 18:12:17 -0800 | [diff] [blame] | 1161 | heap_->verify_post_gc_rosalloc_ = orig_verify_post_gc_; |
| 1162 | } |
| 1163 | }; |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1164 | |
Mathieu Chartier | 02b6a78 | 2012-10-26 13:51:26 -0700 | [diff] [blame] | 1165 | // Parallel GC data structures. |
Ian Rogers | 700a402 | 2014-05-19 16:49:03 -0700 | [diff] [blame] | 1166 | std::unique_ptr<ThreadPool> thread_pool_; |
Mathieu Chartier | 02b6a78 | 2012-10-26 13:51:26 -0700 | [diff] [blame] | 1167 | |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 1168 | // Estimated allocation rate (bytes / second). Computed between the time of the last GC cycle |
| 1169 | // and the start of the current one. |
Mathieu Chartier | 65db880 | 2012-11-20 12:36:46 -0800 | [diff] [blame] | 1170 | uint64_t allocation_rate_; |
| 1171 | |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 1172 | // For a GC cycle, a bitmap that is set corresponding to the |
Ian Rogers | 700a402 | 2014-05-19 16:49:03 -0700 | [diff] [blame] | 1173 | std::unique_ptr<accounting::HeapBitmap> live_bitmap_ GUARDED_BY(Locks::heap_bitmap_lock_); |
| 1174 | std::unique_ptr<accounting::HeapBitmap> mark_bitmap_ GUARDED_BY(Locks::heap_bitmap_lock_); |
Mathieu Chartier | b062fdd | 2012-07-03 09:51:48 -0700 | [diff] [blame] | 1175 | |
Mathieu Chartier | e0f0cb3 | 2012-08-28 11:26:00 -0700 | [diff] [blame] | 1176 | // Mark stack that we reuse to avoid re-allocating the mark stack. |
Ian Rogers | 700a402 | 2014-05-19 16:49:03 -0700 | [diff] [blame] | 1177 | std::unique_ptr<accounting::ObjectStack> mark_stack_; |
Mathieu Chartier | 5301cd2 | 2012-05-31 12:11:36 -0700 | [diff] [blame] | 1178 | |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1179 | // Allocation stack, new allocations go here so that we can do sticky mark bits. This enables us |
| 1180 | // to use the live bitmap as the old mark bitmap. |
Mathieu Chartier | d8195f1 | 2012-10-05 12:21:28 -0700 | [diff] [blame] | 1181 | const size_t max_allocation_stack_size_; |
Ian Rogers | 700a402 | 2014-05-19 16:49:03 -0700 | [diff] [blame] | 1182 | std::unique_ptr<accounting::ObjectStack> allocation_stack_; |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1183 | |
| 1184 | // Second allocation stack so that we can process allocation with the heap unlocked. |
Ian Rogers | 700a402 | 2014-05-19 16:49:03 -0700 | [diff] [blame] | 1185 | std::unique_ptr<accounting::ObjectStack> live_stack_; |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 1186 | |
Mathieu Chartier | cbb2d20 | 2013-11-14 17:45:16 -0800 | [diff] [blame] | 1187 | // Allocator type. |
Mathieu Chartier | 5048223 | 2013-11-21 11:48:14 -0800 | [diff] [blame] | 1188 | AllocatorType current_allocator_; |
Mathieu Chartier | cbb2d20 | 2013-11-14 17:45:16 -0800 | [diff] [blame] | 1189 | const AllocatorType current_non_moving_allocator_; |
| 1190 | |
| 1191 | // Which GCs we run in order when we an allocation fails. |
| 1192 | std::vector<collector::GcType> gc_plan_; |
| 1193 | |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 1194 | // Bump pointer spaces. |
| 1195 | space::BumpPointerSpace* bump_pointer_space_; |
| 1196 | // Temp space is the space which the semispace collector copies to. |
| 1197 | space::BumpPointerSpace* temp_space_; |
| 1198 | |
Hiroshi Yamauchi | 2cd334a | 2015-01-09 14:03:35 -0800 | [diff] [blame] | 1199 | space::RegionSpace* region_space_; |
| 1200 | |
Mathieu Chartier | 0051be6 | 2012-10-12 17:47:11 -0700 | [diff] [blame] | 1201 | // Minimum free guarantees that you always have at least min_free_ free bytes after growing for |
| 1202 | // utilization, regardless of target utilization ratio. |
| 1203 | size_t min_free_; |
| 1204 | |
| 1205 | // The ideal maximum free size, when we grow the heap for utilization. |
| 1206 | size_t max_free_; |
| 1207 | |
Brian Carlstrom | 395520e | 2011-09-25 19:35:00 -0700 | [diff] [blame] | 1208 | // Target ideal heap utilization ratio |
Mathieu Chartier | 0051be6 | 2012-10-12 17:47:11 -0700 | [diff] [blame] | 1209 | double target_utilization_; |
Brian Carlstrom | 395520e | 2011-09-25 19:35:00 -0700 | [diff] [blame] | 1210 | |
Mathieu Chartier | 2f8da3e | 2014-04-15 15:37:02 -0700 | [diff] [blame] | 1211 | // How much more we grow the heap when we are a foreground app instead of background. |
| 1212 | double foreground_heap_growth_multiplier_; |
| 1213 | |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 1214 | // Total time which mutators are paused or waiting for GC to complete. |
Mathieu Chartier | 155dfe9 | 2012-10-09 14:24:49 -0700 | [diff] [blame] | 1215 | uint64_t total_wait_time_; |
| 1216 | |
Ian Rogers | 04d7aa9 | 2013-03-16 14:29:17 -0700 | [diff] [blame] | 1217 | // The current state of heap verification, may be enabled or disabled. |
Mathieu Chartier | 4e30541 | 2014-02-19 10:54:44 -0800 | [diff] [blame] | 1218 | VerifyObjectMode verify_object_mode_; |
Ian Rogers | 04d7aa9 | 2013-03-16 14:29:17 -0700 | [diff] [blame] | 1219 | |
Mathieu Chartier | 1d27b34 | 2014-01-28 12:51:09 -0800 | [diff] [blame] | 1220 | // Compacting GC disable count, prevents compacting GC from running iff > 0. |
| 1221 | size_t disable_moving_gc_count_ GUARDED_BY(gc_complete_lock_); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 1222 | |
| 1223 | std::vector<collector::GarbageCollector*> garbage_collectors_; |
| 1224 | collector::SemiSpace* semi_space_collector_; |
Mathieu Chartier | 52e4b43 | 2014-06-10 11:22:31 -0700 | [diff] [blame] | 1225 | collector::MarkCompact* mark_compact_collector_; |
Hiroshi Yamauchi | d5307ec | 2014-03-27 21:07:51 -0700 | [diff] [blame] | 1226 | collector::ConcurrentCopying* concurrent_copying_collector_; |
Brian Carlstrom | 1f87008 | 2011-08-23 16:02:11 -0700 | [diff] [blame] | 1227 | |
Evgenii Stepanov | 1e13374 | 2015-05-20 12:30:59 -0700 | [diff] [blame] | 1228 | const bool is_running_on_memory_tool_; |
Mathieu Chartier | 692fafd | 2013-11-29 17:24:40 -0800 | [diff] [blame] | 1229 | const bool use_tlab_; |
Hiroshi Yamauchi | 50b2928 | 2013-07-30 13:58:37 -0700 | [diff] [blame] | 1230 | |
Zuo Wang | f37a88b | 2014-07-10 04:26:41 -0700 | [diff] [blame] | 1231 | // Pointer to the space which becomes the new main space when we do homogeneous space compaction. |
Mathieu Chartier | b363f66 | 2014-07-16 13:28:58 -0700 | [diff] [blame] | 1232 | // Use unique_ptr since the space is only added during the homogeneous compaction phase. |
| 1233 | std::unique_ptr<space::MallocSpace> main_space_backup_; |
Zuo Wang | f37a88b | 2014-07-10 04:26:41 -0700 | [diff] [blame] | 1234 | |
| 1235 | // Minimal interval allowed between two homogeneous space compactions caused by OOM. |
| 1236 | uint64_t min_interval_homogeneous_space_compaction_by_oom_; |
| 1237 | |
| 1238 | // Times of the last homogeneous space compaction caused by OOM. |
| 1239 | uint64_t last_time_homogeneous_space_compaction_by_oom_; |
| 1240 | |
| 1241 | // Saved OOMs by homogeneous space compaction. |
| 1242 | Atomic<size_t> count_delayed_oom_; |
| 1243 | |
| 1244 | // Count for requested homogeneous space compaction. |
| 1245 | Atomic<size_t> count_requested_homogeneous_space_compaction_; |
| 1246 | |
| 1247 | // Count for ignored homogeneous space compaction. |
| 1248 | Atomic<size_t> count_ignored_homogeneous_space_compaction_; |
| 1249 | |
| 1250 | // Count for performed homogeneous space compaction. |
| 1251 | Atomic<size_t> count_performed_homogeneous_space_compaction_; |
| 1252 | |
Mathieu Chartier | a5eae69 | 2014-12-17 17:56:03 -0800 | [diff] [blame] | 1253 | // Whether or not a concurrent GC is pending. |
| 1254 | Atomic<bool> concurrent_gc_pending_; |
| 1255 | |
| 1256 | // Active tasks which we can modify (change target time, desired collector type, etc..). |
| 1257 | CollectorTransitionTask* pending_collector_transition_ GUARDED_BY(pending_task_lock_); |
| 1258 | HeapTrimTask* pending_heap_trim_ GUARDED_BY(pending_task_lock_); |
| 1259 | |
Zuo Wang | f37a88b | 2014-07-10 04:26:41 -0700 | [diff] [blame] | 1260 | // Whether or not we use homogeneous space compaction to avoid OOM errors. |
| 1261 | bool use_homogeneous_space_compaction_for_oom_; |
| 1262 | |
Hiroshi Yamauchi | a1c9f01 | 2015-04-02 10:18:12 -0700 | [diff] [blame] | 1263 | // True if the currently running collection has made some thread wait. |
| 1264 | bool running_collection_is_blocking_ GUARDED_BY(gc_complete_lock_); |
| 1265 | // The number of blocking GC runs. |
| 1266 | uint64_t blocking_gc_count_; |
| 1267 | // The total duration of blocking GC runs. |
| 1268 | uint64_t blocking_gc_time_; |
| 1269 | // The duration of the window for the GC count rate histograms. |
| 1270 | static constexpr uint64_t kGcCountRateHistogramWindowDuration = MsToNs(10 * 1000); // 10s. |
| 1271 | // The last time when the GC count rate histograms were updated. |
| 1272 | // This is rounded by kGcCountRateHistogramWindowDuration (a multiple of 10s). |
| 1273 | uint64_t last_update_time_gc_count_rate_histograms_; |
| 1274 | // The running count of GC runs in the last window. |
| 1275 | uint64_t gc_count_last_window_; |
| 1276 | // The running count of blocking GC runs in the last window. |
| 1277 | uint64_t blocking_gc_count_last_window_; |
| 1278 | // The maximum number of buckets in the GC count rate histograms. |
| 1279 | static constexpr size_t kGcCountRateMaxBucketCount = 200; |
| 1280 | // The histogram of the number of GC invocations per window duration. |
| 1281 | Histogram<uint64_t> gc_count_rate_histogram_ GUARDED_BY(gc_complete_lock_); |
| 1282 | // The histogram of the number of blocking GC invocations per window duration. |
| 1283 | Histogram<uint64_t> blocking_gc_count_rate_histogram_ GUARDED_BY(gc_complete_lock_); |
| 1284 | |
Man Cao | 8c2ff64 | 2015-05-27 17:25:30 -0700 | [diff] [blame] | 1285 | // Allocation tracking support |
| 1286 | Atomic<bool> alloc_tracking_enabled_; |
| 1287 | std::unique_ptr<AllocRecordObjectMap> allocation_records_ |
| 1288 | GUARDED_BY(Locks::alloc_tracker_lock_); |
| 1289 | |
Mathieu Chartier | 3100080 | 2015-06-14 14:14:37 -0700 | [diff] [blame] | 1290 | // GC stress related data structures. |
| 1291 | Mutex* backtrace_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER; |
| 1292 | // Debugging variables, seen backtraces vs unique backtraces. |
| 1293 | Atomic<uint64_t> seen_backtrace_count_; |
| 1294 | Atomic<uint64_t> unique_backtrace_count_; |
| 1295 | // Stack trace hashes that we already saw, |
| 1296 | std::unordered_set<uint64_t> seen_backtraces_ GUARDED_BY(backtrace_lock_); |
| 1297 | |
Mathieu Chartier | 5116837 | 2015-08-12 16:40:32 -0700 | [diff] [blame^] | 1298 | // We disable GC when we are shutting down the runtime in case there are daemon threads still |
| 1299 | // allocating. |
| 1300 | bool gc_disabled_for_shutdown_ GUARDED_BY(gc_complete_lock_); |
| 1301 | |
Mathieu Chartier | a5eae69 | 2014-12-17 17:56:03 -0800 | [diff] [blame] | 1302 | friend class CollectorTransitionTask; |
Mathieu Chartier | 6f365cc | 2014-04-23 12:42:27 -0700 | [diff] [blame] | 1303 | friend class collector::GarbageCollector; |
Mathieu Chartier | 52e4b43 | 2014-06-10 11:22:31 -0700 | [diff] [blame] | 1304 | friend class collector::MarkCompact; |
Hiroshi Yamauchi | 2cd334a | 2015-01-09 14:03:35 -0800 | [diff] [blame] | 1305 | friend class collector::ConcurrentCopying; |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 1306 | friend class collector::MarkSweep; |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 1307 | friend class collector::SemiSpace; |
Mathieu Chartier | 39e3261 | 2013-11-12 16:28:05 -0800 | [diff] [blame] | 1308 | friend class ReferenceQueue; |
Mathieu Chartier | c7b83a0 | 2012-09-11 18:07:39 -0700 | [diff] [blame] | 1309 | friend class VerifyReferenceCardVisitor; |
Mathieu Chartier | fd678be | 2012-08-30 14:50:54 -0700 | [diff] [blame] | 1310 | friend class VerifyReferenceVisitor; |
| 1311 | friend class VerifyObjectVisitor; |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 1312 | friend class space::SpaceTest; |
Ian Rogers | 30fab40 | 2012-01-23 15:43:46 -0800 | [diff] [blame] | 1313 | |
Carl Shapiro | 69759ea | 2011-07-21 18:13:35 -0700 | [diff] [blame] | 1314 | DISALLOW_IMPLICIT_CONSTRUCTORS(Heap); |
| 1315 | }; |
| 1316 | |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 1317 | } // namespace gc |
Carl Shapiro | 1fb8620 | 2011-06-27 17:43:13 -0700 | [diff] [blame] | 1318 | } // namespace art |
| 1319 | |
Brian Carlstrom | fc0e321 | 2013-07-17 14:40:12 -0700 | [diff] [blame] | 1320 | #endif // ART_RUNTIME_GC_HEAP_H_ |